@todos-dev/cli 0.1.3 → 0.1.4

package/dist/index.js

@@ -1367,6 +1367,18 @@ function clearConfig() {
   }
 }
 
+// src/lib/log.ts
+var installed = false;
+function installTimestampedLogging() {
+  if (installed) return;
+  installed = true;
+  const stamp = () => `[${(/* @__PURE__ */ new Date()).toISOString()}]`;
+  for (const method of ["log", "info", "warn", "error", "debug"]) {
+    const orig = console[method].bind(console);
+    console[method] = (...args2) => orig(stamp(), ...args2);
+  }
+}
+
 // src/lib/daemon.ts
 var LOG_CAP = 10 * 1024 * 1024;
 var EXIT_TERMINAL = 78;
@@ -1431,6 +1443,7 @@ function spawnSupervisor(userArgs, logFd) {
 var MODE_FLAGS = /* @__PURE__ */ new Set(["--supervisor", "--foreground", "-f"]);
 var userFlagsOnly = (args2) => args2.filter((a) => !MODE_FLAGS.has(a));
 async function runSupervisor(args2) {
+  installTimestampedLogging();
   const userArgs = userFlagsOnly(args2);
   const MAX_BACKOFF = 3e4;
   const STABLE_MS = 6e4;
@@ -14173,14 +14186,14 @@ var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 var _installedGroups = /* @__PURE__ */ new WeakMap();
 function _installLazyMethods(inst, group, methods) {
   const proto = Object.getPrototypeOf(inst);
-  let installed = _installedGroups.get(proto);
-  if (!installed) {
-    installed = /* @__PURE__ */ new Set();
-    _installedGroups.set(proto, installed);
+  let installed2 = _installedGroups.get(proto);
+  if (!installed2) {
+    installed2 = /* @__PURE__ */ new Set();
+    _installedGroups.set(proto, installed2);
   }
-  if (installed.has(group))
+  if (installed2.has(group))
     return;
-  installed.add(group);
+  installed2.add(group);
   for (const key in methods) {
     const fn = methods[key];
     Object.defineProperty(proto, key, {
@@ -16183,6 +16196,7 @@ var PollClient = class {
   runningTasks = /* @__PURE__ */ new Map();
   presenceTimer = null;
   gcTimer = null;
+  pokeTimer = null;
   lastSentTunnelKey;
   revoked = false;
   maxConcurrentTasks = null;
@@ -16223,6 +16237,16 @@ var PollClient = class {
     tunnel?.setNodeChangeHandler(() => void this.reportPresence());
     void this.reportPresence();
   }
+  // Out-of-cycle beat for mirror-health transitions, so the web flips within ~a second
+  // instead of waiting out the ≤20s presence tail. Debounced: a burst of transitions (daemon
+  // restart syncing every mount at once) collapses into one POST carrying the final state.
+  pokePresence() {
+    if (this.pokeTimer) return;
+    this.pokeTimer = setTimeout(() => {
+      this.pokeTimer = null;
+      void this.reportPresence();
+    }, 250);
+  }
   maybeStartClaim() {
     if (this.running && this.canClaim && !this.loopActive) {
       this.loopActive = true;
@@ -16257,6 +16281,10 @@ var PollClient = class {
       clearInterval(this.gcTimer);
       this.gcTimer = null;
     }
+    if (this.pokeTimer) {
+      clearTimeout(this.pokeTimer);
+      this.pokeTimer = null;
+    }
   }
   // The machine was removed from its team (or its token revoked): every /api/machine/* call now
   // 401/403s. Fail fast instead of spinning forever — stop and exit so the operator notices.
@@ -16413,10 +16441,12 @@ function sleep(ms, signal) {
 }
 
 // src/SyncManager.ts
-var import_node_child_process2 = require("node:child_process");
 var import_node_os4 = require("node:os");
 var import_node_path6 = require("node:path");
 
+// src/lib/sidecar.ts
+var import_node_child_process2 = require("node:child_process");
+
 // src/lib/bin.ts
 var import_node_fs5 = require("node:fs");
 var import_node_path5 = require("node:path");
@@ -16482,31 +16512,24 @@ function createNdjsonParser(onEvent) {
   };
 }
 
-// src/SyncManager.ts
+// src/lib/sidecar.ts
 var RESTART_MIN_MS = 1e3;
 var RESTART_MAX_MS = 6e4;
-function expandHome(p) {
-  if (p === "~") return (0, import_node_os4.homedir)();
-  if (p.startsWith("~/") || p.startsWith("~\\")) return (0, import_node_path6.join)((0, import_node_os4.homedir)(), p.slice(2));
-  return p;
-}
-var SyncManager = class {
-  // by mountId
-  constructor(serverUrl, token, machineId) {
-    this.serverUrl = serverUrl;
-    this.token = token;
-    this.machineId = machineId;
+var Sidecar = class {
+  constructor(args2, label, onEvent, onExit) {
+    this.args = args2;
+    this.label = label;
+    this.onExit = onExit;
+    this.parse = createNdjsonParser(onEvent);
   }
   proc = null;
   stopped = false;
   restartTimer = null;
   restartDelayMs = RESTART_MIN_MS;
-  desired = [];
-  health = /* @__PURE__ */ new Map();
+  parse;
   start() {
     this.stopped = false;
-    console.log(`[machine] runner: managing worktree mirrors (machineId=${this.machineId})`);
-    this.spawnSidecar();
+    this.spawn();
   }
   stop() {
     this.stopped = true;
@@ -16517,6 +16540,88 @@ var SyncManager = class {
     this.proc?.kill();
     this.proc = null;
   }
+  // Owner saw the sidecar's healthy signal — future crashes retry quickly again.
+  resetBackoff() {
+    this.restartDelayMs = RESTART_MIN_MS;
+  }
+  // Whether control messages can be sent at all (process up with a writable stdin).
+  alive() {
+    return Boolean(this.proc && !this.proc.killed && this.proc.stdin && !this.proc.stdin.destroyed);
+  }
+  // Write one NDJSON control message to the sidecar's stdin; false when it can't be delivered
+  // (the exit/respawn path is the recovery, so callers just skip).
+  write(msg) {
+    const stdin = this.proc?.stdin;
+    if (!stdin || stdin.destroyed) return false;
+    try {
+      stdin.write(JSON.stringify(msg) + "\n");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  spawn() {
+    try {
+      this.proc = (0, import_node_child_process2.spawn)(TUNNEL_BIN, this.args, { stdio: ["pipe", "pipe", "inherit"] });
+    } catch {
+      console.warn(`[${this.label}] tds-tunnel not available \u2014 disabled`);
+      return;
+    }
+    this.proc.on("error", () => {
+      console.warn(`[${this.label}] sidecar failed to start \u2014 disabled`);
+      this.proc = null;
+    });
+    this.proc.on("exit", () => {
+      this.proc = null;
+      this.onExit?.();
+      this.scheduleRestart();
+    });
+    this.proc.stdout?.on("data", (d) => this.parse(String(d)));
+    this.proc.stdin?.on("error", () => {
+    });
+  }
+  scheduleRestart() {
+    if (this.stopped || this.restartTimer) return;
+    const delay2 = this.restartDelayMs;
+    this.restartDelayMs = Math.min(this.restartDelayMs * 2, RESTART_MAX_MS);
+    console.warn(`[${this.label}] sidecar exited \u2014 restarting in ${Math.round(delay2 / 1e3)}s`);
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      this.spawn();
+    }, delay2);
+  }
+};
+
+// src/SyncManager.ts
+function expandHome(p) {
+  if (p === "~") return (0, import_node_os4.homedir)();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return (0, import_node_path6.join)((0, import_node_os4.homedir)(), p.slice(2));
+  return p;
+}
+var WORKTREE_REBUILD_PATIENCE_MS = 18e4;
+var SyncManager = class {
+  constructor(serverUrl, token, machineId) {
+    this.machineId = machineId;
+    this.sidecar = new Sidecar(
+      ["mirror", "--server", serverUrl, "--token", token, "--machine", machineId],
+      "runner",
+      (e) => this.onEvent(e)
+    );
+  }
+  sidecar;
+  desired = [];
+  health = /* @__PURE__ */ new Map();
+  // by mountId
+  // Fired on coarse health transitions (first cycle, error set/cleared) so the presence beat
+  // carrying the change goes out immediately instead of on the next 20s tick.
+  onHealthChanged;
+  start() {
+    console.log(`[machine] runner: managing worktree mirrors (machineId=${this.machineId})`);
+    this.sidecar.start();
+  }
+  stop() {
+    this.sidecar.stop();
+  }
   // Desired mounts, straight off the presence response. Declarative: resolve dests, remember the
   // set (a respawned daemon gets it replayed on its 'up' event), and forward it.
   setMounts(resolved) {
@@ -16545,64 +16650,36 @@ var SyncManager = class {
       };
     });
   }
-  spawnSidecar() {
-    try {
-      this.proc = (0, import_node_child_process2.spawn)(
-        TUNNEL_BIN,
-        ["mirror", "--server", this.serverUrl, "--token", this.token, "--machine", this.machineId],
-        // stdin is piped: the desired mount set goes down as NDJSON control messages.
-        { stdio: ["pipe", "pipe", "inherit"] }
-      );
-    } catch {
-      console.warn("[machine] runner: tds-tunnel not available \u2014 mirroring disabled");
-      return;
-    }
-    this.proc.on("error", () => {
-      console.warn("[machine] runner: mirror daemon failed to start \u2014 mirroring disabled");
-      this.proc = null;
-    });
-    this.proc.on("exit", () => {
-      this.proc = null;
-      this.scheduleRestart();
-    });
-    this.proc.stdout?.on("data", (d) => this.onStdout(String(d)));
-    this.proc.stdin?.on("error", () => {
-    });
-  }
-  scheduleRestart() {
-    if (this.stopped || this.restartTimer) return;
-    const delay2 = this.restartDelayMs;
-    this.restartDelayMs = Math.min(this.restartDelayMs * 2, RESTART_MAX_MS);
-    console.warn(`[machine] runner: mirror daemon exited \u2014 restarting in ${Math.round(delay2 / 1e3)}s`);
-    this.restartTimer = setTimeout(() => {
-      this.restartTimer = null;
-      this.spawnSidecar();
-    }, delay2);
-  }
-  onStdout = createNdjsonParser((e) => {
+  onEvent(e) {
     if (e.event === "up") {
-      this.restartDelayMs = RESTART_MIN_MS;
+      this.sidecar.resetBackoff();
       this.sendMounts();
     } else if (e.event === "synced" && e.mount) {
+      const prev = this.health.get(e.mount);
       this.health.set(e.mount, { syncedAt: Date.now(), lastError: null });
+      if (!prev?.syncedAt || prev.lastError) this.onHealthChanged?.();
       if (e.changed || e.deleted) console.log(`[machine] runner: mount ${e.mount} \u2193 ${e.changed ?? 0} changed, ${e.deleted ?? 0} deleted`);
+    } else if (e.event === "worktree-missing" && e.mount) {
+      const prev = this.health.get(e.mount);
+      const missingSince = prev?.missingSince ?? Date.now();
+      const lastError = Date.now() - missingSince > WORKTREE_REBUILD_PATIENCE_MS ? e.message ?? "worktree missing" : null;
+      this.health.set(e.mount, { syncedAt: 0, lastError, missingSince });
+      if (!!prev?.syncedAt || (prev?.lastError ?? null) !== lastError) this.onHealthChanged?.();
+      console.log(`[machine] runner: mount ${e.mount}: worktree missing \u2014 rebuild requested`);
     } else if (e.event === "error") {
       if (e.mount) {
-        const h = this.health.get(e.mount);
-        this.health.set(e.mount, { syncedAt: h?.syncedAt ?? 0, lastError: e.message ?? "error" });
-        console.warn(`[machine] runner: mount ${e.mount}: ${e.message ?? "error"}`);
+        const prev = this.health.get(e.mount);
+        const message = e.message ?? "error";
+        this.health.set(e.mount, { syncedAt: prev?.syncedAt ?? 0, lastError: message });
+        if (prev?.lastError !== message) this.onHealthChanged?.();
+        console.warn(`[machine] runner: mount ${e.mount}: ${message}`);
       } else {
         console.warn(`[machine] runner: ${e.message ?? "error"}`);
       }
     }
-  });
+  }
   sendMounts() {
-    const stdin = this.proc?.stdin;
-    if (!stdin || stdin.destroyed) return;
-    try {
-      stdin.write(JSON.stringify({ cmd: "mounts", mounts: this.desired }) + "\n");
-    } catch {
-    }
+    this.sidecar.write({ cmd: "mounts", mounts: this.desired });
   }
 };
 
@@ -16714,26 +16791,30 @@ async function syncModelsToServer(serverUrl, token, runtime) {
 }
 
 // src/lib/tunnel.ts
-var import_node_child_process3 = require("node:child_process");
 var SHELL_BUFFER_CAP = 256 * 1024;
-var RESTART_MIN_MS2 = 1e3;
-var RESTART_MAX_MS2 = 6e4;
 var EMPTY_BUFFER = Buffer.alloc(0);
 var TunnelServer = class _TunnelServer {
-  constructor(serverUrl, token) {
-    this.serverUrl = serverUrl;
-    this.token = token;
-  }
-  proc = null;
   node = null;
   onChange = null;
-  stopped = false;
-  restartTimer = null;
-  restartDelayMs = RESTART_MIN_MS2;
+  // Process lifecycle (spawn / respawn-with-backoff / stdin control) is the shared Sidecar's job;
+  // this class keeps only the domain state that dies with the process: node + shells.
+  sidecar;
   // Reverse shells, keyed by (build, machine) — a build mirrored onto several runners has one shell
   // per machine. Output is buffered even with no live subscriber so output a backgrounded command
   // emits between tool calls survives until the next drain.
   shells = /* @__PURE__ */ new Map();
+  constructor(serverUrl, token) {
+    this.sidecar = new Sidecar(
+      ["serve", "--server", serverUrl, "--token", token],
+      "tunnel",
+      (evt) => this.onEvent(evt),
+      () => {
+        this.node = null;
+        this.closeAllShells();
+        this.onChange?.();
+      }
+    );
+  }
   // Set the single handler fired whenever the tunnel node appears/changes/clears, so presence can
   // be pushed immediately instead of waiting for the next heartbeat tick. Fires now if already ready.
   setNodeChangeHandler(cb) {
@@ -16741,56 +16822,16 @@ var TunnelServer = class _TunnelServer {
     if (this.node) cb();
   }
   start() {
-    this.stopped = false;
-    this.spawnSidecar();
-  }
-  spawnSidecar() {
-    try {
-      this.proc = (0, import_node_child_process3.spawn)(
-        TUNNEL_BIN,
-        ["serve", "--server", this.serverUrl, "--token", this.token],
-        // stdin is piped (not ignored) so we can write reverse-shell control messages to the sidecar.
-        { stdio: ["pipe", "pipe", "inherit"] }
-      );
-    } catch {
-      console.warn("[tunnel] sidecar not available \u2014 runner mirroring disabled");
-      return;
-    }
-    this.proc.on("error", () => {
-      console.warn("[tunnel] sidecar failed to start \u2014 runner mirroring disabled");
-      this.proc = null;
-    });
-    this.proc.on("exit", () => {
-      this.proc = null;
-      this.node = null;
-      this.closeAllShells();
-      this.onChange?.();
-      this.scheduleRestart();
-    });
-    this.proc.stdout?.on("data", (d) => this.onStdout(String(d)));
-    this.proc.stdin?.on("error", () => {
-    });
-  }
-  scheduleRestart() {
-    if (this.stopped || this.restartTimer) return;
-    const delay2 = this.restartDelayMs;
-    this.restartDelayMs = Math.min(this.restartDelayMs * 2, RESTART_MAX_MS2);
-    console.warn(`[tunnel] sidecar exited \u2014 restarting in ${Math.round(delay2 / 1e3)}s`);
-    this.restartTimer = setTimeout(() => {
-      this.restartTimer = null;
-      this.spawnSidecar();
-    }, delay2);
+    this.sidecar.start();
   }
   // Reverse-shell map key: a build mirrored onto several runners has one shell per machine.
   static shellKey(build, machine) {
     return `${build}\0${machine}`;
   }
-  // Sidecar emits newline-delimited JSON events on stdout; `ready` carries the tunnel node, and
-  // shell-opened/shell-output/shell-closed carry reverse-shell traffic for a (build, machine).
-  onStdout = createNdjsonParser((evt) => {
+  onEvent(evt) {
     if (evt.event === "ready" && evt.tailnetAddr && evt.sshHostKey) {
       this.node = { tailnetAddr: evt.tailnetAddr, sshHostKey: evt.sshHostKey };
-      this.restartDelayMs = RESTART_MIN_MS2;
+      this.sidecar.resetBackoff();
       console.log(`[tunnel] ready (tailnet ${evt.tailnetAddr})`);
       this.onChange?.();
     } else if ((evt.event === "shell-opened" || evt.event === "shell-output" || evt.event === "shell-closed") && evt.build) {
@@ -16814,27 +16855,17 @@ var TunnelServer = class _TunnelServer {
     } else if (evt.event === "error") {
       console.warn(`[tunnel] ${evt.message ?? "error"}`);
     }
-  });
+  }
   // --- Reverse shell (agent → user's machine via the sync client) -----------------------------
   // Whether reverse-shell control can be sent at all (sidecar up with a writable stdin). The tool
   // checks this to fail fast instead of writing into the void.
   shellAvailable() {
-    return Boolean(this.proc && !this.proc.killed && this.proc.stdin && !this.proc.stdin.destroyed);
-  }
-  writeControl(msg) {
-    const stdin = this.proc?.stdin;
-    if (!stdin || stdin.destroyed) return false;
-    try {
-      stdin.write(JSON.stringify(msg) + "\n");
-      return true;
-    } catch {
-      return false;
-    }
+    return this.sidecar.alive();
   }
   // Send keystrokes/command text to a (build, machine) shell. data is UTF-8 text (may include control
   // bytes like \x03 for Ctrl-C); it's base64-framed on the wire.
   shellSendInput(build, machine, data) {
-    return this.writeControl({ cmd: "shell-input", build, machine, data: Buffer.from(data, "utf8").toString("base64") });
+    return this.sidecar.write({ cmd: "shell-input", build, machine, data: Buffer.from(data, "utf8").toString("base64") });
   }
   // Whether the client's shell channel is currently registered sidecar-side. undefined = no event
   // seen yet for this key (a client may still be connected — input discovers it); false = it was
@@ -16891,13 +16922,7 @@ var TunnelServer = class _TunnelServer {
     return this.node;
   }
   stop() {
-    this.stopped = true;
-    if (this.restartTimer) {
-      clearTimeout(this.restartTimer);
-      this.restartTimer = null;
-    }
-    this.proc?.kill();
-    this.proc = null;
+    this.sidecar.stop();
     this.node = null;
     this.closeAllShells();
   }
@@ -16957,6 +16982,7 @@ async function startCommand(args2) {
   const { flags, bools } = parseFlags(args2, { f: "foreground" });
   if (bools.supervisor) return runSupervisor(args2);
   if (bools.foreground) {
+    installTimestampedLogging();
     const { config: config2, serverUrl } = await ensureEnrolled(flags);
     return runWorker(config2, serverUrl);
   }
@@ -17089,6 +17115,7 @@ async function runWorker(config2, serverUrl) {
     syncManager.start();
     syncManager.setMounts(lastMounts);
     client.getMountSync = () => syncManager?.status() ?? null;
+    syncManager.onHealthChanged = () => client.pokePresence();
   };
   const disableRunner = () => {
     if (!syncManager) return;
@@ -17788,6 +17815,32 @@ async function logoutCommand() {
   console.log("[tds] Run 'tds start' to enroll again.");
 }
 
+// src/lib/version.ts
+var import_fs6 = require("fs");
+var import_path2 = require("path");
+function getVersion() {
+  let dir = __dirname;
+  for (let i = 0; i < 6; i++) {
+    const p = (0, import_path2.join)(dir, "package.json");
+    if ((0, import_fs6.existsSync)(p)) {
+      try {
+        const pkg = JSON.parse((0, import_fs6.readFileSync)(p, "utf-8"));
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+    const parent = (0, import_path2.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "unknown";
+}
+
+// src/commands/version.ts
+async function versionCommand() {
+  console.log(`tds ${getVersion()}`);
+}
+
 // src/index.ts
 var COMMANDS = {
   start: {
@@ -17857,6 +17910,13 @@ Stop the background daemon (if running), then clear ~/.tds/machine.json so the n
     help: `Usage: tds status
 
 Show this machine's registration and current status.`
+  },
+  version: {
+    run: () => versionCommand(),
+    summary: "Show the tds CLI version",
+    help: `Usage: tds version
+
+Print the installed tds CLI version.`
   },
   provider: {
     run: providerCommand,
@@ -17875,6 +17935,10 @@ Subcommands:
 var args = process.argv.slice(2);
 var cmd = args[0];
 var rest = args.slice(1);
+if (cmd === "--version" || cmd === "-v") {
+  console.log(`tds ${getVersion()}`);
+  process.exit(0);
+}
 if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
   const topic = cmd === "help" ? rest[0] : void 0;
   if (topic && COMMANDS[topic]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@todos-dev/cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "bin": {
     "tds": "dist/index.js"
   },
@@ -27,12 +27,12 @@
     "@tds/types": "0.1.0"
   },
   "optionalDependencies": {
-    "@todos-dev/cli-darwin-arm64": "0.1.3",
-    "@todos-dev/cli-darwin-x64": "0.1.3",
-    "@todos-dev/cli-linux-x64": "0.1.3",
-    "@todos-dev/cli-linux-arm64": "0.1.3",
-    "@todos-dev/cli-win32-x64": "0.1.3",
-    "@todos-dev/cli-win32-arm64": "0.1.3"
+    "@todos-dev/cli-darwin-arm64": "0.1.4",
+    "@todos-dev/cli-darwin-x64": "0.1.4",
+    "@todos-dev/cli-linux-x64": "0.1.4",
+    "@todos-dev/cli-linux-arm64": "0.1.4",
+    "@todos-dev/cli-win32-x64": "0.1.4",
+    "@todos-dev/cli-win32-arm64": "0.1.4"
   },
   "scripts": {
     "dev": "tsx watch src/index.ts",