nolo-cli 0.1.33 → 0.1.34

package/client/localRuntimeAdapter.test.ts

@@ -278,8 +278,8 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("uses agent customProviderUrl for local OpenAI-compatible requests", async () => {
-    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+  test("uses agent-owned custom credentials for local OpenAI-compatible requests", async () => {
+    const requests: Array<{ url: string; auth: string | null; apiKeyHeader: string | null; body: any }> = [];
     const store = new Map<string, any>([
       ["agent-user-1-custom", {
         dbKey: "agent-user-1-custom",
@@ -289,6 +289,8 @@ describe("CLI local runtime adapter", () => {
         provider: "custom-openai-compatible",
         apiSource: "custom",
         customProviderUrl: "https://provider.example/v1/chat/completions",
+        apiKey: "sk-agent-custom",
+        apiKeyHeader: "api-key",
         temperature: 0.2,
         max_tokens: 4096,
         reasoning_effort: "medium",
@@ -319,6 +321,7 @@ describe("CLI local runtime adapter", () => {
         requests.push({
           url: String(url),
           auth: new Headers(init?.headers).get("Authorization"),
+          apiKeyHeader: new Headers(init?.headers).get("api-key"),
           body: JSON.parse(String(init?.body)),
         });
         return Response.json({
@@ -337,7 +340,8 @@ describe("CLI local runtime adapter", () => {
     expect(result.provider).toBe("custom-openai-compatible");
     expect(requests[0]).toMatchObject({
       url: "https://provider.example/v1/chat/completions",
-      auth: "Bearer sk-custom",
+      auth: null,
+      apiKeyHeader: "sk-agent-custom",
       body: {
         model: "custom-coder",
         messages: [
@@ -353,6 +357,57 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
   });
 
+  test("aborts stalled custom provider requests when timeoutMs is provided", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-mimo", {
+        dbKey: "agent-user-1-mimo",
+        id: "mimo",
+        prompt: "Use monthly mimo.",
+        model: "mimo-v2.5-pro",
+        provider: "custom",
+        apiSource: "custom",
+        customProviderUrl: "https://token-plan-cn.xiaomimimo.com/v1",
+        apiKey: "mimo-monthly-key",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      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);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        if (init?.signal?.aborted) {
+          throw init.signal.reason ?? new Error("aborted");
+        }
+        await new Promise((_, reject) => {
+          init?.signal?.addEventListener("abort", () => reject(init.signal?.reason ?? new Error("aborted")));
+        });
+        throw new Error("unreachable");
+      },
+    });
+
+    await expect(runLocalAgentTurn({
+      adapter,
+      agentRef: "mimo",
+      input: "hello",
+      timeoutMs: 10,
+    })).rejects.toThrow(/timed out|aborted/i);
+  });
+
   test("uses loopback transport for localhost custom providers when the default fetch path cannot connect", async () => {
     const store = new Map<string, any>([
       ["agent-user-1-localhost", {
@@ -1269,6 +1324,235 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ exitCode: 0 });
   });
 
+  test("accepts execShell aliases from the local model", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-shell-alias",
+          prompt: "Use shell when needed.",
+          model: "qwen-coder",
+          toolNames: ["execShell"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        execShell: async () => ({
+          content: import.meta.dir,
+          metadata: { exitCode: 0, timedOut: false },
+        }),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        if (requests.length === 1) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-1",
+                  type: "function",
+                  function: { name: "runCommand", arguments: "{\"cmd\":\"pwd\"}" },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "alias ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "print cwd",
+    });
+
+    expect(result.content).toBe("alias ok");
+    expect(requests[1]?.body.messages.at(-1)?.content).toContain(import.meta.dir);
+  });
+
+  test("blocks destructive local execShell calls unless the user explicitly asked to delete", async () => {
+    let executorCalls = 0;
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-shell-guard",
+          prompt: "Use shell when useful.",
+          model: "qwen-coder",
+          toolNames: ["execShell"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        execShell: async () => {
+          executorCalls += 1;
+          return {
+            content: "should not run",
+          };
+        },
+      },
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        const lastToolMessage = [...body.messages]
+          .reverse()
+          .find((message: any) => message.role === "tool");
+        if (lastToolMessage) {
+          expect(String(lastToolMessage.content)).toContain(
+            "destructive_action_requires_confirmation",
+          );
+          return Response.json({
+            choices: [{ message: { content: "guard ok" } }],
+          });
+        }
+        return Response.json({
+          choices: [{
+            message: {
+              content: "",
+              tool_calls: [{
+                id: "call-1",
+                type: "function",
+                function: {
+                  name: "execShell",
+                  arguments: "{\"cmd\":\"rm -rf ./tmp\"}",
+                },
+              }],
+            },
+          }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "inspect cwd but don't delete files",
+    });
+
+    expect(result.content).toBe("guard ok");
+    expect(executorCalls).toBe(0);
+  });
+
+  test("exposes runtime policy tools to the local model even when toolNames omits them", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-policy-shell",
+          prompt: "Use shell when needed.",
+          model: "qwen-coder",
+          runtimeToolPolicy: {
+            version: 1,
+            runtimeTools: ["execShell"],
+          },
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        execShell: async () => ({
+          content: import.meta.dir,
+          metadata: { exitCode: 0, timedOut: false },
+        }),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        if (requests.length === 1) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-1",
+                  type: "function",
+                  function: { name: "execShell", arguments: "{\"cmd\":\"pwd\"}" },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "policy shell ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "print cwd",
+    });
+
+    expect(result.content).toBe("policy shell ok");
+    expect(toolNamesFromRequest(requests[0])).toContain("execShell");
+    expect(requests[1]?.body.messages.at(-1)?.content).toContain(import.meta.dir);
+  });
+
+  test("treats runtime policy visual tools as declared local tools", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-visual",
+          prompt: "Inspect the page.",
+          model: "qwen-coder",
+          runtimeToolPolicy: {
+            version: 1,
+            runtimeTools: ["captureVisualState"],
+          },
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      localToolExecutors: {
+        captureVisualState: async () => ({
+          content: "{\"status\":\"ok\"}",
+        }),
+      },
+      fetchImpl: async (_url, init) => {
+        expect(toolNamesFromRequest({ body: JSON.parse(String(init?.body)) })).toContain("captureVisualState");
+        return Response.json({
+          choices: [{ message: { content: "visual ok" } }],
+        });
+      },
+    });
+
+    await adapter.loadAgentConfig("visual");
+    await expect(adapter.executeTool({
+      id: "call-visual",
+      name: "captureVisualState",
+      arguments: JSON.stringify({ waitSelector: "body" }),
+    })).resolves.toMatchObject({
+      content: "{\"status\":\"ok\"}",
+    });
+  });
+
   test("runs allowed workspace file tools through default local executors", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {

package/client/localRuntimeAdapter.ts

@@ -16,6 +16,7 @@ import {
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
   resolvePlatformChatProviderConfig,
+  resolveRequestedRuntimeToolNames,
   shouldUsePlatformChatProvider,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../agent-runtime";
@@ -169,6 +170,12 @@ async function defaultLoopbackRequest(input: FetchInput, init?: FetchInit) {
       });
     });
     req.on("error", reject);
+    init?.signal?.addEventListener("abort", () => {
+      req.destroy(
+        init.signal?.reason instanceof Error ? init.signal.reason : new Error("request aborted")
+      );
+      reject(init.signal?.reason ?? new Error("request aborted"));
+    }, { once: true });
     if (body) req.write(body);
     req.end();
   });
@@ -191,6 +198,7 @@ async function fetchWithTransientRetry(
       }
       return await fetchImpl(input, init);
     } catch (error) {
+      if (init?.signal?.aborted) throw error;
       if (!isTransientFetchError(error)) throw error;
       lastError = error;
       if (attempt < TRANSIENT_FETCH_MAX_ATTEMPTS) {
@@ -201,6 +209,18 @@ async function fetchWithTransientRetry(
   throw lastError;
 }
 
+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;
+}
+
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
@@ -428,8 +448,11 @@ export function createCliLocalRuntimeAdapter(
         store: await resolveStore(deps),
         userId,
       });
+      const requestedToolNames = agentConfig
+        ? resolveRequestedRuntimeToolNames({ agentConfig })
+        : [];
       activeAgentToolNames = buildLocalPolicyToolNames({
-        toolNames: agentConfig?.toolNames,
+        toolNames: requestedToolNames,
         env: deps.env,
       });
       await activateAgentWorkspaceSession({ agentRef, agentConfig });
@@ -455,9 +478,12 @@ export function createCliLocalRuntimeAdapter(
         });
         return {
           model: providerConfig.model,
-          complete: async (messages) => {
+          complete: async (messages, options) => {
+            const requestedToolNames = resolveRequestedRuntimeToolNames({
+              agentConfig,
+            });
             const tools = buildOpenAiTools({
-              toolNames: agentConfig.toolNames,
+              toolNames: requestedToolNames,
               env: deps.env,
             });
             const request = buildPlatformChatCompletionRequest({
@@ -465,7 +491,11 @@ export function createCliLocalRuntimeAdapter(
               messages,
               tools,
             });
-            const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+            const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            const res = await fetchWithTransientRetry(fetchImpl, request.url, {
+              ...request.init,
+              ...(signal ? { signal } : {}),
+            }, {
               sleep: deps.sleep,
               loopbackRequest,
             });
@@ -488,9 +518,12 @@ export function createCliLocalRuntimeAdapter(
       });
       return {
         model: providerConfig.model,
-        complete: async (messages) => {
+        complete: async (messages, options) => {
+          const requestedToolNames = resolveRequestedRuntimeToolNames({
+            agentConfig,
+          });
           const tools = buildOpenAiTools({
-            toolNames: agentConfig.toolNames,
+            toolNames: requestedToolNames,
             env: deps.env,
           });
           const request = buildOpenAiCompatibleChatCompletionRequest({
@@ -498,7 +531,11 @@ export function createCliLocalRuntimeAdapter(
             messages,
             tools,
           });
-          const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+          const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          const res = await fetchWithTransientRetry(fetchImpl, request.url, {
+            ...request.init,
+            ...(signal ? { signal } : {}),
+          }, {
             sleep: deps.sleep,
             loopbackRequest,
           });

package/commandRegistry.ts

@@ -49,8 +49,8 @@ export function renderHelpText() {
     "  nolo connect",
     "  nolo connect --watch",
     "  nolo connect --ws",
-    "  nolo connect --ws --server-url https://api.nolo.chat --api-key sk_machine_xxx",
-    "  nolo connect --daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx",
+    "  nolo connect --ws --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
+    "  nolo connect --daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
     "  nolo machine status",
     "  nolo doctor",
     "  nolo doctor runtime",

package/database/server/authorityStoreTypes.ts

@@ -0,0 +1,31 @@
+export type AuthorityBatchOperation =
+  | { type: "put"; key: string; value: unknown }
+  | { type: "del"; key: string };
+
+export type AuthorityIteratorOptions = {
+  gte?: string;
+  lte?: string;
+  lt?: string;
+  reverse?: boolean;
+};
+
+export interface AuthorityBatchWriter {
+  put(key: string, value: unknown): void;
+  del(key: string): void;
+  write(): Promise<void>;
+}
+
+export interface AuthorityStore {
+  readonly location?: string;
+  readonly status?: string;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  get<T = any>(key: string): Promise<T>;
+  put(key: string, value: unknown): Promise<void>;
+  del(key: string): Promise<void>;
+  batchWrite(ops: AuthorityBatchOperation[]): Promise<void>;
+  createBatch(): AuthorityBatchWriter;
+  iterator(
+    options?: AuthorityIteratorOptions
+  ): AsyncIterableIterator<[string, unknown]>;
+}

package/database/server/db.ts

@@ -1,37 +1,17 @@
 // 文件路径: packages/database/server/db.ts
 
-import { Level } from "level";
-import path from "path";
-import fs from "fs";
 import { ensureDbOpen } from "./ensureDbOpen";
 import { resolveServerDbPath } from "./dbPath";
+import type { LegacyServerDb } from "./legacyServerDb";
+import type { AuthorityStore } from "./authorityStoreTypes";
+import { getOrCreateServerStoreRuntime } from "./serverStoreFactory";
 
 const DB_PATH = resolveServerDbPath();
 
-// 确保目录存在
-if (!fs.existsSync(path.dirname(DB_PATH))) {
-  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
-}
-
 console.log("数据库配置:");
 console.log("- 当前工作目录:", process.cwd());
 console.log("- 数据库路径:", DB_PATH);
 
-// 安全 JSON 编码：解码失败时返回 null 而非抛异常，防止损坏记录导致进程崩溃
-const safeJsonEncoding = {
-  name: "safe-json",
-  format: "utf8" as const,
-  encode: (data: any) => JSON.stringify(data),
-  decode: (data: string) => {
-    try {
-      return JSON.parse(data);
-    } catch {
-      console.warn("[LevelDB] Corrupted value:", data?.substring?.(0, 60));
-      return null;
-    }
-  },
-};
-
 export function isServerDbLockError(error: unknown): boolean {
   const queue: unknown[] = [error];
   const seen = new Set<unknown>();
@@ -55,13 +35,11 @@ export function isServerDbLockError(error: unknown): boolean {
   return false;
 }
 
-// 单例实例：挂在 globalThis 上，--hot 模式下模块重新求值时复用同一实例，避免 LevelDB 锁冲突
-if (!(globalThis as any).__serverDb) {
-  (globalThis as any).__serverDb = new Level<string, any>(DB_PATH, {
-    valueEncoding: safeJsonEncoding,
-  });
-}
-const serverDb: Level<string, any> = (globalThis as any).__serverDb;
+const {
+  authorityStore,
+  serverDb,
+}: { authorityStore: AuthorityStore; serverDb: LegacyServerDb } =
+  getOrCreateServerStoreRuntime(DB_PATH);
 
 console.log("- LevelDB实际路径:", serverDb.location);
 
@@ -70,6 +48,9 @@ export default serverDb;
 
 // 具名导出：需要的时候可以引用
 export { serverDb };
+export function getServerAuthorityStore() {
+  return authorityStore;
+}
 
 /**
  * 确保数据库处于 open 状态。
@@ -77,11 +58,11 @@ export { serverDb };
  * - 其他状态：尝试 open，一旦失败抛错
  */
 export async function ensureServerDbOpen() {
-  const status = (serverDb as any).status;
+  const status = authorityStore.status;
   if (status === "open") return;
 
   try {
-    await ensureDbOpen(serverDb);
+    await ensureDbOpen(authorityStore);
     if (status !== "opening") {
       console.log("✅ LevelDB 已打开");
     }
@@ -106,11 +87,11 @@ export async function openServerDb() {
  * 优雅关机时关闭 DB
  */
 export async function closeServerDb() {
-  const status = (serverDb as any).status;
+  const status = authorityStore.status;
   if (status !== "open") return;
 
   try {
-    await serverDb.close();
+    await authorityStore.close();
     console.log("✅ LevelDB 已关闭");
   } catch (err) {
     console.error("❌ 关闭 LevelDB 失败:", err);

package/database/server/legacyServerDb.ts

@@ -0,0 +1,58 @@
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+  AuthorityIteratorOptions,
+  AuthorityStore,
+} from "./authorityStoreTypes";
+
+export type LegacyServerDb = {
+  readonly location?: string;
+  readonly status?: string;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  get<T = any>(key: string): Promise<T>;
+  put(key: string, value: unknown): Promise<void>;
+  del(key: string): Promise<void>;
+  batch(ops: AuthorityBatchOperation[]): Promise<void>;
+  batch(): AuthorityBatchWriter;
+  iterator(
+    options?: AuthorityIteratorOptions
+  ): AsyncIterableIterator<[string, unknown]>;
+};
+
+export function createLegacyServerDb(store: AuthorityStore): LegacyServerDb {
+  const batch = (ops?: AuthorityBatchOperation[]) => {
+    if (Array.isArray(ops)) {
+      return store.batchWrite(ops);
+    }
+    return store.createBatch();
+  };
+
+  return {
+    get location() {
+      return store.location;
+    },
+    get status() {
+      return store.status;
+    },
+    async open() {
+      await store.open();
+    },
+    async close() {
+      await store.close();
+    },
+    async get<T = any>(key: string) {
+      return store.get<T>(key);
+    },
+    async put(key: string, value: unknown) {
+      await store.put(key, value);
+    },
+    async del(key: string) {
+      await store.del(key);
+    },
+    batch: batch as LegacyServerDb["batch"],
+    iterator(options: AuthorityIteratorOptions = {}) {
+      return store.iterator(options);
+    },
+  };
+}