@standardagents/code 0.13.4 → 0.13.6

package/README.md

@@ -76,8 +76,9 @@ we're letting new folks in every week.
   thread and keep running across reconnects and resumes.
 - **Idle attachments stay dormant.** Queue/draft snapshots refresh from events and lifecycle
   transitions, stream and idle execution-bridge heartbeats use Durable Object hibernation
-  auto-responses, and transcript safety requests run only while the agent is active. The bridge
-  switches to an observable liveness heartbeat only during a forwarded tool or approval, so
+  auto-responses on a 30-second quiet cadence (real traffic suppresses the keepalive), and
+  transcript safety requests run only while the agent is active. The bridge switches to a
+  5-second observable liveness heartbeat only during a forwarded tool or approval, so
   leaving a terminal attached does not continuously wake an idle thread. Each running client owns
   one account user stream; a machine daemon opens a per-thread execution bridge only while
   forwarded work is active. Stream transitions update machine presence once. Remote filesystem
@@ -134,8 +135,10 @@ Sama One is BYOK: the first time you pick it, the CLI opens
 `https://standardcode.ai/app` where you connect your ChatGPT account once.
 That connection installs the authorization in your account's secret
 environment on the instance — shared by the CLI, web console, and macOS app —
-and the CLI itself never sees or stores the OpenAI key. Sama One sessions are
-not limited by the simultaneous-thread lease.
+and the CLI itself never sees or stores the OpenAI key. Connection changes are
+pushed over the existing account WebSocket to every open client; the clients
+do not poll account metadata. Sama One sessions are not limited by the
+simultaneous-thread lease.
 
 You only do this once per machine. Session start then asks **where the session should run** —
 this machine or any machine whose daemon is online — and offers to **resume** a session for that

package/dist/index.js

@@ -11,6 +11,7 @@ import * as session_state_star from '@standardagents/code-network/session-state'
 import * as transcript_delivery_star from '@standardagents/code-network/transcript-delivery';
 import * as approvals_star from '@standardagents/code-network/approvals';
 import net from 'net';
+import { setImmediate } from 'timers';
 import fs11 from 'fs';
 import { permissionKey, Bridge as Bridge$1 } from '@standardagents/code-network/bridge';
 import readline from 'readline';
@@ -237,6 +238,45 @@ __reExport(approvals_exports, approvals_star);
 var ALLOWED_HOST = "chatgpt.com";
 var ALLOWED_PORT = 443;
 var CHUNK_BYTES = 256 * 1024;
