@logicseek/hello-cc 0.1.4 → 0.1.6

package/lib/core/sessions/launch.mjs

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { shortHash } from '../peers/format.mjs';
+
+export const WEB_CHILD_ENV = 'HCC_WEB_CHILD';
+export const LAUNCH_FINGERPRINT_ENV = 'HCC_LAUNCH_FINGERPRINT';
+export const PROVIDER_STATE_ENV = 'HCC_PROVIDER_STATE';
+
+const LAUNCH_ENV_IGNORED_KEYS = new Set([
+  '_',
+  'COLUMNS',
+  'HCC_DB',
+  'HCC_NO_AUTO_INSTALL_TMUX',
+  'HCC_PEER',
+  'HCC_ROOT',
+  PROVIDER_STATE_ENV,
+  'HCC_SHIM_ENSURED',
+  'HCC_SHIM_NO_ATTACH',
+  'HCC_WEB_TOKEN',
+  LAUNCH_FINGERPRINT_ENV,
+  'LINES',
+  'OLDPWD',
+  'PROMPT_COMMAND',
+  'PS1',
+  'PS2',
+  'PS4',
+  'PWD',
+  'SHLVL',
+  'TERM',
+  'TERMCAP',
+  'TMUX',
+  'TMUX_PANE',
+  'WINDOWID'
+]);
+
+export function childSessionEnv(extra = {}, baseEnv = process.env) {
+  const env = { ...(baseEnv || {}), ...extra };
+  delete env[WEB_CHILD_ENV];
+  return env;
+}
+
+export function launchEnvironmentFingerprint(env) {
+  const entries = Object.entries(env || {})
+    .filter(([key, value]) =>
+      value !== undefined &&
+      value !== null &&
+      !LAUNCH_ENV_IGNORED_KEYS.has(key) &&
+      /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)
+    )
+    .map(([key, value]) => [key, String(value)])
+    .sort(([a], [b]) => a.localeCompare(b));
+  return shortHash(JSON.stringify(entries));
+}
+
+export function launchFingerprint({ command, cwd, env }) {
+  return shortHash(JSON.stringify({
+    command: command || '',
+    cwd: cwd || '',
+    env: launchEnvironmentFingerprint(env || {})
+  }));
+}
+
+export function isLikelyShellCommand(command) {
+  const base = path.basename(String(command || '')).replace(/^-/, '');
+  return new Set(['bash', 'dash', 'fish', 'ksh', 'mksh', 'sh', 'zsh']).has(base);
+}
+
+export function isProviderFallbackWrapper(command) {
+  const text = String(command || '');
+  return text.includes(PROVIDER_STATE_ENV) || /\bexec\s+(?:bash|dash|fish|ksh|mksh|sh|zsh)\b/.test(text);
+}
+
+export function isRelaunchableProviderSession(kind, command, binding = {}) {
+  const provider = binding.provider || kind;
+  return ['claude', 'codex'].includes(provider) && isProviderFallbackWrapper(command);
+}
+
+export function isolatedEnvCommandArgs(env) {
+  const envBin = fs.existsSync('/usr/bin/env') ? '/usr/bin/env' : 'env';
+  const args = [envBin, '-i'];
+  for (const [key, value] of Object.entries(env || {})) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    if (['TMUX', 'TMUX_PANE'].includes(key)) continue;
+    if (value === undefined || value === null) continue;
+    args.push(`${key}=${String(value)}`);
+  }
+  return args;
+}

package/lib/db/schema.mjs

