nolo-cli 0.1.13 → 0.1.15

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/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");
+  });
+});

package/client/localRuntimeAdapter.ts

@@ -0,0 +1,244 @@
+import type {
+  AgentRuntimeAgentConfig,
+  AgentRuntimeHostAdapter,
+  AgentRuntimeSaveTurnInput,
+} from "../agentRuntimeLocal";
+import type { AgentRuntimeChatMessage } from "../../agent-runtime";
+import { getDefaultCliLocalRuntimeDb } from "../localRuntimeDb";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type CliLocalRuntimeDb = {
+  get(key: string): Promise<any>;
+  put(key: string, value: any): Promise<unknown>;
+  batch(ops: Array<{ type: "put"; key: string; value: any }>): Promise<unknown>;
+  iterator(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, any]>;
+};
+
+export type CliLocalRuntimeAdapterDeps = {
+  env: EnvLike;
+  db?: CliLocalRuntimeDb;
+  now?: () => number;
+  createId?: () => string;
+  fetchImpl?: typeof fetch;
+};
+
+async function defaultLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
+  return getDefaultCliLocalRuntimeDb();
+}
+
+function createFallbackId() {
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`.toUpperCase();
+}
+
+function resolveOpenAiCompatibleBaseUrl(env: EnvLike) {
+  return (env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || "https://api.openai.com/v1")
+    .replace(/\/+$/, "");
+}
+
+function resolveApiKey(env: EnvLike) {
+  return env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_API_KEY || "";
+}
+
+function resolveLocalUserId(env: EnvLike) {
+  return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
+}
+
+async function resolveDb(deps: CliLocalRuntimeAdapterDeps) {
+  return deps.db ?? defaultLocalRuntimeDb();
+}
+
+async function readAgentFromDb(args: {
+  db: CliLocalRuntimeDb;
+  agentRef: string;
+  userId: string;
+}): Promise<AgentRuntimeAgentConfig | null> {
+  const candidates = [
+    args.agentRef,
+    `agent-${args.userId}-${args.agentRef}`,
+    `cybot-${args.userId}-${args.agentRef}`,
+  ];
+  for (const key of candidates) {
+    try {
+      const record = await args.db.get(key);
+      if (!record || typeof record !== "object") continue;
+      return {
+        key,
+        ...(typeof record.name === "string" ? { name: record.name } : {}),
+        ...(typeof record.prompt === "string" ? { prompt: record.prompt } : {}),
+        ...(typeof record.model === "string" ? { model: record.model } : {}),
+        ...(typeof record.provider === "string" ? { provider: record.provider } : {}),
+        ...(Array.isArray(record.toolNames) ? { toolNames: record.toolNames } : {}),
+      };
+    } catch {
+      // Try the next local LevelDB key convention.
+    }
+  }
+  return null;
+}
+
+function toOpenAiMessages(messages: AgentRuntimeChatMessage[]) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: typeof message.content === "string"
+      ? message.content
+      : Array.isArray(message.content)
+        ? message.content
+            .map((part) => part.type === "text" ? part.text : `[image:${part.image_url.url}]`)
+            .join("\n")
+        : "",
+  }));
+}
+
+async function readDialogMessages(args: {
+  db: CliLocalRuntimeDb;
+  dialogId: string;
+}) {
+  const messages: AgentRuntimeChatMessage[] = [];
+  const prefix = `dialog-${args.dialogId}-msg-`;
+  const iterator = args.db.iterator({ gte: prefix, lte: `${prefix}\uffff` });
+  for await (const [, value] of iterator) {
+    if (!value || typeof value !== "object") continue;
+    if (value.role === "system") continue;
+    if (value.role === "user" || value.role === "assistant" || value.role === "tool") {
+      messages.push({
+        role: value.role,
+        content: value.content ?? null,
+        ...(typeof value.toolCallId === "string" ? { tool_call_id: value.toolCallId } : {}),
+        ...(Array.isArray(value.tool_calls) ? { tool_calls: value.tool_calls } : {}),
+      });
+    }
+  }
+  return messages;
+}
+
+async function writeDialog(args: {
+  db: CliLocalRuntimeDb;
+  input: AgentRuntimeSaveTurnInput;
+  userId: string;
+  now: () => number;
+  createId: () => string;
+}) {
+  const dialogId = args.createId();
+  const now = args.now();
+  const nowIso = new Date(now).toISOString();
+  const dialogKey = `dialog-${args.userId}-${dialogId}`;
+  const lastUser = [...args.input.messages].reverse().find((message) => message.role === "user");
+  const ops: Array<{ type: "put"; key: string; value: any }> = [
+    {
+      type: "put",
+      key: dialogKey,
+      value: {
+        id: dialogId,
+        dbKey: dialogKey,
+        type: "dialog",
+        userId: args.userId,
+        cybots: [args.input.agentKey],
+        primaryAgentKey: args.input.agentKey,
+        title: typeof lastUser?.content === "string" && lastUser.content.trim()
+          ? lastUser.content.trim().slice(0, 80)
+          : "Local agent run",
+        status: "done",
+        triggerType: "cli-local",
+        executionMode: "foreground",
+        createdAt: nowIso,
+        updatedAt: nowIso,
+        finishedAt: now,
+        usage: args.input.result.usage,
+      },
+    },
+    {
+      type: "put",
+      key: `dialog-${dialogId}-msg-user`,
+      value: {
+        id: "msg-user",
+        dbKey: `dialog-${dialogId}-msg-user`,
+        dialogId,
+        role: "user",
+        content: lastUser?.content ?? "",
+        userId: args.userId,
+        createdAt: nowIso,
+      },
+    },
+    {
+      type: "put",
+      key: `dialog-${dialogId}-msg-assistant`,
+      value: {
+        id: "msg-assistant",
+        dbKey: `dialog-${dialogId}-msg-assistant`,
+        dialogId,
+        role: "assistant",
+        content: args.input.result.content,
+        agentKey: args.input.agentKey,
+        cybotKey: args.input.agentKey,
+        createdAt: nowIso,
+      },
+    },
+  ];
+  await args.db.batch(ops);
+  return { dialogId };
+}
+
+export function createCliLocalRuntimeAdapter(
+  deps: CliLocalRuntimeAdapterDeps
+): AgentRuntimeHostAdapter {
+  const now = deps.now ?? Date.now;
+  const createId = deps.createId ?? createFallbackId;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const userId = resolveLocalUserId(deps.env);
+
+  return {
+    host: "cli",
+    capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence"],
+    loadAgentConfig: async (agentRef) => readAgentFromDb({
+      agentRef,
+      db: await resolveDb(deps),
+      userId,
+    }),
+    loadDialogHistory: async (dialogId) => readDialogMessages({
+      dialogId,
+      db: await resolveDb(deps),
+    }),
+    saveTurn: async (input) => writeDialog({
+      db: await resolveDb(deps),
+      input,
+      userId,
+      now,
+      createId,
+    }),
+    resolveProvider: async (agentConfig) => ({
+      model: agentConfig.model || "gpt-4.1-mini",
+      complete: async (messages) => {
+        const res = await fetchImpl(`${resolveOpenAiCompatibleBaseUrl(deps.env)}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...(resolveApiKey(deps.env)
+              ? { Authorization: `Bearer ${resolveApiKey(deps.env)}` }
+              : {}),
+          },
+          body: JSON.stringify({
+            model: agentConfig.model || "gpt-4.1-mini",
+            messages: toOpenAiMessages(messages),
+            stream: false,
+          }),
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+        }
+        const content = String(data?.choices?.[0]?.message?.content ?? "");
+        return {
+          content,
+          model: agentConfig.model || "gpt-4.1-mini",
+          provider: agentConfig.provider || "openai-compatible",
+          usage: data?.usage,
+          trace: messages,
+        };
+      },
+    }),
+    executeTool: async () => {
+      throw new Error("Local runtime tools are not enabled for text-only CLI runs.");
+    },
+  };
+}

