nolo-cli 0.1.38 → 0.1.39

package/client/agentRun.test.ts

@@ -6,7 +6,8 @@ import {
   findServerPlatformTools,
   runAgentTurn,
 } from "./agentRun";
-import { NOLO_PROJECT_MANAGER_AGENT_KEY } from "../agentAliases";
+import { BUILTIN_NOLO_AGENT_KEY } from "./localRuntimeAdapter";
+import { MIMO_MONTH_AGENT_KEY, NOLO_PROJECT_MANAGER_AGENT_KEY } from "../agentAliases";
 
 class CaptureOutput extends Writable {
   chunks: string[] = [];
@@ -93,6 +94,34 @@ describe("cli agent run client", () => {
     expect(output.text()).not.toContain("tokens=");
   });
 
+  test("prints agent run error details from failed HTTP responses", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "win-codex",
+      agentKey: "agent-win-codex",
+      serverUrl: "https://nolo.chat",
+      message: "restart connector",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      fetchImpl: async () =>
+        Response.json({
+          error: "Connector execution failed",
+          reason: "connector_execution_failed",
+          code: "connector_disconnected_mid_run",
+          message: "Connector disconnected for machine: machine-win",
+        }, { status: 502 }),
+    });
+
+    expect(result).toEqual({ exitCode: 1 });
+    expect(output.text()).toContain("[nolo] Agent request failed: HTTP 502");
+    expect(output.text()).toContain("Connector execution failed");
+    expect(output.text()).toContain("Connector disconnected for machine: machine-win");
+    expect(output.text()).toContain("code=connector_disconnected_mid_run");
+    expect(output.text()).toContain("reason=connector_execution_failed");
+  });
+
   test("prepends task-run context for HTTP agent runs", async () => {
     const output = new CaptureOutput();
     const requests: Array<{ body: any }> = [];
@@ -791,6 +820,161 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("pm > server ok");
   });
 
