synabun 1.3.0 → 2.0.0-beta

package/lib/first-launch-protection.js

@@ -0,0 +1,240 @@
+// The protection user state gets before a new SynaBun version runs for the
+// first time: a verified snapshot of the data home, taken by setup.js before
+// the server (and so any data migration) starts.
+//
+// The snapshot is a promise, so its failure stops the launch. setup.js exits
+// with SNAPSHOT_FAILED_EXIT_CODE and the message from describeSnapshotFailure();
+// there is no flag or environment variable to launch anyway. A fresh install
+// with no user state, and a launch of the version that already ran, need no
+// snapshot and are not affected.
+//
+// The launcher also leaves its stop message in the server's stderr log
+// (recordLauncherFailure), because a detached launch has no terminal: the
+// updater's relaunch reads it back to tell the user why SynaBun did not start.
+
+import { appendFileSync, existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { DATA_HOME_MANIFEST, dataHomeHasState } from './data-home-migration.js';
+
+/** setup.js exits with this when the pre-update snapshot could not be created. */
+export const SNAPSHOT_FAILED_EXIT_CODE = 3;
+
+/** First line of a launcher stop record. updater.mjs looks for the same text. */
+export const LAUNCHER_STOP_MARKER = '===== launcher stopped ';
+
+const noop = () => {};
+
+function readJson(path, fallback) {
+  try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return fallback; }
+}
+
+/**
+ * Why the snapshot an in-app update handed over cannot stand in for a fresh
+ * one, or null when it can. It can only when the updater recorded that it
+ * installed exactly the version now launching, and the archive still passes
+ * verification. A `prepared` update is not enough: its updater may never have
+ * run while the old server went on changing data.
+ */
+async function handoffSnapshotProblem({ handoff, version, backupService }) {
+  if (handoff.status !== 'installed') return 'that update was prepared but never recorded as installed';
+  if (typeof handoff.target !== 'string' || handoff.target !== version) return 'it belongs to an update to another version';
+  if (typeof handoff.snapshotPath !== 'string' || !handoff.snapshotPath) return 'it names no snapshot';
+  if (!existsSync(handoff.snapshotPath)) return 'its snapshot file is gone';
+  try {
+    const service = await backupService();
+    const archive = await service.verifyBackupArchive(handoff.snapshotPath);
+    if (archive?.kind !== 'pre-update') return 'its file is not a pre-update snapshot';
+  } catch (error) {
+    return `its snapshot did not pass verification (${error?.message || error})`;
+  }
+  return null;
+}
+
+/**
+ * Makes sure a verified snapshot exists before `version` runs on a data home
+ * that last ran another version (or that an in-app update just handed over).
+ *
+ * @param {object} input
+ * @param {string} input.dataHome
+ * @param {string} input.version  the version about to launch
+ * @param {() => Promise<{createVerifiedBackup: Function, verifyBackupArchive: Function, applyBackupRetention: Function}>} [input.loadBackupService]
+ * @param {{info?: Function, ok?: Function, warn?: Function}} [input.log]
+ * @returns {Promise<
+ *   {status: 'not-due', reason: 'current-version' | 'no-state'} |
+ *   {status: 'protected', snapshotPath: string, created: boolean, recorded: boolean} |
+ *   {status: 'failed', error: Error, previousVersion: string|null, backupFolder: string}
+ * >} `failed` means no snapshot exists: the caller must not start the server.
+ */
+export async function protectFirstLaunchAfterUpdate({
+  dataHome,
+  version,
+  loadBackupService = () => import('../neural-interface/lib/backup-service.js'),
+  log = {},
+} = {}) {
+  const info = log.info || noop;
+  const ok = log.ok || noop;
+  const warn = log.warn || noop;
+
+  const manifestPath = resolve(dataHome, DATA_HOME_MANIFEST);
+  const handoffPath = resolve(dataHome, 'data', 'update-handoff.json');
+  const manifest = readJson(manifestPath, {}) || {};
+  const handoff = readJson(handoffPath, null);
+  const pendingHandoff = !!handoff && ['prepared', 'installed'].includes(handoff.status);
+  if (manifest.lastAppVersion === version && !pendingHandoff) return { status: 'not-due', reason: 'current-version' };
+  if (!dataHomeHasState(dataHome)) return { status: 'not-due', reason: 'no-state' };
+
+  let loaded = null;
+  const backupService = async () => (loaded ||= await loadBackupService());
+
+  // An in-app update takes the snapshot before it replaces the code. It is
+  // reused only when it is provably the snapshot for this launch.
+  let snapshotPath = null;
+  if (pendingHandoff) {
+    info('Checking the snapshot taken by the updater...');
+    const problem = await handoffSnapshotProblem({ handoff, version, backupService });
+    if (problem) info(`The updater's snapshot is not used: ${problem}. Taking a new one.`);
+    else {
+      snapshotPath = handoff.snapshotPath;
+      ok('Verified the snapshot taken by the updater');
+    }
+  }
+  const created = !snapshotPath;
+
+  if (!snapshotPath) {
+    const folderPath = resolve(dataHome, 'backups', 'updates');
+    let service;
+    try {
+      info(`Protecting user state before first launch of v${version}...`);
+      service = await backupService();
+      const snapshot = await service.createVerifiedBackup({
+        dataHome,
+        databasePath: resolve(dataHome, 'mcp-data', 'memory.db'),
+        folderPath,
+        kind: 'pre-update',
+        appVersion: manifest.lastAppVersion || null,
+        // Without this the checksum and archive phases run silently for minutes
+        // on a large data home, which users read as a hang and kill.
+        onProgress: ({ phase, files, bytes, skippedFiles, skippedBytes }) => {
+          const size = bytes ? ` (${(bytes / 1024 / 1024).toFixed(0)} MB)` : '';
+          if (phase === 'collect') {
+            info(`  ${files} files to protect${size}`);
+            if (skippedFiles) {
+              info(`  Skipping ${skippedFiles} generated media files (${(skippedBytes / 1024 / 1024).toFixed(0)} MB) — an upgrade never touches them`);
+            }
+          } else if (phase === 'checksum') info(`  Checksumming ${files} files...`);
+          else if (phase === 'archive') info(`  Compressing${size}...`);
+          else if (phase === 'verify') info('  Verifying archive integrity...');
+        },
+      });
+      snapshotPath = snapshot.path;
+      ok(`Verified upgrade snapshot: ${snapshot.name}`);
+    } catch (error) {
+      return {
+        status: 'failed',
+        error: error instanceof Error ? error : new Error(String(error)),
+        // The version to go back to: what the in-app update replaced, else what
+        // last ran on this data home. Never the version being launched.
+        previousVersion: [pendingHandoff ? handoff.current : null, manifest.lastAppVersion]
+          .find(value => typeof value === 'string' && value && value !== version) || null,
+        backupFolder: folderPath,
+      };
+    }
+    // The snapshot exists and is verified. Pruning older ones is housekeeping.
+    try { service.applyBackupRetention({ folderPath }); } catch (error) {
+      warn(`Could not prune older upgrade snapshots: ${error.message}`);
+    }
+  }
+
+  // Record the protected launch. The snapshot is already safe, so a failure
+  // here does not stop the launch: the next one takes a snapshot again.
+  try {
+    const nextManifest = {
+      version: 1,
+      installationId: manifest.installationId || `${Date.now()}-${process.pid}`,
+      dataSchemaVersion: manifest.dataSchemaVersion || 1,
+      ...manifest,
+      lastAppVersion: version,
+      lastUpgradeVerifiedAt: new Date().toISOString(),
+      lastUpgradeSnapshot: snapshotPath,
+    };
+    const manifestTemp = `${manifestPath}.${process.pid}.tmp`;
+    writeFileSync(manifestTemp, JSON.stringify(nextManifest, null, 2) + '\n', 'utf-8');
+    renameSync(manifestTemp, manifestPath);
+
+    if (pendingHandoff) {
+      // Closed either way: a handoff whose snapshot was not used is superseded
+      // by the one taken here.
+      writeFileSync(handoffPath, JSON.stringify({
+        ...handoff,
+        status: 'verified',
+        verifiedAt: new Date().toISOString(),
+        launchedVersion: version,
+        snapshotPath,
+        snapshotReused: !created,
+      }, null, 2) + '\n', 'utf-8');
+    }
+  } catch (error) {
+    warn(`The upgrade snapshot is safe at ${snapshotPath}, but recording it failed: ${error.message}`);
+    info('A new snapshot will be taken at the next launch.');
+    return { status: 'protected', snapshotPath, created, recorded: false };
+  }
+  return { status: 'protected', snapshotPath, created, recorded: true };
+}
+
+/**
+ * What to tell the user when the snapshot failed: what failed, what state the
+ * data is in, where it is, and the two ways forward.
+ * @returns {{headline: string, lines: string[]}}
+ */
+export function describeSnapshotFailure({ error, dataHome, version, previousVersion = null, backupFolder = null } = {}) {
+  const folder = backupFolder || resolve(dataHome, 'backups', 'updates');
+  // Without a recorded previous version (a data home older than the record, or
+  // one this version has not recorded yet) there may be nothing to go back to.
+  const goBack = previousVersion
+    ? `Or go back to the version you had: npm i -g synabun@${previousVersion}`
+    : 'Or, if you just updated, go back to the version you had: npm i -g synabun@<that version>';
+  return {
+    headline: `SynaBun v${version} did not start: the snapshot that protects your data before this version runs on it for the first time could not be created.`,
+    lines: [
+      `What failed: ${error?.message || 'unknown error'}`,
+      // Only what is true of the whole launch: an earlier step may have copied
+      // data from an old checkout into the data home (a verified copy; the
+      // source is kept), so "nothing was changed" would say too much.
+      `The server was not started, so v${version} has not converted or deleted any of your memories or settings.`,
+      `Data home: ${dataHome}`,
+      `Snapshot folder: ${folder}`,
+      `To continue: free disk space or fix the permissions of the snapshot folder, then run "synabun" again.`,
+      goBack,
+      'Run "synabun doctor" to inspect the data home.',
+    ],
+  };
+}
+
+/** Where the launcher leaves its stop message: the log the server's stderr goes to. */
+export function launcherLogPath(dataHome) {
+  return resolve(dataHome, 'data', 'server-stderr.log');
+}
+
+/**
+ * Appends why the launcher stopped to launcherLogPath(). Best effort and never
+ * throws: the disk may be the reason for the stop. It creates no folder, so a
+ * data home that does not exist yet stays that way.
+ * @returns {string|null} the log path when the record was written
+ */
+export function recordLauncherFailure({ dataHome, exitCode, headline, lines = [], now = () => new Date() } = {}) {
+  try {
+    if (!dataHome || !existsSync(resolve(dataHome, 'data'))) return null;
+    const path = launcherLogPath(dataHome);
+    const record = [
+      '',
+      `${LAUNCHER_STOP_MARKER}${now().toISOString()} (pid ${process.pid}, exit ${exitCode}) =====`,
+      headline,
+      ...lines,
+      '',
+    ].join('\n');
+    appendFileSync(path, record, 'utf-8');
+    return path;
+  } catch {
+    return null;
+  }
+}

