nolo-cli 0.1.40 → 0.1.41

package/cli/client/localRuntimeAdapter.ts

@@ -42,6 +42,8 @@ import {
   type HybridRecordStore,
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
+import { inferCaptureIntent } from "../../ai/policy/runtimePolicy";
+import { prepareTools } from "../../ai/tools/prepareTools";
 import { taskRunFunctionSchema } from "../../ai/tools/agent/taskRunTool";
 import {
   MIMO_MONTH_AGENT_KEY,
@@ -56,6 +58,11 @@ import {
 } from "../../agent-runtime/noloWorkspaceTools";
 import { executeCli as defaultExecuteCli, type CliExecuteResult, type CliImageInput } from "../../ai/agent/cliExecutor";
 import { buildCliPrompt } from "../../ai/agent/cliPrompt";
+import {
+  readXhsProfileFunc,
+  readXhsProfileFunctionSchema,
+} from "../../ai/tools/readXhsProfileTool";
+import { resolveDefaultXhsProfileDir } from "../../integrations/xhs-reader/bridge/readXhsProfileWithBridge";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
@@ -78,6 +85,14 @@ export const BUILTIN_NOLO_AGENT_ID = NOLO_DEFAULT_AGENT_ID;
 export const BUILTIN_NOLO_AGENT_KEY = NOLO_DEFAULT_AGENT_KEY;
 const CLI_DIR = dirname(fileURLToPath(import.meta.url));
 const CLI_ENTRYPOINT = join(CLI_DIR, "..", "index.ts");
+const LOCAL_SERVER_TABLE_TOOL_NAMES = [
+  "createTable",
+  "addTableRow",
+  "addTableRows",
+  "updateTableRow",
+  "updateTableRows",
+] as const;
+const LOCAL_SERVER_TABLE_TOOL_NAME_SET = new Set<string>(LOCAL_SERVER_TABLE_TOOL_NAMES);
 
 export type CliLocalRuntimeDb = CliKvDb;
 
@@ -91,6 +106,7 @@ export type CliLocalRuntimeAdapterDeps = {
   cwd?: string;
   output?: { write(chunk: string): unknown };
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  readXhsProfile?: typeof readXhsProfileFunc;
   executeCli?: LocalCliExecutor;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
@@ -235,12 +251,14 @@ function buildRequestTimeoutSignal(timeoutMs?: number) {
   if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
     return undefined;
   }
-  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
-    return AbortSignal.timeout(timeoutMs);
-  }
   const controller = new AbortController();
-  setTimeout(() => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
-  return controller.signal;
+  const timeout = setTimeout(() => {
+    controller.abort(new Error(`request timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+  return {
+    signal: controller.signal,
+    clear: () => clearTimeout(timeout),
+  };
 }
 
 function summarizeEndpoint(value: unknown) {
@@ -383,12 +401,17 @@ function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike })
       exposeShellTools: true,
     }),
     ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...((args.toolNames ?? []).includes("read_xhs_profile") ? ["read_xhs_profile"] : []),
+    ...(args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
     ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
 function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
   const toolNames = new Set(args.toolNames ?? []);
+  const tableTools = prepareTools(
+    (args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
+  );
   return [
     ...(toolNames.has("taskRun")
       ? [{
@@ -396,6 +419,13 @@ function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
           function: taskRunFunctionSchema,
         }]
       : []),
+    ...(toolNames.has("read_xhs_profile")
+      ? [{
+          type: "function",
+          function: readXhsProfileFunctionSchema,
+        }]
+      : []),
+    ...tableTools,
   ];
 }
 
@@ -467,29 +497,72 @@ function buildServerPlatformToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
 }) {
+  const postServer = async (path: string, body: object) => {
+    const serverUrl = resolveRuntimeServerUrl(args.env);
+    const authToken = resolveRuntimeAuthToken(args.env);
+    if (!serverUrl) throw new Error("server platform tools require NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
+    if (!authToken) throw new Error("server platform tools require AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
+    const response = await args.fetchImpl(`${serverUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify(body),
+    });
+    const text = await response.text().catch(() => "");
+    if (!response.ok) {
+      throw new Error(`server platform tool bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
+    }
+    return text;
+  };
+  const guardExplicitTableCapture = (call: any) => {
+    if (inferCaptureIntent(String(call.userInput ?? "")) === "strong") return null;
+    return JSON.stringify({
+      error: "knowledge_capture_requires_confirmation",
+      message:
+        "当前本地运行不允许自动写入表格。只有当用户在当前请求里明确要求保存、建表、写入 table 或做成数据集时，才能继续；否则请先询问用户。",
+      policy: {
+        capability: "knowledge_capture",
+        target: "table",
+        mode: "explicit-only-local",
+      },
+    });
+  };
+  const tableExecutors = Object.fromEntries(
+    LOCAL_SERVER_TABLE_TOOL_NAMES.map((toolName) => [
+      toolName,
+      async (call: any) => {
+        const blocked = guardExplicitTableCapture(call);
+        if (blocked) {
+          return {
+            content: blocked,
+            metadata: { serverPlatformTool: true, tableWriteBlocked: true },
+          };
+        }
+        const parsed = parseNoloWorkspaceToolArguments(call.arguments);
+        const path =
+          toolName === "createTable" ? "/api/table/create"
+          : toolName === "addTableRow" ? "/api/table/add-row"
+          : toolName === "addTableRows" ? "/api/table/add-rows"
+          : toolName === "updateTableRow" ? "/api/table/update-row"
+          : "/api/table/update-rows";
+        const content = await postServer(path, parsed);
+        return {
+          content,
+          metadata: { serverPlatformTool: true, tableWrite: true },
+        };
+      },
+    ]),
+  );
   return {
     taskRun: async (call: any) => {
-      const serverUrl = resolveRuntimeServerUrl(args.env);
-      const authToken = resolveRuntimeAuthToken(args.env);
-      if (!serverUrl) throw new Error("taskRun requires NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
-      if (!authToken) throw new Error("taskRun requires AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
-      const response = await args.fetchImpl(`${serverUrl}/api/task-run`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${authToken}`,
-        },
-        body: JSON.stringify(parseNoloWorkspaceToolArguments(call.arguments)),
-      });
-      const text = await response.text().catch(() => "");
-      if (!response.ok) {
-        throw new Error(`taskRun bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
-      }
       return {
-        content: text,
+        content: await postServer("/api/task-run", parseNoloWorkspaceToolArguments(call.arguments)),
         metadata: { serverPlatformTool: true },
       };
     },
+    ...tableExecutors,
   };
 }
 
@@ -498,9 +571,34 @@ function buildLocalToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
   localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
+  readXhsProfile?: CliLocalRuntimeAdapterDeps["readXhsProfile"];
   commandTimeoutMs?: number;
   commandOutputLimit?: number;
 }) {
+  const resolveCliDefaultXhsArgs = (parsedArgs: any) => {
+    if (
+      parsedArgs?.profileDir ||
+      parsedArgs?.profile_dir ||
+      args.env.NOLO_XHS_READER_PROFILE_DIR
+    ) {
+      return parsedArgs;
+    }
+    return {
+      ...parsedArgs,
+      profileDir: resolveDefaultXhsProfileDir({
+        env: {
+          ...process.env,
+          ...args.env,
+          NOLO_DESKTOP: "1",
+          NOLO_DESKTOP_CHANNEL:
+            args.env.NOLO_DESKTOP_CHANNEL?.trim() ||
+            args.env.NOLO_XHS_READER_DESKTOP_CHANNEL?.trim() ||
+            "stable",
+        },
+      }),
+    };
+  };
+
   return {
     ...createLocalWorkspaceToolExecutors({
       workspaceRoot: args.workspaceRoot,
@@ -514,6 +612,22 @@ function buildLocalToolExecutors(args: {
     ...buildCliWorkspaceToolExecutors({
       env: args.env,
     }),
+    read_xhs_profile: async (call: any) => {
+      const parsedArgs = (() => {
+        try { return JSON.parse(call.arguments || "{}"); } catch { return {}; }
+      })();
+      const result = await (args.readXhsProfile ?? readXhsProfileFunc)(
+        resolveCliDefaultXhsArgs(parsedArgs),
+        undefined,
+      );
+      return {
+        content: JSON.stringify(result.rawData),
+        metadata: {
+          xhsLocalBridge: true,
+          displayData: result.displayData,
+        },
+      };
+    },
     ...(args.localToolExecutors ?? {}),
   };
 }
@@ -599,6 +713,7 @@ export function createCliLocalRuntimeAdapter(
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
+    readXhsProfile: deps.readXhsProfile,
     ...runtimeToolExecutionLimits,
   });
 
@@ -629,6 +744,7 @@ export function createCliLocalRuntimeAdapter(
         env: deps.env,
         fetchImpl,
         localToolExecutors: deps.localToolExecutors,
+        readXhsProfile: deps.readXhsProfile,
         ...runtimeToolExecutionLimits,
       });
       return agentConfig;
@@ -725,7 +841,7 @@ export function createCliLocalRuntimeAdapter(
               messages,
               tools,
             });
-            const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            const timeoutSignal = buildRequestTimeoutSignal(options?.timeoutMs);
             logLocalRuntimeDiagnostic("provider.request.start", {
               agentKey: agentConfig.key,
               transport: "platform-proxy",
@@ -740,11 +856,11 @@ export function createCliLocalRuntimeAdapter(
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
               ...request.init,
-              ...(signal ? { signal } : {}),
+              ...(timeoutSignal ? { signal: timeoutSignal.signal } : {}),
             }, {
               sleep: deps.sleep,
               loopbackRequest,
-            });
+            }).finally(() => timeoutSignal?.clear());
             const raw = await res.text().catch(() => "");
             logLocalRuntimeDiagnostic("provider.request.result", {
               agentKey: agentConfig.key,
@@ -798,7 +914,7 @@ export function createCliLocalRuntimeAdapter(
             messages,
             tools,
           });
-          const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          const timeoutSignal = buildRequestTimeoutSignal(options?.timeoutMs);
           logLocalRuntimeDiagnostic("provider.request.start", {
             agentKey: agentConfig.key,
             transport: "direct-openai-compatible",
@@ -812,11 +928,11 @@ export function createCliLocalRuntimeAdapter(
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
             ...request.init,
-            ...(signal ? { signal } : {}),
+            ...(timeoutSignal ? { signal: timeoutSignal.signal } : {}),
           }, {
             sleep: deps.sleep,
             loopbackRequest,
-          });
+          }).finally(() => timeoutSignal?.clear());
           const raw = await res.text().catch(() => "");
           logLocalRuntimeDiagnostic("provider.request.result", {
             agentKey: agentConfig.key,

package/client/agentRun.test.ts

@@ -887,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[] = [];

package/client/agentRun.ts

@@ -197,6 +197,16 @@ function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
   }
 }
 
+function isCliProviderAgentConfig(agentConfig: any) {
+  const cliProvider = typeof agentConfig?.cliProvider === "string"
+    ? agentConfig.cliProvider.trim()
+    : "";
+  const provider = typeof agentConfig?.provider === "string"
+    ? agentConfig.provider.trim()
+    : "";
+  return Boolean(cliProvider) || provider === "agy" || provider === "codex" || provider === "claude";
+}
+
 function resolveAuthToken(env: EnvLike) {
   return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
 }
@@ -234,21 +244,30 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   if (options.localRuntimeCwd) {
     return false;
   }
-  if (isKnownServerPlatformAgent(options)) {
-    options.output.write(
-      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
-        "Use --local explicitly to force local workspace tools.\n"
-    );
-    return true;
-  }
+  const knownServerPlatformAgent = isKnownServerPlatformAgent(options);
   const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) return false;
+  if (!adapter) return knownServerPlatformAgent;
   let agentConfig;
   try {
     agentConfig = await adapter.loadAgentConfig(options.agentKey);
   } catch {
+    if (knownServerPlatformAgent) {
+      options.output.write(
+        `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
+          "Use --local explicitly to force local workspace tools.\n"
+      );
+      return true;
+    }
     return false;
   }
+  if (isCliProviderAgentConfig(agentConfig)) return false;
+  if (knownServerPlatformAgent) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
+        "Use --local explicitly to force local workspace tools.\n"
+    );
+    return true;
+  }
   if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +