nolo-cli 0.1.13 → 0.1.14

package/client/agentRun.test.ts

@@ -0,0 +1,240 @@
+import { describe, expect, test } from "bun:test";
+import { Writable } from "node:stream";
+
+import { runAgentTurn, shouldUseScriptBridge } from "./agentRun";
+
+class CaptureOutput extends Writable {
+  chunks: string[] = [];
+
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void) {
+    this.chunks.push(String(chunk));
+    callback();
+  }
+
+  text() {
+    return this.chunks.join("");
+  }
+}
+
+describe("cli agent run client", () => {
+  test("uses the repo script bridge only when no auth token is available", () => {
+    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: true })).toBe(true);
+    expect(shouldUseScriptBridge({ hasAuthToken: true, scriptPathExists: true })).toBe(false);
+    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: false })).toBe(false);
+  });
+
+  test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
+    const output = new CaptureOutput();
+    const requests: Array<{ url: string; body: any; auth: string | null }> = [];
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      continueDialogId: "dialog-existing",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        requests.push({
+          url: String(url),
+          body: JSON.parse(String(init?.body)),
+          auth: new Headers(init?.headers).get("Authorization"),
+        });
+        return Response.json({
+          content: "hi",
+          dialogId: "dialog-1",
+          usage: { input_tokens: 2, output_tokens: 3 },
+        });
+      },
+    });
+
+    expect(requests).toEqual([
+      {
+        url: "https://nolo.chat/api/agent/run",
+        auth: "Bearer token-123",
+        body: {
+          agentKey: "agent-pub-test",
+          userInput: "hello",
+          continueDialogId: "dialog-existing",
+          runtimeContext: {
+            surface: "cli",
+            host: "terminal",
+            runtime: "bun",
+            entrypoint: "nolo-cli",
+            capabilities: ["text-io", "streaming", "slash-commands"],
+          },
+          stream: true,
+        },
+      },
+    ]);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
+    expect(output.text()).toContain("nolo -> working");
+    expect(output.text()).toContain("nolo > hi");
+    expect(output.text()).not.toContain("tokens=");
+  });
+
+  test("runs forced local turns through the injected runtime adapter without HTTP", async () => {
+    const output = new CaptureOutput();
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async (messages) => ({
+            content: `local:${messages.at(-1)?.content}`,
+            model: "fake-local",
+            trace: messages,
+          }),
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("HTTP should not be called for forced local runs");
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local" });
+    expect(output.text()).toContain("frontend -> working locally");
+    expect(output.text()).toContain("frontend > local:polish notifications");
+  });
+
+  test("builds the default local adapter when env requests local mode", async () => {
+    const output = new CaptureOutput();
+    const builtModes: string[] = [];
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { NOLO_RUNTIME_MODE: "local" },
+      output,
+      localRuntimeAdapterFactory: (env) => {
+        builtModes.push(env.NOLO_RUNTIME_MODE ?? "");
+        return {
+          host: "cli",
+          capabilities: ["local-provider", "local-persistence"],
+          loadAgentConfig: async (agentRef) => ({ key: agentRef, prompt: "Fix UI" }),
+          loadDialogHistory: async () => [],
+          saveTurn: async () => ({ dialogId: "dialog-local-env" }),
+          resolveProvider: async () => ({
+            model: "fake-local",
+            complete: async () => ({ content: "local env ok", model: "fake-local" }),
+          }),
+          executeTool: async () => {
+            throw new Error("no tools expected");
+          },
+        };
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("HTTP should not be called for env local runs");
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-env" });
+    expect(builtModes).toEqual(["local"]);
+    expect(output.text()).toContain("frontend -> working locally");
+  });
+
+  test("streams agent text responses to terminal output", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () =>
+        new Response(
+          [
+            `data: ${JSON.stringify({ type: "text", content: "你" })}`,
+            "",
+            `data: ${JSON.stringify({ type: "text", content: "好" })}`,
+            "",
+            `data: ${JSON.stringify({ type: "done", dialogId: "dialog-stream" })}`,
+            "",
+          ].join("\n"),
+          {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+          }
+        ),
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-stream" });
+    expect(output.text()).toContain("nolo -> working");
+    expect(output.text()).toContain("nolo > 你好");
+  });
+
+  test("prints an auth hint when installed without repo scripts or AUTH_TOKEN", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: {},
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("fetch should not be called");
+      },
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(output.text()).toContain("Set AUTH_TOKEN");
+  });
+
+  test("prints a friendly connection hint instead of crashing on transport errors", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "http://127.0.0.1:38123",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("ConnectionRefused");
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 1 });
+    expect(output.text()).toContain("Could not reach http://127.0.0.1:38123/api/agent/run");
+    expect(output.text()).toContain("set NOLO_SERVER");
+  });
+});