package/lib/paths.d.ts

@@ -0,0 +1,21 @@
+export interface DataHomeOptions {
+  env?: NodeJS.ProcessEnv;
+  home?: string;
+  os?: NodeJS.Platform;
+}
+
+export interface DataHomeDiagnostics {
+  dataHome: string;
+  packageRoot: string;
+  explicitOverride: boolean;
+  dataHomeInsidePackage: boolean;
+  recommendedDataHome: string;
+}
+
+export const PACKAGE_ROOT: string;
+export function isGlobalInstall(): boolean;
+export function getPlatformDataHome(options?: DataHomeOptions): string;
+export function getDataHome(options?: DataHomeOptions): string;
+export function pathIsInside(candidate: string, parent: string): boolean;
+export function getDataHomeDiagnostics(dataHome?: string, packageRoot?: string, options?: DataHomeOptions): DataHomeDiagnostics;
+export function ensureDataDirs(dataHome: string): void;

package/lib/paths.js

@@ -0,0 +1,103 @@
+/**
+ * SynaBun — Shared path resolution
+ *
+ * Separates CODE paths (global npm package) from DATA paths (user-specific).
+ * All consumers import from here to ensure consistent path resolution.
+ */
+
+import { resolve, dirname, relative, isAbsolute, win32 } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mkdirSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Root of the SynaBun package (where code lives).
+ * In global install: /path/to/node_modules/synabun
+ * In dev mode: the repo root
+ */
+export const PACKAGE_ROOT = resolve(__dirname, '..');
+
+/**
+ * Detect if running from a global npm install.
+ */
+export function isGlobalInstall() {
+  return PACKAGE_ROOT.replace(/\\/g, '/').includes('/node_modules/synabun');
+}
+
+/**
+ * Platform-owned location for mutable SynaBun state.
+ *
+ * Code and user data must not share a Git worktree: ignored runtime files can
+ * be silently removed by repository cleanup commands. Keep this helper free of
+ * filesystem side effects so setup/migration code can safely inspect it.
+ */
+export function getPlatformDataHome({
+  env = process.env,
+  home = homedir(),
+  os = platform(),
+} = {}) {
+  if (os === 'win32' && env.APPDATA) return win32.resolve(env.APPDATA, 'synabun');
+  return resolve(home, '.synabun');
+}
+
+/**
+ * Resolve the user's data home directory.
+ *
+ * Priority:
+ * 1. SYNABUN_DATA_HOME env var (explicit override)
+ * 2. Platform default (~/.synabun, %APPDATA%/synabun)
+ *
+ * Development builds intentionally use the same platform-owned default. This
+ * prevents branch switches and `git clean` from touching live user state.
+ */
+export function getDataHome({ env = process.env, home = homedir(), os = platform() } = {}) {
+  if (env.SYNABUN_DATA_HOME) {
+    return resolve(env.SYNABUN_DATA_HOME);
+  }
+  return getPlatformDataHome({ env, home, os });
+}
+
+export function pathIsInside(candidate, parent) {
+  const rel = relative(resolve(parent), resolve(candidate));
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+export function getDataHomeDiagnostics(
+  dataHome = getDataHome(),
+  packageRoot = PACKAGE_ROOT,
+  { env = process.env, home = homedir(), os = platform() } = {},
+) {
+  const resolvedDataHome = resolve(dataHome);
+  const resolvedPackageRoot = resolve(packageRoot);
+  return {
+    dataHome: resolvedDataHome,
+    packageRoot: resolvedPackageRoot,
+    explicitOverride: !!env.SYNABUN_DATA_HOME,
+    dataHomeInsidePackage: pathIsInside(resolvedDataHome, resolvedPackageRoot),
+    recommendedDataHome: getPlatformDataHome({ env, home, os }),
+  };
+}
+
+/**
+ * Create the data directory structure if it doesn't exist.
+ * Safe to call on every startup (idempotent).
+ */
+export function ensureDataDirs(dataHome) {
+  const dirs = [
+    resolve(dataHome, 'data'),
+    resolve(dataHome, 'data', 'images'),
+    resolve(dataHome, 'data', 'custom-icons'),
+    resolve(dataHome, 'data', 'pending-remember'),
+    resolve(dataHome, 'data', 'pending-compact'),
+    resolve(dataHome, 'data', 'loop'),
+    resolve(dataHome, 'data', 'plans'),
+    resolve(dataHome, 'data', 'browser-profiles'),
+    resolve(dataHome, 'mcp-data'),
+  ];
+
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+}

package/mcp-server/dist/config.d.ts

@@ -0,0 +1,22 @@
+export declare const config: {
+    readonly dataHome: string;
+    readonly dataDir: string;
+    readonly sqlite: {
+        readonly dbPath: string;
+    };
+    readonly embedding: {
+        readonly model: "Xenova/all-MiniLM-L6-v2";
+        readonly dimensions: 384;
+    };
+};
+export declare function getEnvPath(): string;
+export declare function detectProject(cwd?: string): string;
+/**
+ * The registered root directory of a project label (or one of its aliases),
+ * or null. Relative `related_files` are relative to this, not to whichever
+ * process happens to read them — over HTTP that is the Neural Interface.
+ */
+export declare function projectRoot(project: string | null | undefined): string | null;
+/** Resolve labels without changing the historic spelling on stored records. */
+export declare function projectAliases(project: string): string[];
+//# sourceMappingURL=config.d.ts.map

package/mcp-server/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,MAAM;;;;;;;;;;CAUT,CAAC;AAIX,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AA4BD,wBAAgB,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAkClD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQ7E;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CASxD"}

package/mcp-server/dist/config.js

@@ -0,0 +1,109 @@
+import path from 'path';
+import fs from 'fs';
+import { getDataHome } from '../../lib/paths.js';
+import { isHttpMode, callerMemoryContext } from './services/identity.js';
+const dataHome = getDataHome();
+// --- Static config ---
+export const config = {
+    dataHome,
+    dataDir: process.env.MEMORY_DATA_DIR || path.resolve(dataHome, 'mcp-data'),
+    sqlite: {
+        dbPath: process.env.SQLITE_DB_PATH || '', // resolved lazily from dataDir
+    },
+    embedding: {
+        model: 'Xenova/all-MiniLM-L6-v2',
+        dimensions: 384,
+    },
+};
+// --- .env path resolution (for file watching) ---
+export function getEnvPath() {
+    return process.env.DOTENV_PATH || path.resolve(dataHome, '.env');
+}
+// --- Project Detection (reads from claude-code-projects.json) ---
+// The project registry lives under <dataHome>/data/, NOT config.dataDir
+// (<dataHome>/mcp-data/). It is written there by neural-interface/server.js and
+// read from there by hooks/claude-code/shared.mjs. Pointing at dataDir meant the
+// file never existed, loadRegisteredProjects() always returned [], and
+// detectProject() silently fell through to a raw directory basename — ignoring
+// every registered project label.
+const PROJECTS_PATH = path.resolve(dataHome, 'data', 'claude-code-projects.json');
+function loadRegisteredProjects() {
+    try {
+        if (!fs.existsSync(PROJECTS_PATH))
+            return [];
+        return JSON.parse(fs.readFileSync(PROJECTS_PATH, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeLabel(label) {
+    return label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+export function detectProject(cwd) {
+    if (!cwd && callerMemoryContext().project)
+        return callerMemoryContext().project;
+    // Over HTTP every caller shares the Neural Interface process, so process.cwd()
+    // is the server's directory, not the caller's — it labeled every memory
+    // "neural-interface" regardless of where the client actually was. Return a
+    // neutral bucket instead of a confident wrong answer: "global" is a mislabel
+    // you can find and fix, "neural-interface" is indistinguishable from a real one.
+    if (!cwd && isHttpMode())
+        return 'global';
+    const dir = cwd || process.cwd();
+    const lower = dir.toLowerCase().replace(/\\/g, '/');
+    const projects = loadRegisteredProjects();
+    // Sort by path length descending — most specific match wins
+    const sorted = projects
+        .map((p) => ({
+        path: p.path.toLowerCase().replace(/\\/g, '/'),
+        label: normalizeLabel(p.label),
+    }))
+        .sort((a, b) => b.path.length - a.path.length);
+    // 1. Exact path prefix match (cwd is inside a registered project)
+    for (const p of sorted) {
+        if (lower.startsWith(p.path + '/') || lower === p.path)
+            return p.label;
+    }
+    // 2. Substring match — cwd folder name contains a registered project's folder name
+    for (const p of sorted) {
+        const projFolder = path.basename(p.path).toLowerCase();
+        if (lower.includes(projFolder))
+            return p.label;
+    }
+    // 3. Fallback to directory basename
+    const base = path.basename(dir).toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    return base || 'global';
+}
+/**
+ * The registered root directory of a project label (or one of its aliases),
+ * or null. Relative `related_files` are relative to this, not to whichever
+ * process happens to read them — over HTTP that is the Neural Interface.
+ */
+export function projectRoot(project) {
+    if (!project)
+        return null;
+    const normalized = normalizeLabel(project);
+    for (const p of loadRegisteredProjects()) {
+        if (!p?.path)
+            continue;
+        if (p.label?.toLowerCase() === project.toLowerCase() || (normalized && (normalizeLabel(p.label ?? '') === normalized || normalizeLabel(path.basename(p.path)) === normalized)))
+            return p.path;
+    }
+    return null;
+}
+/** Resolve labels without changing the historic spelling on stored records. */
+export function projectAliases(project) {
+    const normalized = normalizeLabel(project);
+    const aliases = new Set([project, normalized].filter(Boolean));
+    for (const p of loadRegisteredProjects()) {
+        if (p.label.toLowerCase() === project.toLowerCase() || (normalized && (normalizeLabel(p.label) === normalized || normalizeLabel(path.basename(p.path)) === normalized))) {
+            aliases.add(p.label);
+            if (normalizeLabel(p.label))
+                aliases.add(normalizeLabel(p.label));
+            aliases.add(path.basename(p.path));
+        }
+    }
+    return [...aliases];
+}
+//# sourceMappingURL=config.js.map

package/mcp-server/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/mcp-server/dist/http.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * HTTP transport for SynaBun MCP server.
+ *
+ * STATEFUL: each MCP client (a Claude Code process — CLI window, sidepanel
+ * chat, loop) performs an initialize handshake and receives a unique
+ * Mcp-Session-Id, which it echoes on every subsequent request. That id — or
+ * an explicit X-Synabun-Terminal header injected at launch (loops, sidepanel)
+ * — becomes the caller's identity for browser session/tab isolation. Every
+ * transport.handleRequest call runs inside an AsyncLocalStorage identity
+ * context so neural-interface.ts resolves per-caller state instead of
+ * process-global state (the old stateless mode collapsed every HTTP caller
+ * into one identity → cross-automation tab collisions).
+ *
+ * Mount on any Express app or run standalone.
+ */
+import { type Router } from 'express';
+/**
+ * Initialize DB, categories, and warm up the embedding model.
+ * Safe to call multiple times — only runs once.
+ * Exported so the Neural Interface can eagerly init at startup.
+ */
+export declare function ensureInit(): Promise<void>;
+/**
+ * Create Express routes for the MCP HTTP endpoint.
+ * Auth is handled externally (URL-embedded key in server.js).
+ * Can be mounted on an existing Express app: app.use('/mcp', createMcpRoutes());
+ */
+export declare function createMcpRoutes(): Router;
+//# sourceMappingURL=http.d.ts.map

package/mcp-server/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;GAcG;AAGH,OAAgB,EAAgB,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAyH7D;;;;GAIG;AACH,wBAAsB,UAAU,kBAU/B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,MAAM,CA0GxC"}