arcie 0.1.8 → 0.2.0

package/dist/{dev-DCPOO54H.js → dev-XBXOVOVE.js}

@@ -25,10 +25,12 @@ import {
 } from "./chunk-SGWQZZ2A.js";
 import {
   streamAgent
-} from "./chunk-4WSILP75.js";
+} from "./chunk-3R65GQAE.js";
 import {
-  loadAgent
-} from "./chunk-KVSX4MLK.js";
+  discoverAgents,
+  loadAgent,
+  loadAgentById
+} from "./chunk-XZPC3JSU.js";
 import {
   discoverAgent
 } from "./chunk-6XETPLIF.js";
@@ -36,8 +38,10 @@ import "./chunk-QE46QFID.js";
 import "./chunk-PHTJLJOV.js";
 
 // src/cli/dev.ts
+import { spawn } from "child_process";
 import { createServer } from "http";
-import { resolve } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve } from "path";
 
 // src/cli/tui/renderer/start-block-chat.ts
 import { watch } from "fs";
@@ -769,6 +773,8 @@ function renderBody(block, width, theme, context) {
       return renderWarning(block, width, theme);
     case "result":
       return renderResult(block, width, theme);
+    case "command":
+      return renderCommand(block, theme);
     case "subagent":
       return renderSubagentHeader(block, width, theme);
     case "agent-header":
@@ -931,6 +937,11 @@ function paintCommands(line, theme) {
     (token) => isPromptControlCommand(token) ? theme.colors.blue(token) : token
   );
 }