package/client/agentRun.ts

@@ -1,5 +1,9 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { runLocalAgentTurn } from "../agentRuntimeLocal";
+import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+import { createStreamingTextWriter } from "./streamingOutput";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -15,10 +19,13 @@ type RunAgentTurnOptions = {
   continueDialogId?: string;
   scriptDir: string;
   env: EnvLike;
-  output: OutputLike;
-  scriptPathExists?: (path: string) => boolean;
-  fetchImpl?: typeof fetch;
-};
+  output: OutputLike;
+  runtimeMode?: AgentRuntimeRequestedMode;
+  localRuntimeAdapter?: AgentRuntimeHostAdapter;
+  localRuntimeAdapterFactory?: (env: EnvLike) => AgentRuntimeHostAdapter;
+  scriptPathExists?: (path: string) => boolean;
+  fetchImpl?: typeof fetch;
+};
 
 export type RunAgentTurnResult = {
   exitCode: number;
@@ -38,9 +45,23 @@ function resolveAuthToken(env: EnvLike) {
   return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
 }
 
-function shouldShowUsage(env: EnvLike) {
-  return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
-}
+function shouldShowUsage(env: EnvLike) {
+  return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
+}
+
+function resolveRequestedRuntimeMode(options: RunAgentTurnOptions) {
+  const envMode = options.env.NOLO_RUNTIME_MODE;
+  if (options.runtimeMode) return options.runtimeMode;
+  if (envMode === "local" || envMode === "server" || envMode === "auto") return envMode;
+  return "auto";
+}
+
+function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
+  return createCliLocalRuntimeAdapter({
+    env: options.env,
+    fetchImpl: options.fetchImpl,
+  });
+}
 
 function formatUsage(usage: any, dialogId: unknown) {
   const parts: string[] = [];
@@ -112,7 +133,7 @@ async function runScriptBridge(options: RunAgentTurnOptions, scriptPath: string)
   return { exitCode };
 }
 
-async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string) {
+async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string) {
   options.output.write(`\n${options.agentName} -> working...\n`);
 
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -132,12 +153,12 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
           host: "terminal",
           runtime: "bun",
           entrypoint: "nolo-cli",
-          capabilities: ["text-io", "slash-commands"],
+          capabilities: ["text-io", "streaming", "slash-commands"],
         },
         ...(options.continueDialogId
           ? { continueDialogId: options.continueDialogId }
           : {}),
-        stream: false,
+        stream: true,
       }),
     });
   } catch (error) {
@@ -145,6 +166,11 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
     return { exitCode: 1 };
   }
 
+  const contentType = res.headers.get("content-type") || "";
+  if (contentType.includes("text/event-stream") && res.body) {
+    return readStreamingAgentRun(options, res);
+  }
+
   let data: any = {};
   try {
     data = await res.json();
@@ -175,17 +201,154 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
       ? { dialogId: data.dialogId }
       : {}),
   };
