nolo-cli 0.1.37 → 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";
 
@@ -73,6 +73,47 @@ export type RunAgentTurnResult = {
   streamInterrupted?: boolean;
 };
 
+class Spinner {
+  private timer: any = null;
+  private frameIndex = 0;
+  private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  private isTTY: boolean;
+
+  constructor(
+    private output: OutputLike,
+    private text: string
+  ) {
+    this.isTTY = Boolean((output as any).isTTY ?? process.stdout.isTTY);
+  }
+
+  start() {
+    if (!this.isTTY) {
+      this.output.write(`\n${this.text}...\n`);
+      return;
+    }
+
+    this.frameIndex = 0;
+    this.output.write(`\x1b[36m${this.frames[0]}\x1b[39m ${this.text}...`);
+
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+      this.output.write(`\r\x1b[36m${this.frames[this.frameIndex]}\x1b[39m ${this.text}...`);
+    }, 80);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    if (this.isTTY) {
+      this.output.write("\r\x1b[K");
+    }
+  }
+}
+
+
 const SERVER_PLATFORM_TOOL_NAMES = new Set([
   "addTableRow",
   "addTableRows",
@@ -139,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";
@@ -173,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. ` +
@@ -188,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(
@@ -288,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 ||
@@ -502,7 +578,8 @@ function buildTransportErrorHint(serverUrl: string, error: unknown) {
 }
 
 async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string) {
-  options.output.write(`\n${options.agentName} -> working...\n`);
+  const spinner = new Spinner(options.output, `${options.agentName} -> working`);
+  spinner.start();
 
   const fetchImpl = options.fetchImpl ?? fetch;
   let res: Response;
@@ -556,14 +633,16 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
         ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
         stream: !options.noStream && !options.background,
       }),
-    });
-  } catch (error) {
-    options.output.write(buildTransportErrorHint(options.serverUrl, error));
-    return { exitCode: 1 };
-  }
-
+    });
+  } catch (error) {
+    spinner.stop();
+    options.output.write(buildTransportErrorHint(options.serverUrl, error));
+    return { exitCode: 1 };
+  }
+
   const contentType = res.headers.get("content-type") || "";
   if (contentType.includes("text/event-stream") && res.body) {
+    spinner.stop();
     const result = await readStreamingAgentRun(options, res);
     await recordTaskRunOutcome({
       options,
@@ -577,18 +656,32 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
     });
     return result;
   }
-
-  let data: any = {};
-  try {
-    data = await res.json();
-  } catch {
-    data = {};
-  }
-
+
+  spinner.stop();
+  let data: any = {};
+  try {
+    data = await res.json();
+  } catch {
+    data = {};
+  }
+
   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,
@@ -691,7 +784,8 @@ async function runLocalAgentTurnForCli(
     return { exitCode: 1 };
   }
 
-  options.output.write(`\n${options.agentName} -> working locally...\n`);
+  const spinner = new Spinner(options.output, `${options.agentName} -> working locally`);
+  spinner.start();
   const toolEvents: LocalAgentToolEvent[] = [];
   try {
     const traceLocalTools = shouldTraceLocalTools(options);
@@ -716,11 +810,15 @@ async function runLocalAgentTurnForCli(
         ? {
             onToolEvent: (event) => {
               if (collectToolEvidence) toolEvents.push(event);
-              if (traceLocalTools) options.output.write(formatToolTraceEvent(event));
+              if (traceLocalTools) {
+                spinner.stop();
+                options.output.write(formatToolTraceEvent(event));
+              }
             },
           }
         : {}),
     });
+    spinner.stop();
     const content = result.content.trim();
     if (content) {
       options.output.write(`\n${options.agentName} > ${content}\n`);
@@ -736,6 +834,7 @@ async function runLocalAgentTurnForCli(
     });
     return { exitCode: 0, dialogId: result.dialogId };
   } catch (error) {
+    spinner.stop();
     if (settings.reportFailure) {
       options.output.write(
         `[nolo] Local agent run failed: ${

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;
     }
   });