@standardagents/code 0.9.6 → 0.9.8

package/README.md

@@ -104,6 +104,20 @@ standardcode -e -- <dir>  # prompt for the endpoint for this run
 On first run it connects to the hosted Standard Code instance
 (`https://api.standardcode.ai`) and walks you through a one-time browser sign-in — press
 Enter, approve in the browser, and your key is stored in `~/.standardagents/credentials`.
+### Choosing an agent
+
+Session start opens with an agent picker: **Frontier One** (coming soon),
+**Unlimited One** (the default — adaptive high/low routing), **Sama One**
+(OpenAI-only, powered by your own ChatGPT authorization), and **Dario**
+(unavailable). Skip the menu with `--agent unlimited` or `--agent sama`.
+
+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.
+
 You only do this once per machine. It then offers to **resume** a session tagged for this
 project + machine, or **start a new one**.
 

package/dist/index.js

@@ -249,6 +249,27 @@ var ApiClient = class {
   async verify() {
     return (await this.verifyDetailed()).ok;
   }
+  /**
+   * Re-point a thread's ROOT agent (mid-session agent switch). The runtime
+   * treats this as an explicit handoff: the full conversation is preserved
+   * and the next turn plays on the new agent. Published spec surface
+   * (`PATCH /api/threads/:id { agent_id }`), same as every head uses.
+   */
+  async setThreadAgent(threadId, agentId) {
+    await this.json(`/api/threads/${threadId}`, {
+      method: "PATCH",
+      body: JSON.stringify({ agent_id: agentId })
+    });
+  }
+  /**
+   * Whether the account has completed the Sama One (OpenSama) ChatGPT
+   * connection. Secret env variables come back as metadata only — the
+   * instance never returns the OpenAI key value to a client.
+   */
+  async openSamaStatus() {
+    const body = await this.json("/api/users/me/env");
+    return (body.variables ?? []).some((entry) => entry.name === "OPENSAMA_OPENAI_API_KEY");
+  }
   /**
    * Check the endpoint + token and say PRECISELY what's wrong when they
    * fail. "That token didn't work" is a lie when the real problem is a typo'd
@@ -5648,7 +5669,7 @@ var Tui = class _Tui {
    */
   select(title, items) {
     return new Promise((resolve) => {
-      let idx = 0;
+      let idx = Math.max(0, items.findIndex((it) => !it.disabled));
       this.beginTakeover();
       const cols2 = process.stdout.columns || 80;
       const geo = inputBoxGeometry(cols2);
@@ -5669,7 +5690,7 @@ ${pad}${title}
         let label = it.label.replace(/\s+/g, " ").trim();
         if (label.length > labelMax) label = label.slice(0, Math.max(0, labelMax - 1)) + "\u2026";
         const pointer = sel ? `${C.magenta}\u276F${C.reset} ` : "  ";
-        const styledLabel = sel ? `${C.bold}${C.cyan}${label}${C.reset}` : `${C.dim}${label}${C.reset}`;
+        const styledLabel = it.disabled ? `${C.gray}${label}${C.reset}` : sel ? `${C.bold}${C.cyan}${label}${C.reset}` : `${C.dim}${label}${C.reset}`;
         let content = `${pointer}${styledLabel}`;
         if (hintW) {
           const used = pointerW + label.length;
@@ -5714,7 +5735,7 @@ ${pad}${title}
           idx = (idx + 1) % items.length;
           draw(true);
         } else if (key.name === "return" || key.name === "enter") {
-          close(items[idx].value);
+          if (!items[idx].disabled) close(items[idx].value);
         } else if (key.name === "escape") {
           close(void 0);
         }
@@ -5899,6 +5920,13 @@ var AGENT_ID_VARIANTS = [
   "standard_code_low_agent",
   "standard_code_high_agent"
 ];
+var OPENSAMA_AGENT_ID = "opensama_agent";
+var AGENT_CHOICES = [
+  { id: "frontier_one", title: "Frontier One", description: "coming soon", disabled: true },
+  { id: AGENT_ID, title: "Unlimited One", description: "adaptive high/low routing" },
+  { id: OPENSAMA_AGENT_ID, title: "Sama One", description: "ChatGPT Pro sign-in required" },
+  { id: "dario", title: "Dario", description: "unavailable", disabled: true }
+];
 var PRODUCTION_ENDPOINT = "https://api.standardcode.ai";
 function readVersion() {
   try {
@@ -6822,7 +6850,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
   };
   const sweep = async () => {
     try {
-      const threads = await api.listThreads(AGENT_ID_VARIANTS, [runnerTag]);
+      const threads = await api.listThreads([...AGENT_ID_VARIANTS, OPENSAMA_AGENT_ID], [runnerTag]);
       const recent = threads.sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0)).slice(0, MAX_WORKERS);
       for (const t of recent) {
         await attach(t.id, t.tags, (t.created_at ?? 0) * 1e3);
@@ -7436,6 +7464,9 @@ function printUsage() {
       "                       If url is omitted, prompt for it.",
       "                       Credentials are remembered for that endpoint, but",
       "                       the saved default endpoint is not changed.",
+      "      --agent <name>    Pick the coding agent without the menu:",
+      "                       'unlimited' (Unlimited One, default) or 'sama'",
+      "                       (Sama One \u2014 requires the ChatGPT connection).",
       "  -h, --help            Show this help.",
       ""
     ].join("\n")
@@ -7449,6 +7480,18 @@ function parseArgs2(args) {
       parsed.help = true;
       continue;
     }
+    if (arg === "--agent") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) throw new Error("--agent requires a name (unlimited or sama).");
+      parsed.agent = value;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--agent=")) {
+      parsed.agent = arg.slice("--agent=".length);
+      if (!parsed.agent) throw new Error("--agent requires a name (unlimited or sama).");
+      continue;
+    }
     if (arg === "--endpoint" || arg === "-e") {
       const value = args[i + 1];
       if (value && !value.startsWith("-")) {
@@ -7798,6 +7841,35 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
   void registerProject(api, identity, projectDir).catch(() => {
   });
   const tui = new Tui(1);
+  let selectedAgent = AGENT_ID;
+  if (cliArgs.agent) {
+    const wanted = cliArgs.agent.toLowerCase();
+    if (["sama", "opensama", "sama_one", OPENSAMA_AGENT_ID].includes(wanted)) {
+      selectedAgent = OPENSAMA_AGENT_ID;
+    } else if (["unlimited", "standard", "unlimited_one", AGENT_ID].includes(wanted)) {
+      selectedAgent = AGENT_ID;
+    } else {
+      stdout.write(`${c3.red}error:${c3.reset} Unknown agent "${cliArgs.agent}". Use unlimited or sama.
+`);
+      process.exit(1);
+    }
+  } else {
+    const picked = await tui.select(
+      `${c3.bold}${gradientText("Which agent?")}${c3.reset}  ${c3.dim}\u2191\u2193 \xB7 enter \xB7 esc${c3.reset}`,
+      AGENT_CHOICES.map((choice) => ({
+        label: choice.title,
+        hint: choice.description,
+        value: choice.id,
+        disabled: choice.disabled
+      }))
+    );
+    if (!picked) process.exit(0);
+    selectedAgent = picked;
+  }
+  if (selectedAgent === OPENSAMA_AGENT_ID) {
+    const ok = await ensureSamaAuth(tui, api);
+    if (!ok) process.exit(0);
+  }
   const home = os7.homedir();
   const tildeDir = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
   const shortDir = tildeDir.length > 38 ? "\u2026" + tildeDir.slice(-37) : tildeDir;
@@ -7846,14 +7918,17 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
   const loadingSessions = startLoader("Loading sessions");
   let existing = [];
   try {
-    existing = await api.listThreads(AGENT_ID_VARIANTS, resumeTags);
+    existing = await api.listThreads(
+      selectedAgent === OPENSAMA_AGENT_ID ? [OPENSAMA_AGENT_ID] : AGENT_ID_VARIANTS,
+      resumeTags
+    );
   } catch {
     existing = [];
   }
   const summaries = existing.length > 0 ? await summarizeThreads(api, existing.slice(0, 8)) : [];
   loadingSessions.stop();
   const createSessionThread = async () => {
-    const id = await api.createThread(AGENT_ID, tags);
+    const id = await api.createThread(selectedAgent, tags);
     if (session.mode === "remote" && session.runner && session.remotePath) {
       await api.kvSet(id, "session_info", { cwd: session.remotePath, machine: session.runner.name }).catch(() => {
       });
@@ -7900,6 +7975,70 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
 function shortenPath(p, max = 38) {
   return p.length > max ? "\u2026" + p.slice(-(max - 1)) : p;
 }
+async function ensureSamaAuth(tui, api) {
+  const checking = startLoader("Checking your ChatGPT connection");
+  const already = await api.openSamaStatus().catch(() => false);
+  checking.stop();
+  if (already) return true;
+  const picked = await tui.select(
+    `${c3.bold}${gradientText("Authenticate with ChatGPT")}${c3.reset}  ${c3.dim}Sama One runs on OpenAI using your own ChatGPT Pro account${c3.reset}`,
+    [
+      {
+        label: "Continue with ChatGPT",
+        hint: "connect once \u2014 unlocks your whole account",
+        value: "continue"
+      },
+      { label: "Not now", hint: "go back", value: "cancel" }
+    ]
+  );
+  if (picked !== "continue") return false;
+  openUrl("https://standardcode.ai/app?connect=sama");
+  tui.print(
+    `${c3.dim}Finish connecting ChatGPT in the browser \u2014 waiting here for the authorization to land on your account\u2026${c3.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(
+        `${c3.green}\u2713${c3.reset} ChatGPT connected \u2014 Sama One is now unlocked on your account (terminal, web, and macOS app).`
+      );
+      return true;
+    }
+  }
+  waiting.stop();
+  tui.print(
+    `${c3.yellow}Still not connected.${c3.reset} Finish the flow at ${c3.teal}standardcode.ai/app${c3.reset} and pick Sama One again.`
+  );
+  return false;
+}
+async function runAgentSwitchMenu(tui, api, threadId) {
+  const picked = await tui.select(
+    `${c3.bold}${gradientText("Switch agent")}${c3.reset}  ${c3.dim}takes effect on the next message${c3.reset}`,
+    AGENT_CHOICES.map((choice) => ({
+      label: choice.title,
+      hint: choice.description,
+      value: choice.id,
+      disabled: choice.disabled
+    }))
+  );
+  if (!picked) return;
+  if (picked === OPENSAMA_AGENT_ID) {
+    const ok = await ensureSamaAuth(tui, api);
+    if (!ok) return;
+  }
+  const title = AGENT_CHOICES.find((choice) => choice.id === picked)?.title ?? picked;
+  try {
+    await api.setThreadAgent(threadId, picked);
+    tui.print(`${c3.green}\u2713${c3.reset} Session handed to ${c3.bold}${title}${c3.reset} \u2014 applies from your next message.`);
+  } catch (e) {
+    tui.print(
+      `${c3.red}\u2717 couldn't switch agent:${c3.reset} ${c3.gray}${e instanceof Error ? e.message : String(e)}${c3.reset}`
+    );
+  }
+}
 async function pickRemoteProject(tui, api, runner) {
   const ENTER_PATH = "__enter_path__";
   const projects = Object.entries(runner.projects).sort(
@@ -8611,6 +8750,12 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
         run: () => runMcpMenu(tui, mcpCtl)
       }
     ],
+    {
+      name: "agent",
+      label: "Switch agent",
+      hint: "hand this session to a different agent",
+      run: () => runAgentSwitchMenu(tui, api, threadId)
+    },
     {
       name: "machines",
       label: "Your machines",