nolo-cli 0.1.12 → 0.1.14

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" +

package/client/compactDialog.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, test } from "bun:test";
+import { compactDialog, parseTokenUserId } from "./compactDialog";
+
+// A minimal valid JWT-style token with userId encoded in base64 payload.
+// JWT format: header.payload.signature
+// Payload: { "userId": "user01" }
+const USER_ID = "user01";
+const TOKEN_HEADER = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString("base64");
+const TOKEN_PAYLOAD = Buffer.from(JSON.stringify({ userId: USER_ID })).toString("base64");
+const FAKE_TOKEN = `${TOKEN_HEADER}.${TOKEN_PAYLOAD}.fakesig`;
+
+const OLD_DIALOG_ID = "01OLD0000000000000000000AB";
+const OLD_DIALOG_KEY = `dialog-${USER_ID}-${OLD_DIALOG_ID}`;
+
+const OLD_DIALOG_RECORD = {
+  id: OLD_DIALOG_ID,
+  dbKey: OLD_DIALOG_KEY,
+  type: "dialog",
+  title: "My dialog",
+  cybots: ["agent-pub-01NOLOAPPBLD000000019KCKT0"],
+  spaceId: "myspace",
+  createdAt: "2024-01-01T00:00:00.000Z",
+  updatedAt: "2024-01-01T00:00:00.000Z",
+  inputTokens: 100,
+  outputTokens: 200,
+  totalCost: 0.001,
+  // conversation summary/compression state that must NOT be carried to the fork
+  summary: "This is a long summary of the old conversation.",
+  summarizedBeforeId: "msg-old-summary-anchor",
+  proactiveSummary: "Short recap of prior topics.",
+  proactiveSummaryBeforeId: "msg-old-proactive-anchor",
+  compressionCount: 3,
+  summaryPending: true,
+};
+
+function makeFetchMock(options: {
+  dialogRecord?: Record<string, unknown>;
+  writeOk?: boolean;
+  patchOk?: boolean;
+}) {
+  const calls: { url: string; method: string; body?: unknown }[] = [];
+
+  const fetchMock: typeof fetch = async (input, init) => {
+    const url = String(input);
+    const method = init?.method ?? "GET";
+    const bodyStr = typeof init?.body === "string" ? init.body : undefined;
+    const body = bodyStr ? JSON.parse(bodyStr) : undefined;
+    calls.push({ url, method, body });
+
+    if (method === "GET" || !method) {
+      return new Response(JSON.stringify(options.dialogRecord ?? OLD_DIALOG_RECORD), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (method === "POST") {
+      return new Response("{}", { status: options.writeOk !== false ? 200 : 500 });
+    }
+    if (method === "PATCH") {
+      return new Response("{}", { status: options.patchOk !== false ? 200 : 500 });
+    }
+    return new Response("{}", { status: 404 });
+  };
+
+  return { fetchMock, calls };
+}
+
+describe("compactDialog", () => {
+  test("reads current dialog, writes a forked copy, and returns the new dialog id", async () => {
+    const { fetchMock, calls } = makeFetchMock({});
+
+    const result = await compactDialog({
+      serverUrl: "http://localhost:8080",
+      authToken: FAKE_TOKEN,
+      dialogId: OLD_DIALOG_ID,
+      fetchImpl: fetchMock,
+    });
+
+    // Should have made 3 HTTP calls: read, write, patch (space)
+    expect(calls).toHaveLength(3);
+
+    // 1. Read old dialog
+    expect(calls[0]?.url).toContain(`/api/v1/db/read/${OLD_DIALOG_KEY}`);
+    expect(calls[0]?.method).toBe("GET");
+
+    // 2. Write new dialog
+    expect(calls[1]?.url).toContain("/api/v1/db/write/");
+    expect(calls[1]?.method).toBe("POST");
+    const writeBody = calls[1]?.body as any;
+    expect(writeBody?.data?.inheritedFromDialogKey).toBe(OLD_DIALOG_KEY);
+    expect(writeBody?.data?.cybots).toEqual(OLD_DIALOG_RECORD.cybots);
+    expect(writeBody?.data?.spaceId).toBe("myspace");
+    // Token stats should be reset
+    expect(writeBody?.data?.inputTokens).toBe(0);
+    expect(writeBody?.data?.outputTokens).toBe(0);
+    expect(writeBody?.data?.totalCost).toBe(0);
+    // Key should differ from old
+    expect(writeBody?.customKey).not.toBe(OLD_DIALOG_KEY);
+    expect(writeBody?.customKey).toMatch(/^dialog-user01-/);
+
+    // 3. Patch space
+    expect(calls[2]?.url).toContain("/api/v1/db/patch/space-myspace");
+    expect(calls[2]?.method).toBe("PATCH");
+
+    // Result
+    expect(result.dialogId).toBeDefined();
+    expect(result.dialogId).not.toBe(OLD_DIALOG_ID);
+    expect(result.dialogKey).toMatch(/^dialog-user01-/);
+    expect(result.spaceId).toBe("myspace");
+  });
+
+  test("does not patch space when the dialog has no spaceId", async () => {
+    const dialogWithoutSpace = { ...OLD_DIALOG_RECORD, spaceId: undefined };
+    const { fetchMock, calls } = makeFetchMock({ dialogRecord: dialogWithoutSpace });
+
+    await compactDialog({
+      serverUrl: "http://localhost:8080",
+      authToken: FAKE_TOKEN,
+      dialogId: OLD_DIALOG_ID,
+      fetchImpl: fetchMock,
+    });
+
+    // Only read + write, no patch
+    expect(calls).toHaveLength(2);
+    expect(calls.every((c) => c.method !== "PATCH")).toBe(true);
+  });
+
+  test("throws when the auth token is missing or invalid", async () => {
+    const { fetchMock } = makeFetchMock({});
+
+    await expect(
+      compactDialog({
+        serverUrl: "http://localhost:8080",
+        authToken: "not-a-valid-token",
+        dialogId: OLD_DIALOG_ID,
+        fetchImpl: fetchMock,
+      })
+    ).rejects.toThrow(/invalid or missing auth token/);
+  });
+
+  test("throws when the server read fails", async () => {
+    const fetchFailing: typeof fetch = async () =>
+      new Response("{}", { status: 404 });
+
+    await expect(
+      compactDialog({
+        serverUrl: "http://localhost:8080",
+        authToken: FAKE_TOKEN,
+        dialogId: OLD_DIALOG_ID,
+        fetchImpl: fetchFailing,
+      })
+    ).rejects.toThrow(/Failed to read dialog/);
+  });
+
+  test("space patch failure does not throw (best-effort)", async () => {
+    const { fetchMock } = makeFetchMock({ patchOk: false });
+
+    // Should resolve without throwing even though PATCH fails
+    const result = await compactDialog({
+      serverUrl: "http://localhost:8080",
+      authToken: FAKE_TOKEN,
+      dialogId: OLD_DIALOG_ID,
+      fetchImpl: fetchMock,
+    });
+
+    expect(result.dialogId).toBeDefined();
+  });
+
+  test("forked dialog does NOT inherit conversation summary/compression state", async () => {
+    const { fetchMock, calls } = makeFetchMock({});
+
+    await compactDialog({
+      serverUrl: "http://localhost:8080",
+      authToken: FAKE_TOKEN,
+      dialogId: OLD_DIALOG_ID,
+      fetchImpl: fetchMock,
+    });
+
+    const writeBody = calls[1]?.body as any;
+    const forked = writeBody?.data ?? {};
+
+    // Conversation-state fields must be absent (undefined / not present)
+    expect(forked.summary).toBeUndefined();
+    expect(forked.summarizedBeforeId).toBeUndefined();
+    expect(forked.proactiveSummary).toBeUndefined();
+    expect(forked.proactiveSummaryBeforeId).toBeUndefined();
+    expect(forked.compressionCount).toBeUndefined();
+    expect(forked.summaryPending).toBeUndefined();
+
+    // Config/identity fields must still be carried forward
+    expect(forked.cybots).toEqual(OLD_DIALOG_RECORD.cybots);
+    expect(forked.type).toBe("dialog");
+    expect(forked.spaceId).toBe("myspace");
+    expect(forked.inheritedFromDialogKey).toBe(OLD_DIALOG_KEY);
+    expect(forked.inheritedFromDialogTitle).toBe(OLD_DIALOG_RECORD.title);
+
+    // Stats must be reset
+    expect(forked.inputTokens).toBe(0);
+    expect(forked.outputTokens).toBe(0);
+    expect(forked.totalCost).toBe(0);
+  });
+});
+
+describe("parseTokenUserId", () => {
+  test("extracts userId from a valid JWT token (header.payload.signature)", () => {
+    const userId = "user-12345";
+    const header = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString("base64");
+    const payload = Buffer.from(JSON.stringify({ userId })).toString("base64");
+    const token = `${header}.${payload}.signature`;
+    
+    expect(parseTokenUserId(token)).toBe(userId);
+  });
+
+  test("returns null when token has fewer than 2 segments", () => {
+    expect(parseTokenUserId("onlyonepart")).toBeNull();
+  });
+
+  test("returns null when payload is not valid JSON", () => {
+    const token = "header.not-valid-base64-json.signature";
+    expect(parseTokenUserId(token)).toBeNull();
+  });
+
+  test("returns null when payload does not contain userId", () => {
+    const header = Buffer.from(JSON.stringify({ alg: "HS256" })).toString("base64");
+    const payload = Buffer.from(JSON.stringify({ sub: "someone" })).toString("base64");
+    const token = `${header}.${payload}.signature`;
+    
+    expect(parseTokenUserId(token)).toBeNull();
+  });
+
+  test("returns null when userId is not a string", () => {
+    const header = Buffer.from(JSON.stringify({ alg: "HS256" })).toString("base64");
+    const payload = Buffer.from(JSON.stringify({ userId: 12345 })).toString("base64");
+    const token = `${header}.${payload}.signature`;
+    
+    expect(parseTokenUserId(token)).toBeNull();
+  });
+});

package/client/compactDialog.ts

@@ -8,10 +8,13 @@ const DB_PATH = "/api/v1/db";
 /**
  * Extract userId from a JWT-style auth token without verifying the signature.
  * Mirrors the logic of `parseToken` in `auth/token.ts` without the crypto imports.
+ * @internal - exported for testing only
  */
-function parseTokenUserId(token: string): string | null {
+export function parseTokenUserId(token: string): string | null {
   try {
-    const [payloadBase64] = token.split(".");
+    const parts = token.split(".");
+    if (parts.length < 2) return null;
+    const payloadBase64 = parts[1];
     const payload = JSON.parse(
       Buffer.from(payloadBase64, "base64").toString("utf8")
     );

package/client/localRuntimeAdapter.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, test } from "bun:test";
+
+import { runLocalAgentTurn } from "../../agent-runtime/localLoop";
+import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+
+describe("CLI local runtime adapter", () => {
+  test("loads agent/history from LevelDB and saves dialog/message records back to LevelDB", async () => {
+    const requests: Array<{ url: string; body: any; auth: string | null }> = [];
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        name: "Frontend",
+        prompt: "Fix UI",
+        model: "gpt-4.1-mini",
+        provider: "openai-compatible",
+      }],
+      ["dialog-user-1-dialog-existing", {
+        dbKey: "dialog-user-1-dialog-existing",
+        id: "dialog-existing",
+        type: "dialog",
+        userId: "user-1",
+      }],
+      ["dialog-dialog-existing-msg-001", {
+        dbKey: "dialog-dialog-existing-msg-001",
+        id: "msg-001",
+        dialogId: "dialog-existing",
+        role: "assistant",
+        content: "previous answer",
+      }],
+    ]);
+    const batchOps: any[] = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          batchOps.push(...ops);
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: ({ gte, lte }) => (async function* () {
+          for (const entry of [...store.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            if (entry[0] >= gte && entry[0] <= lte) yield entry;
+          }
+        })(),
+      },
+      now: () => 1710000000000,
+      createId: () => "01LOCAL",
+      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({
+          choices: [{ message: { content: "local adapter ok" } }],
+          usage: { prompt_tokens: 4, completion_tokens: 3 },
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "make it cleaner",
+      continueDialogId: "dialog-existing",
+    });
+
+    expect(result).toMatchObject({
+      content: "local adapter ok",
+      model: "gpt-4.1-mini",
+      dialogId: "01LOCAL",
+    });
+    expect(requests).toEqual([{
+      url: "http://127.0.0.1:11434/v1/chat/completions",
+      auth: "Bearer sk-local",
+      body: {
+        model: "gpt-4.1-mini",
+        messages: [
+          { role: "system", content: "Fix UI" },
+          { role: "assistant", content: "previous answer" },
+          { role: "user", content: "make it cleaner" },
+        ],
+        stream: false,
+      },
+    }]);
+    expect(batchOps.map((op) => op.key)).toEqual([
+      "dialog-user-1-01LOCAL",
+      "dialog-01LOCAL-msg-user",
+      "dialog-01LOCAL-msg-assistant",
+    ]);
+    expect(store.get("dialog-user-1-01LOCAL")).toMatchObject({
+      id: "01LOCAL",
+      dbKey: "dialog-user-1-01LOCAL",
+      type: "dialog",
+      primaryAgentKey: "agent-user-1-frontend",
+      status: "done",
+    });
+    expect(store.get("dialog-01LOCAL-msg-user")).toMatchObject({
+      dialogId: "01LOCAL",
+      role: "user",
+      content: "make it cleaner",
+    });
+    expect(store.get("dialog-01LOCAL-msg-assistant")).toMatchObject({
+      dialogId: "01LOCAL",
+      role: "assistant",
+      content: "local adapter ok",
+    });
+  });
+
+  test("rejects tools until local tool policy is implemented", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {},
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await expect(adapter.executeTool({
+      id: "call-1",
+      name: "execShell",
+      arguments: "{}",
+    })).rejects.toThrow("Local runtime tools are not enabled");
+  });
+});