synabun 2.0.5 → 2.0.9

package/lib/desktop-app.js

@@ -0,0 +1,265 @@
+/**
+ * SynaBun — the desktop app's server
+ *
+ * The Electron window of a packaged build (packaging/desktop/) does not decide
+ * anything about the server itself: it runs `<entry> app-backend --json`
+ * (packaging/runtime/bootstrap.mjs), which comes here. This module finds the
+ * server the window should show, and starts one through the same Start Server
+ * launcher an npm install uses (lib/start-launcher.js runLauncher: the launch
+ * lock, the supervisor record, the health check), so two starts never race.
+ *
+ *   reuse      a server of this install (same entry, same version) answers:
+ *              on the port the window used last, where this data home's
+ *              supervisor says it listens, or on the configured port
+ *   replace    a server of this install from before an update answers: it is
+ *              asked to shut down, and the new version starts in its place
+ *   refuse     another installation of SynaBun answers on the port with this
+ *              same data home (or cannot say which one it uses): it is never
+ *              stopped or adopted, and the window says so
+ *   move       the port is taken by something else (a program, a SynaBun on
+ *              another data home): this install starts on a free port
+ *
+ * Every step is reported as an event ({ type: 'plan' | 'existing' | 'step' |
+ * 'supervisor' | 'ready' | 'conflict' | 'failed', ... }); the window shows them.
+ */
+
+import { createHash } from 'node:crypto';
+import { realpathSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+/**
+ * Which data home a server uses, without saying where it is: the first 16 hex
+ * characters of a SHA-256 of its real path (lower case on Windows, where case
+ * does not tell paths apart). /api/health reports it, so the app can tell a
+ * second copy on the same data from one on another.
+ */
+export function dataHomeId(dataHome, platform = process.platform) {
+  let path = resolve(String(dataHome || ''));
+  try { path = realpathSync.native(path); } catch {}
+  if (platform === 'win32') path = path.toLowerCase();
+  return createHash('sha256').update(path).digest('hex').slice(0, 16);
+}
+
+function samePath(a, b, platform) {
+  const norm = (value) => {
+    let path = String(value || '').replace(/\\/g, '/');
+    try { path = realpathSync.native(path).replace(/\\/g, '/'); } catch {}
+    return platform === 'win32' ? path.toLowerCase() : path;
+  };
+  return !!a && !!b && norm(a) === norm(b);
+}
+
+/**
+ * What answers on a port, for this install:
+ *   'none'               nothing answers
+ *   'other'              something answers that is not a SynaBun server
+ *   'ours'               this install, this version
+ *   'ours-stale'         this install, another version (from before an update)
+ *   'foreign'            another installation, on another data home
+ *   'foreign-same-data'  another installation on this data home, or one that does not say
+ */
+export function classifyServer(health, { entry, packageRoot, version, dataHomeId: ours, platform = process.platform, answered = true } = {}) {
+  if (!health) return { kind: answered ? 'other' : 'none' };
+  if (health.ok !== true || health.storage !== 'sqlite' || typeof health.projectDir !== 'string') return { kind: 'other', health };
+  // This install: the entry it runs from (installEntry; `entry` is only the path that outlives the run, empty for a
+  // copy on its disk image or a translocated one), or the very same application folder. An AppImage's folder is a
+  // new mount every run, and its entry (the image file) is what matches.
+  const theirEntry = health.installEntry || health.entry;
+  if ((entry && theirEntry && samePath(theirEntry, entry, platform)) || (packageRoot && samePath(health.projectDir, packageRoot, platform))) {
+    return { kind: String(health.version || '') === String(version) ? 'ours' : 'ours-stale', health };
+  }
+  if (health.dataHomeId && health.dataHomeId !== ours) return { kind: 'foreign', health };
+  // Said so (the same data home), or said nothing (a server from before 2026-10-17 reports no data home).
+  return { kind: 'foreign-same-data', health, known: !!health.dataHomeId };
+}
+
+/** A server that answers its health check completely: ready for the window. */
+export function serverReady(health) {
+  return !!health && health.ok === true && health.storage === 'sqlite' && typeof health.projectDir === 'string' && !!health.startLauncher;
+}
+
+async function defaultHealth(port, { fetchImpl = globalThis.fetch, timeoutMs = 1500 } = {}) {
+  try {
+    const response = await fetchImpl(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(timeoutMs), headers: { accept: 'application/json' } });
+    if (!response.ok) return { status: response.status };
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+/**
+ * Find or start the server for the desktop app. Resolves with the final event
+ * ('ready', 'conflict' or 'failed'); `emit` receives every event on the way.
+ * Everything that touches the system is a parameter, for the tests.
+ */
+export async function runAppBackend({
+  env = process.env,
+  runtime,
+  packageRoot,
+  dataHome,
+  preferPort = null,
+  platform = process.platform,
+  emit = () => {},
+  launcher,            // lib/start-launcher.js (runLauncher, resolvePort, portAccepts, launcherStatePaths, pidAlive)
+  backgroundCommand,   // lib/desktop-pwa.js: the background start of a packaged build
+  spawn,
+  health = defaultHealth,
+  shutdown = null,
+  sleep = (ms) => new Promise(done => setTimeout(done, ms)),
+  now = () => Date.now(),
+  readyWaitMs = 5 * 60 * 1000,
+  searchSpan = 20,
+} = {}) {
+  const ours = { entry: runtime?.entry || null, packageRoot: packageRoot || runtime?.packageRoot || null, version: runtime?.version || '', dataHomeId: dataHomeId(dataHome, platform), platform };
+  const { runLauncher, resolvePort, portAccepts, launcherStatePaths, pidAlive } = launcher;
+  const configured = resolvePort({ env, dataHome });
+  const paths = launcherStatePaths(dataHome);
+  const supervisorRecord = () => readJson(paths.supervisor);
+  const look = async (port) => {
+    const answer = await health(port);
+    if (answer && answer.ok === undefined && answer.status) return classifyServer(null, { ...ours, answered: true });
+    if (answer) return classifyServer(answer, ours);
+    return classifyServer(null, { ...ours, answered: await portAccepts(port).catch(() => false) });
+  };
+  const ready = (port, extra) => {
+    const record = supervisorRecord();
+    return { type: 'ready', port, supervisorPid: record && !record.endedAt && pidAlive(record.pid) ? record.pid : null, ...extra };
+  };
+  const conflict = (port, found) => ({ type: 'conflict', port, projectDir: found.health?.projectDir || null, install: found.health?.install || null, version: found.health?.version || null });
+
+  emit({ type: 'plan', dataHome, port: configured, preferredPort: configured, dataHomeId: ours.dataHomeId });
+
+  // This install's server from before an update: its files are gone or replaced. It goes; the new one starts.
+  const stopStale = async (stalePort, staleVersion) => {
+    const asked = shutdown ? await shutdown(stalePort) : false;
+    const deadline = now() + 20000;
+    while (await portAccepts(stalePort).catch(() => false)) {
+      if (now() >= deadline) return { type: 'failed', code: 'STALE_SERVER', message: `An older SynaBun server of this copy (v${staleVersion}) still runs on port ${stalePort} and did not stop${asked ? '' : ' when asked'}.`, log: paths.log };
+      await sleep(300);
+    }
+    return null;
+  };
+
+  // 1. A server of this install that is already up: where the window was last,
+  //    or where this data home's supervisor says its server listens. Another
+  //    installation on this data home there is never a reason to start a second one.
+  const record = supervisorRecord();
+  const recordPort = record && !record.endedAt && pidAlive(record.pid) && record.phase === 'listening' ? Number(record.detail?.port) || null : null;
+  for (const earlier of [...new Set([preferPort, recordPort].filter(value => value && value !== configured))]) {
+    const seen = await look(earlier);
+    if (seen.kind === 'none') continue;
+    emit({ type: 'existing', port: earlier, kind: seen.kind, version: seen.health?.version || null });
+    if (seen.kind === 'ours') return finish(ready(earlier, { reused: true, started: false, version: seen.health.version }));
+    // Another installation on this data home, or one too old to say which data home it uses (every server from
+    // before 2026-10-17): the window is told where it runs. Starting this install beside it could mean two
+    // servers on one data home.
+    if (seen.kind === 'foreign-same-data') return finish(conflict(earlier, seen));
+    if (seen.kind === 'ours-stale') {
+      const failed = await stopStale(earlier, seen.health.version);
+      if (failed) return finish(failed);
+    }
+  }
+
+  // 2. The configured port.
+  let port = configured;
+  let alternative = false;
+  const found = await look(configured);
+  if (found.kind !== 'none') emit({ type: 'existing', port: configured, kind: found.kind, version: found.health?.version || null });
+  if (found.kind === 'ours') return finish(ready(configured, { reused: true, started: false, version: found.health.version }));
+  if (found.kind === 'foreign-same-data') return finish(conflict(configured, found));
+  if (found.kind === 'ours-stale') {
+    const failed = await stopStale(configured, found.health.version);
+    if (failed) return finish(failed);
+  } else if (found.kind === 'foreign' || found.kind === 'other') {
+    const free = await freePort([preferPort, ...Array.from({ length: searchSpan }, (_, i) => configured + 1 + i)]);
+    if (!free) return finish({ type: 'failed', code: 'NO_PORT', message: `Port ${configured} is in use by another program, and no free port was found near it.`, log: paths.log });
+    port = free;
+    alternative = true;
+    emit({ type: 'plan', dataHome, port, preferredPort: configured, alternativePort: true, dataHomeId: ours.dataHomeId });
+  }
+
+  async function freePort(candidates) {
+    for (const candidate of [...new Set(candidates.filter(value => Number.isInteger(value) && value > 0 && value < 65536))]) {
+      if (!(await portAccepts(candidate).catch(() => true))) return candidate;
+    }
+    return null;
+  }
+
+  // 3. Start, through the launcher (lock, supervisor record, background start).
+  let launcherPid = null;
+  let lastPhase = null;
+  const reportPhase = (current) => {
+    if (!current?.phase || current.phase === lastPhase) return;
+    lastPhase = current.phase;
+    emit({ type: 'supervisor', phase: current.phase, detail: current.detail || null });
+  };
+  const reporter = () => ({
+    get listening() { return false; },
+    listen: async () => false,
+    step: (id) => emit({ type: 'step', id: String(id) }),
+    supervisor: reportPhase,
+    finish: () => {},
+    linger: async () => {},
+    close: () => {},
+  });
+  const result = await runLauncher({
+    argv: ['--port', String(port)],
+    env: { ...env, NEURAL_PORT: String(port) },
+    packageRoot,
+    background: true,
+    beacon: reporter,
+    spawnImpl: (file, args, options) => {
+      const command = backgroundCommand(runtime, options.env);
+      const child = spawn(command.file, command.args, { ...options, env: command.env, cwd: command.cwd || options.cwd });
+      launcherPid = child.pid || null;
+      return child;
+    },
+  });
+  if (result.outcome === 'failed') {
+    const failure = supervisorRecord();
+    return finish({ type: 'failed', code: failure?.error?.code || 'START_FAILED', message: failure?.phase === 'failed' && failure.error?.message ? failure.error.message : 'SynaBun\'s server could not be started.', log: paths.log });
+  }
+
+  // 4. Until it answers completely (a first start downloads the automation browser and backs up the data).
+  const deadline = now() + readyWaitMs;
+  for (;;) {
+    const answer = await health(port);
+    if (serverReady(answer)) {
+      const kind = classifyServer(answer, ours).kind;
+      if (kind !== 'ours') return finish(kind === 'foreign-same-data' ? conflict(port, { health: answer }) : { type: 'failed', code: 'NOT_OURS', message: `Another program took port ${port} while SynaBun started.`, log: paths.log });
+      return finish(ready(port, { reused: result.outcome !== 'started', started: result.outcome === 'started', launcherPid, version: answer.version, alternativePort: alternative, preferredPort: configured }));
+    }
+    const current = supervisorRecord();
+    reportPhase(current);
+    if (current?.phase === 'failed' && current.error) return finish({ type: 'failed', code: current.error.code || 'START_FAILED', message: current.error.message, log: paths.log });
+    if (now() >= deadline) return finish({ type: 'failed', code: 'NO_ANSWER', message: `SynaBun's server did not answer within ${Math.round(readyWaitMs / 60000)} minutes.`, log: paths.log });
+    await sleep(400);
+  }
+
+  function finish(event) {
+    emit(event);
+    return event;
+  }
+}
+
+/** POST /api/server/shutdown on the loopback address: the server's own graceful stop. */
+export async function requestServerShutdown(port, { fetchImpl = globalThis.fetch } = {}) {
+  try {
+    const response = await fetchImpl(`http://127.0.0.1:${port}/api/server/shutdown`, {
+      method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}', signal: AbortSignal.timeout(3000),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/** Where the launcher writes its log for a data home (what "Open logs" shows). */
+export function launcherLogOf(dataHome) {
+  return join(dataHome, 'data', 'launcher.log');
+}

package/lib/external-tools.js

@@ -2,9 +2,13 @@
  * SynaBun — external tools stay external
  *
  * Claude Code, Codex, OpenCode and Gemini CLI are programs of their own. The
- * user installs them; SynaBun finds what is installed (PATH, Homebrew, npm, the
- * native installers' folders) and talks to it, through a thin JavaScript SDK
- * where there is one. It never installs, ships or runs a copy of its own.
+ * user installs them; SynaBun finds what is installed (Settings, PATH and the
+ * OS PATH, the folders of every install method:
+ * neural-interface/lib/cli-resolver.js) and talks to it, through a thin
+ * JavaScript SDK where there is one. It never ships or runs a copy of its own.
+ * When one is missing, the side panels can run its vendor's official installer
+ * on the user's click (neural-interface/lib/cli-install.js), which installs it
+ * where that installer always does, as the user's own.
  *
  * npm has no way to say "this SDK, without the program it carries": the Claude
  * Agent SDK brings the Claude Code executable as a per-platform optional

package/lib/log-redact.js

@@ -0,0 +1,102 @@
+/**
+ * SynaBun — secrets out of the install and start logs a person is shown
+ *
+ * What the setup wizard's Details (GET /api/setup/install-details) and the
+ * desktop app's start log show is what programs wrote: npm, the user's own
+ * npm, the supervisor and the server. Such output can carry a secret: npm
+ * prints an invalid setting with its value, an error names a URL with its
+ * password, a log line repeats a header or an environment variable. Before
+ * any of it is shown or kept, this takes out
+ *
+ *   - npm auth settings (`//registry…/:_authToken=…`, `_auth`, `_password`)
+ *   - the password in a URL (`https://user:pass@host`)
+ *   - Authorization, Proxy-Authorization, Cookie and API-key headers
+ *   - the token shapes of the usual services (OpenAI / Anthropic `sk-…`,
+ *     GitHub, GitLab, npm, Slack, AWS, Google, Stripe, JWTs, Bearer tokens,
+ *     private key blocks)
+ *   - the value of a variable or setting whose name says it is secret
+ *     (…TOKEN, …SECRET, …PASSWORD, …API_KEY, …CREDENTIALS, …)
+ *
+ * Each becomes [redacted]; the text around it stays. Redact before you cut a
+ * text short: half a secret no longer looks like one.
+ *
+ * No imports: packaging/desktop/src/log-redact.mjs is this file, byte for byte
+ * (the desktop window cannot reach the application's files), and
+ * packaging/tests/log-redact.test.mjs fails when the two differ.
+ */
+
+export const REDACTED = '[redacted]';
+
+// Names whose value is a secret: a word of the name (split on _ - .) is one of these, or it ends in one.
+const SECRET_WORDS = 'TOKEN|TOKENS|SECRET|SECRETS|PASSWORD|PASSWD|PASSPHRASE|PASS|PWD|CREDENTIAL|CREDENTIALS|APIKEY|AUTH|AUTHTOKEN|COOKIE|SESSIONID|SESSION|PRIVATEKEY|ACCESSKEY|SECRETKEY|CLIENTSECRET|SIGNATURE';
+const SECRET_NAME = new RegExp(`(?:^|[_.-])(?:${SECRET_WORDS})$|(?:^|[_.-])(?:${SECRET_WORDS})(?:[_.-])|(?:API|ACCESS|PRIVATE|SECRET|CLIENT|SIGNING|MASTER|ENCRYPTION|SERVICE)[_.-]?KEY(?:$|[_.-])`, 'i');
+// The shell's working folder variables are folders, not passwords.
+const NOT_SECRET = new Set(['PWD', 'OLDPWD', 'SSH_AUTH_SOCK', 'GIT_ASKPASS', 'SSH_ASKPASS', 'SUDO_ASKPASS']);
+
+/** Whether a variable or setting called `name` holds a secret. */
+export function isSecretName(name) {
+  const text = String(name || '').replace(/^[-_]+/, '');
+  if (!text || NOT_SECRET.has(text.toUpperCase())) return false;
+  // camelCase names (accessToken, apiKey) as words.
+  const words = text.replace(/([a-z0-9])([A-Z])/g, '$1_$2');
+  return SECRET_NAME.test(words) || /^(?:auth|password|token|secret)$/i.test(text);
+}
+
+const PATTERNS = [
+  // A private key block, whole (to the end of the text when its end is not in it yet: a log read in pieces).
+  [/-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY-----|$)/g, () => REDACTED],
+  // The rest of such a block in the next piece: its base64 lines (upper and lower case and digits, as key material
+  // has; a hex hash or a row of one letter is not) and its end line.
+  [/^(?=[A-Za-z0-9+/]*[A-Z])(?=[A-Za-z0-9+/]*[a-z])(?=[A-Za-z0-9+/]*[0-9])[A-Za-z0-9+/]{40,}={0,2}$/gm, () => REDACTED],
+  [/-----END [A-Z0-9 ]*PRIVATE KEY-----/g, () => REDACTED],
+  // npm's auth settings: `//registry.npmjs.org/:_authToken=…`, `_auth = …`, `:_password=…` (also as npm_config__auth…).
+  [/((?:\/\/[^\s=:]*(?::\d+)?[^\s=]*?:)?_(?:authToken|auth|password)\s*[=:]\s*)("[^"]*"|'[^']*'|[^\s"',;]+)/gi, (_, head, value) => {
+    const quote = /^["']/.test(value) ? value[0] : '';
+    return `${head}${quote}${REDACTED}${quote}`;
+  }],
+  // The password in a URL's user info.
+  [/\b([a-z][a-z0-9+.-]*:\/\/[^\s/?#@:'"<>]*):([^\s/?#@'"<>]+)@/gi, (_, head) => `${head}:${REDACTED}@`],
+  // Headers: the value to the end of the line.
+  [/(^|[\s"'{,(])((?:proxy-)?authorization|x-api-key|api-key|x-auth-token|x-access-token|cookie|set-cookie)(\s*["']?\s*[:=]\s*["']?)([^\r\n"']+)/gim, (_, lead, name, sep) => `${lead}${name}${sep}${REDACTED}`],
+  // Bearer / Basic / token schemes wherever they stand.
+  [/\b(Bearer|Basic|Token)\s+(?=[A-Za-z0-9._~+/=-]*[0-9+/=_-])[A-Za-z0-9._~+/=-]{12,}/g, (_, scheme) => `${scheme} ${REDACTED}`],
+  // Token shapes of the usual services.
+  [/\b(?:sk|rk|pk)[-_](?:live|test|proj|ant|or|api|svcacct|admin)?[-_]?[A-Za-z0-9_-]{16,}/g, () => REDACTED],
+  [/\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})/g, () => REDACTED],
+  [/\bglpat-[A-Za-z0-9_-]{16,}/g, () => REDACTED],
+  [/\bnpm_[A-Za-z0-9]{30,}/g, () => REDACTED],
+  [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, () => REDACTED],
+  [/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, () => REDACTED],
+  [/\bAIza[0-9A-Za-z_-]{30,}/g, () => REDACTED],
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, () => REDACTED],
+];
+
+// NAME=value, NAME: value, "NAME": "value", --name=value: the value when the name is a secret's.
+const ASSIGNMENT = /(^|[\s,;{(\[]|--)(["']?)([A-Za-z_][A-Za-z0-9_.-]*)\2(\s*[=:]\s*)(\[redacted\]|"[^"]*"|'[^']*'|[^\s"',;)}\]]+)/gm;
+
+/** `text` with every secret this file knows replaced by [redacted]. */
+export function redactSecrets(text) {
+  let out = String(text ?? '');
+  if (!out) return out;
+  for (const [pattern, replace] of PATTERNS) out = out.replace(pattern, replace);
+  out = out.replace(ASSIGNMENT, (whole, lead, quote, name, sep, value) => {
+    if (!isSecretName(name)) return whole;
+    const bare = value.replace(/^["']|["']$/g, '');
+    if (!bare || bare === REDACTED) return whole;
+    const q = /^["']/.test(value) ? value[0] : '';
+    return `${lead}${quote}${name}${quote}${sep}${q}${REDACTED}${q}`;
+  });
+  return out;
+}
+
+/** redactSecrets() over every string inside `value` (objects and arrays copied, at most `depth` levels). */
+export function redactDeep(value, depth = 8) {
+  if (typeof value === 'string') return redactSecrets(value);
+  if (!value || typeof value !== 'object' || depth <= 0) return value;
+  if (Array.isArray(value)) return value.map(item => redactDeep(item, depth - 1));
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    out[key] = isSecretName(key) && typeof item === 'string' && item ? REDACTED : redactDeep(item, depth - 1);
+  }
+  return out;
+}