nolo-cli 0.1.39 → 0.1.41

package/cli/machineWsRunDispatch.ts

@@ -20,9 +20,52 @@ type EnvLike = Record<string, string | undefined>;
 export type LocalCliExecutor = (
   provider: string,
   prompt: string,
-  options: { model?: string; timeout?: number; cwd?: string; yolo?: boolean; env?: EnvLike }
+  options: {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    yolo?: boolean;
+    env?: EnvLike;
+    imageInputs?: Array<{ source: string; materializedPath?: string }>;
+  }
 ) => Promise<{ text: string; raw?: string; elapsed?: number }>;
 
+/**
+ * 从 connector payload 的 userInput 中提取 multimodal 内容。
+ * 如果 userInput 是字符串，直接返回 { text, imageUrls: [] }。
+ * 如果 userInput 是 multimodal content array（`[{ type: "text" }, { type: "image_url" }]`），
+ * 提取 text 和 image_url parts。
+ */
+function extractMultimodalUserInput(userInput: unknown): {
+  text: string;
+  imageUrls: string[];
+} {
+  if (typeof userInput === "string") {
+    return { text: userInput, imageUrls: [] };
+  }
+  if (!Array.isArray(userInput)) {
+    return { text: String(userInput ?? ""), imageUrls: [] };
+  }
+
+  const textParts: string[] = [];
+  const imageUrls: string[] = [];
+
+  for (const part of userInput) {
+    if (!part || typeof part !== "object") continue;
+    if ((part as any).type === "text" && typeof (part as any).text === "string") {
+      textParts.push((part as any).text);
+    } else if (
+      (part as any).type === "image_url" &&
+      typeof (part as any).image_url?.url === "string" &&
+      (part as any).image_url.url.trim()
+    ) {
+      imageUrls.push((part as any).image_url.url.trim());
+    }
+  }
+
+  return { text: textParts.join("\n"), imageUrls };
+}
+
 type ConnectorRuntimePolicy = {
   runtimeTools?: string[];
   agentTools?: string[];
@@ -103,7 +146,6 @@ function summarizeRuntimePolicyForLogs(policy?: ConnectorRuntimePolicy) {
     workspaceMode: policy?.workspace?.mode ?? null,
     workspaceCwd: policy?.workspace?.cwd ?? null,
     shellEnabled: policy?.shell?.enabled ?? null,
-    shellMode: policy?.shell?.mode ?? null,
   };
 }
 
