snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-companion/scripts/archive.mjs

@@ -0,0 +1,27 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import './package.mjs';
+
+const { version } = JSON.parse(await readFile('package.json', 'utf8'));
+const outputDirectory = resolve(
+  process.env.TWENTY_COMPANION_OUTPUT_DIR ?? 'release',
+);
+const archive = resolve(outputDirectory, `Twenty-${version}-macos-arm64.zip`);
+execFileSync('ditto', [
+  '-c',
+  '-k',
+  '--sequesterRsrc',
+  '--keepParent',
+  resolve(outputDirectory, 'Twenty-darwin-arm64/Twenty.app'),
+  archive,
+]);
+const checksum = createHash('sha256');
+for await (const chunk of createReadStream(archive)) checksum.update(chunk);
+await writeFile(
+  `${archive}.sha256`,
+  `${checksum.digest('hex')}  ${basename(archive)}\n`,
+);
+console.log(archive);

packages/twenty-companion/scripts/build.mjs

@@ -0,0 +1,6 @@
+import { build } from 'esbuild';
+import { build as buildRenderer } from 'vite';
+import { electronBuildOptions } from './electron-build.mjs';
+
+await build(electronBuildOptions);
+await buildRenderer();

packages/twenty-companion/scripts/dev.mjs

@@ -0,0 +1,97 @@
+import { spawn } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { createServer } from 'vite';
+import { context } from 'esbuild';
+import electron from 'electron';
+import { electronBuildOptions } from './electron-build.mjs';
+
+const server = await createServer();
+let watcher;
+let child;
+let stopping = false;
+let building = false;
+let launchPending = false;
+
+const stop = async (code = 0) => {
+  if (stopping) return;
+  stopping = true;
+  child?.kill('SIGTERM');
+  await watcher?.dispose();
+  await server.close();
+  process.exit(code);
+};
+
+const launch = () => {
+  if (building) {
+    launchPending = true;
+    return;
+  }
+  launchPending = false;
+  let restarting = false;
+  child = spawn(electron, ['.'], {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    env: { ...process.env, TWENTY_COMPANION_DEV_URL: 'http://127.0.0.1:4317' },
+  });
+  child.on('message', (message) => {
+    if (message?.type === 'development-restarting') restarting = true;
+  });
+  child.on('error', (error) => {
+    console.error('Could not launch Electron.', error);
+    void stop(1);
+  });
+  child.on('exit', (code) => {
+    child = undefined;
+    if (stopping) return;
+    if (restarting && code === 0) launch();
+    else void stop(code ?? 1);
+  });
+};
+
+try {
+  await server.listen();
+  watcher = await context({
+    ...electronBuildOptions,
+    // A failed compilation must not replace either half of the working Electron build.
+    write: false,
+    plugins: [
+      {
+        name: 'restart-electron',
+        setup(build) {
+          build.onStart(() => {
+            building = true;
+          });
+          build.onEnd(async (result) => {
+            try {
+              if (stopping || result.errors.length) return;
+              for (const output of result.outputFiles) {
+                await mkdir(dirname(output.path), { recursive: true });
+                await writeFile(output.path, output.contents);
+              }
+              if (stopping) return;
+              if (!child) launch();
+              else if (child.connected) {
+                console.log(
+                  'Electron rebuilt; restart will wait for recording to finish.',
+                );
+                child.send({ type: 'development-restart' }, (error) => {
+                  if (error && child?.connected)
+                    console.error('Could not request restart.', error);
+                });
+              }
+            } finally {
+              building = false;
+              if (!stopping && launchPending) launch();
+            }
+          });
+        },
+      },
+    ],
+  });
+  await watcher.watch();
+} catch (error) {
+  console.error(error);
+  await stop(1);
+}
+process.on('SIGINT', () => void stop());
+process.on('SIGTERM', () => void stop());

packages/twenty-companion/scripts/electron-build.mjs

@@ -0,0 +1,11 @@
+export const electronBuildOptions = {
+  entryPoints: { main: 'src/main/main.ts', preload: 'src/main/preload.ts' },
+  bundle: true,
+  platform: 'node',
+  target: 'node22',
+  format: 'cjs',
+  outdir: 'dist',
+  outExtension: { '.js': '.cjs' },
+  external: ['electron', '@recallai/desktop-sdk'],
+  sourcemap: true,
+};

packages/twenty-companion/scripts/package.mjs

