abtars 0.1.0-alpha.14 → 0.1.0-alpha.16

package/bundle/abtars-cli.js

@@ -3,7 +3,7 @@
 import {
   showHintOnce,
   update
-} from "./chunk-3Z3EP7E6.js";
+} from "./chunk-TQG56KI3.js";
 import {
   install
 } from "./chunk-RB3X66KM.js";
@@ -1036,7 +1036,7 @@ Next: cd into the abtars repo and run 'abtars update' to build and activate.
   process.stdout.write(`
 \u2500\u2500 Running 'abtars update' \u2500\u2500
 `);
-  const { update: update2 } = await import("./update-U7M63AAV.js");
+  const { update: update2 } = await import("./update-XLWLAPLP.js");
   const updRc = await update2({ source: "local", fromLocal: true, allowAbmindMismatch: false });
   if (updRc !== 0) {
     process.stderr.write(`

package/bundle/chunk-TQG56KI3.js

@@ -0,0 +1,542 @@
+#!/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 {
+  RETENTION,
+  acquireLock,
+  activate,
+  emptyManifest,
+  hashFile,
+  packagePaths,
+  pruneReleases,
+  readManifest,
+  writeManifest
+} from "./chunk-HXJRZWKA.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-EX2SRTUE.js";
+
+// src/cli/commands/update.ts
+init_log_and_swallow();
+import { hostname } from "node:os";
+import { join as join4, dirname } from "node:path";
+import { readFileSync as readFileSync3, existsSync as existsSync4, mkdirSync } from "node:fs";
+import { copyFile as copyFile2, mkdir as mkdir3, chmod, readdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+
+// src/cli/update-sources/local.ts
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { copyFile, cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } 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 = spawnSync(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 = spawnSync(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 readFile(join(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 = !existsSync(join(repoRoot, ".git"));
+  return {
+    name: "local",
+    async prepare(ctx) {
+      if (isNpmPackage) {
+        const bundleDir = join(repoRoot, "bundle");
+        if (!existsSync(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 = join(ctx.releasesDir, version2);
+        await rm(stagedPath2, { recursive: true, force: true });
+        await mkdir(stagedPath2, { recursive: true });
+        await cp(bundleDir, join(stagedPath2, "bundle"), { recursive: true });
+        const coreDir = join(repoRoot, "core");
+        if (existsSync(coreDir)) await cp(coreDir, join(stagedPath2, "core"), { recursive: true });
+        const scriptsSrc = join(repoRoot, "scripts");
+        if (existsSync(scriptsSrc)) await cp(scriptsSrc, join(stagedPath2, "scripts"), { recursive: true });
+        const manifestSrc = join(repoRoot, "install-manifest.json");
+        if (existsSync(manifestSrc)) await copyFile(manifestSrc, join(stagedPath2, "install-manifest.json"));
+        await writeFile(join(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 = join(ctx.releasesDir, version);
+        await rm(stagedPath2, { recursive: true, force: true });
+        await mkdir(stagedPath2, { recursive: true });
+        await cp(join(repoRoot, "bundle"), join(stagedPath2, "bundle"), { recursive: true });
+        const coreSkillsSrc = join(repoRoot, "core", "skills");
+        if (existsSync(coreSkillsSrc)) {
+          await cp(coreSkillsSrc, join(stagedPath2, "core", "skills"), { recursive: true });
+        }
+        await writeFile(join(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version }, null, 2) + "\n");
+        await copyFile(join(repoRoot, "install-manifest.json"), join(stagedPath2, "install-manifest.json"));
+        const packageLockHash2 = await hashFile(join(repoRoot, "package-lock.json"));
+        return { version, stagedPath: stagedPath2, commit, branch, packageLockHash: packageLockHash2, source: "local" };
+      }
+      runCmd("npm", ["run", "build"], repoRoot);
+      const stagedPath = join(ctx.releasesDir, version);
+      await rm(stagedPath, { recursive: true, force: true });
+      await mkdir(stagedPath, { recursive: true });
+      await cp(join(repoRoot, "dist"), join(stagedPath, "dist"), { recursive: true });
+      await copyFile(join(repoRoot, "install-manifest.json"), join(stagedPath, "install-manifest.json"));
+      await rm(ctx.nodeModulesDir, { recursive: true, force: true });
+      await mkdir(ctx.nodeModulesDir, { recursive: true });
+      const rsyncResult = spawnSync(
+        "rsync",
+        ["-aL", "--quiet", `${join(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(join(repoRoot, "package-lock.json"));
+      return { version, stagedPath, commit, branch, packageLockHash, source: "local" };
+    }
+  };
+}
+
+// src/cli/update-sources/npm.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync2, readFileSync, unlinkSync } from "node:fs";
+import { mkdir as mkdir2, rm as rm2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var TIMEOUT_MS = 6e4;
+function run(cmd, args, cwd) {
+  const r = spawnSync2(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(readFileSync(join2(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 = join2(ctx.releasesDir, latest);
+      await rm2(stagedPath, { recursive: true, force: true });
+      await mkdir2(stagedPath, { recursive: true });
+      run("npm", ["pack", `${packageName}@${latest}`, "--pack-destination", stagedPath], stagedPath);
+      const tgzName = `${packageName}-${latest}.tgz`.replace("@", "").replace("/", "-");
+      const tgzPath = join2(stagedPath, tgzName);
+      run("tar", ["-xzf", tgzPath, "--strip-components=1"], stagedPath);
+      if (existsSync2(tgzPath)) unlinkSync(tgzPath);
+      run("npm", ["install", "--omit=dev", "--no-audit", "--no-fund"], stagedPath);
+      return { version: latest, stagedPath, commit: null, branch: null, packageLockHash: null, source: "npm" };
+    }
+  };
+}
+
+// src/components/hints.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, renameSync } from "node:fs";
+import { join as join3 } from "node:path";
+function manifestPath() {
+  const home = process.env["ABTARS_HOME"] ?? join3(process.env["HOME"] ?? "", ".abtars");
+  return join3(home, "manifest.json");
+}
+function readManifest2() {
+  const path = manifestPath();
+  if (!existsSync3(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");
+  renameSync(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/update.ts
+function readJsonField(file, field) {
+  try {
+    return JSON.parse(readFileSync3(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 (!existsSync4(paths.releases) && existsSync4(join4(paths.home, "current"))) {
+    process.stdout.write("Migrating old layout \u2192 releases/...\n");
+    mkdirSync(paths.releases, { recursive: true });
+  }
+  const release = await acquireLock(paths.lock, `update --source ${opts.source}`);
+  try {
+    let repoRoot = opts.repoRoot ?? process.cwd();
+    if (!opts.repoRoot && !existsSync4(join4(repoRoot, ".git"))) {
+      const { realpathSync } = await import("node:fs");
+      const scriptPath = realpathSync(process.argv[1] ?? "");
+      const candidate = join4(dirname(scriptPath), "..");
+      if (existsSync4(join4(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 = join4(staged.stagedPath, "package.json");
+      const { readFileSync: readFileSync4, writeFileSync: writeFileSync2 } = await import("node:fs");
+      try {
+        const pkg = JSON.parse(readFileSync4(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: existsSync5, unlinkSync: unlinkSync2, symlinkSync } = await import("node:fs");
+      const mainLink = join4(staged.stagedPath, "main.js");
+      try {
+        unlinkSync2(mainLink);
+      } catch (err) {
+        logAndSwallow("update", "op", err);
+      }
+      const entry = existsSync5(join4(staged.stagedPath, "bundle", "abtars.js")) ? "bundle/abtars.js" : "dist/main.js";
+      symlinkSync(entry, mainLink);
+    }
+    const { existsSync: ex2, lstatSync, readlinkSync, symlinkSync: sl2, mkdirSync: mk2 } = await import("node:fs");
+    const oldNm = join4(paths.home, "current", "node_modules");
+    const preservedLinks = [];
+    if (ex2(oldNm)) {
+      for (const name of ["abmind", "better-sqlite3"]) {
+        const p = join4(oldNm, name);
+        try {
+          if (ex2(p) && lstatSync(p).isSymbolicLink()) preservedLinks.push({ name, target: readlinkSync(p) });
+        } catch {
+        }
+      }
+    }
+    await activate(paths.current, staged.version);
+    process.stdout.write(`\u2713 current -> releases/${staged.version}
+`);
+    if (preservedLinks.length > 0) {
+      const newNm = join4(paths.home, "current", "node_modules");
+      mk2(newNm, { recursive: true });
+      for (const { name, target } of preservedLinks) {
+        try {
+          sl2(target, join4(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", hostname()),
+      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 = join4(sourceRoot, "scripts");
+    const destScripts = join4(paths.home, "scripts");
+    await mkdir3(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(join4(repoScripts, name), join4(destScripts, name));
+      if (isExecutable(name)) await chmod(join4(destScripts, name), 493);
+      if (isExecutable(name)) {
+        await copyFile2(join4(repoScripts, name), join4(paths.home, name));
+        await chmod(join4(paths.home, name), 493);
+      }
+      const macService = installManifest.services.supervised.macos;
+      if (macService && name === macService.plist && process.platform === "darwin" && home && installMode === "supervised") {
+        const launchAgentsDir = join4(home, "Library", "LaunchAgents");
+        await mkdir3(launchAgentsDir, { recursive: true });
+        const dst = join4(launchAgentsDir, name);
+        const oldContent = await readFile2(dst, "utf-8").catch(() => "");
+        let templated = await readFile2(join4(repoScripts, name), "utf-8");
+        for (const ph of macService.placeholders) templated = templated.replaceAll(ph, home);
+        await writeFile2(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 = join4(home, ".config", "systemd", "user");
+        await mkdir3(systemdDir, { recursive: true });
+        const dst = join4(systemdDir, name);
+        const oldContent = await readFile2(dst, "utf-8").catch(() => "");
+        await copyFile2(join4(repoScripts, name), dst);
+        const newContent = await readFile2(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 mkdir3(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, cpSync, readdirSync } = await import("node:fs");
+    const skillsCoreSrc = join4(staged.stagedPath, "core", "skills");
+    const skillsCoreDst = join4(paths.home, "skills", "core");
+    if (existsSync4(skillsCoreSrc)) {
+      rmSync(skillsCoreDst, { recursive: true, force: true });
+      cpSync(skillsCoreSrc, skillsCoreDst, { recursive: true });
+      const files = readdirSync(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 mkdir3(join4(paths.home, "skills", d), { recursive: true });
+    }
+    for (const stale of ["memory", "ops", "tools", "coding"]) {
+      const p = join4(paths.home, "skills", stale);
+      if (existsSync4(p)) {
+        rmSync(p, { recursive: true, force: 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 = join4(paths.home, "scripts", "doctor.sh");
+    if (existsSync4(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 = join4(paths.home, "watchdog.lock");
+      const wdPid = readJsonField(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 } = await import("./abtars-restart.js");
+        await restart({ 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 } = await import("./abtars-restart.js");
+      await restart({ 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();
+  }
+}
+
+export {
+  showHintOnce,
+  update
+};
+//# sourceMappingURL=chunk-TQG56KI3.js.map