@@ -188,13 +230,13 @@ function runtimeWorkspacePermissionPolicy(
   runtimeEnv: EnvLike,
   cwd: string
 ): PermissionPolicy | null {
+  void runtimeEnv;
   if (!requestsLocalWorkspaceRuntime(runtimePolicy)) return null;
   return {
     mode: "full_access",
     allowFilesystemRead: true,
     allowFilesystemWrite: true,
     allowShell:
-      runtimeEnv.NOLO_LOCAL_SHELL_MODE === "worktree" &&
       Array.isArray(runtimePolicy?.runtimeTools) &&
       runtimePolicy.runtimeTools.includes("execShell"),
     writableRoots: [cwd],
@@ -332,8 +374,6 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     requestId: args.parsed.requestId,
     agentKey,
     cwd: args.cwd,
-    runtimeEnvShellModeBeforePolicy: args.runtimeEnv.NOLO_LOCAL_SHELL_MODE ?? null,
-    runtimeEnvShellModeAfterPolicy: env.NOLO_LOCAL_SHELL_MODE ?? null,
     ...summarizeRuntimePolicyForLogs(policy),
   });
   const adapter = createCliLocalRuntimeAdapter({
@@ -454,7 +494,9 @@ export async function handleConnectorRunMessage(
   try {
     const machinePermissionPolicy = resolveMachineRunPermissionPolicy(agentConfig);
     const runtimePolicy = runtimePolicyFromConnectorPayload(parsed);
-    const userInput = String(parsed.payload?.userInput ?? "");
+    const extractedInput = extractMultimodalUserInput(parsed.payload?.userInput);
+    const userInput = extractedInput.text;
+    const connectorImageUrls = extractedInput.imageUrls;
     const timeout = normalizeConnectorRunTimeoutMs(parsed.payload?.timeoutMs);
     let cwd = resolveConnectorRunCwd({ env: runtimeEnv, policy: machinePermissionPolicy });
     let runContent = "";
@@ -553,6 +595,9 @@ export async function handleConnectorRunMessage(
             effectiveRuntimeEnv.AUTH_TOKEN ||
             effectiveRuntimeEnv.AUTH,
         },
+        ...(connectorImageUrls.length > 0
+          ? { imageInputs: connectorImageUrls.map((url) => ({ source: url })) }
+          : {}),
       }).finally(() => clearInterval(heartbeat));
       logConnectorRun("agent.run.cli.result", {
         requestId: parsed.requestId,

package/cli/offlineMarxistsAgentCommand.ts

@@ -40,15 +40,17 @@ function readFlagValue(args: string[], flag: string) {
 }
 
 function parseUserIdFromToken(token: string) {
-  const payload = token.split(".")[0];
-  if (!payload) return "";
+  const payload = token.split(".")[1];
+  if (!payload) return undefined;
   try {
     const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
     const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
     const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
-    return typeof parsed?.userId === "string" ? parsed.userId : "";
+    return typeof parsed?.userId === "string" && parsed.userId.trim()
+      ? parsed.userId.trim()
+      : undefined;
   } catch {
-    return "";
+    return undefined;
   }
 }
 

package/client/agentConfigResolver.test.ts

@@ -15,7 +15,7 @@ describe("agent config resolver", () => {
       cliProvider: "codex",
       customProviderUrl: "https://provider.example/v1",
       toolNames: ["legacyTool", "readFile"],
-      tools: ["readFile", "applyEdit"],
+      tools: ["readFile", "editFile"],
       runtimeBinding: { machineId: "machine-1" },
       delegation: { target: "local" },
       temperature: 0.2,
@@ -33,7 +33,7 @@ describe("agent config resolver", () => {
       apiSource: "platform",
       cliProvider: "codex",
       customProviderUrl: "https://provider.example/v1",
-      toolNames: ["legacyTool", "readFile", "applyEdit"],
+      toolNames: ["legacyTool", "readFile", "editFile"],
       runtimeBinding: { machineId: "machine-1" },
       delegation: { target: "local" },
       temperature: 0.2,

package/client/agentRun.test.ts

@@ -35,11 +35,11 @@ describe("cli agent run client", () => {
   });
 
   test("identifies server platform tools that local runtime cannot provide", () => {
-    expect(findServerPlatformTools(["readWorkspaceFile", "queryTableRows", "updateTableRow"])).toEqual([
+    expect(findServerPlatformTools(["readFile", "queryTableRows", "updateTableRow"])).toEqual([
       "queryTableRows",
       "updateTableRow",
     ]);
-    expect(findServerPlatformTools(["readWorkspaceFile", "execShell"])).toEqual([]);
+    expect(findServerPlatformTools(["readFile", "execShell"])).toEqual([]);
   });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
@@ -239,7 +239,6 @@ describe("cli agent run client", () => {
       parentDialogId: "dialog-2",
       background: true,
       noStream: true,
-      maxToolRounds: 12,
       timeoutMs: 600000,
       scriptDir: "C:/missing/scripts",
       env: { AUTH_TOKEN: "token-123" },
@@ -259,7 +258,6 @@ describe("cli agent run client", () => {
       inheritedFromDialogKey: "dialog-user-1-dialog-2",
       parentDialogId: "dialog-2",
       background: true,
-      maxRounds: 12,
       timeoutMs: 600000,
       stream: false,
     });
@@ -345,72 +343,75 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend > local:polish notifications");
   });
 
-  test("increases local max tool rounds when a forced local run exhausts them", async () => {
+  test("continues forced local tool loops until the provider returns final text", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
+    let toolCalls = 0;
+
     const result = await runAgentTurn({
       agentName: "frontend",
       agentKey: "frontend-local",
       serverUrl: "https://nolo.chat",
-      message: "polish notifications",
+      message: "make screenshots",
       scriptDir: "C:/missing/scripts",
-      env: { AUTH_TOKEN: "token-123", NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "1" },
+      env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "local",
-      maxToolRounds: 0,
       localRuntimeAdapter: {
         host: "cli",
-        capabilities: ["local-provider", "local-persistence"],
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
         loadAgentConfig: async (agentRef) => ({
           key: agentRef,
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        saveTurn: async () => ({ dialogId: "dialog-local-retry" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
             completeCalls += 1;
-            return {
-              content: "",
-              model: "fake-local",
-              tool_calls: [{
-                id: `call-${completeCalls}`,
-                type: "function",
-                function: { name: "readWorkspaceFile", arguments: "{}" },
-              }],
-            };
+            if (completeCalls <= 3) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: `call-${completeCalls}`,
+                  type: "function",
+                  function: { name: "readFile", arguments: "{}" },
+                }],
+              };
+            }
+            return { content: "done after retry", model: "fake-local" };
           },
         }),
-        executeTool: async () => ({ content: "ok" }),
-      },
-      fetchImpl: async () => {
-        throw new Error("HTTP should not be called for forced local runs");
+        executeTool: async () => {
+          toolCalls += 1;
+          return { content: "ok" };
+        },
       },
     });
 
-    expect(result).toMatchObject({ exitCode: 1 });
-    expect(output.text()).toContain("Local agent used all 0 tool rounds; retrying with 1.");
-    expect(output.text()).toContain("Local agent exceeded max tool rounds: 1");
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-retry" });
+    expect(toolCalls).toBe(3);
+    expect(output.text()).toContain("frontend > done after retry");
   });
 
-  test("completes a forced local run after automatically increasing tool rounds", async () => {
+  test("prints compact local tool trace by default", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
-    let toolCalls = 0;
 
     const result = await runAgentTurn({
       agentName: "frontend",
       agentKey: "frontend-local",
       serverUrl: "https://nolo.chat",
-      message: "make screenshots",
+      message: "inspect repo",
       scriptDir: "C:/missing/scripts",
       env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "local",
-      maxToolRounds: 1,
       localRuntimeAdapter: {
         host: "cli",
         capabilities: ["local-provider", "local-persistence", "local-tools"],
@@ -419,42 +420,39 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local-retry" }),
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
             completeCalls += 1;
-            if (completeCalls <= 3) {
+            if (completeCalls === 1) {
               return {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: `call-${completeCalls}`,
+                  id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: "{}" },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
-            return { content: "done after retry", model: "fake-local" };
+            return { content: "done", model: "fake-local" };
           },
         }),
-        executeTool: async () => {
-          toolCalls += 1;
-          return { content: "ok" };
-        },
+        executeTool: async () => ({ content: "clean" }),
       },
     });
 
-    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-retry" });
-    expect(toolCalls).toBe(2);
-    expect(output.text()).toContain("Local agent used all 1 tool rounds; retrying with 2.");
-    expect(output.text()).toContain("frontend > done after retry");
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
+    expect(output.text()).toContain("[nolo:tool] #1 -> readFile README.md");
+    expect(output.text()).toContain("[nolo:tool] #1 <- readFile");
+    expect(output.text()).toContain("1 line");
   });
 
-  test("prints local tool trace when requested", async () => {
+  test("does not print local tool trace when disabled by env", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
 
@@ -464,10 +462,9 @@ describe("cli agent run client", () => {
       serverUrl: "https://nolo.chat",
       message: "inspect repo",
       scriptDir: "C:/missing/scripts",
-      env: { AUTH_TOKEN: "token-123" },
+      env: { AUTH_TOKEN: "token-123", NOLO_TRACE_TOOLS: "0" },
       output,
       runtimeMode: "local",
-      traceTools: true,
       localRuntimeAdapter: {
         host: "cli",
         capabilities: ["local-provider", "local-persistence", "local-tools"],
@@ -476,10 +473,10 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        saveTurn: async () => ({ dialogId: "dialog-local-no-trace" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
@@ -491,7 +488,7 @@ describe("cli agent run client", () => {
                 tool_calls: [{
                   id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -502,9 +499,79 @@ describe("cli agent run client", () => {
       },
     });
 
-    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
-    expect(output.text()).toContain("[nolo:tool] round 1 -> readWorkspaceFile (call-read)");
-    expect(output.text()).toContain("[nolo:tool] round 1 <- readWorkspaceFile (call-read)");
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local-no-trace" });
+    expect(output.text()).not.toContain("[nolo:tool]");
+  });
+
+  test("prints local tool events as jsonl when requested", async () => {
+    const output = new CaptureOutput();
+    let completeCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "inspect repo",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      eventsMode: "jsonl",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+          toolNames: ["execShell"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local-jsonl" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            if (completeCalls === 1) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: "call-shell",
+                  type: "function",
+                  function: { name: "execShell", arguments: JSON.stringify({ command: "git status --short" }) },
+                }],
+              };
+            }
+            return { content: "done", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "stdout:\nclean\n\nexitCode: 0", metadata: { exitCode: 0 } }),
+      },
+    });
+
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local-jsonl" });
+    const events = output.text()
+      .split(/\r?\n/)
+      .filter((line) => line.startsWith("{"))
+      .map((line) => JSON.parse(line))
+      .filter((event) => typeof event.type === "string" && event.type.startsWith("tool-"));
+    expect(events).toHaveLength(2);
+    expect(events[0]).toMatchObject({
+      schemaVersion: 1,
+      type: "tool-call",
+      round: 1,
+      tool: "execShell",
+      argsPreview: "git status --short",
+    });
+    expect(events[1]).toMatchObject({
+      schemaVersion: 1,
+      type: "tool-result",
+      round: 1,
+      tool: "execShell",
+      summary: expect.stringContaining("exit=0"),
+    });
   });
 
   test("passes local tool evidence to task-run writeback", async () => {
@@ -536,7 +603,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -551,7 +618,7 @@ describe("cli agent run client", () => {
                 tool_calls: [{
                   id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -565,7 +632,7 @@ describe("cli agent run client", () => {
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
     expect(writebacks).toHaveLength(1);
     expect(writebacks[0].toolEvidence).toEqual({
-      toolsUsed: ["readWorkspaceFile"],
+      toolsUsed: ["readFile"],
       summary: {
         callCount: 1,
         resultCount: 1,
@@ -820,6 +887,58 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("pm > server ok");
   });
 
+  test("auto mode keeps local runtime for CLI provider agents even when they declare platform tools", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let providerCalled = false;
+
+    const result = await runAgentTurn({
+      agentName: "frontend-implementer",
+      agentKey: "frontend-implementer",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      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 (agentRef) => ({
+          key: agentRef,
+          name: "AGY",
+          prompt: "Implement frontend tasks.",
+          provider: "agy",
+          cliProvider: "agy",
+          toolNames: ["streamParallelAgents", "taskRun"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-agy-auto-local" }),
+        resolveProvider: async () => ({
+          model: "agy",
+          complete: async () => {
+            providerCalled = true;
+            return { content: "agy local ok", model: "agy" };
+          },
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(providerCalled).toBe(true);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-agy-auto-local" });
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).not.toContain("skipping local runtime");
+    expect(output.text()).toContain("frontend-implementer -> working locally");
+    expect(output.text()).toContain("frontend-implementer > agy local 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[] = [];
@@ -833,7 +952,6 @@ describe("cli agent run client", () => {
       scriptDir: "C:/missing/scripts",
       env: {
         AUTH_TOKEN: "token-123",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       output,
       runtimeMode: "auto",