@@ -0,0 +1,92 @@
+import { packager } from '@electron/packager';
+import { access, cp, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import './build.mjs';
+
+const manifest = JSON.parse(await readFile('package.json', 'utf8'));
+const stagingDirectory = await mkdtemp(
+  join(tmpdir(), 'twenty-desktop-package-'),
+);
+
+// Resolve each dependency from its owner so hoisting cannot change the packaged runtime.
+const copyRuntimeDependency = async (name, ownerManifest, destination) => {
+  const manifestPath = createRequire(ownerManifest).resolve(
+    `${name}/package.json`,
+  );
+  const dependency = JSON.parse(await readFile(manifestPath, 'utf8'));
+  const target = join(destination, 'node_modules', name);
+  await cp(dirname(manifestPath), target, {
+    recursive: true,
+    verbatimSymlinks: true,
+    filter: (source) => source !== join(dirname(manifestPath), 'node_modules'),
+  });
+  for (const child of Object.keys(dependency.dependencies ?? {}))
+    await copyRuntimeDependency(child, manifestPath, target);
+};
+
+try {
+  await cp('dist', join(stagingDirectory, 'dist'), { recursive: true });
+  await cp('assets', join(stagingDirectory, 'assets'), { recursive: true });
+  await writeFile(
+    join(stagingDirectory, 'package.json'),
+    JSON.stringify(
+      {
+        name: manifest.name,
+        productName: manifest.productName,
+        version: manifest.version,
+        description: manifest.description,
+        license: manifest.license,
+        main: manifest.main,
+        dependencies: {
+          '@recallai/desktop-sdk':
+            manifest.dependencies['@recallai/desktop-sdk'],
+        },
+      },
+      null,
+      2,
+    ),
+  );
+  await copyRuntimeDependency(
+    '@recallai/desktop-sdk',
+    resolve('package.json'),
+    stagingDirectory,
+  );
+  const paths = await packager({
+    dir: stagingDirectory,
+    out: process.env.TWENTY_COMPANION_OUTPUT_DIR ?? 'release',
+    name: 'Twenty',
+    executableName: 'Twenty',
+    appBundleId: 'com.twenty.companion',
+    icon: join(process.cwd(), 'assets/twenty.icns'),
+    platform: 'darwin',
+    electronVersion: manifest.devDependencies.electron,
+    arch: 'arm64',
+    overwrite: true,
+    prune: false,
+    electronZipDir: process.env.TWENTY_COMPANION_ELECTRON_ZIP_DIR,
+    // Recall launches its native framework by path outside the Electron archive.
+    asar: { unpackDir: 'node_modules/@recallai/desktop-sdk' },
+    extendInfo: {
+      LSUIElement: false,
+      LSMinimumSystemVersion: '14.2',
+      NSMicrophoneUsageDescription:
+        'Twenty records your voice during calls you choose to capture.',
+      NSAudioCaptureUsageDescription:
+        'Twenty records call audio so it can be saved to your Twenty workspace.',
+      NSAccessibilityUsageDescription:
+        'Twenty detects meetings and shows recording controls.',
+    },
+  });
+  for (const directory of paths)
+    await access(
+      join(
+        directory,
+        'Twenty.app/Contents/Resources/app.asar.unpacked/node_modules/@recallai/desktop-sdk/desktop_sdk_macos_exe',
+      ),
+    );
+  console.log(paths.join('\n'));
+} finally {
+  await rm(stagingDirectory, { recursive: true, force: true });
+}

packages/twenty-companion/scripts/setup-native.mjs

@@ -0,0 +1,27 @@
+import { access } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+if (process.platform !== 'darwin' || process.arch !== 'arm64')
+  throw new Error('Desktop launch and packaging require an Apple Silicon Mac.');
+
+const require = createRequire(import.meta.url);
+for (const [name, artifact, installer] of [
+  ['electron', 'dist/Electron.app/Contents/MacOS/Electron', 'install.js'],
+  ['@recallai/desktop-sdk', 'desktop_sdk_macos_exe', 'setup.js'],
+]) {
+  const directory = dirname(require.resolve(`${name}/package.json`));
+  const artifactPath = join(directory, artifact);
+  try {
+    await access(artifactPath);
+    continue;
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  execFileSync(process.execPath, [join(directory, installer)], {
+    cwd: directory,
+    stdio: 'inherit',
+  });
+  await access(artifactPath);
+}