nolo-cli 0.1.22 → 0.1.23

package/client/agentRun.test.ts

@@ -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({
@@ -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[] = [];
@@ -616,6 +710,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 +879,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({

package/client/agentRun.ts

@@ -59,7 +59,7 @@ type RunAgentTurnOptions = {
   taskRunContext?: TaskRunPromptContext;
   taskRunRecorder?: (args: {
     options: RunAgentTurnOptions;
-    status: "completed" | "failed";
+    status: "running" | "completed" | "failed";
     dialogId?: string;
     resultSummary?: string;
     errorCode?: string;
@@ -69,10 +69,11 @@ type RunAgentTurnOptions = {
   fetchImpl?: typeof fetch;
 };
 
-export type RunAgentTurnResult = {
-  exitCode: number;
-  dialogId?: string;
-};
+export type RunAgentTurnResult = {
+  exitCode: number;
+  dialogId?: string;
+  streamInterrupted?: boolean;
+};
 
 type ScriptBridgeDecision = {
   hasAuthToken: boolean;
@@ -132,6 +133,15 @@ export function findServerPlatformTools(toolNames?: string[]) {
   return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
 }
 
+function resolveServerPlatformToolNames(agentConfig: any) {
+  return findServerPlatformTools([
+    ...(Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : []),
+    ...(Array.isArray(agentConfig?.runtimeToolPolicy?.agentTools)
+      ? agentConfig.runtimeToolPolicy.agentTools
+      : []),
+  ]);
+}
+
 function normalizeAgentRef(ref?: string) {
   return ref?.trim().toLowerCase().replace(/\s+/g, " ");
 }
@@ -190,7 +200,7 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   } catch {
     return false;
   }
-  const serverTools = findServerPlatformTools(agentConfig?.toolNames);
+  const serverTools = resolveServerPlatformToolNames(agentConfig);
   if (serverTools.length === 0) return false;
   options.output.write(
     `[nolo] auto runtime: skipping local runtime because ${options.agentKey} declares server platform tools ` +
@@ -348,7 +358,7 @@ async function runTaskRunCli(args: {
 
 async function defaultTaskRunRecorder(args: {
   options: RunAgentTurnOptions;
-  status: "completed" | "failed";
+  status: "running" | "completed" | "failed";
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
@@ -357,7 +367,7 @@ async function defaultTaskRunRecorder(args: {
   const context = args.options.taskRunContext;
   if (!context?.rowDbKey) return;
   const role = inferTaskRunAgentRole(args.options.agentName || args.options.agentKey);
-  if (role === "reviewer") {
+  if (role === "reviewer" && args.status !== "running") {
     await runTaskRunCli({
       options: args.options,
       cliArgs: [
@@ -415,7 +425,7 @@ async function defaultTaskRunRecorder(args: {
       ],
     });
   }
-  if (role === "reviewer") {
+  if (role === "reviewer" && args.status !== "running") {
     const reviewStatus =
       args.status === "failed" ? "blocked" : classifyTaskRunReviewStatus(args.resultSummary);
     if (reviewStatus) {
@@ -441,7 +451,7 @@ async function defaultTaskRunRecorder(args: {
 
 async function recordTaskRunOutcome(args: {
   options: RunAgentTurnOptions;
-  status: "completed" | "failed";
+  status: "running" | "completed" | "failed";
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
@@ -566,12 +576,28 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
           options.imageUrls
         ),
         runtimeContext: {
-          surface: "cli",
-          host: "terminal",
-          runtime: "bun",
-          entrypoint: "nolo-cli",
-          capabilities: ["text-io", "streaming", "slash-commands"],
-        },
+          surface: "cli",
+          host: "terminal",
+          runtime: "bun",
+          entrypoint: "nolo-cli",
+          capabilities: ["text-io", "streaming", "slash-commands"],
+          ...(options.taskRunContext
+            ? {
+                taskRun: {
+                  rowDbKey: options.taskRunContext.rowDbKey,
+                  ...(options.taskRunContext.taskRunId
+                    ? { taskRunId: options.taskRunContext.taskRunId }
+                    : {}),
+                  ...(options.taskRunContext.workItemId
+                    ? { workItemId: options.taskRunContext.workItemId }
+                    : {}),
+                  ...(options.taskRunContext.artifactIds?.length
+                    ? { artifactIds: options.taskRunContext.artifactIds }
+                    : {}),
+                },
+              }
+            : {}),
+        },
         ...(options.continueDialogId
           ? { continueDialogId: options.continueDialogId }
           : {}),
@@ -597,7 +623,11 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
     const result = await readStreamingAgentRun(options, res);
     await recordTaskRunOutcome({
       options,
-      status: result.exitCode === 0 ? "completed" : "failed",
+      status: result.streamInterrupted
+        ? "running"
+        : result.exitCode === 0
+          ? "completed"
+          : "failed",
       dialogId: result.dialogId,
       ...(result.exitCode !== 0 ? { errorCode: "STREAM_FAILED" } : {}),
     });
@@ -642,9 +672,9 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
   };
   await recordTaskRunOutcome({
     options,
-    status: "completed",
+    status: options.background ? "running" : "completed",
     dialogId: result.dialogId,
-    resultSummary: content || undefined,
+    ...(!options.background && content ? { resultSummary: content } : {}),
   });
   return result;
 }
@@ -747,9 +777,9 @@ async function runLocalAgentTurnForCli(
     }
     await recordTaskRunOutcome({
       options,
-      status: "completed",
+      status: options.background ? "running" : "completed",
       dialogId: result.dialogId,
-      resultSummary: content || undefined,
+      ...(!options.background && content ? { resultSummary: content } : {}),
       toolEvidence: summarizeLocalToolEvidence(toolEvents),
     });
     return { exitCode: 0, dialogId: result.dialogId };
@@ -791,15 +821,20 @@ async function readStreamingAgentRun(
     hasPrintedLabel = true;
   };
 
-  const handlePayload = (payload: any) => {
-    if (payload?.error || payload?.type === "error") {
-      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
-    }
-    if (payload?.type === "done") {
-      if (typeof payload.dialogId === "string") dialogId = payload.dialogId;
-      usage = payload.usage;
-      return;
-    }
+  const handlePayload = (payload: any) => {
+    if (typeof payload?.dialogId === "string" && payload.dialogId.trim()) {
+      dialogId = payload.dialogId;
+    }
+    if (payload?.error || payload?.type === "error") {
+      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
+    }
+    if (payload?.type === "done") {
+      usage = payload.usage;
+      return;
+    }
+    if (payload?.type === "dialog" || payload?.type === "status") {
+      return;
+    }
 
     const chunk =
       payload?.type === "text"
@@ -842,10 +877,18 @@ async function readStreamingAgentRun(
         .trim();
       if (raw) handlePayload(JSON.parse(raw));
     }
-  } catch (error) {
-    options.output.write(`\n[nolo] Agent stream failed: ${error instanceof Error ? error.message : String(error)}\n`);
-    return { exitCode: 1 };
-  } finally {
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (dialogId) {
+      options.output.write(
+        `\n[nolo] Agent stream transport interrupted after dialog ${dialogId} was created: ${message}\n`
+      );
+      options.output.write("[nolo] The agent run may still finish on the server; read the dialog before retrying.\n");
+      return { exitCode: 0, dialogId, streamInterrupted: true };
+    }
+    options.output.write(`\n[nolo] Agent stream failed: ${message}\n`);
+    return { exitCode: 1 };
+  } finally {
     writer.flushAll();
   }
 

package/client/localRuntimeAdapter.test.ts

@@ -353,6 +353,7 @@ describe("CLI local runtime adapter", () => {
         tool_choice: "auto",
         url: "https://api.fireworks.ai/inference/v1/chat/completions",
         provider: "fireworks",
+        agentKey: "agent-user-1-frontend",
       },
     });
     expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
@@ -419,6 +420,7 @@ describe("CLI local runtime adapter", () => {
       body: {
         provider: "fireworks",
         apiSource: "platform",
+        agentKey: "agent-user-1-frontend",
       },
     });
   });

package/client/localRuntimeAdapter.ts

@@ -58,6 +58,7 @@ export type CliLocalRuntimeAdapterDeps = {
   createId?: () => string;
   fetchImpl?: typeof fetch;
   cwd?: string;
+  useCwdAsTaskWorkspaceBase?: boolean;
   output?: { write(chunk: string): unknown };
   prepareTaskWorktree?: typeof prepareTaskWorktree;
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
@@ -254,7 +255,11 @@ export function createCliLocalRuntimeAdapter(
   const localToolBudgets = parseLocalToolBudgets(deps.env);
   const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
-  let workspaceSession: WorkspaceSession = createWorkspaceSession({ cwd: deps.cwd });
+  let workspaceSession: WorkspaceSession = createWorkspaceSession(
+    deps.useCwdAsTaskWorkspaceBase
+      ? { defaultCwd: deps.cwd }
+      : { cwd: deps.cwd }
+  );
   let localToolExecutors = buildLocalToolExecutors({
     workspaceRoot: workspaceSession.workspaceRoot,
     localToolExecutors: deps.localToolExecutors,
@@ -378,12 +383,20 @@ export function createCliLocalRuntimeAdapter(
         budgets: localToolBudgets,
         usage: localToolUsage,
       });
-      return executeLocalToolWithPolicy({
+      const result = await executeLocalToolWithPolicy({
         env: deps.env,
         agentToolNames: activeAgentToolNames,
         call,
         executors: localToolExecutors,
       });
+      return {
+        ...result,
+        metadata: {
+          ...(result.metadata ?? {}),
+          workspaceRoot: workspaceSession.workspaceRoot,
+          workspaceKind: workspaceSession.kind,
+        },
+      };
     },
   };
 }

package/database/actions/common.ts

@@ -2,7 +2,8 @@
 
 import pino from "pino";
 import { getIsDesktopApp } from "app/utils/env";
-import { API_ENDPOINTS, NOLO_CLUSTER_SERVERS } from "../config";
+import { fetchWithTransientReadRetry } from "app/utils/retryFetch";
+import { API_ENDPOINTS, NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "../config";
 
 // RN 下 pino 的 browser 写法可能有兼容性问题
 // 使用简单的 console 封装作为 fallback
@@ -23,7 +24,7 @@ export const logger = isRN ? {
   // },
 });
 const normalizeServer = (server: string): string =>
-  server.trim().replace(/\/+$/, "");
+  normalizeKnownServerOrigin(server) ?? server.trim().replace(/\/+$/, "");
 const isNoloClusterServer = (server: string): boolean =>
   /^https?:\/\/(?:us\.)?nolo\.chat$/i.test(normalizeServer(server));
 
@@ -202,7 +203,7 @@ export const fetchFromServer = async (
   signal?.addEventListener("abort", onExternalAbort);
 
   try {
-    const res = await fetch(
+    const res = await fetchWithTransientReadRetry(
       `${server}${buildReadUrl(dbKey)}`,
       {
         signal: controller.signal as any,

package/database/config.ts

@@ -8,6 +8,25 @@ export const SERVERS = {
 } as const;
 export const NOLO_CLUSTER_SERVERS = Object.values(SERVERS);
 
+const LEGACY_SERVER_ORIGIN_MAP: Record<string, string> = {
+  "https://nolotus.com": SERVERS.MAIN,
+  "https://www.nolotus.com": SERVERS.MAIN,
+  "https://us.nolotus.com": SERVERS.US,
+  "https://www.us.nolotus.com": SERVERS.US,
+};
+
+export const normalizeKnownServerOrigin = (server: unknown): string | null => {
+  if (typeof server !== "string" || server.trim().length === 0) return null;
+  const trimmed = server.trim();
+  let origin: string;
+  try {
+    origin = new URL(trimmed).origin;
+  } catch {
+    origin = trimmed.replace(/\/+$/, "");
+  }
+  return LEGACY_SERVER_ORIGIN_MAP[origin.toLowerCase()] ?? origin;
+};
+
 export const API_ENDPOINTS = {
   DATABASE: `${API_VERSION}/db`,
   SHARE: `${API_VERSION}/share`,