abtars 0.1.0-alpha.16 → 0.1.0-alpha.17

package/bundle/abtars-cli.js

@@ -1,18 +1,17 @@
 #!/usr/bin/env node
  import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
-import {
-  showHintOnce,
-  update
-} from "./chunk-TQG56KI3.js";
 import {
   install
 } from "./chunk-RB3X66KM.js";
 import {
+  RETENTION,
   acquireLock,
   activate,
   emptyManifest,
+  hashFile,
   inspectLock,
   packagePaths,
+  pruneReleases,
   readCurrent,
   readManifest,
   releaseExists,
@@ -136,11 +135,11 @@ function removeLock(path) {
 }
 async function stop(opts) {
   const home = abtarsHome2();
-  const manifestPath = join2(home, "manifest.json");
+  const manifestPath2 = join2(home, "manifest.json");
   const watchdogLock = join2(home, "watchdog.lock");
   const bridgeLock = join2(home, "bridge.lock");
   const force = opts.force ?? false;
-  const installMode = readJsonField(manifestPath, "installMode");
+  const installMode = readJsonField(manifestPath2, "installMode");
   if (installMode === "supervised-daemon" && !force) {
     process.stderr.write(`Bridge runs under supervised-daemon \u2014 use supervisor stop (supervisor will respawn if you kill the process directly).
 `);
@@ -413,8 +412,45 @@ function collectDir(dir, prefix, out) {
 // src/cli/commands/onboard.ts
 init_log_and_swallow();
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname2, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
+
+// src/components/hints.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync, renameSync as renameSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+function manifestPath() {
+  const home = process.env["ABTARS_HOME"] ?? join5(process.env["HOME"] ?? "", ".abtars");
+  return join5(home, "manifest.json");
+}
+function readManifest2() {
+  const path = manifestPath();
+  if (!existsSync4(path)) return {};
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeManifestAtomic(data) {
+  const path = manifestPath();
+  const tmp = path + ".tmp";
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  renameSync2(tmp, path);
+}
+function showHintOnce(id, text) {
+  const manifest = readManifest2();
+  const seen = manifest["hintsSeen"] ?? {};
+  if (seen[id]) return;
+  process.stderr.write(`
+\u{1F4A1} ${text}
+
+`);
+  seen[id] = (/* @__PURE__ */ new Date()).toISOString();
+  manifest["hintsSeen"] = seen;
+  writeManifestAtomic(manifest);
+}
+
+// src/cli/commands/onboard.ts
 var VALID_PROVIDERS = ["openrouter", "anthropic", "openai", "ollama", "kiro", "gemini"];
 var PROVIDER_TRANSPORT_NAME = {
   openrouter: "openrouter",
@@ -451,9 +487,9 @@ async function runInteractive(existing) {
   const { intro, outro, text, select, confirm: confirm2, isCancel, cancel } = await import("./dist-J3T4XVKX.js");
   intro("abtars onboard \u2014 first-time setup");
   const noteEmpty = "press Enter to skip";
-  const { packagePaths: pp, readManifest: rm } = await import("./deploy-lib-import-ODLDL2DB.js");
+  const { packagePaths: pp, readManifest: rm3 } = await import("./deploy-lib-import-ODLDL2DB.js");
   const mfPaths = pp("abtars");
-  const mf = await rm(mfPaths.manifest);
+  const mf = await rm3(mfPaths.manifest);
   const installMode = mf?.installMode ?? "supervised";
   const userName = await text({
     message: "Your name",
@@ -850,11 +886,11 @@ async function onboard(opts) {
     );
     return 2;
   }
-  const envPath = join5(paths.config, ".env");
+  const envPath = join6(paths.config, ".env");
   const existing = await readExisting(envPath);
-  const secretDir = join5(paths.home, "secret");
+  const secretDir = join6(paths.home, "secret");
   const { existsSync: secretExists } = await import("node:fs");
-  const hasSecretToken = secretExists(join5(secretDir, "TELEGRAM_BOT_TOKEN")) || secretExists(join5(secretDir, "DISCORD_BOT_TOKEN"));
+  const hasSecretToken = secretExists(join6(secretDir, "TELEGRAM_BOT_TOKEN")) || secretExists(join6(secretDir, "DISCORD_BOT_TOKEN"));
   const hasUserConfig = existing !== null && (existing.telegramToken || existing.discordBotToken || hasSecretToken);
   if (hasUserConfig && !opts.force) {
     showHintOnce("onboard-reoffer", "Re-running onboard overwrites config. Use --force to confirm, or edit ~/.abtars/config/.env directly.");
@@ -888,7 +924,7 @@ async function onboard(opts) {
   process.stdout.write(`
 \u2713 Wrote ${envPath}
 `);
-  const secretDirPath = join5(paths.home, "secret");
+  const secretDirPath = join6(paths.home, "secret");
   await mkdir(secretDirPath, { recursive: true });
   const secrets = [];
   if (answers.telegramToken) secrets.push(["TELEGRAM_BOT_TOKEN", answers.telegramToken]);
@@ -899,7 +935,7 @@ async function onboard(opts) {
   }
   if (answers.groqApiKey) secrets.push(["GROQ_API_KEY", answers.groqApiKey]);
   for (const [name, value] of secrets) {
-    await writeFile(join5(secretDirPath, name), value, { mode: 384 });
+    await writeFile(join6(secretDirPath, name), value, { mode: 384 });
   }
   if (secrets.length > 0) process.stdout.write(`\u2713 ${secrets.length} secrets \u2192 ${secretDirPath}
 `);
@@ -909,7 +945,7 @@ async function onboard(opts) {
   process.stdout.write(`\u2713 install mode: ${answers.installMode}
 `);
   {
-    const transportPath = join5(paths.config, "transport.json");
+    const transportPath = join6(paths.config, "transport.json");
     let tc = {};
     try {
       tc = JSON.parse(await readFile(transportPath, "utf-8"));
@@ -941,7 +977,7 @@ async function onboard(opts) {
 `);
   }
   {
-    const usersPath = join5(paths.config, "users.json");
+    const usersPath = join6(paths.config, "users.json");
     const userId = answers.userName.toLowerCase().replace(/[^a-z0-9]/g, "") || "user";
     const platforms = {};
     if (answers.telegramChatId) platforms["telegram"] = parseInt(answers.telegramChatId, 10) || answers.telegramChatId;
@@ -962,11 +998,11 @@ async function onboard(opts) {
 `);
   }
   if (answers.userName) {
-    const abmindHome = process.env["ABMIND_HOME"] ?? join5(dirname2(paths.home), ".abmind");
-    const profileDir = join5(abmindHome, "memory", "core");
+    const abmindHome = process.env["ABMIND_HOME"] ?? join6(dirname2(paths.home), ".abmind");
+    const profileDir = join6(abmindHome, "memory", "core");
     const { existsSync: profileExists } = await import("node:fs");
     if (profileExists(profileDir)) {
-      const profilePath = join5(profileDir, "user_profile.md");
+      const profilePath = join6(profileDir, "user_profile.md");
       if (!profileExists(profilePath)) {
         await writeFile(profilePath, `# User Profile
 
@@ -994,13 +1030,13 @@ Name: ${answers.userName}
   if (answers.telegramChatId) {
     await seedDefaultTasks(answers.telegramChatId, paths.home);
   }
-  const agentsDir = join5(paths.home, "agents");
-  const agentRulesPath = join5(agentsDir, "default.md");
+  const agentsDir = join6(paths.home, "agents");
+  const agentRulesPath = join6(agentsDir, "default.md");
   const { existsSync: agentRulesExists } = await import("node:fs");
   if (!agentRulesExists(agentRulesPath)) {
     await mkdir(agentsDir, { recursive: true });
-    const bundledPath = join5(dirname2(fileURLToPath(import.meta.url)), "agents", "default.md");
-    const fallbackPath = join5(dirname2(fileURLToPath(import.meta.url)), "..", "..", "agents", "default.md");
+    const bundledPath = join6(dirname2(fileURLToPath(import.meta.url)), "agents", "default.md");
+    const fallbackPath = join6(dirname2(fileURLToPath(import.meta.url)), "..", "..", "agents", "default.md");
     let content = "# Agent-to-Agent API\n\n<!-- See docs for configuration -->\n";
     try {
       content = await readFile(bundledPath, "utf-8");
@@ -1016,7 +1052,7 @@ Name: ${answers.userName}
   }
   process.stdout.write(`
 \u{1F4A1} To edit providers, agents, hailMary, fallback chains \u2014 edit:
-   ${join5(paths.config, "transport.json")}
+   ${join6(paths.config, "transport.json")}
    Docs: https://aksika.github.io/abtars/
 `);
   if (opts.nonInteractive) {
@@ -1025,33 +1061,22 @@ Next: 'abtars update' to build, then start the bridge.
 `);
     return 0;
   }
-  const { existsSync: existsSync4 } = await import("node:fs");
-  const inRepo = existsSync4(join5(process.cwd(), ".git")) && existsSync4(join5(process.cwd(), "package.json"));
-  if (!inRepo) {
+  const { existsSync: existsSync8 } = await import("node:fs");
+  const hasRelease = existsSync8(join6(paths.home, "current"));
+  if (!hasRelease) {
     process.stdout.write(`
-Next: cd into the abtars repo and run 'abtars update' to build and activate.
+Next: run 'abtars update' to stage the release, then start the bridge.
 `);
     return 0;
   }
-  process.stdout.write(`
-\u2500\u2500 Running 'abtars update' \u2500\u2500
-`);
-  const { update: update2 } = await import("./update-XLWLAPLP.js");
-  const updRc = await update2({ source: "local", fromLocal: true, allowAbmindMismatch: false });
-  if (updRc !== 0) {
-    process.stderr.write(`
-\u26A0\uFE0F  'abtars update' exited with code ${updRc}. Fix and re-run manually.
-`);
-    return updRc;
-  }
   try {
-    const { spawnSync: spawnSync2 } = await import("node:child_process");
-    const which = spawnSync2("which", ["abmind"], { encoding: "utf-8" });
+    const { spawnSync: spawnSync4 } = await import("node:child_process");
+    const which = spawnSync4("which", ["abmind"], { encoding: "utf-8" });
     if (which.status === 0) {
       process.stdout.write(`
 \u2500\u2500 Running 'abmind install' \u2500\u2500
 `);
-      const r = spawnSync2("abmind", ["install"], { stdio: "inherit" });
+      const r = spawnSync4("abmind", ["install"], { stdio: "inherit" });
       if (r.status !== 0) process.stdout.write(`\u26A0 abmind install exited with code ${r.status}
 `);
     } else {
@@ -1080,8 +1105,8 @@ Next: cd into the abtars repo and run 'abtars update' to build and activate.
   if (startCmds.length > 0) {
     for (const cmd of startCmds) process.stdout.write(`  \u2192 ${cmd}
 `);
-    const run = await confirm2({ message: `Enable and start the watchdog service?`, initialValue: true });
-    if (run === true) {
+    const run2 = await confirm2({ message: `Enable and start the watchdog service?`, initialValue: true });
+    if (run2 === true) {
       for (const cmd of startCmds) {
         await new Promise((resolve) => {
           const child = spawn2("bash", ["-lc", cmd], { stdio: "inherit" });
@@ -1099,9 +1124,9 @@ Next: cd into the abtars repo and run 'abtars update' to build and activate.
   return 0;
 }
 async function seedDefaultTasks(chatId, abtarsHome4) {
-  const { existsSync: existsSync4 } = await import("node:fs");
-  const tasksJson = join5(abtarsHome4, "state", "tasks.json");
-  if (existsSync4(tasksJson)) {
+  const { existsSync: existsSync8 } = await import("node:fs");
+  const tasksJson = join6(abtarsHome4, "state", "tasks.json");
+  if (existsSync8(tasksJson)) {
     process.stdout.write(`\u2022 tasks.json exists \u2014 skipping default-task seed
 `);
     return;
@@ -1109,12 +1134,12 @@ async function seedDefaultTasks(chatId, abtarsHome4) {
   const { fileURLToPath: fileURLToPath2 } = await import("node:url");
   const here = dirname2(fileURLToPath2(import.meta.url));
   const candidates = [
-    join5(here, "..", "..", "..", "tasks.default.json"),
-    join5(here, "..", "..", "tasks.default.json")
+    join6(here, "..", "..", "..", "tasks.default.json"),
+    join6(here, "..", "..", "tasks.default.json")
   ];
   let templatePath = null;
   for (const p of candidates) {
-    if (existsSync4(p)) {
+    if (existsSync8(p)) {
       templatePath = p;
       break;
     }
@@ -1133,7 +1158,7 @@ async function seedDefaultTasks(chatId, abtarsHome4) {
 `);
     return;
   }
-  const { spawnSync: spawnSync2 } = await import("node:child_process");
+  const { spawnSync: spawnSync4 } = await import("node:child_process");
   let seeded = 0;
   for (const entry of template) {
     const args = [
@@ -1152,7 +1177,7 @@ async function seedDefaultTasks(chatId, abtarsHome4) {
     if (entry.id) args.push("--id", entry.id);
     if (entry.title) args.push("--title", entry.title);
     if (entry.maxRunsPerDay) args.push("--max-runs-per-day", String(entry.maxRunsPerDay));
-    const result = spawnSync2("abtars-task", args, {
+    const result = spawnSync4("abtars-task", args, {
       encoding: "utf-8",
       env: { ...process.env, ABTARS_HOME: abtarsHome4 }
     });
@@ -1298,6 +1323,511 @@ Re-run 'abtars update' or 'abtars rollback' to reconcile.
   return 0;
 }
 
+// src/cli/commands/update.ts
+init_log_and_swallow();
+import { hostname as hostname2 } from "node:os";
+import { join as join9, dirname as dirname3 } from "node:path";
+import { readFileSync as readFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "node:fs";
+import { copyFile as copyFile2, mkdir as mkdir4, chmod, readdir, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+
+// src/cli/update-sources/local.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+import { copyFile, cp, mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var LocalBuildError = class extends Error {
+  constructor(message, hint) {
+    super(hint ? `${message}
+
+${hint}` : message);
+    this.hint = hint;
+    this.name = "LocalBuildError";
+  }
+};
+function runCmd(cmd, args, cwd) {
+  const r = spawnSync2(cmd, args, { cwd, encoding: "utf-8" });
+  if (r.error) throw new LocalBuildError(`${cmd} ${args.join(" ")} failed: ${r.error.message}`);
+  if (r.status !== 0) {
+    throw new LocalBuildError(
+      `${cmd} ${args.join(" ")} exited with status ${r.status}`,
+      r.stderr?.trim() || void 0
+    );
+  }
+  return r.stdout.trim();
+}
+function tryCmd(cmd, args, cwd) {
+  const r = spawnSync2(cmd, args, { cwd, encoding: "utf-8" });
+  if (r.status !== 0) return null;
+  return r.stdout.trim();
+}
+function checkStaleness(repoRoot, allowStale) {
+  const commit = runCmd("git", ["rev-parse", "--short", "HEAD"], repoRoot);
+  const branch = tryCmd("git", ["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
+  if (allowStale) return { commit, branch: branch === "HEAD" ? null : branch };
+  if (branch === "HEAD" || branch === null) {
+    throw new LocalBuildError(
+      "Working tree is in detached HEAD (no current branch).",
+      "Cannot check for staleness. Pass --from-local to proceed with the current tree."
+    );
+  }
+  runCmd("git", ["fetch", "--quiet"], repoRoot);
+  const upstream = tryCmd("git", ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`], repoRoot);
+  if (upstream === null) {
+    throw new LocalBuildError(
+      `Branch '${branch}' has no upstream configured.`,
+      "Cannot check for staleness. Push the branch, or pass --from-local to proceed with the current tree."
+    );
+  }
+  const behindStr = tryCmd("git", ["rev-list", "--count", `HEAD..${upstream}`], repoRoot);
+  const behind = behindStr === null ? null : Number(behindStr);
+  if (behind === null || !Number.isFinite(behind)) {
+    throw new LocalBuildError(
+      `Could not determine how far HEAD is behind ${upstream}.`,
+      "Pass --from-local to proceed anyway."
+    );
+  }
+  if (behind > 0) {
+    throw new LocalBuildError(
+      `Current branch: ${branch} (${commit})
+${upstream} is ahead by ${behind} commit${behind === 1 ? "" : "s"}.`,
+      `Run 'git pull' first, or pass --from-local to build from the current tree.`
+    );
+  }
+  return { commit, branch };
+}
+async function readPackageVersion(repoRoot) {
+  const pkg = JSON.parse(await readFile2(join7(repoRoot, "package.json"), "utf-8"));
+  if (typeof pkg.version !== "string") {
+    throw new LocalBuildError("package.json has no version field.");
+  }
+  return pkg.version;
+}
+function makeLocalBuildSource(opts = {}) {
+  const repoRoot = opts.repoRoot ?? process.cwd();
+  const isNpmPackage = !existsSync5(join7(repoRoot, ".git"));
+  return {
+    name: "local",
+    async prepare(ctx) {
+      if (isNpmPackage) {
+        const bundleDir = join7(repoRoot, "bundle");
+        if (!existsSync5(bundleDir)) {
+          throw new Error(`No bundle/ found at ${repoRoot}. Run from the abtars npm package or a git checkout.`);
+        }
+        const pkgVersion2 = await readPackageVersion(repoRoot);
+        const version2 = pkgVersion2;
+        const stagedPath2 = join7(ctx.releasesDir, version2);
+        await rm(stagedPath2, { recursive: true, force: true });
+        await mkdir2(stagedPath2, { recursive: true });
+        await cp(bundleDir, join7(stagedPath2, "bundle"), { recursive: true });
+        const coreDir = join7(repoRoot, "core");
+        if (existsSync5(coreDir)) await cp(coreDir, join7(stagedPath2, "core"), { recursive: true });
+        const scriptsSrc = join7(repoRoot, "scripts");
+        if (existsSync5(scriptsSrc)) await cp(scriptsSrc, join7(stagedPath2, "scripts"), { recursive: true });
+        const configSrc = join7(repoRoot, "config");
+        if (existsSync5(configSrc)) await cp(configSrc, join7(stagedPath2, "config"), { recursive: true });
+        const manifestSrc = join7(repoRoot, "install-manifest.json");
+        if (existsSync5(manifestSrc)) await copyFile(manifestSrc, join7(stagedPath2, "install-manifest.json"));
+        await writeFile2(join7(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version: version2 }, null, 2) + "\n");
+        process.stdout.write(`\u2713 staged ${version2} (from npm package)
+`);
+        return { version: version2, stagedPath: stagedPath2, commit: null, branch: null, packageLockHash: null, source: "local" };
+      }
+      const { commit, branch } = checkStaleness(repoRoot, opts.allowStale === true || ctx.allowStale);
+      const pkgVersion = await readPackageVersion(repoRoot);
+      const version = `${pkgVersion}-${commit}`;
+      if (opts.skipInstall !== true) {
+        runCmd("npm", ["install", "--no-audit", "--no-fund"], repoRoot);
+      }
+      const useBundle = process.env["AGENTBRIDGE_BUILD_MODE"] !== "tsc";
+      if (useBundle) {
+        runCmd("npm", ["run", "bundle"], repoRoot);
+        const stagedPath2 = join7(ctx.releasesDir, version);
+        await rm(stagedPath2, { recursive: true, force: true });
+        await mkdir2(stagedPath2, { recursive: true });
+        await cp(join7(repoRoot, "bundle"), join7(stagedPath2, "bundle"), { recursive: true });
+        const coreSkillsSrc = join7(repoRoot, "core", "skills");
+        if (existsSync5(coreSkillsSrc)) {
+          await cp(coreSkillsSrc, join7(stagedPath2, "core", "skills"), { recursive: true });
+        }
+        await writeFile2(join7(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version }, null, 2) + "\n");
+        await copyFile(join7(repoRoot, "install-manifest.json"), join7(stagedPath2, "install-manifest.json"));
+        const packageLockHash2 = await hashFile(join7(repoRoot, "package-lock.json"));
+        return { version, stagedPath: stagedPath2, commit, branch, packageLockHash: packageLockHash2, source: "local" };
+      }
+      runCmd("npm", ["run", "build"], repoRoot);
+      const stagedPath = join7(ctx.releasesDir, version);
+      await rm(stagedPath, { recursive: true, force: true });
+      await mkdir2(stagedPath, { recursive: true });
+      await cp(join7(repoRoot, "dist"), join7(stagedPath, "dist"), { recursive: true });
+      await copyFile(join7(repoRoot, "install-manifest.json"), join7(stagedPath, "install-manifest.json"));
+      await rm(ctx.nodeModulesDir, { recursive: true, force: true });
+      await mkdir2(ctx.nodeModulesDir, { recursive: true });
+      const rsyncResult = spawnSync2(
+        "rsync",
+        ["-aL", "--quiet", `${join7(repoRoot, "node_modules")}/`, `${ctx.nodeModulesDir}/`],
+        { stdio: "inherit" }
+      );
+      if (rsyncResult.status !== 0) {
+        throw new LocalBuildError(
+          `rsync of node_modules failed (status ${rsyncResult.status ?? -1})`,
+          `Ensure rsync is installed. Falling back to node cp would re-create symlinks.`
+        );
+      }
+      const packageLockHash = await hashFile(join7(repoRoot, "package-lock.json"));
+      return { version, stagedPath, commit, branch, packageLockHash, source: "local" };
+    }
+  };
+}
+
+// src/cli/update-sources/npm.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync3, unlinkSync as unlinkSync4 } from "node:fs";
+import { mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+var TIMEOUT_MS = 6e4;
+function run(cmd, args, cwd) {
+  const r = spawnSync3(cmd, args, { cwd, encoding: "utf-8", timeout: TIMEOUT_MS });
+  if (r.error) throw new Error(`${cmd} ${args.join(" ")}: ${r.error.message}`);
+  if (r.status !== 0) throw new Error(`${cmd} ${args.join(" ")} exited ${r.status}: ${r.stderr?.trim()}`);
+  return r.stdout.trim();
+}
+function readLocalVersion(home) {
+  try {
+    const pkg = JSON.parse(readFileSync3(join8(home, "current", "package.json"), "utf-8"));
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function makeNpmSource(packageName) {
+  return {
+    name: "npm",
+    async prepare(ctx) {
+      const latest = run("npm", ["view", packageName, "version"], ctx.home);
+      const current = readLocalVersion(ctx.home);
+      if (latest === current) {
+        throw new Error(`Already at latest version (${latest}). Nothing to update.`);
+      }
+      const stagedPath = join8(ctx.releasesDir, latest);
+      await rm2(stagedPath, { recursive: true, force: true });
+      await mkdir3(stagedPath, { recursive: true });
+      run("npm", ["pack", `${packageName}@${latest}`, "--pack-destination", stagedPath], stagedPath);
+      const tgzName = `${packageName}-${latest}.tgz`.replace("@", "").replace("/", "-");
+      const tgzPath = join8(stagedPath, tgzName);
+      run("tar", ["-xzf", tgzPath, "--strip-components=1"], stagedPath);
+      if (existsSync6(tgzPath)) unlinkSync4(tgzPath);
+      run("npm", ["install", "--omit=dev", "--no-audit", "--no-fund"], stagedPath);
+      return { version: latest, stagedPath, commit: null, branch: null, packageLockHash: null, source: "npm" };
+    }
+  };
+}
+
+// src/cli/commands/update.ts
+function readJsonField2(file, field) {
+  try {
+    return JSON.parse(readFileSync4(file, "utf-8"))[field];
+  } catch {
+    return void 0;
+  }
+}
+async function update(opts) {
+  if (opts.source !== "local" && opts.source !== "npm") {
+    process.stderr.write(`--source ${opts.source} is not yet supported.
+Use --source local (default) or --source npm.
+`);
+    return 2;
+  }
+  const paths = packagePaths("abtars");
+  if (!existsSync7(paths.releases) && existsSync7(join9(paths.home, "current"))) {
+    process.stdout.write("Migrating old layout \u2192 releases/...\n");
+    mkdirSync2(paths.releases, { recursive: true });
+  }
+  const release = await acquireLock(paths.lock, `update --source ${opts.source}`);
+  try {
+    let repoRoot = opts.repoRoot ?? process.cwd();
+    if (!opts.repoRoot && !existsSync7(join9(repoRoot, ".git"))) {
+      const { realpathSync } = await import("node:fs");
+      const scriptPath = realpathSync(process.argv[1] ?? "");
+      const candidate = join9(dirname3(scriptPath), "..");
+      if (existsSync7(join9(candidate, "bundle"))) repoRoot = candidate;
+    }
+    const source = opts.source === "npm" ? makeNpmSource("abtars") : makeLocalBuildSource({ repoRoot, allowStale: opts.fromLocal });
+    if (opts.fromLocal) {
+      showHintOnce("update-from-local", "Building from working copy (--from-local). To sync with remote first: git pull && abtars update");
+    }
+    process.stdout.write(`Building from local checkout (${process.cwd()})...
+`);
+    const staged = await source.prepare({
+      releasesDir: paths.releases,
+      nodeModulesDir: paths.nodeModules,
+      home: paths.home,
+      allowStale: opts.fromLocal
+    });
+    process.stdout.write(`\u2713 staged ${staged.version} at ${staged.stagedPath}
+`);
+    {
+      const pkgPath = join9(staged.stagedPath, "package.json");
+      const { readFileSync: readFileSync5, writeFileSync: writeFileSync2 } = await import("node:fs");
+      try {
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+        const externals = { patchright: "^1.59.4", "rettiwt-api": "^4.1.3" };
+        pkg.dependencies = { ...pkg.dependencies, ...externals };
+        writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+        const { execSync } = await import("node:child_process");
+        execSync("npm install --omit=dev --ignore-scripts 2>/dev/null", { cwd: staged.stagedPath, timeout: 6e4 });
+        process.stdout.write(`\u2713 external deps installed
+`);
+      } catch (err) {
+        process.stdout.write(`\u26A0 external deps install failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+    {
+      const { existsSync: existsSync8, unlinkSync: unlinkSync5, symlinkSync } = await import("node:fs");
+      const mainLink = join9(staged.stagedPath, "main.js");
+      try {
+        unlinkSync5(mainLink);
+      } catch (err) {
+        logAndSwallow("update", "op", err);
+      }
+      const entry = existsSync8(join9(staged.stagedPath, "bundle", "abtars.js")) ? "bundle/abtars.js" : "dist/main.js";
+      symlinkSync(entry, mainLink);
+    }
+    const { existsSync: ex2, lstatSync, readlinkSync: readlinkSync2, symlinkSync: sl2, mkdirSync: mk2 } = await import("node:fs");
+    const oldNm = join9(paths.home, "current", "node_modules");
+    const preservedLinks = [];
+    if (ex2(oldNm)) {
+      for (const name of ["abmind", "better-sqlite3"]) {
+        const p = join9(oldNm, name);
+        try {
+          if (ex2(p) && lstatSync(p).isSymbolicLink()) preservedLinks.push({ name, target: readlinkSync2(p) });
+        } catch {
+        }
+      }
+    }
+    await activate(paths.current, staged.version);
+    process.stdout.write(`\u2713 current -> releases/${staged.version}
+`);
+    if (preservedLinks.length > 0) {
+      const newNm = join9(paths.home, "current", "node_modules");
+      mk2(newNm, { recursive: true });
+      for (const { name, target } of preservedLinks) {
+        try {
+          sl2(target, join9(newNm, name));
+        } catch {
+        }
+      }
+    }
+    const prior = await readManifest(paths.manifest);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const newPriorReleases = prior?.version ? [
+      {
+        version: prior.version,
+        commit: prior.commit,
+        activatedAt: prior.activatedAt,
+        packageLockHash: prior.packageLockHash
+      },
+      ...prior.priorReleases ?? []
+    ].slice(0, RETENTION - 1) : prior?.priorReleases ?? [];
+    await writeManifest(paths.manifest, {
+      ...prior ?? emptyManifest("abtars", hostname2()),
+      version: staged.version,
+      commit: staged.commit,
+      branch: staged.branch,
+      packageLockHash: staged.packageLockHash,
+      activatedAt: now,
+      source: "local",
+      priorReleases: newPriorReleases
+    });
+    process.stdout.write(`\u2713 manifest updated
+`);
+    const pruned = await pruneReleases(
+      paths.releases,
+      [staged.version, ...newPriorReleases.map((r) => r.version)],
+      staged.version,
+      RETENTION
+    );
+    if (pruned.length > 0) {
+      process.stdout.write(`\u2713 pruned ${pruned.length} old release${pruned.length === 1 ? "" : "s"}: ${pruned.join(", ")}
+`);
+    }
+    process.stdout.write(`
+Update complete: ${staged.version}
+`);
+    const { loadManifest } = await import("./install-manifest-MCJCAYSR.js");
+    const sourceRoot = staged.stagedPath;
+    const installManifest = loadManifest(sourceRoot);
+    const repoScripts = join9(sourceRoot, "scripts");
+    const destScripts = join9(paths.home, "scripts");
+    await mkdir4(destScripts, { recursive: true });
+    const allScriptFiles = await readdir(repoScripts).catch(() => []);
+    const matchesInclude = (name) => installManifest.scripts.include.some((pattern) => {
+      const ext = pattern.replace("*", "");
+      return name.endsWith(ext);
+    });
+    const scriptFiles = allScriptFiles.filter(matchesInclude);
+    const home = process.env["HOME"] ?? "";
+    let serviceChanged = false;
+    const installMode = (await readManifest(paths.manifest))?.installMode ?? "supervised";
+    const isExecutable = (name) => {
+      const ext = installManifest.scripts.executable.replace("*", "");
+      return name.endsWith(ext);
+    };
+    for (const name of scriptFiles) {
+      await copyFile2(join9(repoScripts, name), join9(destScripts, name));
+      if (isExecutable(name)) await chmod(join9(destScripts, name), 493);
+      if (isExecutable(name)) {
+        await copyFile2(join9(repoScripts, name), join9(paths.home, name));
+        await chmod(join9(paths.home, name), 493);
+      }
+      const macService = installManifest.services.supervised.macos;
+      if (macService && name === macService.plist && process.platform === "darwin" && home && installMode === "supervised") {
+        const launchAgentsDir = join9(home, "Library", "LaunchAgents");
+        await mkdir4(launchAgentsDir, { recursive: true });
+        const dst = join9(launchAgentsDir, name);
+        const oldContent = await readFile3(dst, "utf-8").catch(() => "");
+        let templated = await readFile3(join9(repoScripts, name), "utf-8");
+        for (const ph of macService.placeholders) templated = templated.replaceAll(ph, home);
+        await writeFile3(dst, templated);
+        if (oldContent !== templated) serviceChanged = true;
+      }
+      const linuxService = installManifest.services.supervised.linux;
+      if (linuxService?.units.includes(name) && process.platform === "linux" && home && installMode === "supervised") {
+        const systemdDir = join9(home, ".config", "systemd", "user");
+        await mkdir4(systemdDir, { recursive: true });
+        const dst = join9(systemdDir, name);
+        const oldContent = await readFile3(dst, "utf-8").catch(() => "");
+        await copyFile2(join9(repoScripts, name), dst);
+        const newContent = await readFile3(dst, "utf-8").catch(() => "");
+        if (oldContent !== newContent) serviceChanged = true;
+      }
+    }
+    process.stdout.write(`\u2713 scripts refreshed (${scriptFiles.length} files)
+`);
+    const { writeWrapper } = await import("./install-AJ7VW76P.js");
+    await mkdir4(paths.bin, { recursive: true });
+    for (const name of installManifest.cliWrappers) {
+      await writeWrapper(paths.bin, name, paths.current, false);
+    }
+    process.stdout.write(`\u2713 wrappers refreshed (${installManifest.cliWrappers.length} files)
+`);
+    const { rmSync: rmSync2, cpSync, readdirSync: readdirSync3 } = await import("node:fs");
+    const skillsCoreSrc = join9(staged.stagedPath, "core", "skills");
+    const skillsCoreDst = join9(paths.home, "skills", "core");
+    if (existsSync7(skillsCoreSrc)) {
+      rmSync2(skillsCoreDst, { recursive: true, force: true });
+      cpSync(skillsCoreSrc, skillsCoreDst, { recursive: true });
+      const files = readdirSync3(skillsCoreDst, { recursive: true });
+      const count = files.filter((f) => f.endsWith("SKILL.md")).length;
+      process.stdout.write(`\u2713 skills/core synced (${count} skills)
+`);
+    }
+    for (const d of ["custom", "downloaded", "self"]) {
+      await mkdir4(join9(paths.home, "skills", d), { recursive: true });
+    }
+    for (const stale of ["memory", "ops", "tools", "coding"]) {
+      const p = join9(paths.home, "skills", stale);
+      if (existsSync7(p)) {
+        rmSync2(p, { recursive: true, force: true });
+      }
+    }
+    const releaseConfig = join9(staged.stagedPath, "config");
+    const destConfig = join9(paths.home, "config");
+    if (existsSync7(releaseConfig)) {
+      for (const f of readdirSync3(releaseConfig)) {
+        if (!f.endsWith(".example")) continue;
+        const target = join9(destConfig, f.replace(".example", ""));
+        if (!existsSync7(target)) {
+          cpSync(join9(releaseConfig, f), target);
+        }
+      }
+      const defaultTransport = join9(releaseConfig, "transport.default.json");
+      if (existsSync7(defaultTransport)) cpSync(defaultTransport, join9(destConfig, "transport.default.json"));
+    }
+    const coreSrc = join9(staged.stagedPath, "core");
+    const coreDst = join9(paths.home, "core");
+    if (existsSync7(coreSrc)) {
+      await mkdir4(coreDst, { recursive: true });
+      cpSync(coreSrc, coreDst, { recursive: true });
+    }
+    if (serviceChanged) {
+      if (process.platform === "darwin") {
+        process.stdout.write(`\u26A0\uFE0F  LaunchAgent plist updated \u2014 reload with: launchctl bootout gui/$(id -u)/com.abtars.watchdog && launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.abtars.watchdog.plist
+`);
+      } else {
+        process.stdout.write(`\u26A0\uFE0F  systemd service updated \u2014 reload with: systemctl --user daemon-reload && systemctl --user restart abtars-watchdog
+`);
+      }
+    }
+    void hashFile;
+    const { ensureInstallInvariants } = await import("./ensure-invariants-K2ZUZ6NR.js");
+    const invariantResults = await ensureInstallInvariants(process.cwd(), paths.home);
+    if (invariantResults.length > 0) {
+      process.stdout.write(`\u2713 invariants: ${invariantResults.join(", ")}
+`);
+    }
+    const doctorPath = join9(paths.home, "scripts", "doctor.sh");
+    if (existsSync7(doctorPath)) {
+      process.stdout.write("\n\u{1FA7A} Health check...\n");
+      try {
+        const { execSync } = await import("node:child_process");
+        execSync(`bash "${doctorPath}" --fix`, { stdio: "inherit", timeout: 3e4 });
+      } catch (err) {
+        process.stderr.write(`\u26A0\uFE0F doctor --fix failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+    const manifestForRestart = await readManifest(paths.manifest);
+    const restartMode = manifestForRestart?.installMode;
+    if (!restartMode) {
+      process.stderr.write("\u274C installMode not set in manifest.json. Run 'abtars install' first.\n");
+      return 1;
+    }
+    if (restartMode === "supervised-daemon" || restartMode === "supervised") {
+      process.stdout.write("\nRestarting bridge via watchdog...\n");
+      const wdLock = join9(paths.home, "watchdog.lock");
+      const wdPid = readJsonField2(wdLock, "pid");
+      if (wdPid && wdPid > 0) {
+        try {
+          process.kill(wdPid, "SIGUSR1");
+          process.stdout.write(`\u267B\uFE0F USR1 sent to watchdog (PID ${wdPid}) \u2014 bridge will restart
+`);
+        } catch {
+          process.stdout.write(`\u26A0\uFE0F Could not signal watchdog (PID ${wdPid}). Restart manually:
+`);
+          if (process.platform === "darwin") {
+            process.stdout.write(`  launchctl kickstart -k gui/$(id -u)/com.abtars.watchdog
+`);
+          } else {
+            process.stdout.write(`  systemctl --user restart abtars-watchdog
+`);
+          }
+        }
+      } else {
+        process.stdout.write(`\u26A0\uFE0F Watchdog not running. Cold restart...
+`);
+        const { restart: restart2 } = await import("./abtars-restart.js");
+        await restart2({ cold: true }).catch((err) => {
+          process.stderr.write(`\u26A0\uFE0F Restart failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        });
+      }
+    } else {
+      process.stdout.write("\nRestarting bridge...\n");
+      const { restart: restart2 } = await import("./abtars-restart.js");
+      await restart2({ cold: true }).catch((err) => {
+        process.stderr.write(`\u26A0\uFE0F Restart failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      });
+    }
+    const { printHealthSummary } = await import("./health-check-RJ2SUJYL.js");
+    printHealthSummary(paths.home);
+    return 0;
+  } finally {
+    await release();
+  }
+}
+
 // src/cli/abtars.ts
 process.umask(63);
 function parseArgs(argv) {