nolo-cli 0.1.40 → 0.1.41

package/client/localRuntimeAdapter.test.ts

@@ -535,11 +535,8 @@ describe("CLI local runtime adapter", () => {
       env: {
         NOLO_LOCAL_USER_ID: "user-1",
       },
-      db: {
-        get: async (key) => {
-          if (!store.has(key)) throw new Error(`not found: ${key}`);
-          return store.get(key);
-        },
+      store: {
+        read: async (key) => store.get(key) ?? null,
         put: async (key, value) => {
           store.set(key, value);
         },
@@ -892,7 +889,7 @@ describe("CLI local runtime adapter", () => {
 
     expect(result.content).toBe("platform longer retry ok");
     expect(attempts).toBe(6);
-    expect(retryDelays.length).toBe(5);
+    expect(retryDelays.length).toBeGreaterThanOrEqual(3);
     expect(retryDelays[0]).toBeGreaterThan(0);
   });
 
@@ -1469,6 +1466,141 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ serverPlatformTool: true });
   });
 
+  test("exposes declared server table write tools in local runtime requests", 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-local-table",
+          prompt: "Use table tools.",
+          model: "gpt-4.1-mini",
+          toolNames: ["createTable", "addTableRow", "addTableRows"],
+        }),
+        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: "table",
+      input: "采集并写入 table",
+    });
+
+    const toolNames = toolNamesFromRequest(requests[0]);
+    expect(toolNames).toContain("createTable");
+    expect(toolNames).toContain("addTableRow");
+    expect(toolNames).toContain("addTableRows");
+  });
+
+  test("executes declared createTable through the server table bridge when capture is explicit", async () => {
+    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-table-write",
+          toolNames: ["createTable"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (url, init) => {
+        requests.push({
+          url: String(url),
+          auth: new Headers(init?.headers).get("authorization"),
+          body: JSON.parse(String(init?.body)),
+        });
+        return Response.json({
+          ok: true,
+          tenantId: "user-1",
+          tableId: "table-1",
+        });
+      },
+    });
+
+    await adapter.loadAgentConfig("table-write");
+    const result = await adapter.executeTool({
+      id: "call-create-table",
+      name: "createTable",
+      userInput: "采集这个用户并写入 table",
+      arguments: JSON.stringify({
+        title: "XHS profile",
+        columns: [{ name: "nickname" }],
+      }),
+    });
+
+    expect(requests).toEqual([
+      {
+        url: "https://us.nolo.chat/api/table/create",
+        auth: "Bearer token-1",
+        body: {
+          title: "XHS profile",
+          columns: [{ name: "nickname" }],
+        },
+      },
+    ]);
+    expect(result.content).toContain("\"tableId\":\"table-1\"");
+    expect(result.metadata).toMatchObject({
+      serverPlatformTool: true,
+      tableWrite: true,
+    });
+  });
+
+  test("blocks local table writes when the current user request is not explicit capture", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-table-blocked",
+          toolNames: ["createTable"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        throw new Error("blocked createTable must not reach the server");
+      },
+    });
+
+    await adapter.loadAgentConfig("table-blocked");
+    const result = await adapter.executeTool({
+      id: "call-create-table-blocked",
+      name: "createTable",
+      userInput: "总结这个用户画像",
+      arguments: JSON.stringify({
+        title: "XHS profile",
+        columns: [{ name: "nickname" }],
+      }),
+    });
+
+    const parsed = JSON.parse(result.content);
+    expect(parsed.error).toBe("knowledge_capture_requires_confirmation");
+    expect(result.metadata).toMatchObject({
+      serverPlatformTool: true,
+      tableWriteBlocked: true,
+    });
+  });
+
   test("adds typed CLI workspace tools to the default nolo local agent request", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
@@ -1896,6 +2028,305 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
+  test("exposes read_xhs_profile to OpenAI-compatible providers when the agent declares it", 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-local-xhs",
+          prompt: "Read XHS profile.",
+          model: "gpt-4.1-mini",
+          toolNames: ["read_xhs_profile"],
+        }),
+        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: "xhs",
+      input: "读取小红书用户主页",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toContain("read_xhs_profile");
+  });
+
+  test("does not expose read_xhs_profile when the agent does not declare it", 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-local-no-xhs",
+          prompt: "Be helpful.",
+          model: "gpt-4.1-mini",
+        }),
+        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: "no-xhs",
+      input: "hello",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).not.toContain("read_xhs_profile");
+  });
+
+  test("executes read_xhs_profile locally through the desktop bridge", async () => {
+    const xhsCalls: Array<{ args: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs",
+          id: "xhs-agent",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      localToolExecutors: {
+        read_xhs_profile: async (call) => {
+          const parsed = JSON.parse(call.arguments || "{}");
+          xhsCalls.push({ args: parsed });
+          return {
+            content: JSON.stringify({
+              ok: true,
+              data: {
+                profile: { nickname: "test-soul", redId: "12345" },
+                notes: [],
+                noteDetails: [],
+                analysis: {
+                  totalNotes: 0,
+                  commentBuckets: [],
+                },
+              },
+            }),
+            metadata: { xhsLocalBridge: true },
+          };
+        },
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-agent");
+    const result = await adapter.executeTool({
+      id: "call-xhs-1",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+        maxScrollPages: 3,
+      }),
+    });
+
+    expect(xhsCalls).toHaveLength(1);
+    expect(xhsCalls[0].args.url).toBe(
+      "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556"
+    );
+    expect(xhsCalls[0].args.maxScrollPages).toBe(3);
+    expect(result.metadata).toMatchObject({ xhsLocalBridge: true });
+    const parsed = JSON.parse(result.content);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.data.profile.nickname).toBe("test-soul");
+  });
+
+  test("default read_xhs_profile executor calls the local bridge reader", async () => {
+    const readerCalls: Array<{ args: any; thunkApi: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs-default",
+          id: "xhs-default",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      readXhsProfile: async (args, thunkApi) => {
+        readerCalls.push({ args, thunkApi });
+        return {
+          rawData: {
+            ok: true,
+            data: {
+              profile: { nickname: "default-bridge", redId: "67890" },
+              notes: [],
+              noteDetails: [],
+              commentsByNote: {},
+              analysis: {
+                totalNotes: 0,
+                averageLikes: 0,
+                averageComments: 0,
+                averageCollects: 0,
+                averageShares: 0,
+                commentBuckets: [],
+                themes: [],
+              },
+            },
+            fetchedAt: "2026-06-03T00:00:00.000Z",
+          } as any,
+          displayData: "小红书用户: default-bridge",
+        };
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-default");
+    const result = await adapter.executeTool({
+      id: "call-xhs-default",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+        includeComments: true,
+        maxCommentPagesPerNote: 1,
+      }),
+    });
+
+    expect(readerCalls).toHaveLength(1);
+    expect(readerCalls[0].args).toMatchObject({
+      url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+      includeComments: true,
+      maxCommentPagesPerNote: 1,
+    });
+    expect(String(readerCalls[0].args.profileDir).replaceAll("\\", "/")).toContain(
+      "chat.nolo.desktop/stable/external-readers/xhs-profile"
+    );
+    expect(readerCalls[0].thunkApi).toBeUndefined();
+    expect(result.metadata).toMatchObject({
+      xhsLocalBridge: true,
+      displayData: "小红书用户: default-bridge",
+    });
+    expect(JSON.parse(result.content).data.profile.nickname).toBe("default-bridge");
+  });
+
+  test("default read_xhs_profile executor honors explicit XHS profile env", async () => {
+    const readerCalls: Array<{ args: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_XHS_READER_PROFILE_DIR: "/tmp/custom-xhs-profile",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs-env",
+          id: "xhs-env",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      readXhsProfile: async (args) => {
+        readerCalls.push({ args });
+        return {
+          rawData: {
+            ok: true,
+            data: {
+              profile: { nickname: "env-bridge" },
+              notes: [],
+              noteDetails: [],
+              commentsByNote: {},
+              analysis: { totalNotes: 0, commentBuckets: [] },
+            },
+            fetchedAt: "2026-06-03T00:00:00.000Z",
+          } as any,
+          displayData: "小红书用户: env-bridge",
+        };
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-env");
+    await adapter.executeTool({
+      id: "call-xhs-env",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+      }),
+    });
+
+    expect(readerCalls).toHaveLength(1);
+    expect(readerCalls[0].args.profileDir).toBeUndefined();
+  });
+
+  test("read_xhs_profile executor does not falsely succeed when bridge is unavailable", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs-fail",
+          id: "xhs-fail",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      localToolExecutors: {
+        read_xhs_profile: async () => ({
+          content: JSON.stringify({
+            ok: false,
+            code: "network_error",
+            message: "read_xhs_profile needs Playwright but it is not installed.",
+          }),
+          metadata: { xhsLocalBridge: true, bridgeError: true },
+        }),
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-fail");
+    const result = await adapter.executeTool({
+      id: "call-xhs-fail",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+      }),
+    });
+
+    const parsed = JSON.parse(result.content);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.code).toBe("network_error");
+    expect(result.metadata).toMatchObject({ bridgeError: true });
+  });
+
   test("runs allowed workspace file tools through default local executors", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {