nolo-cli 0.1.32 → 0.1.34

package/client/localProviderResolver.test.ts

@@ -11,15 +11,18 @@ describe("CLI local provider resolver", () => {
         provider: "custom",
         apiSource: "custom",
         customProviderUrl: "https://provider.example/v1/chat/completions",
+        apiKey: "sk-agent-custom",
+        apiKeyHeader: "api-key",
       },
       env: {
-        OPENAI_API_KEY: "sk-env",
+        OPENAI_API_KEY: "sk-env-should-not-win",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
       },
     })).toEqual({
       model: "qwen-coder",
       endpoint: "https://provider.example/v1/chat/completions",
-      apiKey: "sk-env",
+      apiKey: "sk-agent-custom",
+      apiKeyHeader: "api-key",
       provider: "custom",
       requestOptions: {},
     });
@@ -53,6 +56,27 @@ describe("CLI local provider resolver", () => {
     });
   });
 
+  test("defaults Xiaomi custom endpoints to api-key auth header", () => {
+    expect(resolveCliOpenAiProviderConfig({
+      agentConfig: {
+        key: "agent-user-1-mimo",
+        provider: "custom",
+        apiSource: "custom",
+        model: "mimo-v2.5-pro",
+        customProviderUrl: "https://token-plan-cn.xiaomimimo.com/v1",
+        apiKey: "mimo-monthly-key",
+      },
+      env: {},
+    })).toEqual({
+      model: "mimo-v2.5-pro",
+      endpoint: "https://token-plan-cn.xiaomimimo.com/v1/chat/completions",
+      apiKey: "mimo-monthly-key",
+      apiKeyHeader: "api-key",
+      provider: "custom",
+      requestOptions: {},
+    });
+  });
+
   test("carries explicit agent inference options for request body construction", () => {
     expect(resolveCliOpenAiProviderConfig({
       agentConfig: {

package/client/localRuntimeAdapter.test.ts

@@ -3,7 +3,6 @@ import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { createHostRuntimeConfig } from "../agent-runtime";
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
@@ -23,9 +22,7 @@ describe("CLI local runtime adapter", () => {
     "searchFiles",
   ];
   const SHELL_LOCAL_CODING_TOOL_NAMES = [
-    "readFile",
-    "writeFile",
-    "editFile",
+    ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
     "execShell",
   ];
 
@@ -33,14 +30,6 @@ describe("CLI local runtime adapter", () => {
     return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
   }
 
-  function createCliHostRuntimeConfig(allowShell = false, workspaceBinding: "explicit-cwd" | "default-cwd" = "explicit-cwd") {
-    return createHostRuntimeConfig({
-      surface: "cli-local",
-      workspaceBinding,
-      allowShell,
-    });
-  }
-
   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>([
@@ -289,59 +278,8 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("runs apiSource=cli agents through the local CLI executor even when direct provider env is present", async () => {
-    const executions: Array<{ provider: string; prompt: string; options: any }> = [];
-    const adapter = createCliLocalRuntimeAdapter({
-      env: {
-        OPENAI_API_KEY: "sk-local",
-        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-      },
-      cwd: import.meta.dir,
-      db: {
-        get: async () => ({
-          dbKey: "agent-local-frontend",
-          id: "frontend",
-          apiSource: "cli",
-          cliProvider: "agy",
-          prompt: "Fix UI",
-          model: "",
-        }),
-        put: async () => {},
-        batch: async () => {},
-        iterator: () => (async function* () {})(),
-      },
-      fetchImpl: async () => {
-        throw new Error("OpenAI-compatible fetch should not run for local CLI agents");
-      },
-      executeCli: async (provider, prompt, options) => {
-        executions.push({ provider, prompt, options });
-        return { text: "cli local ok", raw: "cli local ok", elapsed: 10 };
-      },
-    });
-
-    const result = await runLocalAgentTurn({
-      adapter,
-      agentRef: "frontend",
-      input: "make it cleaner",
-    });
-
-    expect(result).toMatchObject({
-      content: "cli local ok",
-      model: "agy",
-    });
-    expect(executions).toEqual([{
-      provider: "agy",
-      prompt: "make it cleaner",
-      options: expect.objectContaining({
-        cwd: import.meta.dir,
-        yolo: true,
-        systemPrompt: "Fix UI",
-      }),
-    }]);
-  });
-
-  test("uses agent customProviderUrl for local OpenAI-compatible requests", async () => {
-    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+  test("uses agent-owned custom credentials for local OpenAI-compatible requests", async () => {
+    const requests: Array<{ url: string; auth: string | null; apiKeyHeader: string | null; body: any }> = [];
     const store = new Map<string, any>([
       ["agent-user-1-custom", {
         dbKey: "agent-user-1-custom",
@@ -351,6 +289,8 @@ describe("CLI local runtime adapter", () => {
         provider: "custom-openai-compatible",
         apiSource: "custom",
         customProviderUrl: "https://provider.example/v1/chat/completions",
+        apiKey: "sk-agent-custom",
+        apiKeyHeader: "api-key",
         temperature: 0.2,
         max_tokens: 4096,
         reasoning_effort: "medium",
@@ -381,6 +321,7 @@ describe("CLI local runtime adapter", () => {
         requests.push({
           url: String(url),
           auth: new Headers(init?.headers).get("Authorization"),
+          apiKeyHeader: new Headers(init?.headers).get("api-key"),
           body: JSON.parse(String(init?.body)),
         });
         return Response.json({
@@ -399,7 +340,8 @@ describe("CLI local runtime adapter", () => {
     expect(result.provider).toBe("custom-openai-compatible");
     expect(requests[0]).toMatchObject({
       url: "https://provider.example/v1/chat/completions",
-      auth: "Bearer sk-custom",
+      auth: null,
+      apiKeyHeader: "sk-agent-custom",
       body: {
         model: "custom-coder",
         messages: [
@@ -415,6 +357,57 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
   });
 
+  test("aborts stalled custom provider requests when timeoutMs is provided", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-mimo", {
+        dbKey: "agent-user-1-mimo",
+        id: "mimo",
+        prompt: "Use monthly mimo.",
+        model: "mimo-v2.5-pro",
+        provider: "custom",
+        apiSource: "custom",
+        customProviderUrl: "https://token-plan-cn.xiaomimimo.com/v1",
+        apiKey: "mimo-monthly-key",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      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) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        if (init?.signal?.aborted) {
+          throw init.signal.reason ?? new Error("aborted");
+        }
+        await new Promise((_, reject) => {
+          init?.signal?.addEventListener("abort", () => reject(init.signal?.reason ?? new Error("aborted")));
+        });
+        throw new Error("unreachable");
+      },
+    });
+
+    await expect(runLocalAgentTurn({
+      adapter,
+      agentRef: "mimo",
+      input: "hello",
+      timeoutMs: 10,
+    })).rejects.toThrow(/timed out|aborted/i);
+  });
+
   test("uses loopback transport for localhost custom providers when the default fetch path cannot connect", async () => {
     const store = new Map<string, any>([
       ["agent-user-1-localhost", {
@@ -746,10 +739,6 @@ describe("CLI local runtime adapter", () => {
         id: "shell",
         prompt: "Use shell.",
         model: "gpt-4.1-mini",
-        runtimeToolPolicy: {
-          version: 1,
-          runtimeTools: ["execShell"],
-        },
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -1054,28 +1043,17 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("rejects execShell when the host disables shell even if the agent requested it", async () => {
+  test("rejects tools unless the local tool policy allows and registers them", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: { NOLO_LOCAL_USER_ID: "user-1" },
-      hostRuntimeConfig: createCliHostRuntimeConfig(),
-      db: {
-        get: async () => ({
-          dbKey: "agent-user-1-shell",
-          toolNames: ["execShell"],
-        }),
-        put: async () => {},
-        batch: async () => {},
-        iterator: () => (async function* () {})(),
-      },
+      env: {},
       fetchImpl: async () => Response.json({}),
     });
 
-    await adapter.loadAgentConfig("shell");
     await expect(adapter.executeTool({
       id: "call-1",
       name: "execShell",
       arguments: "{}",
-    })).rejects.toThrow("execShell is not requested by this agent runtime.");
+    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE");
   });
 
   test("executes explicitly allowed registered local tools declared by the agent", async () => {
@@ -1117,22 +1095,19 @@ describe("CLI local runtime adapter", () => {
     expect(result.content).toContain("README.md");
   });
 
-  test("defaults the CLI local host runtime to shell-on when runtimeToolPolicy requests execShell", async () => {
+  test("advertises execShell to OpenAI-compatible providers when shell mode is enabled", 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 () => ({
           dbKey: "agent-local-shell",
           prompt: "Use shell.",
           model: "gpt-4.1-mini",
-          runtimeToolPolicy: {
-            version: 1,
-            runtimeTools: ["execShell"],
-          },
         }),
         put: async () => {},
         batch: async () => {},
@@ -1155,81 +1130,6 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toEqual(SHELL_LOCAL_CODING_TOOL_NAMES);
   });
 
-  test("keeps advertised fallback workspace tools executable when shell is explicitly disabled", async () => {
-    const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-shell-off-"));
-    try {
-      const adapter = createCliLocalRuntimeAdapter({
-        env: {},
-        hostRuntimeConfig: createCliHostRuntimeConfig(false),
-        db: {
-          get: async () => ({
-            dbKey: "agent-local-shell-off",
-            runtimeToolPolicy: {
-              version: 1,
-              runtimeTools: ["execShell"],
-            },
-          }),
-          put: async () => {},
-          batch: async () => {},
-          iterator: () => (async function* () {})(),
-        },
-        cwd: workspaceRoot,
-        fetchImpl: async () => Response.json({}),
-      });
-
-      await adapter.loadAgentConfig("shell-off");
-      const result = await adapter.executeTool({
-        id: "call-list-files",
-        name: "listFiles",
-        arguments: JSON.stringify({ path: "." }),
-      });
-
-      expect(result.metadata).toMatchObject({ path: ".", count: 0 });
-      expect(result.content).toBe("");
-    } finally {
-      rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("does not advertise execShell when only a legacy runtimeToolPolicy.shell block is present", 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",
-      },
-      hostRuntimeConfig: createCliHostRuntimeConfig(true),
-      db: {
-        get: async () => ({
-          dbKey: "agent-local-legacy-shell",
-          prompt: "Do not get shell from legacy policy.",
-          model: "gpt-4.1-mini",
-          runtimeToolPolicy: {
-            version: 1,
-            shell: { enabled: true, mode: "worktree" },
-          },
-        }),
-        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: "legacy-shell",
-      input: "pwd",
-    });
-
-    expect(toolNamesFromRequest(requests[0])).not.toContain("execShell");
-  });
-
   test("allows default semantic workspace tools without legacy agent tool declarations", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {
@@ -1391,17 +1291,13 @@ describe("CLI local runtime adapter", () => {
     }
   });
 
-  test("runs execShell locally when the host grants shell capability", async () => {
+  test("runs execShell locally in explicit worktree shell mode", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: {},
-      hostRuntimeConfig: createCliHostRuntimeConfig(true),
+      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
       db: {
         get: async () => ({
           dbKey: "agent-local-shell",
-          runtimeToolPolicy: {
-            version: 1,
-            runtimeTools: ["execShell"],
-          },
+          toolNames: ["execShell"],
         }),
         put: async () => {},
         batch: async () => {},
@@ -1428,6 +1324,235 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ exitCode: 0 });
   });
 
+  test("accepts execShell aliases from the local model", 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 () => ({
+          dbKey: "agent-local-shell-alias",
+          prompt: "Use shell when needed.",
+          model: "qwen-coder",
+          toolNames: ["execShell"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        execShell: async () => ({
+          content: import.meta.dir,
+          metadata: { exitCode: 0, timedOut: false },
+        }),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        if (requests.length === 1) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-1",
+                  type: "function",
+                  function: { name: "runCommand", arguments: "{\"cmd\":\"pwd\"}" },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "alias ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "print cwd",
+    });
+
+    expect(result.content).toBe("alias ok");
+    expect(requests[1]?.body.messages.at(-1)?.content).toContain(import.meta.dir);
+  });
+
+  test("blocks destructive local execShell calls unless the user explicitly asked to delete", async () => {
+    let executorCalls = 0;
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-shell-guard",
+          prompt: "Use shell when useful.",
+          model: "qwen-coder",
+          toolNames: ["execShell"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        execShell: async () => {
+          executorCalls += 1;
+          return {
+            content: "should not run",
+          };
+        },
+      },
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        const lastToolMessage = [...body.messages]
+          .reverse()
+          .find((message: any) => message.role === "tool");
+        if (lastToolMessage) {
+          expect(String(lastToolMessage.content)).toContain(
+            "destructive_action_requires_confirmation",
+          );
+          return Response.json({
+            choices: [{ message: { content: "guard ok" } }],
+          });
+        }
+        return Response.json({
+          choices: [{
+            message: {
+              content: "",
+              tool_calls: [{
+                id: "call-1",
+                type: "function",
+                function: {
+                  name: "execShell",
+                  arguments: "{\"cmd\":\"rm -rf ./tmp\"}",
+                },
+              }],
+            },
+          }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "inspect cwd but don't delete files",
+    });
+
+    expect(result.content).toBe("guard ok");
+    expect(executorCalls).toBe(0);
+  });
+
+  test("exposes runtime policy tools to the local model even when toolNames omits them", 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 () => ({
+          dbKey: "agent-local-policy-shell",
+          prompt: "Use shell when needed.",
+          model: "qwen-coder",
+          runtimeToolPolicy: {
+            version: 1,
+            runtimeTools: ["execShell"],
+          },
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        execShell: async () => ({
+          content: import.meta.dir,
+          metadata: { exitCode: 0, timedOut: false },
+        }),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        if (requests.length === 1) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-1",
+                  type: "function",
+                  function: { name: "execShell", arguments: "{\"cmd\":\"pwd\"}" },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "policy shell ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "print cwd",
+    });
+
+    expect(result.content).toBe("policy shell ok");
+    expect(toolNamesFromRequest(requests[0])).toContain("execShell");
+    expect(requests[1]?.body.messages.at(-1)?.content).toContain(import.meta.dir);
+  });
+
+  test("treats runtime policy visual tools as declared local tools", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-visual",
+          prompt: "Inspect the page.",
+          model: "qwen-coder",
+          runtimeToolPolicy: {
+            version: 1,
+            runtimeTools: ["captureVisualState"],
+          },
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        captureVisualState: async () => ({
+          content: "{\"status\":\"ok\"}",
+        }),
+      },
+      fetchImpl: async (_url, init) => {
+        expect(toolNamesFromRequest({ body: JSON.parse(String(init?.body)) })).toContain("captureVisualState");
+        return Response.json({
+          choices: [{ message: { content: "visual ok" } }],
+        });
+      },
+    });
+
+    await adapter.loadAgentConfig("visual");
+    await expect(adapter.executeTool({
+      id: "call-visual",
+      name: "captureVisualState",
+      arguments: JSON.stringify({ waitSelector: "body" }),
+    })).resolves.toMatchObject({
+      content: "{\"status\":\"ok\"}",
+    });
+  });
+
   test("runs allowed workspace file tools through default local executors", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {