starkbot-cli 0.1.4 → 0.2.1

package/dist/index.js

@@ -867,13 +867,159 @@ var init_connect = __esm({
   }
 });
 
+// src/lib/status.ts
+import ora2 from "ora";
+import chalk2 from "chalk";
+var subtypeColor, toolColor, subagentColor, dimText, StatusTracker;
+var init_status2 = __esm({
+  "src/lib/status.ts"() {
+    "use strict";
+    subtypeColor = chalk2.hex("#7C3AED").bold;
+    toolColor = chalk2.yellow;
+    subagentColor = chalk2.cyan;
+    dimText = chalk2.dim;
+    StatusTracker = class {
+      spinner;
+      activeSubtype = "";
+      activeTools = [];
+      activeSubagents = /* @__PURE__ */ new Map();
+      // label -> subtype
+      paused = false;
+      constructor() {
+        this.spinner = ora2({ color: "magenta", spinner: "dots" });
+      }
+      handleEvent(event) {
+        switch (event.type) {
+          case "tool_call":
+            this.addTool(event.tool_name ?? "unknown");
+            break;
+          case "tool_result":
+            this.removeTool(event.tool_name ?? "unknown");
+            break;
+          case "subagent_spawned":
+            this.addSubagent(event.label ?? "?", event.agent_subtype);
+            break;
+          case "subagent_completed":
+          case "subagent_failed":
+            this.removeSubagent(event.label ?? "?");
+            break;
+          case "subtype_change":
+            this.setSubtype(event.agent_subtype ?? event.label ?? "");
+            break;
+          case "thinking":
+            this.setThinking(event.content);
+            break;
+          case "task_started":
+            if (event.task_name) this.setTask(event.task_name);
+            break;
+          case "task_completed":
+            this.updateSpinner();
+            break;
+          case "text":
+            this.pauseForText();
+            if (event.content) process.stdout.write(event.content);
+            this.resumeAfterText();
+            break;
+          case "done":
+            this.finish();
+            break;
+        }
+      }
+      prefix() {
+        if (this.activeSubtype) {
+          return `${subtypeColor(`[${this.activeSubtype}]`)} `;
+        }
+        return "";
+      }
+      addTool(name) {
+        if (!this.activeTools.includes(name)) {
+          this.activeTools.push(name);
+        }
+        this.updateSpinner();
+      }
+      removeTool(name) {
+        this.activeTools = this.activeTools.filter((t) => t !== name);
+        this.updateSpinner();
+      }
+      addSubagent(label, subtype) {
+        this.activeSubagents.set(label, subtype ?? "");
+        this.updateSpinner();
+      }
+      removeSubagent(label) {
+        this.activeSubagents.delete(label);
+        this.updateSpinner();
+      }
+      setSubtype(subtype) {
+        this.activeSubtype = subtype;
+        this.updateSpinner();
+      }
+      setThinking(message) {
+        const text = `${this.prefix()}${dimText(message || "thinking...")}`;
+        this.ensureSpinning(text);
+      }
+      setTask(taskName) {
+        const text = `${this.prefix()}${dimText(taskName)}`;
+        this.ensureSpinning(text);
+      }
+      updateSpinner() {
+        const parts = [];
+        for (const [label, subtype] of this.activeSubagents) {
+          const st = subtype ? ` (${subtype})` : "";
+          parts.push(subagentColor(`subagent "${label}"${st} running`));
+        }
+        if (this.activeTools.length > 0) {
+          const names = this.activeTools.map((t) => toolColor(t)).join(", ");
+          parts.push(`calling ${names}`);
+        }
+        if (parts.length === 0) {
+          if (this.spinner.isSpinning && !this.paused) {
+            this.spinner.stop();
+          }
+          return;
+        }
+        const text = `${this.prefix()}${parts.join(" | ")}`;
+        this.ensureSpinning(text);
+      }
+      ensureSpinning(text) {
+        if (this.paused) return;
+        if (this.spinner.isSpinning) {
+          this.spinner.text = text;
+        } else {
+          this.spinner.start(text);
+        }
+      }
+      pauseForText() {
+        if (this.spinner.isSpinning) {
+          this.spinner.stop();
+        }
+        this.paused = true;
+      }
+      resumeAfterText() {
+        this.paused = false;
+        if (this.activeTools.length > 0 || this.activeSubagents.size > 0) {
+          this.updateSpinner();
+        }
+      }
+      finish() {
+        if (this.spinner.isSpinning) {
+          this.spinner.stop();
+        }
+        this.activeTools = [];
+        this.activeSubagents.clear();
+        this.activeSubtype = "";
+        this.paused = false;
+      }
+    };
+  }
+});
+
 // src/commands/chat.ts
 var chat_exports = {};
 __export(chat_exports, {
   chatOneShotCommand: () => chatOneShotCommand,
   chatReplCommand: () => chatReplCommand
 });
