@standardagents/code 0.9.2 → 0.9.3

package/dist/index.js

@@ -5060,7 +5060,7 @@ function loadMachineIdentity() {
   try {
     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 {
   }
@@ -5075,15 +5075,6 @@ function saveMachineIdentity(identity) {
   fs4.mkdirSync(dir(), { recursive: true });
   fs4.writeFileSync(file(), 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();
-}
 function daemonClientId(identity) {
   return `daemon:${identity.machine_id}`;
 }
@@ -5096,6 +5087,7 @@ function machineIdFromDaemonClientId(clientId) {
 }
 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}`;
@@ -5103,6 +5095,20 @@ function machineKey(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;
@@ -5120,12 +5126,36 @@ function parseMachineRecord(value) {
     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;
@@ -5134,7 +5164,7 @@ 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,
@@ -5146,9 +5176,8 @@ 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(loadMachineIdentity());
   record.hostname = os9.hostname();
   record.platform = process.platform;
   record.arch = process.arch;
@@ -5233,13 +5262,6 @@ async function clearMachineCommands(api, machineId, appliedIds) {
 }
 async function applyMachineCommand(api, identity, cmd) {
   switch (cmd.kind) {
-    case "rename": {
-      const name = typeof cmd.args?.name === "string" ? cmd.args.name.trim() : "";
-      if (!name) return "rename: ignored (empty name)";
-      setMachineName(name);
-      await updateOwnMachineRecord(api, identity);
-      return `renamed to "${name}"`;
-    }
     case "add_project": {
       const path12 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
       if (!path12) return "add_project: ignored (no path)";
@@ -5519,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,
@@ -5648,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}`);
@@ -5677,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}`);
@@ -5722,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()) {
@@ -6089,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] : [];
@@ -6117,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;
@@ -6125,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,
@@ -6144,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;
@@ -6157,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
 `);
@@ -6187,9 +6223,11 @@ async function projectCommand(action, target) {
   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, dir2);
-    stdout.write(`${c2.green}\u2713${c2.reset} Registered ${dir2} for remote sessions on ${machineDisplayName(identity)}.
+    stdout.write(`${c2.green}\u2713${c2.reset} Registered ${dir2} for remote sessions on ${displayName}.
 `);
   } else {
     await unregisterProject(api, identity, dir2);
@@ -6907,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,
@@ -6915,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
       },
@@ -7726,24 +7770,27 @@ async function runMachinesMenu(tui, api, self) {
 async function manageMachine(tui, api, self, machine) {
   const isSelf = machine.id === self.machine_id;
   const online = daemonOnline(machine);
-  const remoteReachable = !isSelf && !!machine.daemon;
+  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.yellow}${machine.name} has no daemon${c3.reset} ${c3.gray}\u2014 it only runs the interactive CLI, so it can't be managed remotely. Manage it from that machine, or install its daemon.${c3.reset}`
+      `${c3.dim}${machine.name} has no daemon \u2014 you can rename it here; update and project changes need its daemon installed.${c3.reset}`
     );
-    return;
-  }
-  if (remoteReachable && !online) {
+  } 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}`, [
-    { label: "Rename", value: "rename" },
-    { label: "Update standardcode", hint: `v${machine.version ?? "?"} \u2192 latest`, value: "update" },
-    { label: "Manage projects", hint: `${Object.keys(machine.projects).length}`, value: "projects" },
-    { label: "Back", value: "back" }
-  ]);
+  const action = await tui.select(`${c3.bold}${machine.name}${c3.reset}`, options);
   if (!action || action === "back") return;
   const dispatch = async (kind, args) => {
     if (isSelf) {
@@ -7755,9 +7802,9 @@ async function manageMachine(tui, api, self, machine) {
   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 || !name.trim()) return;
-    await dispatch("rename", { name: name.trim() });
-    tui.print(`${c3.green}\u2713${c3.reset} Rename to "${name.trim()}" ${c3.gray}${applyNote}.${c3.reset}`);
+    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);