-}
+}
+
+async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
+  const adapter =
+    options.localRuntimeAdapter ||
+    options.localRuntimeAdapterFactory?.(options.env) ||
+    buildDefaultLocalRuntimeAdapter(options);
+  if (!adapter) {
+    options.output.write("[nolo] Local runtime was requested but no local runtime adapter is available.\n");
+    return { exitCode: 1 };
+  }
+
+  options.output.write(`\n${options.agentName} -> working locally...\n`);
+  try {
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: options.agentKey,
+      input: options.message,
+      continueDialogId: options.continueDialogId,
+    });
+    const content = result.content.trim();
+    if (content) {
+      options.output.write(`\n${options.agentName} > ${content}\n`);
+    } else {
+      options.output.write(`\n${options.agentName} > (no text response)\n`);
+    }
+    return { exitCode: 0, dialogId: result.dialogId };
+  } catch (error) {
+    options.output.write(
+      `[nolo] Local agent run failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return { exitCode: 1 };
+  }
+}
+
+async function readStreamingAgentRun(
+  options: RunAgentTurnOptions,
+  res: Response,
+): Promise<RunAgentTurnResult> {
+  const reader = res.body?.getReader();
+  if (!reader) {
+    options.output.write("[nolo] Agent stream response did not include a readable body.\n");
+    return { exitCode: 1 };
+  }
+
+  const decoder = new TextDecoder();
+  const writer = createStreamingTextWriter({
+    write: (chunk) => options.output.write(chunk),
+  });
+  let buffer = "";
+  let content = "";
+  let dialogId: string | undefined;
+  let usage: any;
+  let hasPrintedLabel = false;
+
+  const printLabel = () => {
+    if (hasPrintedLabel) return;
+    options.output.write(`\n${options.agentName} > `);
+    hasPrintedLabel = true;
+  };
+
+  const handlePayload = (payload: any) => {
+    if (payload?.error || payload?.type === "error") {
+      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
+    }
+    if (payload?.type === "done") {
+      if (typeof payload.dialogId === "string") dialogId = payload.dialogId;
+      usage = payload.usage;
+      return;
+    }
+
+    const chunk =
+      payload?.type === "text"
+        ? payload.content
+        : typeof payload?.chunk === "string"
+          ? payload.chunk
+          : "";
+    if (!chunk) return;
+
+    printLabel();
+    content += chunk;
+    writer.push(chunk);
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
 
-export async function runAgentTurn(options: RunAgentTurnOptions) {
-  const authToken = resolveAuthToken(options.env);
-  const scriptPath = join(options.scriptDir, "chatWithAgent.ts");
-  const scriptPathExists = (options.scriptPathExists ?? existsSync)(scriptPath);
+      buffer += decoder.decode(value, { stream: true });
+      const events = buffer.split("\n\n");
+      buffer = events.pop() ?? "";
 
-  if (shouldUseScriptBridge({ hasAuthToken: Boolean(authToken), scriptPathExists })) {
-    return runScriptBridge(options, scriptPath);
+      for (const event of events) {
+        const dataLines = event
+          .split("\n")
+          .filter((line) => line.startsWith("data:"))
+          .map((line) => line.slice(5).trim())
+          .filter(Boolean);
+        for (const raw of dataLines) {
+          handlePayload(JSON.parse(raw));
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const raw = buffer
+        .split("\n")
+        .find((line) => line.startsWith("data:"))
+        ?.slice(5)
+        .trim();
+      if (raw) handlePayload(JSON.parse(raw));
+    }
+  } catch (error) {
+    options.output.write(`\n[nolo] Agent stream failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return { exitCode: 1 };
+  } finally {
+    writer.flushAll();
   }
 
+  if (!content) {
+    options.output.write(`\n${options.agentName} > (no text response)\n`);
+  } else {
+    options.output.write("\n");
+  }
+
+  const usageText = formatUsage(usage, dialogId);
+  if (usageText && shouldShowUsage(options.env)) options.output.write(`${usageText}\n`);
+  return {
+    exitCode: 0,
+    ...(dialogId ? { dialogId } : {}),
+  };
+}
+
+export async function runAgentTurn(options: RunAgentTurnOptions) {
+  const authToken = resolveAuthToken(options.env);
+  const scriptPath = join(options.scriptDir, "chatWithAgent.ts");
+  const scriptPathExists = (options.scriptPathExists ?? existsSync)(scriptPath);
+
+  if (resolveRequestedRuntimeMode(options) === "local") {
+    return runInjectedLocalAgentTurn(options);
+  }
+
+  if (shouldUseScriptBridge({ hasAuthToken: Boolean(authToken), scriptPathExists })) {
+    return runScriptBridge(options, scriptPath);
+  }
+
   if (!authToken) {
     options.output.write(
       "[nolo] This install needs an auth token before it can talk to agents.\n" +