nolo-cli 0.1.22 → 0.1.26

package/client/agentRun.test.ts

@@ -45,7 +45,7 @@ describe("cli agent run client", () => {
       "queryTableRows",
       "updateTableRow",
     ]);
-    expect(findServerPlatformTools(["readWorkspaceFile", "gitStatus"])).toEqual([]);
+    expect(findServerPlatformTools(["readWorkspaceFile", "execShell"])).toEqual([]);
   });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
@@ -84,15 +84,15 @@ describe("cli agent run client", () => {
           agentKey: "agent-pub-test",
           userInput: "hello",
           continueDialogId: "dialog-existing",
-          runtimeContext: {
-            surface: "cli",
-            host: "terminal",
-            runtime: "bun",
-            entrypoint: "nolo-cli",
-            capabilities: ["text-io", "streaming", "slash-commands"],
-          },
-          stream: true,
-        },
+          runtimeContext: {
+            surface: "cli",
+            host: "terminal",
+            runtime: "bun",
+            entrypoint: "nolo-cli",
+            capabilities: ["text-io", "streaming", "slash-commands"],
+          },
+          stream: true,
+        },
       },
     ]);
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
@@ -132,6 +132,12 @@ describe("cli agent run client", () => {
     expect(requests[0]?.body.userInput).toContain("rowDbKey: row-b2e06f801f-01TASK");
     expect(requests[0]?.body.userInput).toContain("workItemId: frontend-filter");
     expect(requests[0]?.body.userInput).toContain("User task:\nFix the filter UI");
+    expect(requests[0]?.body.runtimeContext.taskRun).toEqual({
+      rowDbKey: "row-b2e06f801f-01TASK",
+      taskRunId: "taskrun-1",
+      workItemId: "frontend-filter",
+      artifactIds: ["artifact-1"],
+    });
   });
 
   test("records task-run completion after an HTTP agent run returns a dialog", async () => {
@@ -243,6 +249,42 @@ describe("cli agent run client", () => {
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
   });
 
+  test("records background task-run handoff as running instead of completed", async () => {
+    const output = new CaptureOutput();
+    const writebacks: any[] = [];
+
+    const result = await runAgentTurn({
+      agentName: "frontend-implementer",
+      agentKey: "agent-frontend",
+      serverUrl: "https://nolo.chat",
+      message: "Fix settings style FOUC",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      runtimeMode: "server",
+      background: true,
+      noStream: true,
+      taskRunContext: {
+        rowDbKey: "row-b2e06f801f-01TASK",
+        workItemId: "self",
+      },
+      taskRunRecorder: async (args) => {
+        writebacks.push(args);
+      },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        return Response.json({ dialogId: "dialog-bg", status: "pending" }, { status: 202 });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-bg" });
+    expect(writebacks).toHaveLength(1);
+    expect(writebacks[0]).toMatchObject({
+      status: "running",
+      dialogId: "dialog-bg",
+    });
+  });
+
   test("runs forced local turns through the injected runtime adapter without HTTP", async () => {
     const output = new CaptureOutput();
     const result = await runAgentTurn({
@@ -421,7 +463,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["gitStatus"],
+          toolNames: ["readWorkspaceFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -434,9 +476,9 @@ describe("cli agent run client", () => {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: "call-status",
+                  id: "call-read",
                   type: "function",
-                  function: { name: "gitStatus", arguments: "{}" },
+                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -449,8 +491,8 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
-    expect(output.text()).toContain("[nolo:tool] round 1 -> gitStatus (call-status)");
-    expect(output.text()).toContain("[nolo:tool] round 1 <- gitStatus (call-status)");
+    expect(output.text()).toContain("[nolo:tool] round 1 -> readWorkspaceFile (call-read)");
+    expect(output.text()).toContain("[nolo:tool] round 1 <- readWorkspaceFile (call-read)");
   });
 
   test("passes local tool evidence to task-run writeback", async () => {
@@ -482,7 +524,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["gitStatus"],
+          toolNames: ["readWorkspaceFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -495,9 +537,9 @@ describe("cli agent run client", () => {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: "call-status",
+                  id: "call-read",
                   type: "function",
-                  function: { name: "gitStatus", arguments: "{}" },
+                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -512,7 +554,7 @@ describe("cli agent run client", () => {
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
     expect(writebacks).toHaveLength(1);
     expect(writebacks[0].toolEvidence).toEqual({
-      toolsUsed: ["gitStatus"],
+      toolsUsed: ["readWorkspaceFile"],
       summary: {
         callCount: 1,
         resultCount: 1,
@@ -522,6 +564,58 @@ describe("cli agent run client", () => {
     });
   });
 
+  test("records local background task-run handoff as running instead of completed", async () => {
+    const output = new CaptureOutput();
+    const writebacks: any[] = [];
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "inspect repo in background",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      background: true,
+      taskRunContext: {
+        rowDbKey: "row-b2e06f801f-01TASK",
+        workItemId: "self",
+      },
+      taskRunRecorder: async (args) => {
+        writebacks.push(args);
+      },
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local-bg" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => ({ content: "accepted locally", model: "fake-local" }),
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-bg" });
+    expect(writebacks).toHaveLength(1);
+    expect(writebacks[0]).toMatchObject({
+      status: "running",
+      dialogId: "dialog-local-bg",
+    });
+    expect(writebacks[0].resultSummary).toBeUndefined();
+  });
+
   test("auto mode prefers a working local runtime before HTTP", async () => {
     const output = new CaptureOutput();
     const httpCalls: string[] = [];
@@ -566,6 +660,110 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend -> working locally");
   });
 
+  test("auto mode refreshes missing local agent config and retries local once before HTTP", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let loadAgentConfigCalls = 0;
+    let localCompletions = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      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", "leveldb-persistence"],
+        loadAgentConfig: async (agentRef) => {
+          loadAgentConfigCalls += 1;
+          if (loadAgentConfigCalls < 3) return null;
+          return {
+            key: agentRef,
+            name: "Frontend",
+            prompt: "Fix UI",
+            model: "fake-local",
+          };
+        },
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-auto-local-retried" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            localCompletions += 1;
+            return { content: "auto local after refresh", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-auto-local-retried" });
+    expect(loadAgentConfigCalls).toBe(4);
+    expect(localCompletions).toBe(1);
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).toContain("refreshing from the configured server and retrying local once");
+    expect(output.text().match(/working locally/g)?.length).toBe(2);
+  });
+
+  test("auto mode falls back to HTTP when local agent config is still missing after one refresh retry", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: Array<{ url: string; body: any }> = [];
+    let loadAgentConfigCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      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", "leveldb-persistence"],
+        loadAgentConfig: async () => {
+          loadAgentConfigCalls += 1;
+          return null;
+        },
+        loadDialogHistory: async () => [],
+        saveTurn: async () => {
+          throw new Error("local runtime should not save when config is missing");
+        },
+        resolveProvider: async () => {
+          throw new Error("local provider should not run when config is missing");
+        },
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server fallback", dialogId: "dialog-server-fallback" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server-fallback" });
+    expect(loadAgentConfigCalls).toBe(3);
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe("frontend-local");
+    expect(output.text()).toContain("refreshing from the configured server and retrying local once");
+    expect(output.text()).toContain("frontend -> working");
+    expect(output.text()).toContain("frontend > server fallback");
+  });
+
   test("auto mode skips local runtime for agents that declare server platform tools", async () => {
     const output = new CaptureOutput();
     const httpCalls: Array<{ url: string; body: any }> = [];
@@ -616,6 +814,58 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("pm > server ok");
   });
 
+  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 }> = [];
+
+    const result = await runAgentTurn({
+      agentName: "pm",
+      agentKey: "agent-policy-platform-tools",
+      serverUrl: "https://nolo.chat",
+      message: "query task rows",
+      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: "PM",
+          prompt: "Manage task rows",
+          model: "fake-local",
+          runtimeToolPolicy: {
+            version: 1,
+            agentTools: ["queryTableRows", "taskRun"],
+            runtimeTools: ["execShell"],
+          },
+        }),
+        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");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server ok", dialogId: "dialog-server-policy" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server-policy" });
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe("agent-policy-platform-tools");
+    expect(output.text()).toContain("auto runtime: skipping local runtime");
+    expect(output.text()).toContain("queryTableRows, taskRun");
+  });
+
   test("auto mode skips known platform agents when local config cannot be read", async () => {
     const output = new CaptureOutput();
     const httpCalls: Array<{ url: string; body: any }> = [];
@@ -733,11 +983,67 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-stream" });
-    expect(output.text()).toContain("nolo -> working");
-    expect(output.text()).toContain("nolo > 你好");
-  });
-
-  test("prints an auth hint when installed without repo scripts or AUTH_TOKEN", async () => {
+    expect(output.text()).toContain("nolo -> working");
+    expect(output.text()).toContain("nolo > 你好");
+  });
+
+  test("returns a recoverable dialog when a server stream drops after dialog creation", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        let sent = false;
+        return new Response(
+          new ReadableStream({
+            pull(controller) {
+              const encoder = new TextEncoder();
+              if (!sent) {
+                sent = true;
+                controller.enqueue(
+                  encoder.encode(
+                    [
+                      `data: ${JSON.stringify({
+                        type: "dialog",
+                        dialogId: "dialog-recoverable",
+                        status: "running",
+                      })}`,
+                      "",
+                      `data: ${JSON.stringify({ type: "text", content: "partial" })}`,
+                      "",
+                    ].join("\n")
+                  )
+                );
+                return;
+              }
+              controller.error(new Error("socket closed"));
+            },
+          }),
+          {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+          }
+        );
+      },
+    });
+
+    expect(result).toEqual({
+      exitCode: 0,
+      dialogId: "dialog-recoverable",
+      streamInterrupted: true,
+    });
+    expect(output.text()).toContain("dialog dialog-recoverable was created");
+    expect(output.text()).toContain("read the dialog before retrying");
+  });
+
+  test("prints an auth hint when installed without repo scripts or AUTH_TOKEN", async () => {
     const output = new CaptureOutput();
 
     const result = await runAgentTurn({