+  test("auto mode does not skip monthly Mimo when a local shell cwd is already bound", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let providerCalled = false;
+
+    const result = await runAgentTurn({
+      agentName: MIMO_MONTH_AGENT_KEY,
+      agentKey: MIMO_MONTH_AGENT_KEY,
+      serverUrl: "https://us.nolo.chat",
+      message: "fix tests and commit",
+      scriptDir: "C:/missing/scripts",
+      env: {
+        AUTH_TOKEN: "token-123",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      output,
+      runtimeMode: "auto",
+      localRuntimeCwd: "/repo/.worktrees/nolo-agent-mimo",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "包月 Mimo",
+          prompt: "Implement backend tasks.",
+          provider: "custom",
+          model: "mimo-v2.5-pro",
+          toolNames: ["queryTableRows"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-mimo-local" }),
+        resolveProvider: async () => ({
+          model: "mimo-v2.5-pro",
+          complete: async () => {
+            providerCalled = true;
+            return { content: "local mimo ok", model: "mimo-v2.5-pro" };
+          },
+        }),
+        executeTool: async () => ({ content: "ok" }),
+      },
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(providerCalled).toBe(true);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-mimo-local" });
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).not.toContain("skipping local runtime");
+    expect(output.text()).toContain(`${MIMO_MONTH_AGENT_KEY} -> working locally`);
+  });
+
+  test("auto mode skips local runtime for machine-bound localhost custom providers", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: Array<{ url: string; body: any }> = [];
+
+    const result = await runAgentTurn({
+      agentName: "win-qwen",
+      agentKey: "agent-win-qwen",
+      serverUrl: "https://nolo.chat",
+      message: "run on the bound Windows machine",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123", OPENAI_API_KEY: "local-provider-present" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Win Qwen",
+          prompt: "Windows local model",
+          provider: "custom",
+          model: "qwen",
+          customProviderUrl: "http://127.0.0.1:8080/v1/chat/completions",
+          runtimeBinding: {
+            machineId: "machine-win",
+            ownerUserId: "user-1",
+            connectorSurface: "cli",
+          },
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => {
+          throw new Error("local runtime should be skipped");
+        },
+        resolveProvider: async () => {
+          throw new Error("local provider should be skipped");
+        },
+        executeTool: async () => {
+          throw new Error("local tools should be skipped");
+        },
+      },
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server connector ok", dialogId: "dialog-win" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-win" });
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe("agent-win-qwen");
+    expect(output.text()).toContain("auto runtime: skipping local runtime");
+    expect(output.text()).toContain("machine-bound localhost custom provider");
+    expect(output.text()).not.toContain("win-qwen -> working locally");
+  });
+
+  test("auto mode keeps builtin nolo on local runtime so CLI workspace tools are available", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let providerCalled = false;
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: BUILTIN_NOLO_AGENT_KEY,
+      serverUrl: "https://nolo.chat",
+      message: "帮我总结最近 10 个对话",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async () => ({
+          key: BUILTIN_NOLO_AGENT_KEY,
+          name: "nolo",
+          prompt: "Use workspace tools.",
+          model: "fake-local",
+          toolNames: ["queryTableRows", "addTableRow", "updateTableRow"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-builtin-nolo-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            providerCalled = true;
+            return { content: "local nolo with tools", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "[]" }),
+      },
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(providerCalled).toBe(true);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-builtin-nolo-local" });
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).not.toContain("skipping local runtime");
+    expect(output.text()).toContain("nolo -> working locally");
+  });
+
   test("auto mode skips local runtime for server platform tools declared by runtime policy", async () => {
     const output = new CaptureOutput();
     const httpCalls: Array<{ url: string; body: any }> = [];

package/client/agentRun.ts

@@ -9,7 +9,7 @@ import {
 } from "../agentAliases";
 import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+import { createCliLocalRuntimeAdapter, isBuiltinNoloAgentRef } from "./localRuntimeAdapter";
 import { createStreamingTextWriter } from "./streamingOutput";
 import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
 
@@ -180,10 +180,27 @@ function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
   const normalizedKey = normalizeAgentRef(options.agentKey);
   return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
 }
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
+
+function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
+  const machineId =
+    agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object"
+      ? String(agentConfig.runtimeBinding.machineId ?? "").trim()
+      : "";
+  const providerUrl = typeof agentConfig?.customProviderUrl === "string"
+    ? agentConfig.customProviderUrl.trim()
+    : "";
+  if (!machineId || !providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+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";
@@ -214,6 +231,10 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 }
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
+  if (isBuiltinNoloAgentRef(options.agentKey)) return false;
+  if (options.localRuntimeCwd && options.env.NOLO_LOCAL_SHELL_MODE === "worktree") {
+    return false;
+  }
   if (isKnownServerPlatformAgent(options)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
@@ -229,6 +250,13 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   } catch {
     return false;
   }
+  if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +
+        "Use --local explicitly to force the current machine.\n"
+    );
+    return true;
+  }
   const serverTools = resolveServerPlatformToolNames(agentConfig);
   if (serverTools.length === 0) return false;
   options.output.write(
@@ -329,6 +357,13 @@ function formatToolTraceEvent(event: LocalAgentToolEvent) {
 
 function shouldAttemptAutoLocal(options: RunAgentTurnOptions) {
   if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  if (
+    options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" &&
+    isBuiltinNoloAgentRef(options.agentKey) &&
+    resolveAuthToken(options.env)
+  ) {
+    return true;
+  }
   return Boolean(
     options.env.NOLO_LOCAL_OPENAI_API_KEY ||
       options.env.OPENAI_API_KEY ||
@@ -632,8 +667,21 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
 
   if (!res.ok) {
     options.output.write(`[nolo] Agent request failed: HTTP ${res.status}\n`);
-    if (data?.error || data?.message) {
-      options.output.write(`${data.error || data.message}\n`);
+    const errorText = typeof data?.error === "string" ? data.error.trim() : "";
+    const messageText = typeof data?.message === "string" ? data.message.trim() : "";
+    const reasonText = typeof data?.reason === "string" ? data.reason.trim() : "";
+    const codeText = typeof data?.code === "string" ? data.code.trim() : "";
+    if (errorText || messageText) {
+      options.output.write(`${errorText || messageText}\n`);
+      if (messageText && messageText !== errorText) {
+        options.output.write(`${messageText}\n`);
+      }
+      if (codeText && codeText !== errorText && codeText !== messageText) {
+        options.output.write(`code=${codeText}\n`);
+      }
+      if (reasonText && reasonText !== errorText && reasonText !== messageText) {
+        options.output.write(`reason=${reasonText}\n`);
+      }
     }
     await recordTaskRunOutcome({
       options,

package/client/localRuntimeAdapter.test.ts

@@ -1043,17 +1043,20 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("rejects tools unless the local tool policy allows and registers them", async () => {
+  test("requires explicit shell mode for registered execShell", async () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {},
+      localToolExecutors: {
+        execShell: async (call) => ({ content: `shell:${call.arguments}` }),
+      },
       fetchImpl: async () => Response.json({}),
     });
 
     await expect(adapter.executeTool({
       id: "call-1",
       name: "execShell",
-      arguments: "{}",
-    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE");
+      arguments: "{\"cmd\":\"pwd\"}",
+    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE=worktree");
   });
 
   test("executes explicitly allowed registered local tools declared by the agent", async () => {
@@ -1095,7 +1098,7 @@ 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 only in explicit shell mode", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
@@ -1248,46 +1251,108 @@ 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;
     }
   });