@standardagents/code 0.9.1 → 0.9.3

package/dist/index.js

@@ -409,6 +409,21 @@ var ApiClient = class {
     } catch {
     }
   }
+  /**
+   * Run a user-typed `!command` on the thread's execution owner (wherever the
+   * session runs — e.g. a remote VPS daemon). The instance forwards it over
+   * the bridge, records it in history, and returns the combined output.
+   */
+  async runCommand(threadId, command) {
+    try {
+      return await this.json(
+        `/api/threads/${threadId}/run_command`,
+        { method: "POST", body: JSON.stringify({ command }) }
+      );
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
   /** The thread's current goal (set via set_goal / update_goal_step). */
   async getGoal(threadId) {
     try {
@@ -1208,9 +1223,9 @@ function setMcpServerEnabled(name, enabled) {
   write(cfg);
 }
 function write(cfg) {
-  const file = configFile();
-  fs4.mkdirSync(path3.dirname(file), { recursive: true });
-  fs4.writeFileSync(file, JSON.stringify(cfg, null, 2), { mode: 384 });
+  const file2 = configFile();
+  fs4.mkdirSync(path3.dirname(file2), { recursive: true });
+  fs4.writeFileSync(file2, JSON.stringify(cfg, null, 2), { mode: 384 });
 }
 function parseServerSpec(spec) {
   const trimmed = spec.trim();
@@ -1349,12 +1364,12 @@ var HostTools = class {
     }
   }
   async readFile(args) {
-    const file = this.resolve(String(args.path || ""));
-    const stat = await fsp.stat(file).catch(() => null);
+    const file2 = this.resolve(String(args.path || ""));
+    const stat = await fsp.stat(file2).catch(() => null);
     if (!stat) return { ok: false, error: `File not found: ${args.path}` };
     if (stat.isDirectory()) return { ok: false, error: `${args.path} is a directory` };
     if (stat.size > 2e6) return { ok: false, error: `File too large (${stat.size} bytes)` };
-    const content = await fsp.readFile(file, "utf8");
+    const content = await fsp.readFile(file2, "utf8");
     const lines = content.split("\n");
     const offset = typeof args.offset === "number" ? Math.max(1, args.offset) : 1;
     const limit = typeof args.limit === "number" ? args.limit : lines.length;
@@ -1390,24 +1405,24 @@ var HostTools = class {
     return { ok: true, result: rel.join("\n") || "(no files)" };
   }
   async writeFile(args) {
-    const file = this.resolve(String(args.path || ""));
+    const file2 = this.resolve(String(args.path || ""));
     const content = String(args.content ?? "");
-    await fsp.mkdir(path3.dirname(file), { recursive: true });
-    const existed = fs4.existsSync(file);
-    await fsp.writeFile(file, content, "utf8");
+    await fsp.mkdir(path3.dirname(file2), { recursive: true });
+    const existed = fs4.existsSync(file2);
+    await fsp.writeFile(file2, content, "utf8");
     return {
       ok: true,
-      result: `${existed ? "Overwrote" : "Created"} ${path3.relative(this.projectDir, file)} (${Buffer.byteLength(content)} bytes)`
+      result: `${existed ? "Overwrote" : "Created"} ${path3.relative(this.projectDir, file2)} (${Buffer.byteLength(content)} bytes)`
     };
   }
   async editFile(args) {
-    const file = this.resolve(String(args.path || ""));
+    const file2 = this.resolve(String(args.path || ""));
     const oldStr = String(args.old_string ?? "");
     const newStr = String(args.new_string ?? "");
     const replaceAll = args.replace_all === true;
-    const stat = await fsp.stat(file).catch(() => null);
+    const stat = await fsp.stat(file2).catch(() => null);
     if (!stat) return { ok: false, error: `File not found: ${args.path}` };
-    const content = await fsp.readFile(file, "utf8");
+    const content = await fsp.readFile(file2, "utf8");
     if (oldStr === "") return { ok: false, error: "old_string cannot be empty" };
     const count = content.split(oldStr).length - 1;
     if (count === 0) return { ok: false, error: "old_string not found in file (it must match exactly)." };
@@ -1415,8 +1430,8 @@ var HostTools = class {
       return { ok: false, error: `old_string is not unique (${count} matches). Add more context or set replace_all.` };
     }
     const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
-    await fsp.writeFile(file, updated, "utf8");
-    return { ok: true, result: `Edited ${path3.relative(this.projectDir, file)} (${count} replacement${count === 1 ? "" : "s"})` };
+    await fsp.writeFile(file2, updated, "utf8");
+    return { ok: true, result: `Edited ${path3.relative(this.projectDir, file2)} (${count} replacement${count === 1 ? "" : "s"})` };
   }
   /**
    * Copy a file from the THREAD filesystem (e.g. a generated /attachments/*
@@ -1839,11 +1854,11 @@ ${tail}` : " No output was captured.")
   async walkGlob(base, pattern) {
     const re = globToRegExp(pattern);
     const out = [];
-    const walk = async (dir) => {
-      const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const walk = async (dir2) => {
+      const entries = await fsp.readdir(dir2, { withFileTypes: true }).catch(() => []);
       for (const e of entries) {
         if (e.name === ".git" || e.name === "node_modules") continue;
-        const full = path3.join(dir, e.name);
+        const full = path3.join(dir2, e.name);
         if (e.isDirectory()) await walk(full);
         else {
           const rel = path3.relative(this.projectDir, full);
@@ -5039,13 +5054,13 @@ function relaxTlsForLocalEndpoint(endpoint) {
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
   return true;
 }
-var DIR2 = path3.join(os9.homedir(), ".standardagents");
-var FILE2 = path3.join(DIR2, "machine.json");
+var dir = () => path3.join(os9.homedir(), ".standardagents");
+var file = () => path3.join(dir(), "machine.json");
 function loadMachineIdentity() {
   try {
-    const parsed = JSON.parse(fs4.readFileSync(FILE2, "utf8"));
+    const parsed = JSON.parse(fs4.readFileSync(file(), "utf8"));
     if (typeof parsed.machine_id === "string" && parsed.machine_id.length > 0) {
-      return parsed;
+      return { machine_id: parsed.machine_id, created_at: parsed.created_at ?? Date.now() };
     }
   } catch {
   }
@@ -5057,17 +5072,8 @@ function loadMachineIdentity() {
   return identity;
 }
 function saveMachineIdentity(identity) {
-  fs4.mkdirSync(DIR2, { recursive: true });
-  fs4.writeFileSync(FILE2, JSON.stringify(identity, null, 2), { mode: 384 });
-}
-function setMachineName(name) {
-  const identity = loadMachineIdentity();
-  identity.name = name.trim() || void 0;
-  saveMachineIdentity(identity);
-  return identity;
-}
-function machineDisplayName(identity) {
-  return identity.name?.trim() || os9.hostname();
+  fs4.mkdirSync(dir(), { recursive: true });
+  fs4.writeFileSync(file(), JSON.stringify(identity, null, 2), { mode: 384 });
 }
 function daemonClientId(identity) {
   return `daemon:${identity.machine_id}`;
@@ -5080,10 +5086,29 @@ function machineIdFromDaemonClientId(clientId) {
   return clientId.startsWith("daemon:") ? clientId.slice("daemon:".length) : null;
 }
 var KEY_PREFIX = "standardcode.machine.";
+var CMD_SUFFIX = ".cmd";
+var NAME_SUFFIX = ".name";
 var DAEMON_ONLINE_WINDOW_MS = 90 * 1e3;
 function machineKey(machineId) {
   return `${KEY_PREFIX}${machineId}`;
 }
+function commandKey(machineId) {
+  return `${KEY_PREFIX}${machineId}${CMD_SUFFIX}`;
+}
+function nameKey(machineId) {
+  return `${KEY_PREFIX}${machineId}${NAME_SUFFIX}`;
+}
+function machineDisplayName(record) {
+  return record.name?.trim() || "" || (record.hostname || "") || (record.id || "") || "machine";
+}
+async function getMachineName(api, machineId) {
+  const v = await api.userKvGet(nameKey(machineId));
+  return typeof v === "string" && v.trim() ? v.trim() : null;
+}
+async function setMachineName(api, machineId, name) {
+  const trimmed = name.trim();
+  await api.userKvSet(nameKey(machineId), trimmed || null);
+}
 function parseMachineRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const r = value;
@@ -5094,18 +5119,43 @@ function parseMachineRecord(value) {
     hostname: typeof r.hostname === "string" ? r.hostname : "",
     platform: typeof r.platform === "string" ? r.platform : "",
     arch: typeof r.arch === "string" ? r.arch : "",
+    version: typeof r.version === "string" ? r.version : void 0,
     daemon: r.daemon && typeof r.daemon === "object" && !Array.isArray(r.daemon) ? r.daemon : null,
     projects: r.projects && typeof r.projects === "object" && !Array.isArray(r.projects) ? r.projects : {},
     created_at: typeof r.created_at === "number" ? r.created_at : 0,
     updated_at: typeof r.updated_at === "number" ? r.updated_at : 0
   };
 }
+async function loadRawMachine(api, machineId) {
+  return parseMachineRecord(await api.userKvGet(machineKey(machineId)));
+}
 async function loadMachines(api) {
   const entries = await api.userKvList(KEY_PREFIX);
-  return entries.map((e) => parseMachineRecord(e.value)).filter((m) => m !== null);
+  const records = [];
+  const names = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const rest = e.key.slice(KEY_PREFIX.length);
+    if (rest.endsWith(CMD_SUFFIX)) continue;
+    if (rest.endsWith(NAME_SUFFIX)) {
+      const id = rest.slice(0, -NAME_SUFFIX.length);
+      if (typeof e.value === "string" && e.value.trim()) names.set(id, e.value.trim());
+      continue;
+    }
+    const rec = parseMachineRecord(e.value);
+    if (rec) records.push(rec);
+  }
+  for (const rec of records) {
+    const override = names.get(rec.id);
+    if (override) rec.name = override;
+  }
+  return records;
 }
 async function loadMachine(api, machineId) {
-  return parseMachineRecord(await api.userKvGet(machineKey(machineId)));
+  const rec = await loadRawMachine(api, machineId);
+  if (!rec) return null;
+  const override = await getMachineName(api, machineId);
+  if (override) rec.name = override;
+  return rec;
 }
 function daemonOnline(record, now = Date.now()) {
   return !!record.daemon && now - record.daemon.last_seen_at < DAEMON_ONLINE_WINDOW_MS;
@@ -5114,10 +5164,11 @@ function newRecord(identity) {
   const now = Date.now();
   return {
     id: identity.machine_id,
-    name: machineDisplayName(identity),
+    name: os9.hostname(),
     hostname: os9.hostname(),
     platform: process.platform,
     arch: process.arch,
+    version: readVersion() || void 0,
     daemon: null,
     projects: {},
     created_at: now,
@@ -5125,12 +5176,12 @@ function newRecord(identity) {
   };
 }
 async function updateOwnMachineRecord(api, identity, mutate) {
-  const existing = await loadMachine(api, identity.machine_id);
+  const existing = await loadRawMachine(api, identity.machine_id);
   const record = existing ?? newRecord(identity);
-  record.name = machineDisplayName(identity);
   record.hostname = os9.hostname();
   record.platform = process.platform;
   record.arch = process.arch;
+  record.version = readVersion() || record.version;
   mutate?.(record);
   record.updated_at = Date.now();
   await api.userKvSet(machineKey(identity.machine_id), record);
@@ -5179,6 +5230,56 @@ async function clearDaemon(api, identity) {
     record.daemon = null;
   });
 }
+function parseCommands(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (c4) => !!c4 && typeof c4 === "object" && typeof c4.id === "string" && typeof c4.kind === "string"
+  );
+}
+async function enqueueMachineCommand(api, machineId, kind, args) {
+  const key = commandKey(machineId);
+  const queue = parseCommands(await api.userKvGet(key));
+  const cmd = {
+    id: crypto.randomBytes(6).toString("hex"),
+    kind,
+    args,
+    requested_at: Date.now()
+  };
+  queue.push(cmd);
+  await api.userKvSet(key, queue);
+  return cmd.id;
+}
+async function readMachineCommands(api, machineId) {
+  return parseCommands(await api.userKvGet(commandKey(machineId)));
+}
+async function clearMachineCommands(api, machineId, appliedIds) {
+  if (appliedIds.length === 0) return;
+  const key = commandKey(machineId);
+  const remaining = parseCommands(await api.userKvGet(key)).filter(
+    (c4) => !appliedIds.includes(c4.id)
+  );
+  await api.userKvSet(key, remaining.length ? remaining : null);
+}
+async function applyMachineCommand(api, identity, cmd) {
+  switch (cmd.kind) {
+    case "add_project": {
+      const path12 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
+      if (!path12) return "add_project: ignored (no path)";
+      await registerProject(api, identity, path12);
+      return `added project ${path12}`;
+    }
+    case "remove_project": {
+      const path12 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
+      if (!path12) return "remove_project: ignored (no path)";
+      await unregisterProject(api, identity, path12);
+      return `removed project ${path12}`;
+    }
+    case "update":
+      return "update requested";
+    default:
+      return `unknown command ${cmd.kind}`;
+  }
+}
 
 // src/relay.ts
 var APPROVAL_REQUEST_KEY = "approval_request";
@@ -5257,31 +5358,31 @@ function readCache() {
 }
 function writeCache(latest) {
   try {
-    const dir = cacheDir();
-    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    const dir2 = cacheDir();
+    if (!fs4.existsSync(dir2)) fs4.mkdirSync(dir2, { recursive: true });
     fs4.writeFileSync(cachePath(), JSON.stringify({ latest, timestamp: Date.now() }));
   } catch {
   }
 }
-function readAutoUpdateState(dir = cacheDir()) {
+function readAutoUpdateState(dir2 = cacheDir()) {
   try {
-    const raw = fs4.readFileSync(path3.join(dir, STATE_FILE), "utf-8");
+    const raw = fs4.readFileSync(path3.join(dir2, STATE_FILE), "utf-8");
     const state = JSON.parse(raw);
     return typeof state?.version === "string" ? state : null;
   } catch {
     return null;
   }
 }
-function writeAutoUpdateState(state, dir = cacheDir()) {
+function writeAutoUpdateState(state, dir2 = cacheDir()) {
   try {
-    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
-    fs4.writeFileSync(path3.join(dir, STATE_FILE), JSON.stringify(state));
+    if (!fs4.existsSync(dir2)) fs4.mkdirSync(dir2, { recursive: true });
+    fs4.writeFileSync(path3.join(dir2, STATE_FILE), JSON.stringify(state));
   } catch {
   }
 }
-function clearAutoUpdateState(dir = cacheDir()) {
+function clearAutoUpdateState(dir2 = cacheDir()) {
   try {
-    fs4.unlinkSync(path3.join(dir, STATE_FILE));
+    fs4.unlinkSync(path3.join(dir2, STATE_FILE));
   } catch {
   }
 }
@@ -5321,10 +5422,10 @@ function decideAutoUpdate(info, opts) {
   }
   return "start";
 }
-function startBackgroundUpdate(latest, pm, dir = cacheDir()) {
+function startBackgroundUpdate(latest, pm, dir2 = cacheDir()) {
   const startedAt = Date.now();
-  writeAutoUpdateState({ version: latest, startedAt, exitCode: null }, dir);
-  const stateFile = path3.join(dir, STATE_FILE);
+  writeAutoUpdateState({ version: latest, startedAt, exitCode: null }, dir2);
+  const stateFile = path3.join(dir2, STATE_FILE);
   const { cmd, args } = updateCommand(pm);
   const script = `const cp=require('child_process');const fs=require('fs');const r=cp.spawnSync(${JSON.stringify(cmd)},${JSON.stringify(args)},{shell:process.platform==='win32',encoding:'utf8'});const out=((r.stdout||'')+(r.stderr||'')).slice(-2000);fs.writeFileSync(${JSON.stringify(stateFile)},JSON.stringify({version:${JSON.stringify(latest)},startedAt:${startedAt},exitCode:r.status==null?-1:r.status,finishedAt:Date.now(),output:out}));`;
   try {
@@ -5332,14 +5433,14 @@ function startBackgroundUpdate(latest, pm, dir = cacheDir()) {
     child.unref();
     return true;
   } catch {
-    writeAutoUpdateState({ version: latest, startedAt, exitCode: -1, finishedAt: Date.now() }, dir);
+    writeAutoUpdateState({ version: latest, startedAt, exitCode: -1, finishedAt: Date.now() }, dir2);
     return false;
   }
 }
-function consumeAppliedUpdate(currentVersion, dir = cacheDir()) {
-  const state = readAutoUpdateState(dir);
+function consumeAppliedUpdate(currentVersion, dir2 = cacheDir()) {
+  const state = readAutoUpdateState(dir2);
   if (!state || state.version !== currentVersion) return null;
-  clearAutoUpdateState(dir);
+  clearAutoUpdateState(dir2);
   return state.exitCode === 0 ? state : null;
 }
 async function fetchLatest(currentVersion) {
@@ -5412,6 +5513,7 @@ function runUpdate(pm) {
 
 // src/daemon.ts
 var HEARTBEAT_MS = 3e4;
+var COMMAND_POLL_MS = 8e3;
 var RECLAIM_PROBE_MS = 2 * 6e4;
 var UPDATE_CHECK_MS = 6 * 60 * 6e4;
 var SWEEP_MS = 10 * 6e4;
@@ -5439,11 +5541,10 @@ function pathFromTags(tags) {
   return raw.replace(/^~(?=\/|$)/, os9.homedir());
 }
 var ThreadWorker = class {
-  constructor(api, identity, threadId, projectDir, createdAt) {
+  constructor(api, identity, machineName, threadId, projectDir, createdAt) {
     this.threadId = threadId;
     this.projectDir = projectDir;
     this.createdAt = createdAt;
-    const machineName = machineDisplayName(identity);
     this.perm = { level: 1, alwaysAllow: /* @__PURE__ */ new Set(), allowRisk: /* @__PURE__ */ new Set() };
     this.session = new ExecutionSession({
       api,
@@ -5568,9 +5669,13 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
 `);
     process.exit(1);
   }
+  let displayName = machineDisplayName(await loadMachine(api, identity.machine_id).catch(() => null) ?? {
+    hostname: os9.hostname(),
+    id: identity.machine_id
+  });
   const applied = consumeAppliedUpdate(version);
   daemonLog(
-    `daemon starting \u2014 v${version}${applied ? " (freshly auto-updated)" : ""}, machine ${identity.machine_id} (${machineDisplayName(identity)}), endpoint ${endpoint}`
+    `daemon starting \u2014 v${version}${applied ? " (freshly auto-updated)" : ""}, machine ${identity.machine_id} (${displayName}), endpoint ${endpoint}`
   );
   process.on("uncaughtException", (err) => {
     daemonLog(`FATAL uncaughtException: ${err?.stack || err}`);
@@ -5597,7 +5702,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
       daemonLog(`cannot prepare project dir ${projectDir}: ${e instanceof Error ? e.message : String(e)}`);
       return;
     }
-    const worker = new ThreadWorker(api, identity, threadId, projectDir, createdAt || Date.now());
+    const worker = new ThreadWorker(api, identity, displayName, threadId, projectDir, createdAt || Date.now());
     worker.onEvicted = (id) => detach(id);
     workers.set(threadId, worker);
     daemonLog(`attached ${threadId.slice(0, 8)} \u2192 ${projectDir}`);
@@ -5642,6 +5747,10 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
   const heartbeat = setInterval(() => {
     void touchDaemon(api, identity, version).catch(() => {
     });
+    void getMachineName(api, identity.machine_id).then((n) => {
+      if (n) displayName = n;
+    }).catch(() => {
+    });
   }, HEARTBEAT_MS);
   const reclaim = setInterval(() => {
     for (const worker of workers.values()) {
@@ -5674,6 +5783,55 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
   };
   void checkUpdates();
   const updateTimer = setInterval(() => void checkUpdates(), UPDATE_CHECK_MS);
+  let draining = false;
+  const drainCommands = async () => {
+    if (draining) return;
+    draining = true;
+    try {
+      const cmds = await readMachineCommands(api, identity.machine_id);
+      if (cmds.length === 0) return;
+      const applied2 = [];
+      let forcedUpdate = false;
+      for (const cmd of cmds) {
+        try {
+          if (cmd.kind === "update") {
+            forcedUpdate = true;
+            applied2.push(cmd.id);
+            continue;
+          }
+          const result = await applyMachineCommand(api, identity, cmd);
+          daemonLog(`command ${cmd.kind}: ${result}`);
+          applied2.push(cmd.id);
+        } catch (e) {
+          daemonLog(`command ${cmd.kind} failed: ${e instanceof Error ? e.message : String(e)}`);
+          applied2.push(cmd.id);
+        }
+      }
+      await clearMachineCommands(api, identity.machine_id, applied2).catch(() => {
+      });
+      if (forcedUpdate) {
+        const pm = detectPackageManager();
+        if (!pm) {
+          daemonLog("forced update requested but this is not an installed build \u2014 ignoring");
+        } else if (![...workers.values()].some((w) => w.busy)) {
+          daemonLog(`forced update: running ${pm} install now`);
+          const { ok, output: output4 } = await runUpdate(pm);
+          daemonLog(`forced update ${ok ? "succeeded" : "failed"}: ${output4.trim().split("\n").slice(-2).join(" | ")}`);
+          if (ok) {
+            daemonLog("restarting to apply the forced update");
+            shutdown(0);
+          }
+        } else {
+          daemonLog("forced update deferred \u2014 a session is busy; will retry");
+          void checkUpdates();
+        }
+      }
+    } finally {
+      draining = false;
+    }
+  };
+  void drainCommands();
+  const commandTimer = setInterval(() => void drainCommands(), COMMAND_POLL_MS);
   const sweeper = setInterval(() => {
     if (updateReady && ![...workers.values()].some((w) => w.busy)) {
       daemonLog("restarting to apply the installed update");
@@ -5686,6 +5844,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
     clearInterval(heartbeat);
     clearInterval(reclaim);
     clearInterval(updateTimer);
+    clearInterval(commandTimer);
     clearInterval(sweeper);
     for (const worker of workers.values()) worker.stop();
     events.close();
@@ -5705,15 +5864,15 @@ function resolveDaemonCommand(extraArgs = []) {
   if (!entry) throw new Error("Cannot determine how this CLI was launched.");
   const argv = [process.execPath];
   if (entry.endsWith(".ts")) {
-    let dir = path3.dirname(entry);
+    let dir2 = path3.dirname(entry);
     let tsx = null;
-    for (let i = 0; i < 6 && dir !== path3.dirname(dir); i++) {
-      const candidate = path3.join(dir, "node_modules", "tsx", "dist", "cli.mjs");
+    for (let i = 0; i < 6 && dir2 !== path3.dirname(dir2); i++) {
+      const candidate = path3.join(dir2, "node_modules", "tsx", "dist", "cli.mjs");
       if (fs4.existsSync(candidate)) {
         tsx = candidate;
         break;
       }
-      dir = path3.dirname(dir);
+      dir2 = path3.dirname(dir2);
     }
     if (!tsx) {
       throw new Error(
@@ -5959,15 +6118,16 @@ async function installCommand(endpointFlag) {
   const endpoint = resolveEndpoint(endpointFlag);
   const api = await ensureSignedIn(endpoint);
   const identity = loadMachineIdentity();
+  const existing = await loadMachine(api, identity.machine_id).catch(() => null);
+  const suggested = machineDisplayName(existing ?? { hostname: os9.hostname(), id: identity.machine_id });
   const rl = readline2.createInterface({ input: stdin, output: stdout });
-  const suggested = machineDisplayName(identity);
   const answer = (await rl.question(
     `${c2.bold}Machine name${c2.reset} ${c2.dim}(shown in the session picker)${c2.reset} [${suggested}]: `
   )).trim();
   rl.close();
-  if (answer) setMachineName(answer);
-  const named = loadMachineIdentity();
-  await updateOwnMachineRecord(api, named);
+  if (answer) await setMachineName(api, identity.machine_id, answer);
+  await updateOwnMachineRecord(api, identity);
+  const displayName = answer || suggested;
   stdout.write(`${c2.dim}Installing the always-on service\u2026${c2.reset}
 `);
   const extra = endpointFlag ? ["--endpoint", endpoint] : [];
@@ -5987,7 +6147,7 @@ async function installCommand(endpointFlag) {
   let alive = false;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, 2e3));
-    const record = await loadMachine(api, named.machine_id);
+    const record = await loadMachine(api, identity.machine_id);
     if (record && daemonOnline(record)) {
       alive = true;
       break;
@@ -5995,7 +6155,7 @@ async function installCommand(endpointFlag) {
   }
   if (alive) {
     stdout.write(
-      `${c2.green}\u2713${c2.reset} ${c2.bold}${machineDisplayName(named)}${c2.reset} is online.
+      `${c2.green}\u2713${c2.reset} ${c2.bold}${displayName}${c2.reset} is online.
 
 Sessions started elsewhere can now run on this machine.
 ${c2.dim}Projects register automatically when you run standardcode in a directory here,
@@ -6014,12 +6174,14 @@ async function statusCommand() {
   const status = serviceStatus();
   const identity = loadMachineIdentity();
   stdout.write(`${c2.bold}Service:${c2.reset}  ${status.detail}
-`);
-  stdout.write(`${c2.bold}Machine:${c2.reset}  ${machineDisplayName(identity)} ${c2.dim}(${identity.machine_id})${c2.reset}
 `);
   const endpoint = resolveEndpoint();
   const cred = getCredential(endpoint);
   if (!cred) {
+    stdout.write(
+      `${c2.bold}Machine:${c2.reset}  ${os9.hostname()} ${c2.dim}(${identity.machine_id})${c2.reset}
+`
+    );
     stdout.write(`${c2.bold}Account:${c2.reset}  ${c2.yellow}not signed in to ${endpoint}${c2.reset}
 `);
     return;
@@ -6027,6 +6189,10 @@ async function statusCommand() {
   relaxTlsForLocalEndpoint(endpoint);
   const api = new ApiClient(endpoint, cred.access_token);
   const record = await loadMachine(api, identity.machine_id).catch(() => null);
+  stdout.write(
+    `${c2.bold}Machine:${c2.reset}  ${machineDisplayName(record ?? { hostname: os9.hostname(), id: identity.machine_id })} ${c2.dim}(${identity.machine_id})${c2.reset}
+`
+  );
   if (!record) {
     stdout.write(`${c2.bold}Registry:${c2.reset} not registered yet
 `);
@@ -6048,22 +6214,24 @@ async function projectCommand(action, target) {
 `);
     process.exit(1);
   }
-  const dir = path3.resolve(target);
-  if (action === "add" && !fs4.existsSync(dir)) {
-    stdout.write(`${c2.red}\u2717${c2.reset} ${dir} does not exist on this machine.
+  const dir2 = path3.resolve(target);
+  if (action === "add" && !fs4.existsSync(dir2)) {
+    stdout.write(`${c2.red}\u2717${c2.reset} ${dir2} does not exist on this machine.
 `);
     process.exit(1);
   }
   const endpoint = resolveEndpoint();
   const api = await ensureSignedIn(endpoint);
   const identity = loadMachineIdentity();
+  const record = await loadMachine(api, identity.machine_id).catch(() => null);
+  const displayName = machineDisplayName(record ?? { hostname: os9.hostname(), id: identity.machine_id });
   if (action === "add") {
-    await registerProject(api, identity, dir);
-    stdout.write(`${c2.green}\u2713${c2.reset} Registered ${dir} for remote sessions on ${machineDisplayName(identity)}.
+    await registerProject(api, identity, dir2);
+    stdout.write(`${c2.green}\u2713${c2.reset} Registered ${dir2} for remote sessions on ${displayName}.
 `);
   } else {
-    await unregisterProject(api, identity, dir);
-    stdout.write(`${c2.green}\u2713${c2.reset} Removed ${dir} from this machine's projects.
+    await unregisterProject(api, identity, dir2);
+    stdout.write(`${c2.green}\u2713${c2.reset} Removed ${dir2} from this machine's projects.
 `);
   }
 }
@@ -6195,6 +6363,20 @@ function parseArgs2(args) {
   }
   return parsed;
 }
+function printCommandBlock(tui, command, output4, ok, where) {
+  tui.print("");
+  const note = where ? `  ${c3.dim}(ran on ${where})${c3.reset}` : "";
+  tui.print(`${c3.magenta}!${c3.reset} ${c3.bold}${command}${c3.reset}${note}`);
+  const body = (output4 ?? "").replace(/\s+$/, "");
+  if (body) {
+    for (const line of body.split("\n")) {
+      tui.print(`  ${ok ? c3.dim : c3.red}${line}${c3.reset}`);
+    }
+  } else {
+    tui.print(`  ${c3.dim}(no output)${c3.reset}`);
+  }
+  tui.print("");
+}
 function printAssistant(tui, text) {
   const cols2 = Math.max(20, (process.stdout.columns || 80) - 3);
   tui.clearStream();
@@ -6243,7 +6425,7 @@ ${c3.teal}\u25C7${c3.reset} ${c3.dim}Standard Code \u2014 see you soon.${c3.rese
 }
 function printWelcome(endpoint, projectDir) {
   const home = os9.homedir();
-  const dir = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
+  const dir2 = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
   const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
   const version = readVersion();
   const pad = "  ";
@@ -6251,7 +6433,7 @@ function printWelcome(endpoint, projectDir) {
     `${c3.bold}${gradientText("Standard Code")}${c3.reset}${version ? `  ${c3.dim}v${version}${c3.reset}` : ""}`,
     `${c3.dim}terminal coding agent${c3.reset}`,
     ...endpoint === PRODUCTION_ENDPOINT ? [] : [`${c3.teal}${host}${c3.reset}`],
-    `${c3.dim}${dir}${c3.reset}`
+    `${c3.dim}${dir2}${c3.reset}`
   ];
   const markWidth = Math.max(...LOGO_MARK.map((l) => [...l].length));
   const metaTop = Math.floor((LOGO_MARK.length - meta.length) / 2);
@@ -6598,10 +6780,10 @@ async function pickRemoteProject(tui, runner) {
   const projects = Object.entries(runner.projects).sort(
     (a, b) => (b[1]?.last_used_at ?? 0) - (a[1]?.last_used_at ?? 0)
   );
-  const items = projects.map(([dir, p]) => ({
-    label: shortenPath(dir, 48),
+  const items = projects.map(([dir2, p]) => ({
+    label: shortenPath(dir2, 48),
     hint: p?.last_used_at ? relativeTime(p.last_used_at / 1e3) : "",
-    value: dir
+    value: dir2
   }));
   items.push({ label: `\uFF0B Another path on ${runner.name}\u2026`, hint: "type a directory", value: ENTER_PATH });
   const picked = await tui.select(
@@ -6687,12 +6869,23 @@ async function printHistory(api, threadId, tui) {
   } catch {
     return;
   }
-  const convo = msgs.filter((m) => m.role === "user" || m.role === "assistant" && messageText(m.content).trim()).sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
+  const convo = msgs.filter(
+    (m) => m.metadata?.user_command || m.role === "user" || m.role === "assistant" && messageText(m.content).trim()
+  ).sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
   if (!convo.length) return;
   const shown = convo.slice(-24);
   tui.print(`${c3.dim}\u2500\u2500 resuming session \xB7 ${convo.length} message${convo.length === 1 ? "" : "s"} \u2500\u2500${c3.reset}`);
   if (shown.length < convo.length) tui.print(`${c3.dim}   \u2026 earlier messages omitted${c3.reset}`);
   for (const m of shown) {
+    if (m.metadata?.user_command) {
+      printCommandBlock(
+        tui,
+        String(m.metadata.command ?? ""),
+        String(m.metadata.output ?? messageText(m.content)),
+        m.metadata.ok !== false
+      );
+      continue;
+    }
     const text = messageText(m.content).trim();
     if (!text) continue;
     if (m.role === "user") tui.printUserMessage(text);
@@ -6752,6 +6945,12 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed,
     if (ownerDaemonMachine === session.identity.machine_id) claim = "takeover";
   }
   if (!remote) {
+    const localDisplayName = machineDisplayName(
+      await loadMachine(api, session.identity.machine_id).catch(() => null) ?? {
+        hostname: machine,
+        id: session.identity.machine_id
+      }
+    );
     exec = new ExecutionSession({
       api,
       threadId,
@@ -6760,7 +6959,7 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed,
       perm,
       identity: {
         clientId: interactiveClientId(session.identity),
-        clientName: `${machineDisplayName(session.identity)} (terminal)`,
+        clientName: `${localDisplayName} (terminal)`,
         clientKind: "interactive",
         claim
       },
@@ -7009,6 +7208,25 @@ why: ${req.requestPermission}` : ""}`,
     busy = true;
     tui.setWorking(true);
   };
+  const whereLabel = remote ? runnerName : "this machine";
+  let bangRunning = false;
+  const runBangCommand = async (command) => {
+    if (bangRunning) {
+      tui.print(`${c3.dim}a command is already running \u2014 one at a time.${c3.reset}`);
+      return;
+    }
+    bangRunning = true;
+    tui.print(`${c3.magenta}!${c3.reset} ${c3.dim}running on ${whereLabel}\u2026${c3.reset}`);
+    try {
+      const res = await api.runCommand(threadId, command);
+      if (res.messageId) shownIds.add(res.messageId);
+      printCommandBlock(tui, command, res.ok ? res.output ?? "" : res.error ?? "command failed", res.ok, whereLabel);
+    } catch (e) {
+      printCommandBlock(tui, command, e instanceof Error ? e.message : String(e), false, whereLabel);
+    } finally {
+      bangRunning = false;
+    }
+  };
   const flushQueued = async () => {
     if (!queued.length) return;
     const toSend = queued.splice(0);
@@ -7173,6 +7391,12 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
         run: () => runMcpMenu(tui, mcpCtl)
       }
     ],
+    {
+      name: "machines",
+      label: "Your machines",
+      hint: "list, rename, update, manage projects",
+      run: () => runMachinesMenu(tui, api, session.identity)
+    },
     {
       name: "daemon",
       label: "Machine daemon",
@@ -7206,7 +7430,18 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
   const history = await loadHistory(api, threadId, historySeedThreadId);
   tui.setHistory(history);
   tui.onSubmit = (text, images) => {
-    appendHistory(api, threadId, history, text);
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith("!") && !trimmed.startsWith("!!")) {
+      const command = trimmed.slice(1).trim();
+      if (command) {
+        appendHistory(api, threadId, history, text);
+        void runBangCommand(command);
+      }
+      return;
+    }
+    const outgoing = trimmed.startsWith("!!") ? text.replace("!!", "!") : text;
+    appendHistory(api, threadId, history, outgoing);
+    text = outgoing;
     if (editingQueued) {
       editingQueued = false;
       queued.push({ text, images });
@@ -7339,6 +7574,15 @@ ${c3.dim}runs on ${request.machine || runnerName}${c3.reset}`,
         void offerUpgrade({ auto: true });
         continue;
       }
+      if (m.metadata?.user_command) {
+        printCommandBlock(
+          tui,
+          String(m.metadata.command ?? ""),
+          String(m.metadata.output ?? text),
+          m.metadata.ok !== false
+        );
+        continue;
+      }
       if (m.role === "assistant" && text) printAssistant(tui, text);
       else if (m.role === "system" && text) tui.print(`${c3.dim}${text}${c3.reset}`);
       else if (m.role === "user" && text) {
@@ -7492,6 +7736,120 @@ async function runLevelMenu(tui, perm) {
     perm.level = picked;
   }
 }
+async function runMachinesMenu(tui, api, self) {
+  let machines;
+  try {
+    machines = await loadMachines(api);
+  } catch (e) {
+    tui.print(`${c3.red}\u2717 couldn't load machines:${c3.reset} ${c3.gray}${e instanceof Error ? e.message : String(e)}${c3.reset}`);
+    return;
+  }
+  if (!machines.length) {
+    tui.print(`${c3.gray}No machines registered yet. Run standardcode on a machine (or install its daemon) to register it.${c3.reset}`);
+    return;
+  }
+  machines.sort((a, b) => (b.updated_at ?? 0) - (a.updated_at ?? 0));
+  const picked = await tui.select(
+    `${c3.bold}Your machines${c3.reset}  ${c3.dim}(\u2191/\u2193 \xB7 enter \xB7 esc)${c3.reset}`,
+    machines.map((m) => {
+      const isSelf = m.id === self.machine_id;
+      const online = daemonOnline(m);
+      const daemonBit = m.daemon ? online ? "daemon online" : "daemon offline" : "no daemon";
+      const nproj = Object.keys(m.projects).length;
+      return {
+        label: `${m.name}${isSelf ? " (this machine)" : ""}`,
+        hint: `${m.hostname} \xB7 ${m.platform}/${m.arch} \xB7 v${m.version ?? "?"} \xB7 ${daemonBit} \xB7 ${nproj} project${nproj === 1 ? "" : "s"}`,
+        value: m.id
+      };
+    })
+  );
+  if (!picked) return;
+  const machine = machines.find((m) => m.id === picked);
+  await manageMachine(tui, api, self, machine);
+}
+async function manageMachine(tui, api, self, machine) {
+  const isSelf = machine.id === self.machine_id;
+  const online = daemonOnline(machine);
+  const canRunCommands = isSelf || !!machine.daemon;
+  const options = [
+    { label: "Rename", value: "rename" }
+  ];
+  if (canRunCommands) {
+    options.push(
+      { label: "Update standardcode", hint: `v${machine.version ?? "?"} \u2192 latest`, value: "update" },
+      { label: "Manage projects", hint: `${Object.keys(machine.projects).length}`, value: "projects" }
+    );
+  }
+  options.push({ label: "Back", value: "back" });
+  if (!isSelf && !machine.daemon) {
+    tui.print(
+      `${c3.dim}${machine.name} has no daemon \u2014 you can rename it here; update and project changes need its daemon installed.${c3.reset}`
+    );
+  } else if (!isSelf && machine.daemon && !online) {
+    tui.print(
+      `${c3.dim}${machine.name}'s daemon is offline \u2014 queued changes apply when it next comes online.${c3.reset}`
+    );
+  }
+  const action = await tui.select(`${c3.bold}${machine.name}${c3.reset}`, options);
+  if (!action || action === "back") return;
+  const dispatch = async (kind, args) => {
+    if (isSelf) {
+      await applyMachineCommand(api, self, { kind, args});
+    } else {
+      await enqueueMachineCommand(api, machine.id, kind, args);
+    }
+  };
+  const applyNote = isSelf ? "applied" : `queued \u2014 ${machine.name}'s daemon will apply it within ~10s`;
+  if (action === "rename") {
+    const name = await tui.prompt(`New name for ${machine.name}`, machine.name);
+    if (name === null || !name.trim()) return;
+    await setMachineName(api, machine.id, name.trim());
+    tui.print(`${c3.green}\u2713${c3.reset} Renamed ${c3.bold}${machine.name}${c3.reset} \u2192 ${c3.bold}${name.trim()}${c3.reset}.`);
+  } else if (action === "update") {
+    if (isSelf) {
+      await runUpdateCommand(tui);
+    } else {
+      const go = await tui.select(`Force ${machine.name} to update standardcode now?`, [
+        { label: "Yes, update & restart its daemon", value: "yes" },
+        { label: "Cancel", value: "no" }
+      ]);
+      if (go !== "yes") return;
+      await dispatch("update");
+      tui.print(`${c3.green}\u2713${c3.reset} Update ${c3.gray}${applyNote} (its daemon updates and restarts on the new version).${c3.reset}`);
+    }
+  } else if (action === "projects") {
+    await manageMachineProjects(tui, api, self, machine, dispatch, applyNote);
+  }
+}
+async function manageMachineProjects(tui, api, self, machine, dispatch, applyNote) {
+  const ADD = "__add__";
+  const paths = Object.keys(machine.projects).sort();
+  const picked = await tui.select(
+    `${c3.bold}Projects on ${machine.name}${c3.reset}  ${c3.dim}(enter to remove \xB7 esc)${c3.reset}`,
+    [
+      ...paths.map((p) => ({ label: p, hint: "enter to remove", value: p })),
+      { label: "\uFF0B Add a project directory\u2026", hint: "absolute path", value: ADD }
+    ]
+  );
+  if (!picked) return;
+  if (picked === ADD) {
+    const path12 = await tui.prompt(
+      `Absolute project path on ${machine.name}`,
+      machine.id === self.machine_id ? process.cwd() : "/home/you/project"
+    );
+    if (!path12 || !path12.trim()) return;
+    const trimmed = path12.trim();
+    if (!trimmed.startsWith("/") && !trimmed.startsWith("~")) {
+      tui.print(`${c3.yellow}Use an absolute path (starting with / or ~).${c3.reset}`);
+      return;
+    }
+    await dispatch("add_project", { path: trimmed });
+    tui.print(`${c3.green}\u2713${c3.reset} Add ${trimmed} ${c3.gray}${applyNote}.${c3.reset}`);
+  } else {
+    await dispatch("remove_project", { path: picked });
+    tui.print(`${c3.green}\u2713${c3.reset} Remove ${picked} ${c3.gray}${applyNote}.${c3.reset}`);
+  }
+}
 function showDaemonInfo(tui, session) {
   if (session.mode === "remote" && session.runner) {
     tui.print(
@@ -7519,6 +7877,7 @@ function showKeybindings(tui) {
   tui.print(`${c3.gray}shortcuts:${c3.reset}`);
   tui.print(`${c3.gray}  shift-tab${c3.reset}  cycle auto-accept level (1\u20135)`);
   tui.print(`${c3.gray}  /${c3.reset}          open the command palette (type to filter)`);
+  tui.print(`${c3.gray}  !cmd${c3.reset}       run a shell command on the session's machine (e.g. !ls); !! to send a literal !`);
   tui.print(`${c3.gray}  ctrl-v${c3.reset}     paste an image from the clipboard ([#Image 1])`);
   tui.print(`${c3.gray}  \u2191 / \u2193${c3.reset}      cycle past messages (on the input's top line)`);
   tui.print(`${c3.gray}  \u2190${c3.reset}          from the start of the input: select the [\u2699 n bg] badge (enter opens it)`);