@@ -0,0 +1,324 @@
+import { CliError } from '../shared/errors.mjs';
+
+export const DB_SCHEMA_VERSION = 5;
+
+const sleepBuffer = new SharedArrayBuffer(4);
+const sleepView = new Int32Array(sleepBuffer);
+
+function now() {
+  return Math.floor(Date.now() / 1000);
+}
+
+function sleepSync(ms) {
+  Atomics.wait(sleepView, 0, 0, ms);
+}
+
+function isSqliteBusy(err) {
+  const text = `${err?.code || ''} ${err?.message || ''} ${err?.errstr || ''}`;
+  return err?.errcode === 5 ||
+    err?.errcode === 6 ||
+    err?.errcode === 261 ||
+    /SQLITE_BUSY|SQLITE_LOCKED|database is locked|database is busy/i.test(text);
+}
+
+export function execWithBusyRetry(db, sql, { attempts = 30, delayMs = 100, ignoreBusy = false } = {}) {
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      db.exec(sql);
+      return true;
+    } catch (err) {
+      if (!isSqliteBusy(err)) throw err;
+      if (attempt === attempts - 1) {
+        if (ignoreBusy) return false;
+        throw err;
+      }
+      sleepSync(delayMs);
+    }
+  }
+  return false;
+}
+
+export function tx(db, fn) {
+  execWithBusyRetry(db, 'BEGIN IMMEDIATE;');
+  try {
+    const result = fn();
+    db.exec('COMMIT;');
+    return result;
+  } catch (err) {
+    try {
+      db.exec('ROLLBACK;');
+    } catch {
+      // Ignore rollback failures; the original error is more useful.
+    }
+    throw err;
+  }
+}
+
+export function initSchema(db, { beforePostMigrationIndexes = null } = {}) {
+  const existingVersion = readSchemaVersion(db);
+  if (existingVersion > DB_SCHEMA_VERSION) {
+    throw new CliError('DB_SCHEMA_TOO_NEW', `Database schema version ${existingVersion} is newer than this hcc (${DB_SCHEMA_VERSION})`, {
+      db_schema_version: existingVersion,
+      supported_schema_version: DB_SCHEMA_VERSION
+    });
+  }
+  createBaseSchema(db);
+  runSchemaMigrations(db);
+  if (typeof beforePostMigrationIndexes === 'function') beforePostMigrationIndexes(db);
+  createPostMigrationIndexes(db);
+}
+
+function createBaseSchema(db) {
+  execWithBusyRetry(db, `
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS peers (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL,
+      role TEXT,
+      worktree TEXT,
+      branch TEXT,
+      pid INTEGER,
+      status TEXT NOT NULL DEFAULT 'idle',
+      capabilities TEXT,
+      created_at INTEGER NOT NULL,
+      last_seen_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS peer_bindings (
+      peer TEXT PRIMARY KEY,
+      provider TEXT NOT NULL,
+      provider_session_id TEXT,
+      provider_session_name TEXT,
+      resume_mode TEXT NOT NULL DEFAULT 'new',
+      resume_arg TEXT,
+      command TEXT,
+      transport TEXT NOT NULL,
+      runtime_session_id TEXT,
+      runtime_target TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (peer) REFERENCES peers(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      body TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      assignee TEXT,
+      owner TEXT,
+      parent_id INTEGER,
+      team_role TEXT,
+      priority INTEGER NOT NULL DEFAULT 100,
+      created_by TEXT,
+      claimed_at INTEGER,
+      completed_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      sender TEXT NOT NULL,
+      recipient TEXT,
+      task_id INTEGER,
+      kind TEXT NOT NULL DEFAULT 'note',
+      body TEXT NOT NULL,
+      reply_to INTEGER,
+      thread_id INTEGER,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS message_reads (
+      message_id INTEGER NOT NULL,
+      peer TEXT NOT NULL,
+      read_at INTEGER NOT NULL,
+      PRIMARY KEY (message_id, peer),
+      FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS locks (
+      resource TEXT PRIMARY KEY,
+      base_resource TEXT,
+      scope TEXT NOT NULL DEFAULT '*',
+      owner TEXT NOT NULL,
+      task_id INTEGER,
+      reason TEXT,
+      expires_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS handoffs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER,
+      from_peer TEXT NOT NULL,
+      to_peer TEXT,
+      summary TEXT NOT NULL,
+      changed_files TEXT,
+      tests TEXT,
+      risks TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      actor TEXT,
+      task_id INTEGER,
+      payload TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_status_priority ON tasks(status, priority, id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_owner ON tasks(owner);
+    CREATE INDEX IF NOT EXISTS idx_messages_recipient_id ON messages(recipient, id);
+    CREATE INDEX IF NOT EXISTS idx_events_id ON events(id);
+    CREATE INDEX IF NOT EXISTS idx_locks_expires ON locks(expires_at);
+  `);
+}
+
+function createPostMigrationIndexes(db) {
+  execWithBusyRetry(db, `
+    CREATE INDEX IF NOT EXISTS idx_peer_bindings_provider_session ON peer_bindings(provider, provider_session_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_provider_session_id_unique
+      ON peer_bindings(provider, provider_session_id)
+      WHERE provider_session_id IS NOT NULL;
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_provider_session_name_unique
+      ON peer_bindings(provider, provider_session_name)
+      WHERE provider_session_name IS NOT NULL;
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_runtime_target_unique
+      ON peer_bindings(runtime_target)
+      WHERE runtime_target IS NOT NULL;
+  `);
+}
+
+function tableColumns(db, tableName) {
+  return new Set(db.prepare(`PRAGMA table_info(${tableName})`).all().map((col) => col.name));
+}
+
+function tableExists(db, tableName) {
+  return Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1").get(tableName));
+}
+
+export function readSchemaVersion(db) {
+  const metaExists = tableExists(db, 'meta');
+  const metaVersion = metaExists ? Number(db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value || 0) : 0;
+  const pragmaVersion = Number(db.prepare('PRAGMA user_version').get()?.user_version || 0);
+  const migrationVersion = tableExists(db, 'schema_migrations')
+    ? Number(db.prepare('SELECT MAX(version) AS version FROM schema_migrations').get()?.version || 0)
+    : 0;
+  return Math.max(metaVersion, pragmaVersion, migrationVersion);
+}
+
+function writeSchemaVersion(db, version) {
+  db.prepare(`
+    INSERT INTO meta(key, value) VALUES ('schema_version', ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(String(version));
+  db.exec(`PRAGMA user_version = ${Number(version)}`);
+}
+
+function recordSchemaMigration(db, version, name) {
+  db.prepare(`
+    INSERT INTO schema_migrations(version, name, applied_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(version) DO NOTHING
+  `).run(version, name, now());
+}
+
+function addColumnIfMissing(db, tableName, columnName, ddl) {
+  const columns = tableColumns(db, tableName);
+  if (!columns.has(columnName)) db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${ddl}`);
+}
+
+function runSchemaMigrations(db) {
+  const migrations = [
+    {
+      version: 1,
+      name: 'baseline',
+      up() {
+        // createBaseSchema already created the baseline tables.
+      }
+    },
+    {
+      version: 2,
+      name: 'peer binding runtime targets',
+      up(database) {
+        addColumnIfMissing(database, 'peer_bindings', 'runtime_target', 'runtime_target TEXT');
+      }
+    },
+    {
+      version: 3,
+      name: 'threaded messages',
+      up(database) {
+        addColumnIfMissing(database, 'messages', 'reply_to', 'reply_to INTEGER');
+        addColumnIfMissing(database, 'messages', 'thread_id', 'thread_id INTEGER');
+        database.exec(`
+          UPDATE messages SET thread_id = id WHERE thread_id IS NULL;
+          CREATE INDEX IF NOT EXISTS idx_messages_thread_id ON messages(thread_id, id);
+        `);
+      }
+    },
+    {
+      version: 4,
+      name: 'team task hierarchy',
+      up(database) {
+        addColumnIfMissing(database, 'tasks', 'parent_id', 'parent_id INTEGER');
+        addColumnIfMissing(database, 'tasks', 'team_role', 'team_role TEXT');
+        database.exec('CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id, priority, id);');
+      }
+    },
+    {
+      version: 5,
+      name: 'scoped advisory locks',
+      up(database) {
+        addColumnIfMissing(database, 'locks', 'base_resource', 'base_resource TEXT');
+        addColumnIfMissing(database, 'locks', 'scope', "scope TEXT NOT NULL DEFAULT '*'");
+        database.exec(`
+          UPDATE locks
+          SET base_resource = resource
+          WHERE base_resource IS NULL OR base_resource = '';
+          UPDATE locks
+          SET scope = '*'
+          WHERE scope IS NULL OR scope = '';
+          CREATE INDEX IF NOT EXISTS idx_locks_base_scope ON locks(base_resource, scope);
+        `);
+      }
+    }
+  ];
+  let version = readSchemaVersion(db);
+  if (version > DB_SCHEMA_VERSION) {
+    throw new CliError('DB_SCHEMA_TOO_NEW', `Database schema version ${version} is newer than this hcc (${DB_SCHEMA_VERSION})`, {
+      db_schema_version: version,
+      supported_schema_version: DB_SCHEMA_VERSION
+    });
+  }
+  const applied = new Set(db.prepare('SELECT version FROM schema_migrations').all().map((row) => Number(row.version)));
+  tx(db, () => {
+    for (const migration of migrations) {
+      if (version >= migration.version && applied.has(migration.version)) continue;
+      migration.up(db);
+      recordSchemaMigration(db, migration.version, migration.name);
+      applied.add(migration.version);
+      version = migration.version;
+      writeSchemaVersion(db, version);
+    }
+    if (version === 0) {
+      version = DB_SCHEMA_VERSION;
+    }
+    for (const migration of migrations) {
+      if (migration.version <= version) recordSchemaMigration(db, migration.version, migration.name);
+    }
+    writeSchemaVersion(db, version);
+  });
+}

package/lib/db/stores/peers.mjs

@@ -0,0 +1,231 @@
+import { CliError } from '../../shared/errors.mjs';
+import {
+  bindingHasProviderSession,
+  bindingHasRuntime,
+  bindingProviderSessionValue,
+  comparePeerBindings,
+  mergePeerBinding,
+  mergeRuntimeBinding
+} from '../../core/peers/bindings.mjs';
+
+function defaultNow() {
+  return Math.floor(Date.now() / 1000);
+}
+
+function noopEvent() {}
+
+export function createPeerBindingStore(deps = {}) {
+  const now = typeof deps.now === 'function' ? deps.now : defaultNow;
+  const addEvent = typeof deps.addEvent === 'function' ? deps.addEvent : noopEvent;
+
+  function dedupePeerBindingRows(db, rows, eventType, payload = {}) {
+    if (!rows || rows.length < 2) return 0;
+    const ordered = [...rows].sort(comparePeerBindings);
+    const survivor = ordered[0];
+    let deleted = 0;
+    for (const row of ordered.slice(1)) {
+      db.prepare('DELETE FROM peer_bindings WHERE peer = ?').run(row.peer);
+      deleted += 1;
+      addEvent(db, eventType, survivor.peer, null, {
+        ...payload,
+        kept_peer: survivor.peer,
+        removed_peer: row.peer,
+        removed_transport: row.transport || null,
+        removed_runtime_target: row.runtime_target || null
+      });
+    }
+    return deleted;
+  }
+
+  function dedupeProviderSessionColumn(db, column) {
+    const groups = db.prepare(`
+      SELECT provider, ${column} AS session_value
+      FROM peer_bindings
+      WHERE ${column} IS NOT NULL
+      GROUP BY provider, ${column}
+      HAVING COUNT(*) > 1
+    `).all();
+    let deleted = 0;
+    for (const group of groups) {
+      const rows = db.prepare(`
+        SELECT *
+        FROM peer_bindings
+        WHERE provider = ? AND ${column} = ?
+      `).all(group.provider, group.session_value);
+      deleted += dedupePeerBindingRows(db, rows, 'provider.session.deduped', {
+        provider: group.provider,
+        provider_session: group.session_value,
+        provider_session_column: column
+      });
+    }
+    return deleted;
+  }
+
+  function dedupeRuntimeTargets(db) {
+    const groups = db.prepare(`
+      SELECT runtime_target
+      FROM peer_bindings
+      WHERE runtime_target IS NOT NULL
+      GROUP BY runtime_target
+      HAVING COUNT(*) > 1
+    `).all();
+    let deleted = 0;
+    for (const group of groups) {
+      const rows = db.prepare(`
+        SELECT *
+        FROM peer_bindings
+        WHERE runtime_target = ?
+      `).all(group.runtime_target);
+      deleted += dedupePeerBindingRows(db, rows, 'runtime.target.deduped', {
+        runtime_target: group.runtime_target
+      });
+    }
+    return deleted;
+  }
+
+  function dedupePeerBindings(db) {
+    for (let i = 0; i < 5; i += 1) {
+      const deleted =
+        dedupeProviderSessionColumn(db, 'provider_session_id') +
+        dedupeProviderSessionColumn(db, 'provider_session_name') +
+        dedupeRuntimeTargets(db);
+      if (!deleted) return;
+    }
+  }
+
+  function findProviderSessionBinding(db, binding) {
+    if (!bindingHasProviderSession(binding)) return null;
+    return db.prepare(`
+      SELECT *
+      FROM peer_bindings
+      WHERE provider = ?
+        AND peer <> ?
+        AND (
+          (? IS NOT NULL AND provider_session_id = ?)
+          OR (? IS NOT NULL AND provider_session_name = ?)
+        )
+      LIMIT 1
+    `).get(
+      binding.provider,
+      binding.peer,
+      binding.provider_session_id || null,
+      binding.provider_session_id || null,
+      binding.provider_session_name || null,
+      binding.provider_session_name || null
+    ) || null;
+  }
+
+  function canonicalizePeerBinding(db, binding, options = {}) {
+    const existing = db.prepare('SELECT * FROM peer_bindings WHERE peer = ?').get(binding.peer);
+    let next = mergePeerBinding(existing, binding);
+    const conflict = findProviderSessionBinding(db, next);
+    if (!conflict) return { peer: next.peer, binding: next, merged_from: null };
+
+    const incomingRuntime = bindingHasRuntime(next);
+    const conflictRuntime = bindingHasRuntime(conflict);
+    const providerSession = bindingProviderSessionValue(next);
+    const override = Boolean(options.override);
+
+    if (override && incomingRuntime) {
+      db.prepare('DELETE FROM peer_bindings WHERE peer = ?').run(conflict.peer);
+      return { peer: next.peer, binding: next, merged_from: conflict.peer };
+    }
+
+    if (conflictRuntime && !incomingRuntime) {
+      next = mergeRuntimeBinding(conflict, { ...next, peer: conflict.peer });
+      return { peer: conflict.peer, binding: next, merged_from: binding.peer };
+    }
+
+    if (!conflictRuntime && incomingRuntime) {
+      db.prepare('DELETE FROM peer_bindings WHERE peer = ?').run(conflict.peer);
+      return { peer: next.peer, binding: next, merged_from: conflict.peer };
+    }
+
+    if (!conflictRuntime && !incomingRuntime) {
+      next = {
+        ...next,
+        peer: conflict.peer,
+        command: conflict.command || next.command || null,
+        runtime_session_id: conflict.runtime_session_id || next.runtime_session_id || conflict.peer
+      };
+      return { peer: conflict.peer, binding: next, merged_from: binding.peer };
+    }
+
+    if (conflict.runtime_target && next.runtime_target && conflict.runtime_target === next.runtime_target) {
+      next = mergeRuntimeBinding(conflict, { ...next, peer: conflict.peer });
+      return { peer: conflict.peer, binding: next, merged_from: binding.peer };
+    }
+
+    throw new CliError('PROVIDER_SESSION_IN_USE', `${next.provider} session ${providerSession} is already bound to ${conflict.peer}`, {
+      peer: conflict.peer,
+      provider: conflict.provider,
+      provider_session: providerSession,
+      runtime_target: conflict.runtime_target || null
+    });
+  }
+
+  function upsertPeerBinding(db, binding, force = false) {
+    const t = now();
+    const existing = db.prepare('SELECT * FROM peer_bindings WHERE peer = ?').get(binding.peer);
+    binding = mergePeerBinding(existing, binding);
+    if ((binding.provider_session_id || binding.provider_session_name) && !force) {
+      const conflict = findProviderSessionBinding(db, binding);
+      if (conflict) {
+        const providerSession = bindingProviderSessionValue(conflict);
+        throw new CliError('PROVIDER_SESSION_IN_USE', `${binding.provider} session ${providerSession} is already bound to ${conflict.peer}`, {
+          peer: conflict.peer,
+          provider: conflict.provider,
+          provider_session: providerSession
+        });
+      }
+    }
+    db.prepare(`
+      INSERT INTO peer_bindings(
+        peer, provider, provider_session_id, provider_session_name, resume_mode,
+        resume_arg, command, transport, runtime_session_id, runtime_target, created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(peer) DO UPDATE SET
+        provider = excluded.provider,
+        provider_session_id = excluded.provider_session_id,
+        provider_session_name = excluded.provider_session_name,
+        resume_mode = excluded.resume_mode,
+        resume_arg = excluded.resume_arg,
+        command = excluded.command,
+        transport = excluded.transport,
+        runtime_session_id = excluded.runtime_session_id,
+        runtime_target = excluded.runtime_target,
+        updated_at = excluded.updated_at
+    `).run(
+      binding.peer,
+      binding.provider,
+      binding.provider_session_id || null,
+      binding.provider_session_name || null,
+      binding.resume_mode || 'new',
+      binding.resume_arg || null,
+      binding.command || null,
+      binding.transport,
+      binding.runtime_session_id || binding.peer,
+      binding.runtime_target || null,
+      t,
+      t
+    );
+  }
+
+  function upsertCanonicalPeerBinding(db, binding, force = false, options = {}) {
+    const result = canonicalizePeerBinding(db, binding, options);
+    upsertPeerBinding(db, result.binding, force);
+    return result;
+  }
+
+  return {
+    canonicalizePeerBinding,
+    dedupePeerBindings,
+    dedupePeerBindingRows,
+    dedupeProviderSessionColumn,
+    dedupeRuntimeTargets,
+    findProviderSessionBinding,
+    upsertCanonicalPeerBinding,
+    upsertPeerBinding
+  };
+}

package/lib/db-schema.mjs

@@ -0,0 +1,7 @@
+export {
+  DB_SCHEMA_VERSION,
+  execWithBusyRetry,
+  initSchema,
+  readSchemaVersion,
+  tx
+} from './db/schema.mjs';

package/lib/errors.mjs

@@ -0,0 +1 @@
+export { CliError } from './shared/errors.mjs';

package/lib/format.mjs

@@ -0,0 +1,39 @@
+export function compactText(value, limit = 160) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  return text.length > limit ? `${text.slice(0, limit - 1)}\u2026` : text;
+}
+
+export function formatJson(ok, dataOrError) {
+  if (ok) return JSON.stringify({ ok: true, data: dataOrError }, null, 2);
+  return JSON.stringify({ ok: false, error: dataOrError }, null, 2);
+}
+
+export function printResult(ctx, data, render) {
+  if (ctx.json) {
+    console.log(formatJson(true, data));
+  } else {
+    const output = render ? render(data) : String(data ?? '');
+    if (output) console.log(output);
+  }
+}
+
+export function shellQuoteArg(value) {
+  const text = String(value);
+  if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+export function shellExports(values) {
+  return Object.entries(values)
+    .map(([key, value]) => `export ${key}=${shellQuoteArg(value)}`)
+    .join('\n');
+}
+
+export function table(rows, columns) {
+  if (!rows.length) return '(none)';
+  const widths = columns.map((col) => Math.max(col.label.length, ...rows.map((row) => String(col.value(row) ?? '').length)));
+  const header = columns.map((col, i) => col.label.padEnd(widths[i])).join('  ');
+  const sep = widths.map((w) => '-'.repeat(w)).join('  ');
+  const body = rows.map((row) => columns.map((col, i) => String(col.value(row) ?? '').padEnd(widths[i])).join('  '));
+  return [header, sep, ...body].join('\n');
+}