+function renderCommand(block, theme) {
+  const c = theme.colors;
+  const status = block.status === "error" ? `${c.red(theme.glyph.error)} ` : "";
+  return [`${c.cyan(theme.glyph.user)} ${status}${c.blue(block.body ?? "")}`];
+}
 function renderResult(block, width, theme) {
   const marker = theme.colors.dim(theme.glyph.elbow);
   const lines = wrap(block.body ?? "", width - 7);
@@ -1005,6 +1016,24 @@ var TerminalRenderer = class {
   writeAgentHeader(body) {
     this.apply([{ type: "commit", block: { kind: "agent-header", body } }]);
   }
+  /**
+   * Echoes a slash-command invocation to scrollback so it chains with the
+   * transcript above (blue `▌ /model`) and the {@link writeCommandResult}
+   * that hangs beneath it can share visual context.
+   */
+  writeCommandInvocation(text, status) {
+    const block = { kind: "command", body: text };
+    if (status === "error") block.status = "error";
+    this.apply([{ type: "commit", block }]);
+  }
+  /**
+   * Writes a command outcome hung under the previous invocation with the
+   * elbow connector (`⎿  message`). Multi-line messages soft-wrap under the
+   * elbow.
+   */
+  writeCommandResult(text) {
+    this.apply([{ type: "commit", block: { kind: "result", body: text } }]);
+  }
   readPrompt() {
     return new Promise((resolve2) => {
       this.#pendingResolve = resolve2;
@@ -1232,28 +1261,35 @@ async function startBlockChat(options) {
       if (trimmed.startsWith("/")) {
         const command = parsePromptCommand(trimmed);
         if (command === null) {
-          renderer.writeError("Unknown command", `${trimmed} \u2014 try /help`);
+          renderer.writeCommandInvocation(trimmed, "error");
+          renderer.writeCommandResult("Unknown command \u2014 try /help");
           continue;
         }
+        if (command.type === "exit") {
+          renderer.writeCommandInvocation(trimmed);
+          return;
+        }
+        renderer.writeCommandInvocation(trimmed);
         switch (command.type) {
-          case "exit":
-            return;
           case "help":
-            for (const line of formatPromptCommandHelp().split("\n")) {
-              renderer.writeNotice(line);
-            }
+            renderer.writeCommandResult(formatPromptCommandHelp());
             continue;
           case "clear":
           case "new":
             for (const op of translator.reset()) renderer.apply([op]);
             await commitHeader();
             continue;
-          case "extension":
-            await handleExtension(command, renderer, agentDir, commitHeader);
+          case "extension": {
+            const outcome = await handleExtension(command, agentDir);
+            if (outcome.message.length > 0) renderer.writeCommandResult(outcome.message);
+            if (outcome.refresh) await commitHeader();
             continue;
-          case "loglevel":
-            handleLogLevel(command, renderer, logLevelState);
+          }
+          case "loglevel": {
+            const outcome = handleLogLevel(command, logLevelState);
+            renderer.writeCommandResult(outcome.message);
             continue;
+          }
         }
         continue;
       }
@@ -1265,120 +1301,122 @@ async function startBlockChat(options) {
     renderer.stop();
   }
 }
-async function handleExtension(command, renderer, agentDir, commitHeader) {
+async function handleExtension(command, agentDir) {
   const argument = command.argument.trim();
   switch (command.name) {
     case "model":
-      await handleModel(argument, renderer, agentDir, commitHeader);
-      return;
+      return handleModel(argument, agentDir);
     case "provider":
-      handleProvider(renderer, agentDir);
-      return;
+      return handleProvider(agentDir);
     case "channels":
-      handleChannels(argument, renderer, agentDir);
-      return;
+      return handleChannels(argument, agentDir);
     default:
-      renderer.writeNotice(`/${command.name} is not supported here`);
+      return { message: `/${command.name} is not supported here` };
   }
 }
-async function handleModel(argument, renderer, agentDir, commitHeader) {
+function handleModel(argument, agentDir) {
   const current = readAgentModel(agentDir);
   if (argument.length === 0) {
-    renderer.writeNotice(
-      current ? `current model: ${current}` : "no model configured in agent/agent.ts"
-    );
-    renderer.writeNotice("change it with: /model <provider/slug>");
-    return;
+    const lines = [
+      current ? `Current model: ${current}` : "No model configured in agent/agent.ts",
+      "Change with: /model <provider/slug>"
+    ];
+    return { message: lines.join("\n") };
   }
   if (current === argument) {
-    renderer.writeNotice(`model is already ${argument}`);
-    return;
+    return { message: `Model is already ${argument}` };
   }
   const changed = writeAgentModel(agentDir, argument);
   if (!changed) {
-    renderer.writeError(
-      "Model not changed",
-      "Could not update agent/agent.ts \u2014 file missing or model field not found."
-    );
-    return;
+    return {
+      message: "Could not update agent/agent.ts \u2014 file missing or model field not found."
+    };
   }
-  renderer.writeNotice(`model set to ${argument}`);
-  await commitHeader();
+  return { message: `Model set to ${argument}`, refresh: true };
 }
-function handleProvider(renderer, agentDir) {
+function handleProvider(agentDir) {
   const status = providerKeyStatus(agentDir);
   const configured = status.filter((row) => row.set);
   if (configured.length === 0) {
-    renderer.writeNotice("no provider keys configured");
-    renderer.writeNotice("edit .env.local to add CENCORI_API_KEY or a direct provider key");
-    return;
+    return {
+      message: [
+        "No provider keys configured.",
+        "Edit .env.local to add CENCORI_API_KEY or a direct provider key."
+      ].join("\n")
+    };
   }
-  renderer.writeNotice("provider keys:");
+  const lines = ["Provider keys:"];
   for (const row of status) {
     if (row.set) {
-      renderer.writeNotice(`  ${row.key} = ${row.masked} (${row.source})`);
+      lines.push(`  ${row.key} = ${row.masked} (${row.source})`);
     } else {
-      renderer.writeNotice(`  ${row.key} \u2014 not set`);
+      lines.push(`  ${row.key} \u2014 not set`);
     }
   }
+  return { message: lines.join("\n") };
 }
-function handleChannels(argument, renderer, agentDir) {
+function handleChannels(argument, agentDir) {
   if (argument.length === 0) {
     const channels = listChannels(agentDir);
     if (channels.length === 0) {
-      renderer.writeNotice("no channels scaffolded");
-      renderer.writeNotice("add one with: /channels add web");
-      return;
+      return {
+        message: ["No channels scaffolded.", "Add one with: /channels add web"].join("\n")
+      };
     }
-    renderer.writeNotice("channels:");
-    for (const channel of channels) renderer.writeNotice(`  ${channel.name} \u2014 ${channel.path}`);
-    renderer.writeNotice("add another with: /channels add <kind>");
-    return;
+    const lines = ["Channels:"];
+    for (const channel of channels) lines.push(`  ${channel.name} \u2014 ${channel.path}`);
+    lines.push("Add another with: /channels add <kind>");
+    return { message: lines.join("\n") };
   }
   const parts = argument.split(/\s+/);
   const subcommand = parts[0];
   const kind = parts[1];
   if (subcommand !== "add") {
-    renderer.writeError("Unknown /channels subcommand", `try: /channels add web`);
-    return;
+    return { message: `Unknown subcommand '${subcommand}' \u2014 try: /channels add web` };
   }
   if (kind !== "web") {
-    renderer.writeError("Unsupported channel kind", `${kind ?? "(none)"} \u2014 only 'web' is supported`);
-    return;
+    return {
+      message: `Unsupported channel kind '${kind ?? ""}' \u2014 only 'web' is supported`
+    };
   }
   try {
     const result = scaffoldWebChat(agentDir);
     if (result.alreadyExisted) {
-      renderer.writeNotice(`channels/web already exists \u2014 left it untouched`);
-      return;
+      return { message: `channels/web already exists at ${result.targetPath}` };
     }
-    renderer.writeNotice(`scaffolded ${result.targetPath}`);
-    renderer.writeNotice("next: cd into it, npm install, npm run dev");
+    return {
+      message: [
+        `Scaffolded ${result.targetPath}`,
+        "Next: cd into it, npm install, npm run dev"
+      ].join("\n")
+    };
   } catch (err) {
-    renderer.writeError(
-      "Channel scaffold failed",
-      err instanceof Error ? err.message : String(err)
-    );
+    return {
+      message: `Channel scaffold failed: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
 }
-function handleLogLevel(command, renderer, state) {
+function handleLogLevel(command, state) {
   const argument = command.argument.trim();
   if (argument.length === 0) {
-    renderer.writeNotice(`log level: ${state.mode}`);
-    renderer.writeNotice("change with: /loglevel all | stderr | none");
-    renderer.writeNotice("note: arcie does not currently capture subprocess logs.");
-    return;
+    return {
+      message: [
+        `Log level: ${state.mode}`,
+        "Change with: /loglevel all | stderr | none",
+        "Note: arcie does not currently capture subprocess logs."
+      ].join("\n")
+    };
   }
   if (!VALID_LOG_MODES.has(argument)) {
-    renderer.writeError(
-      "Invalid log level",
-      `${argument} \u2014 pick one of: all, stderr, none`
-    );
-    return;
+    return { message: `Invalid log level '${argument}' \u2014 pick one of: all, stderr, none` };
   }
   state.mode = argument;
-  renderer.writeNotice(`log level: ${state.mode}`);
-  renderer.writeNotice("note: arcie does not currently capture subprocess logs.");
+  return {
+    message: [
+      `Log level: ${state.mode}`,
+      "Note: arcie does not currently capture subprocess logs."
+    ].join("\n")
+  };
 }
 async function streamOneTurn(renderer, translator, agentDir, message) {
   let sawApproval = false;
@@ -2094,42 +2132,165 @@ async function listenWithFallback(server, startPort) {
     `Could not find a free port in ${startPort}..${startPort + MAX_PORT_ATTEMPTS - 1}`
   );
 }
+function isPortFree(port) {
+  return new Promise((resolve2) => {
+    const probe = createServer();
+    probe.once("error", () => resolve2(false));
+    probe.once("listening", () => {
+      probe.close(() => resolve2(true));
+    });
+    probe.listen(port);
+  });
+}
+async function findFreePort(startPort, maxAttempts = MAX_PORT_ATTEMPTS) {
+  for (let offset = 0; offset < maxAttempts; offset += 1) {
+    const port = startPort + offset;
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error(`No free port in ${startPort}..${startPort + maxAttempts - 1}`);
+}
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    const child = spawn(command, [url], {
+      detached: true,
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function waitForHttp(url, timeoutMs = 3e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(url, { method: "GET" });
+      if (res.status < 500) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+async function installWebDeps(webDir) {
+  return new Promise((resolve2) => {
+    const child = spawn("npm", ["install", "--no-fund", "--no-audit"], {
+      cwd: webDir,
+      stdio: "ignore"
+    });
+    child.once("exit", (code) => resolve2(code === 0));
+    child.once("error", () => resolve2(false));
+  });
+}
+async function startWebChannel(agentDir, arcieUrl, webPort) {
+  const webDir = join2(agentDir, "channels", "web");
+  if (!existsSync2(join2(webDir, "package.json"))) return void 0;
+  if (!existsSync2(join2(webDir, "node_modules"))) {
+    console.log(`  ${dimmed(`web    installing channels/web deps (first run)\u2026`)}`);
+    const installed = await installWebDeps(webDir);
+    if (!installed) {
+      console.log();
+      console.log(`  ${grey("\u26A0")} channels/web install failed \u2014 try manually:`);
+      console.log(`  ${dimmed(`  cd ${webDir} && npm install`)}`);
+      console.log();
+      return void 0;
+    }
+  }
+  const child = spawn("npm", ["run", "dev", "--", "--port", String(webPort)], {
+    cwd: webDir,
+    env: { ...process.env, ARCIE_URL: arcieUrl },
+    stdio: "ignore",
+    detached: false
+  });
+  const url = `http://localhost:${webPort}`;
+  const ready = await waitForHttp(url, 45e3);
+  if (!ready) {
+    console.log();
+    console.log(`  ${grey("\u26A0")} channels/web didn't come up within 45s`);
+    child.kill();
+    return void 0;
+  }
+  return { url, process: child };
+}
 async function devCommand(options) {
   const agentDirPath = resolve(process.cwd(), options.agentDir);
   const requestedPort = parseInt(options.port, 10);
+  const streamTurn = async (res, body, agentId) => {
+    try {
+      const { message, stream } = JSON.parse(body);
+      if (typeof message !== "string" || message.length === 0) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "message is required" }));
+        return;
+      }
+      if (stream) {
+        res.writeHead(200, {
+          "Content-Type": "application/x-ndjson",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        });
+        const runOpts = agentId !== void 0 ? { agentId } : {};
+        for await (const event of streamAgent(agentDirPath, message, runOpts)) {
+          res.write(JSON.stringify(event) + "\n");
+        }
+        res.end();
+      } else {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        const runOpts = agentId !== void 0 ? { agentId } : {};
+        for await (const _event of streamAgent(agentDirPath, message, runOpts)) {
+        }
+        res.end(JSON.stringify({ status: "ok" }));
+      }
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  };
+  const listAgents = async () => {
+    const discovered = discoverAgents(agentDirPath);
+    const summaries = await Promise.all(
+      discovered.map(async ({ id }) => {
+        try {
+          const loaded = await loadAgentById(agentDirPath, id);
+          const { config } = loaded.manifest;
+          return {
+            id,
+            name: config.name ?? id,
+            model: config.model,
+            description: config.description ?? ""
+          };
+        } catch {
+          return { id, name: id, model: "", description: "" };
+        }
+      })
+    );
+    return summaries;
+  };
   const server = createServer(async (req, res) => {
-    if (await handleSessionsRequest(req, res)) {
+    if (await handleSessionsRequest(req, res)) return;
+    const method = req.method ?? "GET";
+    const url = req.url ?? "/";
+    if (method === "GET" && url === "/agents") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(await listAgents()));
       return;
     }
-    if (req.method === "POST" && req.url === "/") {
+    const agentsMatch = url.match(/^\/agents\/([^/?]+)(?:\?.*)?$/);
+    if (method === "POST" && agentsMatch !== null) {
       let body = "";
       for await (const chunk of req) body += chunk;
-      try {
-        const { message, stream } = JSON.parse(body);
-        if (stream) {
-          res.writeHead(200, {
-            "Content-Type": "application/x-ndjson",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive"
-          });
-          for await (const event of streamAgent(agentDirPath, message)) {
-            res.write(JSON.stringify(event) + "\n");
-          }
-          res.end();
-        } else {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          for await (const _event of streamAgent(agentDirPath, message)) {
-          }
-          res.end(JSON.stringify({ status: "ok" }));
-        }
-      } catch (err) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(err) }));
-      }
-    } else {
-      res.writeHead(404);
-      res.end("Not found");
+      await streamTurn(res, body, decodeURIComponent(agentsMatch[1]));
+      return;
     }
+    if (method === "POST" && url === "/") {
+      let body = "";
+      for await (const chunk of req) body += chunk;
+      await streamTurn(res, body, void 0);
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
   });
   let boundPort;
   try {
@@ -2166,25 +2327,50 @@ async function devCommand(options) {
         );
         console.log();
       }
-      console.log(`  ${dimmed(`http://localhost:${boundPort}`)}`);
-      console.log();
-      console.log(`  ${dimmed(`$ curl -X POST http://localhost:${boundPort} \\`)}`);
-      console.log(`  ${dimmed(`  -H "Content-Type: application/json" \\`)}`);
-      console.log(`  ${dimmed(`  -d '{"message": "hello"}'`)}`);
-      console.log();
+      console.log(`  ${dimmed(`agent  http://localhost:${boundPort}`)}`);
       const missing = checkProviderKeys(agent.manifest.config.model);
       if (missing.length > 0) {
+        console.log();
         console.log(`  ${grey("\u26A0")} Missing API keys: ${missing.join(", ")}`);
         console.log(`  ${dimmed("  Set them in .env.local or your environment")}`);
-        console.log();
       }
     } catch {
       console.log(`  ${agentDirPath}`);
       console.log();
-      console.log(`  ${dimmed(`http://localhost:${boundPort}`)}`);
-      console.log();
+      console.log(`  ${dimmed(`agent  http://localhost:${boundPort}`)}`);
+    }
+  }
+  let webChannel;
+  if (!options.input && options.noWeb !== true) {
+    const webDir = join2(agentDirPath, "channels", "web");
+    if (existsSync2(webDir)) {
+      try {
+        const webPort = await findFreePort(3001);
+        console.log(`  ${dimmed(`web    starting on http://localhost:${webPort}\u2026`)}`);
+        webChannel = await startWebChannel(agentDirPath, `http://localhost:${boundPort}`, webPort);
+        if (webChannel !== void 0) {
+          console.log(`  ${dimmed(`web    http://localhost:${webPort}`)}`);
+          if (options.noOpen !== true) openBrowser(webChannel.url);
+        }
+      } catch (err) {
+        console.log(
+          `  ${grey("\u26A0")} could not start web channel: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     }
   }
+  if (!options.input) {
+    console.log();
+    console.log(`  ${dimmed("Ctrl+C to stop")}`);
+    console.log();
+  }
+  const shutdown = () => {
+    if (webChannel !== void 0) webChannel.process.kill();
+    server.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
   if (options.input) {
     void startBlockChat({ agentDir: agentDirPath });
   }
@@ -2192,4 +2378,4 @@ async function devCommand(options) {
 export {
   devCommand
 };
-//# sourceMappingURL=dev-DCPOO54H.js.map
+//# sourceMappingURL=dev-XBXOVOVE.js.map