package/client/profileConfig.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  buildEnvFromProfile,
+  loadProfileConfig,
+  saveDefaultProfile,
+} from "./profileConfig";
+
+describe("cli profile config", () => {
+  test("saves and loads the default profile", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nolo-profile-"));
+    try {
+      const path = join(dir, "config.json");
+
+      saveDefaultProfile(path, {
+        serverUrl: "https://nolo.chat",
+        authToken: "token-123",
+        agentKey: "agent-pub-abc",
+        agentName: "app-builder",
+      });
+
+      const config = loadProfileConfig(path);
+      expect(config.currentProfile).toBe("default");
+      expect(config.profiles.default.serverUrl).toBe("https://nolo.chat");
+      expect(config.profiles.default.authToken).toBe("token-123");
+      expect(buildEnvFromProfile(config)).toEqual({
+        NOLO_PROFILE: "default",
+        NOLO_SERVER: "https://nolo.chat",
+        AUTH_TOKEN: "token-123",
+        NOLO_AGENT: "agent-pub-abc",
+        NOLO_AGENT_NAME: "app-builder",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/client/streamingOutput.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+
+import { createStreamingTextWriter, splitStreamingText } from "./streamingOutput";
+
+describe("streamingOutput", () => {
+  test("splits text into user-visible characters instead of UTF-16 code units", () => {
+    expect(splitStreamingText("A你👍🏽B")).toEqual(["A", "你", "👍🏽", "B"]);
+  });
+
+  test("flushes text in small character batches", () => {
+    const chunks: string[] = [];
+    const writer = createStreamingTextWriter({
+      write: (chunk) => chunks.push(chunk),
+      batchSize: 2,
+    });
+
+    writer.push("abcd");
+    writer.flushAll();
+
+    expect(chunks).toEqual(["ab", "cd"]);
+  });
+});