+var TunnelFrameCoalescer = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  emit;
+  chunks = [];
+  bytes = 0;
+  scheduled = false;
+  push(chunk) {
+    if (chunk.length === 0) return;
+    let offset = 0;
+    while (offset < chunk.length) {
+      const remaining = CHUNK_BYTES - this.bytes;
+      const take = Math.min(remaining, chunk.length - offset);
+      this.chunks.push(chunk.subarray(offset, offset + take));
+      this.bytes += take;
+      offset += take;
+      if (this.bytes === CHUNK_BYTES) this.flush();
+    }
+    if (this.bytes > 0 && !this.scheduled) {
+      this.scheduled = true;
+      setImmediate(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  flush() {
+    if (this.bytes === 0) return;
+    const chunk = this.chunks.length === 1 ? this.chunks[0] : Buffer.concat(this.chunks, this.bytes);
+    this.chunks = [];
+    this.bytes = 0;
+    this.emit(chunk);
+  }
+  discard() {
+    this.chunks = [];
+    this.bytes = 0;
+  }
+};
 var TunnelManager = class {
   constructor(send) {
     this.send = send;
@@ -302,18 +342,19 @@ var TunnelManager = class {
     const socket = net.connect({ host, port });
     socket.setNoDelay(true);
     socket.setKeepAlive(true, 15e3);
-    this.tunnels.set(id, { socket });
+    const outbound = new TunnelFrameCoalescer((chunk) => {
+      this.send({ type: "stream_data", id, data: chunk.toString("base64") });
+    });
+    this.tunnels.set(id, { socket, outbound });
     socket.on("connect", () => {
       opened = true;
       this.send({ type: "stream_opened", id });
     });
     socket.on("data", (data) => {
-      for (let i = 0; i < data.length; i += CHUNK_BYTES) {
-        const slice = data.subarray(i, i + CHUNK_BYTES);
-        this.send({ type: "stream_data", id, data: slice.toString("base64") });
-      }
+      outbound.push(data);
     });
     socket.on("end", () => {
+      outbound.flush();
       this.send({ type: "stream_end", id });
       this.tunnels.delete(id);
     });
@@ -321,12 +362,14 @@ var TunnelManager = class {
       if (!opened) {
         this.send({ type: "stream_error", id, error: `Tunnel connect failed: ${error.message}` });
       } else {
+        outbound.flush();
         this.send({ type: "stream_abort", id, error: error.message });
       }
       this.tunnels.delete(id);
     });
     socket.on("close", () => {
       if (this.tunnels.has(id)) {
+        outbound.flush();
         this.send({ type: "stream_end", id });
         this.tunnels.delete(id);
       }
@@ -340,6 +383,7 @@ var TunnelManager = class {
     const tunnel = this.tunnels.get(id);
     if (!tunnel) return;
     this.tunnels.delete(id);
+    tunnel.outbound.discard();
     try {
       tunnel.socket.destroy();
     } catch {
@@ -2520,7 +2564,7 @@ var Tui = class _Tui {
   /**
    * Set the context-window fill percentage (0–100), or null to hide it.
    * Driven by the runtime's `context_usage` KV, scaled to the compaction
-   * trigger (see index.ts poll). Always painted on the status line far right.
+   * trigger. Always painted on the status line far right.
    */
   setContextPct(pct) {
     const next = pct == null ? null : Math.max(0, Math.min(100, Math.round(pct)));
@@ -2855,8 +2899,8 @@ var Tui = class _Tui {
   // (which renders full markdown), so there's no double-render.
   static STREAM_TAIL = 20;
   // How long a reasoning-only preview may sit untouched before it's wiped. A
-  // visible answer must NEVER expire: it is the only copy until polling
-  // promotes the durable message into terminal scrollback.
+  // visible answer must NEVER expire: it is the only copy until the durable
+  // boundary event promotes the message into terminal scrollback.
   static STREAM_IDLE_MS = 1e4;
   /** Append a fragment of streamed answer text (rendered as progressive Markdown). */
   streamResponseDelta(delta, messageId) {
@@ -3904,7 +3948,7 @@ function readVersion() {
     if (typeof pkg.version === "string" && pkg.version) return pkg.version;
   } catch {
   }
-  return "0.13.4" ;
+  return "0.13.6" ;
 }
 function isLocalHost(host) {
   return host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".local") || host.endsWith(".localhost") || /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host);
@@ -6955,8 +6999,11 @@ function usage() {
       `${c3.bold}standardcode daemon${c3.reset} \u2014 headless execution client for this machine`,
       "",
       `${c3.bold}Commands${c3.reset}`,
-      "  install [--endpoint url]   Sign in (if needed), name this machine, and install",
+      "  install [--endpoint url] [--name label | --yes]",
+      "                             Sign in (if needed), name this machine, and install",
       "                             the always-on service (launchd / systemd).",
+      "                             --name/--yes skip the name prompt (non-interactive,",
+      "                             e.g. when another app drives the install).",
       "  uninstall                  Stop and remove the service.",
       "  status                     Service + registry status for this machine.",
       "  run [--endpoint url]       Run the daemon in the foreground (what the service runs).",
@@ -6981,6 +7028,32 @@ function parseEndpointFlag(args) {
   }
   return { endpoint, rest };
 }
+function parseInstallFlags(args) {
+  const rest = [];
+  let name;
+  let yes = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--yes" || arg === "-y") {
+      yes = true;
+    } else if (arg === "--name") {
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        name = next;
+        i++;
+      } else {
+        yes = true;
+      }
+    } else if (arg.startsWith("--name=")) {
+      const value = arg.slice("--name=".length);
+      if (value) name = value;
+      else yes = true;
+    } else {
+      rest.push(arg);
+    }
+  }
+  return { name: name?.trim() || void 0, yes, rest };
+}
 function resolveEndpoint(flag) {
   return (0, credentials_exports.normalizeEndpoint)(
     flag || process.env.STANDARD_CODE_DAEMON_ENDPOINT || (0, credentials_exports.defaultEndpoint)() || PRODUCTION_ENDPOINT
@@ -7014,17 +7087,22 @@ async function ensureSignedIn(endpoint) {
 `);
   return api;
 }
-async function installCommand(endpointFlag) {
+async function installCommand(endpointFlag, opts = {}) {
   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: os6.hostname(), id: identity.machine_id });
-  const rl = readline3.createInterface({ input: stdin, output: stdout });
-  const answer = (await rl.question(
-    `${c3.bold}Machine name${c3.reset} ${c3.dim}(shown in the session picker)${c3.reset} [${suggested}]: `
-  )).trim();
-  rl.close();
+  let answer = "";
+  if (opts.name) {
+    answer = opts.name;
+  } else if (!opts.yes) {
+    const rl = readline3.createInterface({ input: stdin, output: stdout });
+    answer = (await rl.question(
+      `${c3.bold}Machine name${c3.reset} ${c3.dim}(shown in the session picker)${c3.reset} [${suggested}]: `
+    )).trim();
+    rl.close();
+  }
   if (answer) await setMachineName(api, identity.machine_id, answer);
   await updateOwnMachineRecord(api, identity);
   const displayName = answer || suggested;
@@ -7141,16 +7219,13 @@ async function runDaemonCommand(argv) {
   const { endpoint, rest } = parseEndpointFlag(restArgs);
   switch (command) {
     case "run":
-      if (rest.includes("--ephemeral") || process.env.STANDARD_CODE_EPHEMERAL === "1") {
-        process.stdin.resume();
-        process.stdin.on("end", () => process.exit(0));
-        process.stdin.on("close", () => process.exit(0));
-      }
       await runDaemon({ endpoint: endpoint || process.env.STANDARD_CODE_DAEMON_ENDPOINT });
       return;
-    case "install":
-      await installCommand(endpoint);
+    case "install": {
+      const flags = parseInstallFlags(rest);
+      await installCommand(endpoint, flags);
       return;
+    }
     case "uninstall": {
       const result = uninstallService();
       stdout.write(`${result.ok ? c3.green + "\u2713" : c3.red + "\u2717"}${c3.reset} ${result.detail}
@@ -8028,7 +8103,7 @@ ${c5.dim}Install this machine's daemon (\`standardcode daemon install\`) or run
         const threadAgent = existing.find((t) => t.id === picked)?.agent_id;
         selectedAgent = threadAgent === OPENSAMA_AGENT_ID ? OPENSAMA_AGENT_ID : AGENT_ID;
         if (selectedAgent === OPENSAMA_AGENT_ID) {
-          const ok = await ensureSamaAuth(tui, api);
+          const ok = await ensureSamaAuth(tui, api, accountStream);
           if (!ok) continue;
         }
         break flow;
@@ -8060,7 +8135,7 @@ ${c5.dim}Install this machine's daemon (\`standardcode daemon install\`) or run
         selectedAgent = picked;
       }
       if (selectedAgent === OPENSAMA_AGENT_ID) {
-        const ok = await ensureSamaAuth(tui, api);
+        const ok = await ensureSamaAuth(tui, api, accountStream);
         if (!ok) {
           if (agentOverride) process.exit(0);
           continue;
@@ -8095,7 +8170,7 @@ ${c5.dim}Install this machine's daemon (\`standardcode daemon install\`) or run
 function shortenPath(p, max = 38) {
   return p.length > max ? "\u2026" + p.slice(-(max - 1)) : p;
 }
-async function ensureSamaAuth(tui, api) {
+async function ensureSamaAuth(tui, api, accountStream) {
   const checking = startLoader("Checking your ChatGPT connection");
   const already = await api.openSamaStatus().catch(() => false);
   checking.stop();
@@ -8117,24 +8192,55 @@ async function ensureSamaAuth(tui, api) {
     `${c5.dim}Finish connecting ChatGPT in the browser \u2014 waiting here for the authorization to land on your account\u2026${c5.reset}`
   );
   const waiting = startLoader("Waiting for your ChatGPT authorization");
-  const deadline = Date.now() + 5 * 60 * 1e3;
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, 3e3));
-    if (await api.openSamaStatus().catch(() => false)) {
-      waiting.stop();
-      tui.print(
-        `${c5.green}\u2713${c5.reset} ChatGPT connected \u2014 Sama One is now unlocked on your account (terminal, web, and macOS app).`
-      );
-      return true;
-    }
-  }
+  const connected = await waitForSamaAuthorization(api, accountStream, 5 * 60 * 1e3);
   waiting.stop();
+  if (connected) {
+    tui.print(
+      `${c5.green}\u2713${c5.reset} ChatGPT connected \u2014 Sama One is now unlocked on your account (terminal, web, and macOS app).`
+    );
+    return true;
+  }
   tui.print(
     `${c5.yellow}Still not connected.${c5.reset} Finish the flow at ${c5.teal}standardcode.ai/app${c5.reset} and pick Sama One again.`
   );
   return false;
 }
-async function runAgentSwitchMenu(tui, api, threadId) {
+function waitForSamaAuthorization(api, accountStream, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let checking = false;
+    let stopEvent = () => {
+    };
+    let stopConnection = () => {
+    };
+    let timer;
+    const finish = (connected) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      stopEvent();
+      stopConnection();
+      resolve(connected);
+    };
+    timer = setTimeout(() => finish(false), timeoutMs);
+    const reconcile = async () => {
+      if (settled || checking) return;
+      checking = true;
+      const connected = await api.openSamaStatus().catch(() => false);
+      checking = false;
+      if (connected) finish(true);
+    };
+    stopEvent = accountStream.onEvent((event, data) => {
+      if (event !== "standardcode.opensama_changed") return;
+      if (data?.connected === true) finish(true);
+    });
+    stopConnection = accountStream.onConnection((state) => {
+      if (state === "connected") void reconcile();
+    });
+    void reconcile();
+  });
+}
+async function runAgentSwitchMenu(tui, api, accountStream, threadId) {
   const picked = await tui.select(
     `${c5.bold}Switch agent${c5.reset}  ${c5.dim}takes effect on the next message${c5.reset}`,
     AGENT_CHOICES.map((choice) => ({
@@ -8146,7 +8252,7 @@ async function runAgentSwitchMenu(tui, api, threadId) {
   );
   if (!picked) return;
   if (picked === OPENSAMA_AGENT_ID) {
-    const ok = await ensureSamaAuth(tui, api);
+    const ok = await ensureSamaAuth(tui, api, accountStream);
     if (!ok) return;
   }
   const title = AGENT_CHOICES.find((choice) => choice.id === picked)?.title ?? picked;
@@ -8367,7 +8473,8 @@ async function runInteractive(tui, api, accountStream, threadId, projectDir, mac
     },
     // Live streaming preview: answer text and (opt-in) internal reasoning feed
     // the TUI's ephemeral preview; the committed message still renders from
-    // polling, which calls tui.clearStream() first so there's no double-render.
+    // the durable boundary event, which clears the preview before printing so
+    // there's no double-render.
     onChunk: (text, mid) => tui.streamResponseDelta(text, mid),
     onReasoningChunk: (text, mid) => tui.streamThinkingDelta(text, mid),
     onAssistantText: () => {
@@ -8848,7 +8955,7 @@ ${c5.gray}Close another session (its slot frees within ~90s), then resend your m
       name: "agent",
       label: "Switch agent",
       hint: "hand this session to a different agent",
-      run: () => runAgentSwitchMenu(tui, api, threadId)
+      run: () => runAgentSwitchMenu(tui, api, accountStream, threadId)
     },
     {
       name: "machines",