bertrand 0.17.0 → 0.18.0

package/dist/bertrand.js

@@ -25,12 +25,173 @@ var init_paths = __esm(() => {
     root: join(homedir(), BERTRAND_DIR),
     db: join(homedir(), BERTRAND_DIR, "bertrand.db"),
     hooks: join(homedir(), BERTRAND_DIR, "hooks"),
-    sessions: join(homedir(), BERTRAND_DIR, "sessions")
+    sessions: join(homedir(), BERTRAND_DIR, "sessions"),
+    syncEnv: join(homedir(), BERTRAND_DIR, "sync.env")
   };
 });
 
+// src/sync/config.ts
+import {
+  readFileSync,
+  statSync,
+  writeFileSync,
+  chmodSync,
+  existsSync
+} from "fs";
+function parseEnv(contents) {
+  const out = {};
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const eq = line.indexOf("=");
+    if (eq === -1)
+      continue;
+    const key = line.slice(0, eq).trim();
+    if (!KEYS.includes(key))
+      continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function hasSyncConfig() {
+  return existsSync(paths.syncEnv);
+}
+function loadSyncConfig() {
+  if (!existsSync(paths.syncEnv))
+    return null;
+  const mode = statSync(paths.syncEnv).mode & 511;
+  if (mode & 63) {
+    console.warn(`warning: ${paths.syncEnv} was mode 0${mode.toString(8)} (should be 0600). Tightening to 0600.`);
+    try {
+      chmodSync(paths.syncEnv, 384);
+    } catch (e) {
+      console.warn(`failed to chmod 0600: ${e instanceof Error ? e.message : String(e)}. Fix manually.`);
+    }
+  }
+  const env = parseEnv(readFileSync(paths.syncEnv, "utf8"));
+  if (!env.SUPABASE_URL || !env.SUPABASE_SERVICE_KEY || !env.BERTRAND_SYNC_BUCKET || !env.BERTRAND_ENCRYPTION_KEY) {
+    return null;
+  }
+  return {
+    supabaseUrl: env.SUPABASE_URL,
+    supabaseServiceKey: env.SUPABASE_SERVICE_KEY,
+    bucket: env.BERTRAND_SYNC_BUCKET,
+    objectKey: env.BERTRAND_SYNC_OBJECT || "bertrand.db.enc",
+    encryptionKey: env.BERTRAND_ENCRYPTION_KEY,
+    clientName: env.BERTRAND_CLIENT_NAME || `bertrand-${process.platform}-${process.pid}`
+  };
+}
+function saveSyncConfig(cfg) {
+  const lines = [
+    "# bertrand sync configuration",
+    "# Created by `bertrand sync onboard`. chmod 600.",
+    "#",
+    "# SUPABASE_SERVICE_KEY has read+write access to your storage bucket.",
+    "# Treat it like an SSH private key. Do not commit. Do not share.",
+    "#",
+    "# BERTRAND_ENCRYPTION_KEY is the AES-256-GCM key used to encrypt the DB",
+    "# locally before upload. Without it the uploaded blob can't be decrypted.",
+    "# Use the SAME key on every machine that should be able to pull this DB.",
+    `SUPABASE_URL=${cfg.supabaseUrl}`,
+    `SUPABASE_SERVICE_KEY=${cfg.supabaseServiceKey}`,
+    `BERTRAND_SYNC_BUCKET=${cfg.bucket}`,
+    `BERTRAND_SYNC_OBJECT=${cfg.objectKey}`,
+    `BERTRAND_ENCRYPTION_KEY=${cfg.encryptionKey}`,
+    `BERTRAND_CLIENT_NAME=${cfg.clientName}`,
+    ""
+  ];
+  writeFileSync(paths.syncEnv, lines.join(`
+`), { mode: 384 });
+  chmodSync(paths.syncEnv, 384);
+}
+var KEYS;
+var init_config = __esm(() => {
+  init_paths();
+  KEYS = [
+    "SUPABASE_URL",
+    "SUPABASE_SERVICE_KEY",
+    "BERTRAND_SYNC_BUCKET",
+    "BERTRAND_SYNC_OBJECT",
+    "BERTRAND_ENCRYPTION_KEY",
+    "BERTRAND_CLIENT_NAME"
+  ];
+});
+
+// src/lib/config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  writeFileSync2(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+function patchConfig(patch) {
+  const current = readConfig() ?? {};
+  const next = deepMerge(current, patch);
+  writeConfig(next);
+  return next;
+}
+function deepMerge(base, patch) {
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    const existing = out[k];
+    if (isPlainObject(existing) && isPlainObject(v)) {
+      out[k] = deepMerge(existing, v);
+    } else if (v !== undefined) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isSyncEnabled() {
+  return readConfig()?.sync?.enabled === true;
+}
+var CONFIG_PATH;
+var init_config2 = __esm(() => {
+  init_paths();
+  CONFIG_PATH = join2(paths.root, "config.json");
+});
+
+// src/sync/trigger.ts
+import { spawn } from "child_process";
+function spawnSync(op) {
+  if (!isSyncEnabled() || !hasSyncConfig())
+    return;
+  const bin = process.argv[1] && process.argv[1].endsWith(".ts") ? process.execPath : "bertrand";
+  const args = process.argv[1] && process.argv[1].endsWith(".ts") ? ["run", process.argv[1], "sync", op] : ["sync", op];
+  const child = spawn(bin, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function triggerBackgroundPull() {
+  spawnSync("pull");
+}
+function triggerBackgroundPush() {
+  spawnSync("push");
+}
+var init_trigger = __esm(() => {
+  init_config();
+  init_config2();
+});
+
 // src/cli/router.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 function register(name, handler) {
   commands.set(name, handler);
 }
@@ -38,7 +199,7 @@ function alias(from, to) {
   aliases.set(from, to);
 }
 async function autoInitIfFirstRun() {
-  if (existsSync(paths.db))
+  if (existsSync2(paths.db))
     return;
   const init = commands.get("init");
   if (!init)
@@ -57,6 +218,7 @@ async function route(argv) {
   const command = args[0];
   if (!command) {
     await autoInitIfFirstRun();
+    triggerBackgroundPull();
     const handler2 = commands.get("launch");
     if (!handler2)
       throw new Error("No launch command registered");
@@ -92,11 +254,13 @@ Usage:
   bertrand archive <name>   Archive/unarchive a session
   bertrand update           Hook-facing state writer (internal)
   bertrand serve            Start dashboard HTTP server
+  bertrand sync <op>        push|pull|status|onboard (see: bertrand sync --help)
 `.trim());
 }
 var commands, aliases;
 var init_router = __esm(() => {
   init_paths();
+  init_trigger();
   commands = new Map;
   aliases = new Map;
 });
@@ -411,6 +575,7 @@ var init_update = __esm(() => {
   init_sessions();
   init_events();
   init_conversations();
+  init_trigger();
   EVENT_STATUS_MAP = {
     "session.waiting": "waiting",
     "session.answered": "active",
@@ -480,11 +645,14 @@ var init_update = __esm(() => {
     if (event === "session.waiting" && conversationId && meta?.question) {
       updateLastQuestion(conversationId, meta.question);
     }
+    if (event === "session.end") {
+      triggerBackgroundPush();
+    }
   });
 });
 
 // src/lib/transcript.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 function getContextWindowSize(model) {
   for (const [prefix, size] of Object.entries(CONTEXT_WINDOW_SIZES)) {
     if (model.startsWith(prefix))
@@ -493,9 +661,9 @@ function getContextWindowSize(model) {
   return 200000;
 }
 function getLatestAssistantTurn(filePath) {
-  if (!existsSync2(filePath))
+  if (!existsSync3(filePath))
     return null;
-  const text2 = readFileSync(filePath, "utf-8");
+  const text2 = readFileSync3(filePath, "utf-8");
   const lines = text2.split(`
 `);
   const assistantEntries = [];
@@ -553,9 +721,9 @@ function getLatestAssistantTurn(filePath) {
   };
 }
 function getContextSnapshot(filePath) {
-  if (!existsSync2(filePath))
+  if (!existsSync3(filePath))
     return null;
-  const text2 = readFileSync(filePath, "utf-8");
+  const text2 = readFileSync3(filePath, "utf-8");
   const lines = text2.split(`
 `);
   for (let i = lines.length - 1;i >= 0; i--) {
@@ -822,8 +990,8 @@ class NoopAdapter {
 }
 
 // src/terminal/index.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
 function getTerminalAdapter() {
   if (cachedAdapter)
     return cachedAdapter;
@@ -842,7 +1010,7 @@ function getTerminalAdapter() {
 }
 function readConfigTerminal() {
   try {
-    const config = JSON.parse(readFileSync2(join2(paths.root, "config.json"), "utf-8"));
+    const config = JSON.parse(readFileSync4(join3(paths.root, "config.json"), "utf-8"));
     return config.terminal ?? null;
   } catch {
     return null;
@@ -1193,8 +1361,8 @@ var init_session_archive = __esm(() => {
 
 // src/server/index.ts
 import { execFile } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 function liveStats(sessionId) {
   return {
     sessionId,
@@ -1247,11 +1415,11 @@ function match(pathname, url) {
 }
 function findDashboardDir() {
   const candidates = [
-    join3(import.meta.dir, "dashboard"),
-    join3(import.meta.dir, "..", "dashboard")
+    join4(import.meta.dir, "dashboard"),
+    join4(import.meta.dir, "..", "dashboard")
   ];
   for (const dir of candidates) {
-    if (existsSync3(join3(dir, "index.html")))
+    if (existsSync4(join4(dir, "index.html")))
       return dir;
   }
   return null;
@@ -1260,13 +1428,13 @@ async function serveDashboard(pathname) {
   if (!DASHBOARD_DIR)
     return null;
   const requested = pathname === "/" ? "/index.html" : pathname;
-  const filePath = join3(DASHBOARD_DIR, requested);
+  const filePath = join4(DASHBOARD_DIR, requested);
   if (!filePath.startsWith(DASHBOARD_DIR))
     return null;
   const file = Bun.file(filePath);
   if (await file.exists())
     return new Response(file);
-  return new Response(Bun.file(join3(DASHBOARD_DIR, "index.html")));
+  return new Response(Bun.file(join4(DASHBOARD_DIR, "index.html")));
 }
 function startServer(port = PORT) {
   const server = Bun.serve({
@@ -1387,6 +1555,652 @@ var init_serve = __esm(() => {
   });
 });
 
+// src/sync/snapshot.ts
+import { Database as Database2 } from "bun:sqlite";
+import { existsSync as existsSync5, unlinkSync } from "fs";
+function takeSnapshot() {
+  cleanupSnapshot();
+  const src = new Database2(paths.db, { readonly: true });
+  try {
+    src.exec(`VACUUM INTO '${SNAPSHOT_PATH.replace(/'/g, "''")}'`);
+  } finally {
+    src.close();
+  }
+  return SNAPSHOT_PATH;
+}
+function cleanupSnapshot() {
+  for (const suffix of SIDECAR_SUFFIXES) {
+    const p = SNAPSHOT_PATH + suffix;
+    if (existsSync5(p)) {
+      try {
+        unlinkSync(p);
+      } catch {}
+    }
+  }
+}
+var SIDECAR_SUFFIXES, SNAPSHOT_PATH;
+var init_snapshot2 = __esm(() => {
+  init_paths();
+  SIDECAR_SUFFIXES = ["", "-wal", "-shm"];
+  SNAPSHOT_PATH = `${paths.db}.sync-snapshot`;
+});
+
+// src/sync/crypto.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+function parseKey(base64Key) {
+  const buf = Buffer.from(base64Key, "base64");
+  if (buf.length !== 32) {
+    throw new Error(`BERTRAND_ENCRYPTION_KEY must decode to 32 bytes (got ${buf.length}). ` + `Generate one with: openssl rand -base64 32`);
+  }
+  return buf;
+}
+function generateKeyBase64() {
+  return randomBytes(32).toString("base64");
+}
+function encrypt(plaintext, base64Key) {
+  const key = parseKey(base64Key);
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv(ALGO, key, iv);
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([MAGIC, iv, ciphertext, tag]);
+}
+function decrypt(blob, base64Key) {
+  if (blob.length < MAGIC.length + IV_LEN + TAG_LEN) {
+    throw new Error("encrypted blob too small to be valid");
+  }
+  if (!blob.subarray(0, MAGIC.length).equals(MAGIC)) {
+    throw new Error("not a bertrand encrypted blob (magic prefix mismatch). " + "Did you upload a plaintext .db file by mistake?");
+  }
+  const key = parseKey(base64Key);
+  const iv = blob.subarray(MAGIC.length, MAGIC.length + IV_LEN);
+  const tag = blob.subarray(blob.length - TAG_LEN);
+  const ciphertext = blob.subarray(MAGIC.length + IV_LEN, blob.length - TAG_LEN);
+  const decipher = createDecipheriv(ALGO, key, iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+var ALGO = "aes-256-gcm", IV_LEN = 12, TAG_LEN = 16, MAGIC;
+var init_crypto = __esm(() => {
+  MAGIC = Buffer.from("BTRD1", "ascii");
+});
+
+// src/sync/engine.ts
+import { createClient } from "@supabase/supabase-js";
+import { readFileSync as readFileSync5, renameSync, statSync as statSync2, openSync, writeSync, fsyncSync, closeSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { execFileSync } from "child_process";
+function client(cfg) {
+  if (!cfg)
+    return null;
+  return createClient(cfg.supabaseUrl, cfg.supabaseServiceKey, {
+    auth: { persistSession: false, autoRefreshToken: false }
+  });
+}
+async function push() {
+  if (!hasSyncConfig()) {
+    return { ok: false, operation: "push", error: "no sync config \u2014 run `bertrand sync onboard`" };
+  }
+  const cfg = loadSyncConfig();
+  const supabase = client(cfg);
+  if (!cfg || !supabase) {
+    return { ok: false, operation: "push", error: "sync config incomplete" };
+  }
+  const started = performance.now();
+  try {
+    let snapshotPath;
+    try {
+      snapshotPath = takeSnapshot();
+    } catch (e) {
+      return {
+        ok: false,
+        operation: "push",
+        error: `snapshot failed: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+    const plaintext = readFileSync5(snapshotPath);
+    const ciphertext = encrypt(plaintext, cfg.encryptionKey);
+    const { error } = await supabase.storage.from(cfg.bucket).upload(cfg.objectKey, ciphertext, {
+      contentType: "application/octet-stream",
+      upsert: true
+    });
+    if (error) {
+      return { ok: false, operation: "push", error: `upload failed: ${error.message}` };
+    }
+    return {
+      ok: true,
+      operation: "push",
+      bytes: ciphertext.length,
+      durationMs: Math.round(performance.now() - started)
+    };
+  } catch (e) {
+    return { ok: false, operation: "push", error: e instanceof Error ? e.message : String(e) };
+  } finally {
+    cleanupSnapshot();
+  }
+}
+async function pull(opts = {}) {
+  if (!hasSyncConfig()) {
+    return { ok: false, operation: "pull", error: "no sync config \u2014 run `bertrand sync onboard`" };
+  }
+  const cfg = loadSyncConfig();
+  const supabase = client(cfg);
+  if (!cfg || !supabase) {
+    return { ok: false, operation: "pull", error: "sync config incomplete" };
+  }
+  const holders = findHolders(paths.db);
+  if (holders.length > 0) {
+    const procs = holders.map((h) => `${h.command}(${h.pid})`).join(", ");
+    if (!opts.force) {
+      return {
+        ok: false,
+        operation: "pull",
+        error: `${paths.db} is held by ${procs} \u2014 close active bertrand sessions before pulling, ` + `or pass --force to overwrite anyway (risks corrupting the running session).`
+      };
+    }
+    console.warn(`warning: --force pulling while ${procs} hold ${paths.db}. The running process may crash on next file access.`);
+  }
+  const started = performance.now();
+  try {
+    const { data, error } = await supabase.storage.from(cfg.bucket).download(cfg.objectKey);
+    if (error || !data) {
+      if (error?.message?.toLowerCase().includes("not found")) {
+        return {
+          ok: true,
+          operation: "pull",
+          pulled: false,
+          bytes: 0,
+          durationMs: Math.round(performance.now() - started)
+        };
+      }
+      return { ok: false, operation: "pull", error: `download failed: ${error?.message ?? "no data"}` };
+    }
+    const ciphertext = Buffer.from(await data.arrayBuffer());
+    const plaintext = decrypt(ciphertext, cfg.encryptionKey);
+    const tmp = `${paths.db}.pull-${process.pid}`;
+    const fd = openSync(tmp, "w");
+    try {
+      writeSync(fd, plaintext);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(tmp, paths.db);
+    const dirFd = openSync(dirname2(paths.db), "r");
+    try {
+      fsyncSync(dirFd);
+    } finally {
+      closeSync(dirFd);
+    }
+    return {
+      ok: true,
+      operation: "pull",
+      pulled: true,
+      bytes: plaintext.length,
+      durationMs: Math.round(performance.now() - started)
+    };
+  } catch (e) {
+    return { ok: false, operation: "pull", error: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function status() {
+  const cfg = loadSyncConfig();
+  if (!cfg)
+    return { configured: false, local: null, remote: null };
+  let local = null;
+  try {
+    const s = statSync2(paths.db);
+    local = { size: s.size, modifiedAt: new Date(s.mtimeMs) };
+  } catch {
+    local = null;
+  }
+  const supabase = client(cfg);
+  let remote = null;
+  if (supabase) {
+    try {
+      const parentPath = cfg.objectKey.includes("/") ? cfg.objectKey.slice(0, cfg.objectKey.lastIndexOf("/")) : "";
+      const fileName = cfg.objectKey.includes("/") ? cfg.objectKey.slice(cfg.objectKey.lastIndexOf("/") + 1) : cfg.objectKey;
+      const { data, error } = await supabase.storage.from(cfg.bucket).list(parentPath, { search: fileName });
+      if (!error && data) {
+        const match2 = data.find((f) => f.name === fileName);
+        if (match2) {
+          remote = {
+            size: match2.metadata?.size ?? 0,
+            modifiedAt: new Date(match2.updated_at ?? match2.created_at ?? Date.now())
+          };
+        }
+      }
+    } catch {}
+  }
+  return { configured: true, local, remote };
+}
+function findHolders(path) {
+  try {
+    const out = execFileSync("lsof", ["-F", "pcn", path], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const holders = [];
+    let pid = 0;
+    let command = "";
+    for (const line of out.split(`
+`)) {
+      if (line.startsWith("p"))
+        pid = Number(line.slice(1));
+      else if (line.startsWith("c"))
+        command = line.slice(1);
+      else if (line.startsWith("n")) {
+        if (pid && pid !== process.pid && command) {
+          holders.push({ pid, command });
+        }
+      }
+    }
+    return holders;
+  } catch {
+    return [];
+  }
+}
+var init_engine = __esm(() => {
+  init_paths();
+  init_config();
+  init_snapshot2();
+  init_crypto();
+});
+
+// src/sync/invite.ts
+function encodeInvite(cfg) {
+  const bundle = {
+    v: VERSION,
+    url: cfg.supabaseUrl,
+    key: cfg.supabaseServiceKey,
+    bucket: cfg.bucket,
+    obj: cfg.objectKey,
+    ek: cfg.encryptionKey
+  };
+  return SCHEME + Buffer.from(JSON.stringify(bundle), "utf8").toString("base64url");
+}
+function isInvite(value) {
+  return typeof value === "string" && value.startsWith(SCHEME);
+}
+function decodeInvite(invite) {
+  if (!invite.startsWith(SCHEME)) {
+    throw new Error(`invite must start with ${SCHEME}`);
+  }
+  const payload = invite.slice(SCHEME.length).trim();
+  let parsed;
+  try {
+    const json = Buffer.from(payload, "base64url").toString("utf8");
+    parsed = JSON.parse(json);
+  } catch {
+    throw new Error("invite is malformed \u2014 could not decode base64/JSON payload");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("invite payload is not a JSON object");
+  }
+  const bundle = parsed;
+  if (bundle.v !== VERSION) {
+    throw new Error(`invite version ${String(bundle.v)} is not supported by this bertrand (expected v${VERSION}). ` + `Upgrade or downgrade so both machines run the same version.`);
+  }
+  for (const field of ["url", "key", "bucket", "obj", "ek"]) {
+    if (!bundle[field] || typeof bundle[field] !== "string") {
+      throw new Error(`invite is missing required field: ${field}`);
+    }
+  }
+  return {
+    supabaseUrl: bundle.url,
+    supabaseServiceKey: bundle.key,
+    bucket: bundle.bucket,
+    objectKey: bundle.obj,
+    encryptionKey: bundle.ek
+  };
+}
+var SCHEME = "bertrand-sync://", VERSION = 1;
+
+// src/lib/format.ts
+function formatDuration(ms) {
+  if (ms < MINUTE)
+    return `${Math.round(ms / SECOND)}s`;
+  const days = Math.floor(ms / DAY);
+  const hours = Math.floor(ms % DAY / HOUR);
+  const minutes = Math.floor(ms % HOUR / MINUTE);
+  if (days > 0)
+    return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+  if (hours > 0)
+    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+  return `${minutes}m`;
+}
+function formatAgo(isoOrDate) {
+  const date = typeof isoOrDate === "string" ? new Date(isoOrDate) : isoOrDate;
+  const ms = Date.now() - date.getTime();
+  if (ms < MINUTE)
+    return "just now";
+  if (ms < HOUR)
+    return `${Math.floor(ms / MINUTE)}m ago`;
+  if (ms < DAY)
+    return `${Math.floor(ms / HOUR)}h ago`;
+  if (ms < 2 * DAY)
+    return "yesterday";
+  if (ms < 7 * DAY)
+    return `${Math.floor(ms / DAY)}d ago`;
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function truncate(text2, maxLen) {
+  if (text2.length <= maxLen)
+    return text2;
+  return text2.slice(0, maxLen - 1) + "\u2026";
+}
+function formatTime(iso, includeDate = false) {
+  const date = new Date(iso);
+  const time = date.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit"
+  });
+  if (!includeDate)
+    return time;
+  const day = date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric"
+  });
+  return `${day} ${time}`;
+}
+var SECOND = 1000, MINUTE, HOUR, DAY;
+var init_format = __esm(() => {
+  MINUTE = 60 * SECOND;
+  HOUR = 60 * MINUTE;
+  DAY = 24 * HOUR;
+});
+
+// src/cli/commands/sync.ts
+var exports_sync = {};
+import { hostname } from "os";
+function printUsage2() {
+  console.log(`
+bertrand sync \u2014 replicate your local DB to Supabase Storage (opt-in)
+
+Usage:
+  bertrand sync onboard           Interactive: configure Supabase + bucket + encryption key
+  bertrand sync invite            Print a paste-able bundle for another machine
+  bertrand sync <bundle>          One-liner: decode bundle, save config, pull
+  bertrand sync push              VACUUM \u2192 encrypt \u2192 upload
+  bertrand sync pull [--force]    Download \u2192 decrypt \u2192 atomic-replace (refuses if active)
+  bertrand sync status            Local + remote object size and timestamps
+  bertrand sync enable            Turn auto-triggers on (assumes onboard already ran)
+  bertrand sync disable           Turn auto-triggers off without deleting credentials
+
+Cross-machine setup:
+  Machine A:  bertrand sync invite
+              \u2192 bertrand-sync://eyJ\u2026   (transmit via Signal/iMessage/AirDrop \u2014 sensitive)
+  Machine B:  bertrand sync bertrand-sync://eyJ\u2026
+              \u2192 onboards, pulls, ready
+`.trim());
+}
+function abort(reason) {
+  console.error(`Aborted: ${reason}`);
+  process.exit(1);
+}
+function prompt(label, opts = {}) {
+  const suffix = opts.default ? ` [${opts.default}]` : "";
+  process.stdout.write(`${label}${suffix}: `);
+  return new Promise((resolve) => {
+    let buf = "";
+    const onData = (chunk) => {
+      const s = chunk.toString("utf8");
+      for (const ch of s) {
+        if (ch === `
+` || ch === "\r") {
+          process.stdin.off("data", onData);
+          process.stdin.pause();
+          process.stdout.write(`
+`);
+          return resolve(buf.trim() || opts.default || "");
+        }
+        buf += ch;
+      }
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function runOnboard() {
+  const existing = loadSyncConfig();
+  if (existing) {
+    console.log(`Existing config at ${paths.syncEnv}:`);
+    console.log(`  SUPABASE_URL:           ${existing.supabaseUrl}`);
+    console.log(`  SUPABASE_SERVICE_KEY:   ${existing.supabaseServiceKey.slice(0, 12)}\u2026`);
+    console.log(`  BERTRAND_SYNC_BUCKET:   ${existing.bucket}`);
+    console.log(`  BERTRAND_SYNC_OBJECT:   ${existing.objectKey}`);
+    console.log(`  BERTRAND_ENCRYPTION_KEY: (set, redacted)`);
+    console.log(`  BERTRAND_CLIENT_NAME:   ${existing.clientName}`);
+    console.log(`
+Delete ${paths.syncEnv} and re-run to start over.`);
+    return;
+  }
+  console.log(`Bertrand sync setup \u2014 Supabase Storage
+`);
+  console.log(`In the Supabase dashboard (app.supabase.com):`);
+  console.log(`  1. Create or pick a project`);
+  console.log(`  2. Settings \u2192 General: copy the Project ID (the 20-char lowercase string`);
+  console.log(`     shown under "Reference ID" \u2014 looks like "xxxxxxxxxxxxxxxxxxxx")`);
+  console.log(`  3. Settings \u2192 API: copy the service_role key (NOT the anon key \u2014 service_role`);
+  console.log(`     is below it and warns "keep secret")`);
+  console.log(`  4. Storage \u2192 New bucket: name it "bertrand", PRIVATE (uncheck "Public bucket")
+`);
+  const projectId = await prompt("Project ID");
+  if (!projectId)
+    return abort("no project ID provided");
+  if (!/^[a-z0-9]{15,30}$/i.test(projectId)) {
+    return abort(`"${projectId}" doesn't look like a Supabase project ID. ` + `Expected the 20-ish char string from Settings \u2192 General, not the project name.`);
+  }
+  const supabaseUrl = `https://${projectId}.supabase.co`;
+  console.log(`  \u2192 Project URL: ${supabaseUrl}`);
+  const supabaseServiceKey = await prompt("SUPABASE_SERVICE_KEY (eyJ\u2026)");
+  if (!supabaseServiceKey)
+    return abort("no service key provided");
+  if (!supabaseServiceKey.startsWith("eyJ")) {
+    return abort("service key must be a JWT starting with eyJ \u2014 did you paste the URL by mistake?");
+  }
+  const bucket = await prompt("Storage bucket name", { default: "bertrand" });
+  const objectKey = await prompt("Object key", { default: "bertrand.db.enc" });
+  const defaultName = `bertrand-${hostname()}`;
+  const clientName = await prompt("Client name", { default: defaultName });
+  console.log(`
+Encryption key`);
+  console.log(`  First machine?    Press ENTER to generate a fresh AES-256-GCM key.`);
+  console.log(`  Additional machine? Paste the key from your other machine.
+`);
+  const pasted = await prompt("BERTRAND_ENCRYPTION_KEY");
+  let encryptionKey;
+  if (pasted) {
+    const decoded = Buffer.from(pasted, "base64");
+    if (decoded.length !== 32) {
+      return abort(`pasted key is ${decoded.length} bytes when decoded; expected 32. ` + `Copy the full key from your other machine without trimming.`);
+    }
+    encryptionKey = pasted;
+    console.log(`  \u2713 Using pasted key \u2014 this machine can decrypt blobs from the other one.
+`);
+  } else {
+    encryptionKey = generateKeyBase64();
+    console.log(`
+Generated a new key. Save this somewhere safe \u2014 you'll need it on every`);
+    console.log(`other machine that should be able to pull this DB:
+`);
+    console.log(`  ${encryptionKey}
+`);
+    console.log(`Hit ENTER to confirm you've saved it.`);
+    await prompt("");
+  }
+  saveSyncConfig({ supabaseUrl, supabaseServiceKey, bucket, objectKey, encryptionKey, clientName });
+  patchConfig({ sync: { enabled: true } });
+  console.log(`Wrote ${paths.syncEnv} (mode 0600). Sync auto-triggers enabled.`);
+  console.log(`
+Next:`);
+  console.log(`  bertrand sync push      Send your current local DB to Supabase`);
+  console.log(`  bertrand sync status    See sizes and timestamps`);
+  console.log(`
+On another machine: paste the same SUPABASE_URL, a fresh SERVICE_KEY (you can reuse),`);
+  console.log(`the same bucket and object key, and the SAME encryption key. Then \`bertrand sync pull\`.`);
+}
+async function runPush() {
+  if (!hasSyncConfig())
+    return abort("no sync config \u2014 run `bertrand sync onboard`");
+  process.stdout.write("Snapshot \u2192 encrypt \u2192 upload\u2026 ");
+  const result = await push();
+  if (result.ok) {
+    console.log(`done (${formatBytes(result.bytes)} in ${result.durationMs}ms).`);
+  } else {
+    console.log("failed.");
+    console.error(result.error);
+    process.exit(1);
+  }
+}
+async function runPull(args) {
+  if (!hasSyncConfig())
+    return abort("no sync config \u2014 run `bertrand sync onboard`");
+  const force = args.includes("--force");
+  process.stdout.write("Download \u2192 decrypt \u2192 replace\u2026 ");
+  const result = await pull({ force });
+  if (result.ok) {
+    if (result.pulled) {
+      console.log(`done (${formatBytes(result.bytes)} in ${result.durationMs}ms).`);
+    } else {
+      console.log("no remote object yet \u2014 nothing to pull.");
+    }
+  } else {
+    console.log("failed.");
+    console.error(result.error);
+    process.exit(1);
+  }
+}
+async function runStatus() {
+  if (!hasSyncConfig()) {
+    console.log("Sync is not configured. Run `bertrand sync onboard` to set up.");
+    return;
+  }
+  console.log(`Sync status (${paths.syncEnv}):`);
+  console.log(`  Auto-triggers:       ${isSyncEnabled() ? "enabled" : "disabled"}`);
+  const s = await status();
+  if (s.local) {
+    console.log(`  Local:               ${formatBytes(s.local.size)}, modified ${formatAgo(s.local.modifiedAt)}`);
+  } else {
+    console.log(`  Local:               (no DB file yet)`);
+  }
+  if (s.remote) {
+    console.log(`  Remote:              ${formatBytes(s.remote.size)}, modified ${formatAgo(s.remote.modifiedAt)}`);
+  } else {
+    console.log(`  Remote:              (no object \u2014 push to create)`);
+  }
+}
+function runEnable() {
+  if (!hasSyncConfig()) {
+    return abort("no sync config \u2014 run `bertrand sync onboard` first");
+  }
+  patchConfig({ sync: { enabled: true } });
+  console.log("Sync auto-triggers enabled. Pull-on-launch and push-on-session-end will fire.");
+}
+function runInvite() {
+  const cfg = loadSyncConfig();
+  if (!cfg) {
+    return abort("no sync config \u2014 run `bertrand sync onboard` first");
+  }
+  const invite = encodeInvite(cfg);
+  console.log("Sensitive: this bundle contains a Supabase service_role token AND your DB encryption key.");
+  console.log(`Transmit only over a secure channel (Signal, iMessage, AirDrop). Treat like an SSH private key.
+`);
+  console.log(invite);
+  console.log(`
+On the other machine:`);
+  console.log(`  bertrand sync ${invite.slice(0, 32)}\u2026`);
+}
+async function runBootstrap(invite) {
+  if (hasSyncConfig()) {
+    return abort(`sync config already exists at ${paths.syncEnv}. ` + `Delete it first if you really want to overwrite: \`rm ${paths.syncEnv}\``);
+  }
+  let decoded;
+  try {
+    decoded = decodeInvite(invite);
+  } catch (e) {
+    return abort(e instanceof Error ? e.message : String(e));
+  }
+  const clientName = `bertrand-${hostname()}`;
+  saveSyncConfig({ ...decoded, clientName });
+  patchConfig({ sync: { enabled: true } });
+  console.log(`Wrote ${paths.syncEnv} (mode 0600). Auto-triggers enabled.`);
+  console.log(`Pulling\u2026`);
+  const result = await pull();
+  if (result.ok) {
+    if (result.pulled) {
+      console.log(`\u2713 Done (${formatBytes(result.bytes)} in ${result.durationMs}ms). Run \`bertrand\` to start.`);
+    } else {
+      console.log(`\u2713 Config saved, but no remote object yet \u2014 nothing to pull.`);
+      console.log(`  Run \`bertrand sync push\` on the source machine first.`);
+    }
+  } else {
+    console.error(`Pull failed: ${result.error}`);
+    console.error(`(Config is saved, so you can fix and re-run \`bertrand sync pull\`.)`);
+    process.exit(1);
+  }
+}
+function runDisable() {
+  patchConfig({ sync: { enabled: false } });
+  console.log("Sync auto-triggers disabled. Credentials still in place \u2014 re-enable any time with `bertrand sync enable`.");
+  console.log("Manual `bertrand sync push` / `pull` still work while disabled.");
+}
+function formatBytes(n) {
+  if (n < 1024)
+    return `${n}B`;
+  if (n < 1024 * 1024)
+    return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(2)}MB`;
+}
+var init_sync = __esm(() => {
+  init_router();
+  init_config();
+  init_engine();
+  init_crypto();
+  init_paths();
+  init_format();
+  init_config2();
+  register("sync", async (args) => {
+    const sub = args[0];
+    if (sub && isInvite(sub)) {
+      await runBootstrap(sub);
+      return;
+    }
+    switch (sub) {
+      case "push":
+        await runPush();
+        return;
+      case "pull":
+        await runPull(args.slice(1));
+        return;
+      case "status":
+        await runStatus();
+        return;
+      case "onboard":
+        await runOnboard();
+        return;
+      case "invite":
+        runInvite();
+        return;
+      case "enable":
+        runEnable();
+        return;
+      case "disable":
+        runDisable();
+        return;
+      case undefined:
+      case "--help":
+      case "-h":
+        printUsage2();
+        return;
+      default:
+        console.error(`Unknown subcommand: ${sub}`);
+        printUsage2();
+        process.exit(1);
+    }
+  });
+});
+
 // src/db/queries/groups.ts
 import { eq as eq6, like, or, isNull } from "drizzle-orm";
 function createGroup(opts) {
@@ -1484,60 +2298,6 @@ var init_template2 = __esm(() => {
   init_template();
 });
 
-// src/lib/format.ts
-function formatDuration(ms) {
-  if (ms < MINUTE)
-    return `${Math.round(ms / SECOND)}s`;
-  const days = Math.floor(ms / DAY);
-  const hours = Math.floor(ms % DAY / HOUR);
-  const minutes = Math.floor(ms % HOUR / MINUTE);
-  if (days > 0)
-    return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
-  if (hours > 0)
-    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
-  return `${minutes}m`;
-}
-function formatAgo(isoOrDate) {
-  const date = typeof isoOrDate === "string" ? new Date(isoOrDate) : isoOrDate;
-  const ms = Date.now() - date.getTime();
-  if (ms < MINUTE)
-    return "just now";
-  if (ms < HOUR)
-    return `${Math.floor(ms / MINUTE)}m ago`;
-  if (ms < DAY)
-    return `${Math.floor(ms / HOUR)}h ago`;
-  if (ms < 2 * DAY)
-    return "yesterday";
-  if (ms < 7 * DAY)
-    return `${Math.floor(ms / DAY)}d ago`;
-  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
-}
-function truncate(text2, maxLen) {
-  if (text2.length <= maxLen)
-    return text2;
-  return text2.slice(0, maxLen - 1) + "\u2026";
-}
-function formatTime(iso, includeDate = false) {
-  const date = new Date(iso);
-  const time = date.toLocaleTimeString("en-US", {
-    hour: "numeric",
-    minute: "2-digit"
-  });
-  if (!includeDate)
-    return time;
-  const day = date.toLocaleDateString("en-US", {
-    month: "short",
-    day: "numeric"
-  });
-  return `${day} ${time}`;
-}
-var SECOND = 1000, MINUTE, HOUR, DAY;
-var init_format = __esm(() => {
-  MINUTE = 60 * SECOND;
-  HOUR = 60 * MINUTE;
-  DAY = 24 * HOUR;
-});
-
 // src/contract/context.ts
 function buildSiblingContext(groupId, groupPath, currentSessionId) {
   const siblings = getSessionsByGroup(groupId).filter((s) => s.id !== currentSessionId);
@@ -1567,7 +2327,7 @@ var init_context = __esm(() => {
 });
 
 // src/engine/process.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function launchClaude(opts) {
   const args = [];
   if (opts.resume) {
@@ -1585,7 +2345,7 @@ function launchClaude(opts) {
     BERTRAND_SESSION_SLUG: opts.sessionSlug
   };
   return new Promise((resolve, reject) => {
-    const child = spawn("claude", args, {
+    const child = spawn2("claude", args, {
       env,
       stdio: "inherit",
       shell: false
@@ -1683,12 +2443,12 @@ var init_spawn_context = __esm(() => {
 });
 
 // src/lib/server-lifecycle.ts
-import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync3, writeFileSync, unlinkSync } from "fs";
-import { join as join4 } from "path";
+import { spawn as spawn3 } from "child_process";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join5 } from "path";
 function readPidFile() {
   try {
-    const pid = Number(readFileSync3(deps.pidFile, "utf-8").trim());
+    const pid = Number(readFileSync6(deps.pidFile, "utf-8").trim());
     return Number.isFinite(pid) && pid > 0 ? pid : null;
   } catch {
     return null;
@@ -1714,7 +2474,7 @@ async function isPortListening(port) {
 }
 function removePidFile() {
   try {
-    unlinkSync(deps.pidFile);
+    unlinkSync2(deps.pidFile);
   } catch {}
 }
 async function ensureServerStarted() {
@@ -1728,14 +2488,14 @@ async function ensureServerStarted() {
   const bin = deps.resolveBin();
   if (!bin)
     return;
-  const child = spawn2(bin, ["serve"], {
+  const child = spawn3(bin, ["serve"], {
     detached: true,
     stdio: "ignore",
     env: { ...process.env, BERTRAND_PORT: String(deps.port) }
   });
   child.unref();
   if (child.pid)
-    writeFileSync(deps.pidFile, String(child.pid));
+    writeFileSync3(deps.pidFile, String(child.pid));
 }
 function stopServerIfIdle() {
   if (deps.getActiveCount() > 0)
@@ -1753,11 +2513,11 @@ var init_server_lifecycle = __esm(() => {
   init_paths();
   init_sessions();
   defaultDeps = {
-    pidFile: join4(paths.root, "server.pid"),
+    pidFile: join5(paths.root, "server.pid"),
     port: Number(process.env.BERTRAND_PORT ?? 5200),
     resolveBin() {
       try {
-        const config = JSON.parse(readFileSync3(join4(paths.root, "config.json"), "utf-8"));
+        const config = JSON.parse(readFileSync6(join5(paths.root, "config.json"), "utf-8"));
         return typeof config?.bin === "string" ? config.bin : null;
       } catch {
         return null;
@@ -1902,13 +2662,13 @@ var init_session = __esm(() => {
 });
 
 // src/tui/app.tsx
-import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
-import { join as join5 } from "path";
+import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync7, unlinkSync as unlinkSync3 } from "fs";
+import { join as join6 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 async function runScreen(screen, ...args) {
   const tmpFile = `/tmp/bertrand-tui-${process.pid}-${Date.now()}.json`;
-  const child = spawn3("bun", ["run", SCREEN_ENTRY, screen, tmpFile, ...args], {
+  const child = spawn4("bun", ["run", SCREEN_ENTRY, screen, tmpFile, ...args], {
     stdio: "inherit"
   });
   const exitCode = await new Promise((resolve) => {
@@ -1917,8 +2677,8 @@ async function runScreen(screen, ...args) {
   if (exitCode !== 0) {
     throw new Error(`TUI screen "${screen}" exited with code ${exitCode}`);
   }
-  const result = JSON.parse(readFileSync4(tmpFile, "utf-8"));
-  unlinkSync2(tmpFile);
+  const result = JSON.parse(readFileSync7(tmpFile, "utf-8"));
+  unlinkSync3(tmpFile);
   return result;
 }
 async function startLaunchTui() {
@@ -2002,8 +2762,8 @@ var init_app = __esm(() => {
   init_session_archive();
   init_session();
   SCREEN_ENTRY = (() => {
-    const built = join5(import.meta.dir, "run-screen.js");
-    return existsSync4(built) ? built : join5(import.meta.dir, "run-screen.tsx");
+    const built = join6(import.meta.dir, "run-screen.js");
+    return existsSync6(built) ? built : join6(import.meta.dir, "run-screen.tsx");
   })();
 });
 
@@ -2082,14 +2842,14 @@ var init_launch = __esm(() => {
 });
 
 // src/db/migrate.ts
-import { Database as Database2 } from "bun:sqlite";
+import { Database as Database3 } from "bun:sqlite";
 import { drizzle as drizzle2 } from "drizzle-orm/bun-sqlite";
 import { migrate } from "drizzle-orm/bun-sqlite/migrator";
 import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 function runMigrations() {
-  mkdirSync2(dirname2(paths.db), { recursive: true });
-  const sqlite = new Database2(paths.db);
+  mkdirSync2(dirname3(paths.db), { recursive: true });
+  const sqlite = new Database3(paths.db);
   sqlite.exec("PRAGMA journal_mode = WAL");
   sqlite.exec("PRAGMA foreign_keys = ON");
   const db = drizzle2(sqlite);
@@ -2376,14 +3136,14 @@ var init_scripts = __esm(() => {
 });
 
 // src/hooks/install.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, chmodSync } from "fs";
-import { join as join6 } from "path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, chmodSync as chmodSync2 } from "fs";
+import { join as join7 } from "path";
 function installHookScripts(bin) {
   mkdirSync3(paths.hooks, { recursive: true });
   for (const [filename, scriptFn] of Object.entries(HOOK_SCRIPTS)) {
-    const filePath = join6(paths.hooks, filename);
-    writeFileSync2(filePath, scriptFn(bin));
-    chmodSync(filePath, 493);
+    const filePath = join7(paths.hooks, filename);
+    writeFileSync4(filePath, scriptFn(bin));
+    chmodSync2(filePath, 493);
   }
   console.log(`Installed ${Object.keys(HOOK_SCRIPTS).length} hook scripts to ${paths.hooks}`);
 }
@@ -2393,8 +3153,8 @@ var init_install = __esm(() => {
 });
 
 // src/hooks/settings.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
 import { homedir as homedir2 } from "os";
 function isBertrandGroup(group) {
   return group.hooks?.some((h) => h.command?.includes(".bertrand/hooks/")) ?? false;
@@ -2402,7 +3162,7 @@ function isBertrandGroup(group) {
 function installHookSettings() {
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync5(SETTINGS_PATH, "utf-8"));
+    settings = JSON.parse(readFileSync8(SETTINGS_PATH, "utf-8"));
   } catch {}
   const existingHooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
   const merged = { ...existingHooks };
@@ -2411,15 +3171,15 @@ function installHookSettings() {
     merged[eventType] = [...existing, ...bertrandGroups];
   }
   settings.hooks = merged;
-  mkdirSync4(dirname3(SETTINGS_PATH), { recursive: true });
-  writeFileSync3(SETTINGS_PATH, JSON.stringify(settings, null, 2) + `
+  mkdirSync4(dirname4(SETTINGS_PATH), { recursive: true });
+  writeFileSync5(SETTINGS_PATH, JSON.stringify(settings, null, 2) + `
 `);
   console.log(`Updated ${SETTINGS_PATH} with bertrand hooks`);
 }
 var SETTINGS_PATH, BERTRAND_HOOKS;
 var init_settings = __esm(() => {
   init_paths();
-  SETTINGS_PATH = join7(homedir2(), ".claude", "settings.json");
+  SETTINGS_PATH = join8(homedir2(), ".claude", "settings.json");
   BERTRAND_HOOKS = {
     PreToolUse: [
       {
@@ -2463,8 +3223,8 @@ var init_settings = __esm(() => {
 });
 
 // src/lib/completions.ts
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
-import { join as join8 } from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "fs";
+import { join as join9 } from "path";
 function bashCompletion() {
   return `# bertrand bash completion
 _bertrand() {
@@ -2494,11 +3254,11 @@ function fishCompletion() {
 `;
 }
 function generateCompletions() {
-  const dir = join8(paths.root, "completions");
+  const dir = join9(paths.root, "completions");
   mkdirSync5(dir, { recursive: true });
-  writeFileSync4(join8(dir, "bertrand.bash"), bashCompletion());
-  writeFileSync4(join8(dir, "_bertrand"), zshCompletion());
-  writeFileSync4(join8(dir, "bertrand.fish"), fishCompletion());
+  writeFileSync6(join9(dir, "bertrand.bash"), bashCompletion());
+  writeFileSync6(join9(dir, "_bertrand"), zshCompletion());
+  writeFileSync6(join9(dir, "bertrand.fish"), fishCompletion());
   console.log(`Shell completions written to ${dir}`);
   console.log("  Add to your shell config:");
   console.log(`    bash: source ${dir}/bertrand.bash`);
@@ -2525,9 +3285,9 @@ var init_completions = __esm(() => {
 
 // src/cli/commands/init.ts
 var exports_init = {};
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, chmodSync as chmodSync2 } from "fs";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7, chmodSync as chmodSync3 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function detectTerminal() {
   try {
     execSync2("which wsh", { stdio: "ignore" });
@@ -2536,35 +3296,24 @@ function detectTerminal() {
     return "other";
   }
 }
-function writeConfig(config) {
-  writeFileSync5(CONFIG_PATH, JSON.stringify(config, null, 2) + `
-`);
-}
-function readConfig() {
-  try {
-    return JSON.parse(readFileSync6(CONFIG_PATH, "utf-8"));
-  } catch {
-    return null;
-  }
-}
 function resolveBin() {
   const onPath = Bun.which("bertrand");
   if (onPath)
     return onPath;
   const entry = process.argv[1];
   if (entry && SOURCE_ENTRY.test(entry)) {
-    const launcherDir = join9(paths.root, "bin");
-    const launcher = join9(launcherDir, "bertrand-dev");
+    const launcherDir = join10(paths.root, "bin");
+    const launcher = join10(launcherDir, "bertrand-dev");
     mkdirSync6(launcherDir, { recursive: true });
-    writeFileSync5(launcher, `#!/usr/bin/env bash
+    writeFileSync7(launcher, `#!/usr/bin/env bash
 exec ${process.execPath} ${JSON.stringify(entry)} "$@"
 `);
-    chmodSync2(launcher, 493);
+    chmodSync3(launcher, 493);
     return launcher;
   }
   return null;
 }
-var CONFIG_PATH, SOURCE_ENTRY;
+var SOURCE_ENTRY;
 var init_init = __esm(() => {
   init_router();
   init_migrate();
@@ -2572,7 +3321,7 @@ var init_init = __esm(() => {
   init_settings();
   init_paths();
   init_completions();
-  CONFIG_PATH = join9(paths.root, "config.json");
+  init_config2();
   SOURCE_ENTRY = /\/src\/index\.tsx?$/;
   register("init", async () => {
     console.log(`bertrand init
@@ -3122,10 +3871,10 @@ var init_log = __esm(() => {
 
 // src/cli/commands/stats.ts
 var exports_stats = {};
-function getMetrics(sessionId, name, status) {
+function getMetrics(sessionId, name, status2) {
   const stats = getSessionStats(sessionId);
   if (stats) {
-    return { name, status, ...stats };
+    return { name, status: status2, ...stats };
   }
   const timing = computeTimingsLive(sessionId);
   const allEvents = getEventsBySession(sessionId);
@@ -3142,7 +3891,7 @@ function getMetrics(sessionId, name, status) {
   }
   return {
     name,
-    status,
+    status: status2,
     eventCount: allEvents.length,
     conversationCount: conversations2.size,
     interactionCount,
@@ -3390,7 +4139,8 @@ var hotPath = {
   "recap-thinking": () => Promise.resolve().then(() => (init_recap_thinking(), exports_recap_thinking)),
   badge: () => Promise.resolve().then(() => (init_badge(), exports_badge)),
   notify: () => Promise.resolve().then(() => (init_notify(), exports_notify)),
-  serve: () => Promise.resolve().then(() => (init_serve(), exports_serve))
+  serve: () => Promise.resolve().then(() => (init_serve(), exports_serve)),
+  sync: () => Promise.resolve().then(() => (init_sync(), exports_sync))
 };
 if (command && command in hotPath) {
   await hotPath[command]();
@@ -3409,7 +4159,8 @@ if (command && command in hotPath) {
     Promise.resolve().then(() => (init_recap_thinking(), exports_recap_thinking)),
     Promise.resolve().then(() => (init_serve(), exports_serve)),
     Promise.resolve().then(() => (init_badge(), exports_badge)),
-    Promise.resolve().then(() => (init_notify(), exports_notify))
+    Promise.resolve().then(() => (init_notify(), exports_notify)),
+    Promise.resolve().then(() => (init_sync(), exports_sync))
   ]);
 }
 await route(process.argv);

package/dist/run-screen.js

@@ -577,7 +577,8 @@ var paths = {
   root: join(homedir(), BERTRAND_DIR),
   db: join(homedir(), BERTRAND_DIR, "bertrand.db"),
   hooks: join(homedir(), BERTRAND_DIR, "hooks"),
-  sessions: join(homedir(), BERTRAND_DIR, "sessions")
+  sessions: join(homedir(), BERTRAND_DIR, "sessions"),
+  syncEnv: join(homedir(), BERTRAND_DIR, "sync.env")
 };
 
 // src/db/schema.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bertrand",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "publishConfig": {
     "access": "public"
   },
@@ -47,6 +47,7 @@
   },
   "dependencies": {
     "@orchetron/storm": "^0.2.0",
+    "@supabase/supabase-js": "^2.108.1",
     "drizzle-orm": "^0.44.0",
     "nanoid": "^5.1.5",
     "react": "^19.2.5"