-import { createInterface as createInterface2 } from "readline";
+import { createInterface as createInterface2 } from "readline/promises";
 function requireGateway() {
   const creds = requireCredentials();
   if (!creds.gateway_token || !creds.instance_domain) {
@@ -886,41 +1032,66 @@ function requireGateway() {
     creds.gateway_token
   );
 }
-function printSseEvent(event) {
-  switch (event.type) {
-    case "tool_call": {
-      const name = event.tool_name ?? "unknown";
-      process.stdout.write(dim(`[${name}...] `));
-      break;
+function isAuthError(err) {
+  return err?.message?.includes("HTTP 401") || err?.message?.includes("Invalid gateway token");
+}
+async function tryRefreshToken() {
+  const creds = loadCredentials();
+  if (!creds?.jwt) return null;
+  try {
+    const client = new FlashClient(creds.jwt);
+    const { token, domain } = await client.getGatewayToken();
+    updateCredentials({ gateway_token: token, instance_domain: domain });
+    const gw = new GatewayClient(`https://${domain}`, token);
+    const ok = await gw.ping();
+    if (ok) {
+      printSuccess("Gateway token refreshed automatically.");
+      return gw;
     }
-    case "tool_result":
-      break;
-    case "text":
-      if (event.content) {
-        process.stdout.write(event.content);
-      }
-      break;
-    case "done":
-      break;
+  } catch {
   }
+  return null;
 }
 async function chatOneShotCommand(message) {
-  const gw = requireGateway();
+  let gw = requireGateway();
+  const status = new StatusTracker();
   process.stdout.write(`${prefix.agent} `);
   try {
-    await gw.chatStream(message, printSseEvent);
+    await gw.chatStream(message, (event) => status.handleEvent(event));
     console.log();
   } catch (err) {
+    status.finish();
     console.log();
-    printError(err.message);
+    if (isAuthError(err)) {
+      printWarning("Gateway token is invalid or expired. Attempting to refresh...");
+      const refreshed = await tryRefreshToken();
+      if (refreshed) {
+        gw = refreshed;
+        process.stdout.write(`${prefix.agent} `);
+        const status2 = new StatusTracker();
+        try {
+          await gw.chatStream(message, (event) => status2.handleEvent(event));
+          console.log();
+          return;
+        } catch (retryErr) {
+          status2.finish();
+          console.log();
+          printError(retryErr.message);
+        }
+      } else {
+        printError("Could not refresh token. Run `starkbot connect` to set a new gateway token.");
+      }
+    } else {
+      printError(err.message);
+    }
     process.exit(1);
   }
 }
 async function chatReplCommand() {
-  const gw = requireGateway();
+  let gw = requireGateway();
   console.log(
     dim(
-      "Starkbot CLI \u2014 type a message, /new to reset, /sessions to list, /quit to exit"
+      "Starkbot CLI \u2014 type a message, /new to reset, /sessions to list, /connect to refresh token, /quit to exit"
     )
   );
   const rl = createInterface2({
@@ -928,109 +1099,148 @@ async function chatReplCommand() {
     output: process.stdout,
     terminal: true
   });
-  const prompt = () => {
-    rl.question(`${prefix.you} `, async (input) => {
-      const trimmed = input.trim();
-      if (!trimmed) {
-        prompt();
-        return;
+  let running = true;
+  while (running) {
+    let input;
+    try {
+      input = await rl.question(`${prefix.you} `);
+    } catch {
+      break;
+    }
+    const trimmed = input.trim();
+    if (!trimmed) continue;
+    switch (trimmed) {
+      case "/quit":
+      case "/exit":
+      case "/q":
+        running = false;
+        console.log(dim("Goodbye!"));
+        break;
+      case "/new": {
+        try {
+          const resp = await gw.newSession();
+          console.log(
+            `${prefix.system} New session created (id: ${resp.session_id})`
+          );
+        } catch (err) {
+          console.log(`${prefix.error} ${err.message}`);
+        }
+        break;
       }
-      switch (trimmed) {
-        case "/quit":
-        case "/exit":
-        case "/q":
-          rl.close();
-          console.log(dim("Goodbye!"));
-          return;
-        case "/new": {
-          try {
-            const resp = await gw.newSession();
-            console.log(
-              `${prefix.system} New session created (id: ${resp.session_id})`
-            );
-          } catch (err) {
-            console.log(`${prefix.error} ${err.message}`);
+      case "/sessions": {
+        try {
+          const resp = await gw.listSessions();
+          if (resp.sessions.length === 0) {
+            console.log(`${prefix.system} No sessions found`);
+          } else {
+            console.log(`${prefix.system} Sessions:`);
+            for (const s of resp.sessions) {
+              console.log(
+                `  ${info(s.session_key)} | ${s.message_count} msgs | last active: ${dim(s.last_activity_at)}`
+              );
+            }
           }
-          prompt();
-          return;
+        } catch (err) {
+          console.log(`${prefix.error} ${err.message}`);
         }
-        case "/sessions": {
+        break;
+      }
+      case "/connect": {
+        console.log(`${prefix.system} Refreshing gateway token...`);
+        const refreshed = await tryRefreshToken();
+        if (refreshed) {
+          gw = refreshed;
+        } else {
+          console.log(`${prefix.system} Auto-refresh failed. Enter a new gateway token manually.`);
           try {
-            const resp = await gw.listSessions();
-            if (resp.sessions.length === 0) {
-              console.log(`${prefix.system} No sessions found`);
-            } else {
-              console.log(`${prefix.system} Sessions:`);
-              for (const s of resp.sessions) {
-                console.log(
-                  `  ${info(s.session_key)} | ${s.message_count} msgs | last active: ${dim(s.last_activity_at)}`
-                );
+            const newToken = (await rl.question(`${prefix.system} Gateway token: `)).trim();
+            if (newToken) {
+              const creds = requireCredentials();
+              const domain = creds.instance_domain;
+              updateCredentials({ gateway_token: newToken });
+              gw = new GatewayClient(`https://${domain}`, newToken);
+              const ok = await gw.ping();
+              if (ok) {
+                printSuccess(`Reconnected to ${domain}`);
+              } else {
+                printWarning("Token saved but instance is not responding.");
               }
+            } else {
+              console.log(`${prefix.system} Cancelled.`);
             }
-          } catch (err) {
-            console.log(`${prefix.error} ${err.message}`);
+          } catch {
           }
-          prompt();
-          return;
         }
-        case "/help":
-          console.log(`${prefix.system} Commands:`);
-          console.log(`  ${info("/new")}      \u2014 Start a new session`);
-          console.log(`  ${info("/sessions")} \u2014 List sessions`);
-          console.log(
-            `  ${info("/history <id>")} \u2014 Show message history`
-          );
-          console.log(`  ${info("/quit")}     \u2014 Exit`);
-          prompt();
-          return;
-        default:
-          if (trimmed.startsWith("/history")) {
-            const parts = trimmed.split(/\s+/);
-            if (parts.length < 2) {
-              console.log(
-                `${prefix.system} Usage: /history <session_id>`
-              );
+        break;
+      }
+      case "/help":
+        console.log(`${prefix.system} Commands:`);
+        console.log(`  ${info("/new")}      \u2014 Start a new session`);
+        console.log(`  ${info("/sessions")} \u2014 List sessions`);
+        console.log(
+          `  ${info("/history <id>")} \u2014 Show message history`
+        );
+        console.log(`  ${info("/connect")}  \u2014 Refresh gateway token`);
+        console.log(`  ${info("/quit")}     \u2014 Exit`);
+        break;
+      default:
+        if (trimmed.startsWith("/history")) {
+          const parts = trimmed.split(/\s+/);
+          if (parts.length < 2) {
+            console.log(
+              `${prefix.system} Usage: /history <session_id>`
+            );
+          } else {
+            const sid = parseInt(parts[1], 10);
+            if (isNaN(sid)) {
+              console.log(`${prefix.error} Invalid session ID: ${parts[1]}`);
             } else {
-              const sid = parseInt(parts[1], 10);
-              if (isNaN(sid)) {
-                console.log(`${prefix.error} Invalid session ID: ${parts[1]}`);
-              } else {
-                try {
-                  const resp = await gw.getHistory(sid);
-                  for (const m of resp.messages) {
-                    const p = m.role === "user" ? prefix.you : m.role === "assistant" ? prefix.agent : dim(`${m.role}>`);
-                    console.log(`${p} ${m.content}`);
-                  }
-                } catch (err) {
-                  console.log(`${prefix.error} ${err.message}`);
+              try {
+                const resp = await gw.getHistory(sid);
+                for (const m of resp.messages) {
+                  const p = m.role === "user" ? prefix.you : m.role === "assistant" ? prefix.agent : dim(`${m.role}>`);
+                  console.log(`${p} ${m.content}`);
                 }
+              } catch (err) {
+                console.log(`${prefix.error} ${err.message}`);
               }
             }
-            prompt();
-            return;
           }
-          process.stdout.write(`${prefix.agent} `);
-          try {
-            await gw.chatStream(trimmed, printSseEvent);
-            console.log();
-          } catch (err) {
-            console.log();
+          break;
+        }
+        process.stdout.write(`${prefix.agent} `);
+        try {
+          const status = new StatusTracker();
+          await gw.chatStream(trimmed, (event) => status.handleEvent(event));
+          console.log();
+        } catch (err) {
+          console.log();
+          if (isAuthError(err)) {
+            console.log(`${prefix.error} ${err.message}`);
+            console.log(warn("  Gateway token is invalid or expired. Attempting to refresh..."));
+            const refreshed = await tryRefreshToken();
+            if (refreshed) {
+              gw = refreshed;
+              console.log(dim("  Try your message again."));
+            } else {
+              console.log(warn("  Auto-refresh failed. Use /connect to enter a new token."));
+            }
+          } else {
             console.log(`${prefix.error} ${err.message}`);
           }
-          prompt();
-      }
-    });
-  };
-  prompt();
-  rl.on("close", () => {
-    process.exit(0);
-  });
+        }
+    }
+  }
+  rl.close();
+  process.exit(0);
 }
 var init_chat = __esm({
   "src/commands/chat.ts"() {
     "use strict";
     init_credentials();
+    init_flash_client();
     init_gateway_client();
+    init_status2();
     init_ui();
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starkbot-cli",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "CLI for Starkbot — login, provision, and chat with your bot from the terminal",
   "type": "module",
   "bin": {