nolo-cli 0.1.38 → 0.1.40

package/client/localRuntimeAdapter.test.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
+import { MIMO_MONTH_AGENT_KEY } from "../agentAliases";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime adapter", () => {
@@ -13,23 +14,183 @@ describe("CLI local runtime adapter", () => {
     "writeFile",
     "editFile",
     "searchFiles",
+    "execShell",
   ];
   const LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES = [
-    "writeWorkspaceFile",
     "listFiles",
     "readFile",
+    "writeFile",
     "editFile",
     "searchFiles",
+    "execShell",
   ];
   const SHELL_LOCAL_CODING_TOOL_NAMES = [
     ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
-    "execShell",
+  ];
+  const DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES = [
+    "listDialogs",
+    "readDialog",
+    "listAgents",
+    "readAgent",
+    "listSpaces",
+    "readSpace",
+    "readDoc",
+    "readSkillDoc",
+    "queryTableRows",
+    "cliWhoami",
+    "cliDoctor",
+  ];
+  const DEFAULT_PRIVATE_LOCAL_TOOL_NAMES = [
+    ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
+    ...DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES,
   ];
 
   function toolNamesFromRequest(request: any) {
     return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
   }
 
+  test("runs cli-provider agents through the local CLI executor instead of OpenAI-compatible direct mode", async () => {
+    const cliExecutions: Array<{ provider: string; prompt: string; options: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        OPENAI_API_KEY: "sk-should-not-be-used",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== "agent-user-1-frontend") throw new Error(`not found: ${key}`);
+          return {
+            dbKey: "agent-user-1-frontend",
+            id: "frontend",
+            name: "Frontend",
+            prompt: "You are the frontend implementer.",
+            apiSource: "cli",
+            cliProvider: "agy",
+            model: "gemini-3.1-pro",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: "/repo/worktree",
+      now: () => 1710000000000,
+      createId: () => "01CLI",
+      fetchImpl: async () => {
+        throw new Error("OpenAI-compatible fetch should not be used for cli providers");
+      },
+      executeCli: async (provider, prompt, options) => {
+        cliExecutions.push({ provider, prompt, options });
+        return { text: "cli ok", raw: "cli ok", elapsed: 1 };
+      },
+    } as any);
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "add tooltip",
+    });
+
+    expect(result).toMatchObject({
+      content: "cli ok",
+      model: "gemini-3.1-pro",
+    });
+    expect(cliExecutions).toHaveLength(1);
+    expect(cliExecutions[0]).toMatchObject({
+      provider: "agy",
+      options: {
+        model: "gemini-3.1-pro",
+        cwd: "/repo/worktree",
+        yolo: true,
+      },
+    });
+    expect(cliExecutions[0].prompt).toContain("You are the frontend implementer.");
+    expect(cliExecutions[0].prompt).toContain("add tooltip");
+  });
+
+  test("fails cli-provider local runs clearly when the requested local CLI is unavailable", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        OPENAI_API_KEY: "sk-should-not-be-used",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== "agent-user-1-frontend") throw new Error(`not found: ${key}`);
+          return {
+            dbKey: "agent-user-1-frontend",
+            id: "frontend",
+            name: "Frontend",
+            prompt: "You are the frontend implementer.",
+            apiSource: "cli",
+            cliProvider: "agy",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        throw new Error("OpenAI-compatible fetch should not be used for cli providers");
+      },
+      executeCli: async () => {
+        throw new Error("agy: command not found");
+      },
+    } as any);
+
+    await expect(runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "add tooltip",
+    })).rejects.toThrow("Local CLI provider \"agy\" is unavailable");
+  });
+
+  test("passes cli-provider image inputs to the CLI executor instead of rejecting", async () => {
+    let cliCalledWith: any = null;
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== "agent-user-1-frontend") throw new Error(`not found: ${key}`);
+          return {
+            dbKey: "agent-user-1-frontend",
+            id: "frontend",
+            name: "Frontend",
+            prompt: "You are the frontend implementer.",
+            apiSource: "cli",
+            cliProvider: "agy",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      executeCli: async (provider, prompt, options) => {
+        cliCalledWith = { provider, prompt, options };
+        return { text: "image handled", raw: "", elapsed: 1 };
+      },
+    } as any);
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: [
+        { type: "text", text: "look at this screenshot" },
+        { type: "image_url", image_url: { url: "https://example.com/screen.png" } },
+      ],
+    });
+
+    expect(result.content).toBe("image handled");
+    expect(cliCalledWith).not.toBeNull();
+    expect(cliCalledWith.provider).toBe("agy");
+    expect(cliCalledWith.prompt).toContain("look at this screenshot");
+    expect(cliCalledWith.options.imageInputs).toEqual([
+      { source: "https://example.com/screen.png" },
+    ]);
+  });
+
   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>([
@@ -122,7 +283,7 @@ describe("CLI local runtime adapter", () => {
         stream: false,
       },
     });
-    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
     expect(batchOps.map((op) => op.key)).toEqual([
       "dialog-user-1-dialog-existing",
       "dialog-dialog-existing-msg-1710000000000-001",
@@ -354,7 +515,7 @@ describe("CLI local runtime adapter", () => {
         reasoning_effort: "medium",
       },
     });
-    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
   });
 
   test("aborts stalled custom provider requests when timeoutMs is provided", async () => {
@@ -473,7 +634,7 @@ describe("CLI local runtime adapter", () => {
         stream: false,
       },
     });
-    expect(toolNamesFromRequest(loopbackRequests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(loopbackRequests[0])).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
   });
 
   test("uses the Nolo chat proxy when local provider keys are absent", async () => {
@@ -485,7 +646,7 @@ describe("CLI local runtime adapter", () => {
         prompt: "Fix UI.",
         model: "accounts/fireworks/models/kimi-k2p6",
         provider: "fireworks",
-        tools: ["writeWorkspaceFile"],
+        tools: ["writeFile"],
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -546,7 +707,10 @@ describe("CLI local runtime adapter", () => {
         agentKey: "agent-user-1-frontend",
       },
     });
-    expect(toolNamesFromRequest(requests[0])).toEqual(LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(requests[0])).toEqual([
+      ...LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES,
+      ...DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES,
+    ]);
   });
 
   test("uses the Nolo chat proxy for platform agents even when direct provider env exists", async () => {
@@ -560,7 +724,7 @@ describe("CLI local runtime adapter", () => {
         provider: "fireworks",
         apiSource: "platform",
         useServerProxy: true,
-        tools: ["readWorkspaceFile"],
+        tools: ["readFile"],
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -745,7 +909,6 @@ describe("CLI local runtime adapter", () => {
       env: {
         NOLO_LOCAL_USER_ID: "user-1",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async (key) => {
@@ -851,7 +1014,7 @@ describe("CLI local runtime adapter", () => {
         prompt: "Read narrowly",
         model: "gpt-4.1-mini",
         provider: "openai-compatible",
-        tools: ["readWorkspaceFile"],
+        tools: ["readFile"],
       }],
     ]);
     let requestCount = 0;
@@ -860,7 +1023,7 @@ describe("CLI local runtime adapter", () => {
         NOLO_LOCAL_USER_ID: "user-1",
         NOLO_LOCAL_OPENAI_BASE_URL: "https://llm.example/v1",
         NOLO_LOCAL_OPENAI_API_KEY: "sk-test",
-        NOLO_LOCAL_TOOL_BUDGETS: "readWorkspaceFile=1",
+        NOLO_LOCAL_TOOL_BUDGETS: "readFile=1",
       },
       store: {
         read: async (key) => {
@@ -881,7 +1044,7 @@ describe("CLI local runtime adapter", () => {
       now: () => 1710000000000,
       createId: () => "01BUDGET",
       localToolExecutors: {
-        readWorkspaceFile: async () => ({ content: "file content" }),
+        readFile: async () => ({ content: "file content" }),
       },
       fetchImpl: async (_url, init) => {
         requestCount += 1;
@@ -898,7 +1061,7 @@ describe("CLI local runtime adapter", () => {
                 id: `call-read-${requestCount}`,
                 type: "function",
                 function: {
-                  name: "readWorkspaceFile",
+                  name: "readFile",
                   arguments: JSON.stringify({ path: "file.ts" }),
                 },
               }],
@@ -912,7 +1075,6 @@ describe("CLI local runtime adapter", () => {
       adapter,
       agentRef: "agent-user-1-reader",
       input: "inspect",
-      maxToolRounds: 3,
     });
 
     expect(result.content).toBe("budget handled");
@@ -1043,17 +1205,22 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("rejects tools unless the local tool policy allows and registers them", async () => {
+  test("allows registered execShell by default", async () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {},
+      localToolExecutors: {
+        execShell: async (call) => ({ content: `shell:${call.arguments}` }),
+      },
       fetchImpl: async () => Response.json({}),
     });
 
-    await expect(adapter.executeTool({
+    const result = await adapter.executeTool({
       id: "call-1",
       name: "execShell",
-      arguments: "{}",
-    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE");
+      arguments: "{\"cmd\":\"pwd\"}",
+    });
+
+    expect(result.content).toContain("\"cmd\":\"pwd\"");
   });
 
   test("executes explicitly allowed registered local tools declared by the agent", async () => {
@@ -1095,13 +1262,12 @@ describe("CLI local runtime adapter", () => {
     expect(result.content).toContain("README.md");
   });
 
-  test("advertises execShell to OpenAI-compatible providers when shell mode is enabled", async () => {
+  test("advertises execShell to OpenAI-compatible providers by default", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         OPENAI_API_KEY: "sk-local",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1127,6 +1293,61 @@ describe("CLI local runtime adapter", () => {
       input: "pwd",
     });
 
+    expect(toolNamesFromRequest(requests[0])).toEqual([
+      ...SHELL_LOCAL_CODING_TOOL_NAMES,
+      ...DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES,
+    ]);
+  });
+
+  test("keeps monthly Mimo local model tools to the compact coding surface", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: [
+            "read",
+            "searchDialogMessages",
+            "searchFiles",
+            "codeSearch",
+            "listFiles",
+            "readFile",
+            "writeFile",
+            "editFile",
+            "searchFiles",
+            "legacyLocalAlias",
+            "applyPatch",
+            "execShell",
+            "checkEnv",
+            "queryTableRows",
+            "taskRun",
+          ],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: MIMO_MONTH_AGENT_KEY,
+      input: "inspect cwd",
+    });
+
     expect(toolNamesFromRequest(requests[0])).toEqual(SHELL_LOCAL_CODING_TOOL_NAMES);
   });
 
@@ -1248,52 +1469,114 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ serverPlatformTool: true });
   });
 
-  test("activates an agent-declared task worktree before running workspace tools", async () => {
-    const taskWorktreeRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-worktree-"));
-    const chunks: string[] = [];
+  test("adds typed CLI workspace tools to the default nolo local agent request", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+          id: "01NOLOAPPBLD000000019KCKT0",
+          name: "nolo",
+          prompt: "Route through typed tools.",
+          model: "gpt-4.1-mini",
+          tools: ["fetchWebpage"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+      input: "帮我总结最近 10 个对话",
+    });
+
+    const toolNames = toolNamesFromRequest(requests[0]);
+    expect(toolNames).toContain("listDialogs");
+    expect(toolNames).toContain("readDialog");
+    expect(toolNames).toContain("listAgents");
+    expect(toolNames).toContain("readSpace");
+    expect(toolNames).toContain("queryTableRows");
+  });
+
+  test("executes typed CLI workspace tools through whitelisted nolo commands", async () => {
+    const spawnCalls: Array<{ cmd: string[]; env: NodeJS.ProcessEnv }> = [];
+    const originalSpawn = Bun.spawn;
+    Bun.spawn = ((options: { cmd: string[]; env: NodeJS.ProcessEnv }) => {
+      spawnCalls.push(options);
+      return {
+        stdout: new ReadableStream({
+          start(controller) {
+            controller.enqueue(new TextEncoder().encode("dialog output\n"));
+            controller.close();
+          },
+        }),
+        stderr: new ReadableStream({
+          start(controller) {
+            controller.close();
+          },
+        }),
+        exited: Promise.resolve(0),
+      };
+    }) as unknown as typeof Bun.spawn;
+
     try {
-      await Bun.write(join(taskWorktreeRoot, "README.md"), "worktree ok\n");
       const adapter = createCliLocalRuntimeAdapter({
         env: {
           NOLO_LOCAL_USER_ID: "user-1",
+          AUTH_TOKEN: "token-1",
         },
-        output: { write: (chunk) => chunks.push(chunk) },
         db: {
           get: async () => ({
-            dbKey: "agent-user-1-frontend",
-            id: "frontend",
-            prompt: "Use local workspace tools.",
-            runtimeBinding: { localWorkspaceMode: "task-worktree" },
+            dbKey: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+            id: "01NOLOAPPBLD000000019KCKT0",
           }),
           put: async () => {},
           batch: async () => {},
           iterator: () => (async function* () {})(),
         },
-        prepareTaskWorktree: async ({ agentKey }) => ({
-          path: taskWorktreeRoot,
-          branchName: `nolo-agent-${agentKey}`,
-        }),
         fetchImpl: async () => Response.json({}),
       });
 
-      await adapter.loadAgentConfig("frontend");
+      await adapter.loadAgentConfig("agent-pub-01NOLOAPPBLD000000019KCKT0");
       const result = await adapter.executeTool({
-        id: "call-read",
-        name: "readFile",
-        arguments: JSON.stringify({ path: "README.md" }),
+        id: "call-list-dialogs",
+        name: "listDialogs",
+        arguments: JSON.stringify({ limit: 3 }),
       });
 
-      expect(result.content).toBe("worktree ok\n");
-      expect(chunks.join("")).toContain(`workspace session: task-worktree ${taskWorktreeRoot}`);
-      expect(chunks.join("")).toContain("branch nolo-agent-frontend");
+      expect(result.content).toBe("dialog output\n");
+      expect(result.metadata).toMatchObject({
+        cliWorkspaceTool: true,
+        exitCode: 0,
+      });
+      expect(spawnCalls[0]?.cmd.at(-5)?.endsWith("packages/cli/index.ts")).toBe(true);
+      expect(spawnCalls[0]?.cmd.slice(-4)).toEqual([
+        "dialog",
+        "list",
+        "--limit",
+        "3",
+      ]);
     } finally {
-      rmSync(taskWorktreeRoot, { recursive: true, force: true });
+      Bun.spawn = originalSpawn;
     }
   });
 
-  test("runs execShell locally in explicit worktree shell mode", async () => {
+  test("runs execShell locally by default", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      env: {},
       db: {
         get: async () => ({
           dbKey: "agent-local-shell",
@@ -1324,12 +1607,11 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ exitCode: 0 });
   });
 
-  test("applies runtime policy shell output limit to local executors without adding a timeout", async () => {
+  test("applies runtime policy shell settings to local executors without adding a timeout", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1361,8 +1643,8 @@ describe("CLI local runtime adapter", () => {
                     name: "execShell",
                     arguments: JSON.stringify({
                       cmd: process.platform === "win32"
-                        ? "'abcdefghijklmnopqrstuvwxyz0123456789'.PadRight(500, 'x')"
-                        : "bun -e 'console.log(\"x\".repeat(500))'",
+                        ? "'abcdefghijklmnopqrstuvwxyz0123456789'"
+                        : "node -e 'console.log(\"x\".repeat(50))'",
                     }),
                   },
                 }],
@@ -1384,7 +1666,7 @@ describe("CLI local runtime adapter", () => {
 
     expect(result.content).toBe("limits applied");
     const toolResult = requests[1]?.body.messages.at(-1)?.content ?? "";
-    expect(toolResult).toContain("[truncated ");
+    expect(toolResult).toContain("exitCode: 0");
     expect(toolResult).not.toContain("command timed out");
   });
 
@@ -1393,7 +1675,6 @@ describe("CLI local runtime adapter", () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1450,7 +1731,6 @@ describe("CLI local runtime adapter", () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1518,7 +1798,6 @@ describe("CLI local runtime adapter", () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1624,7 +1903,7 @@ describe("CLI local runtime adapter", () => {
         ["agent-user-1-writer", {
           dbKey: "agent-user-1-writer",
           id: "writer",
-          toolNames: ["writeWorkspaceFile"],
+          toolNames: ["writeFile"],
         }],
       ]);
       const adapter = createCliLocalRuntimeAdapter({
@@ -1647,7 +1926,7 @@ describe("CLI local runtime adapter", () => {
       await adapter.loadAgentConfig("writer");
       const result = await adapter.executeTool({
         id: "call-1",
-        name: "writeWorkspaceFile",
+        name: "writeFile",
         arguments: JSON.stringify({
           path: "src/app.ts",
           content: "export const cliValue = 1;\n",