nolo-cli 0.1.38 → 0.1.40

package/client/localRuntimeAdapter.ts

@@ -5,6 +5,8 @@ import type {
 } from "../agentRuntimeLocal";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   buildLocalWorkspacePolicyToolNames,
   buildLocalWorkspaceToolset,
@@ -19,6 +21,7 @@ import {
   resolveCurrentRunRuntimeToolPolicy,
   resolveLocalWorkspaceExecutorOptionsFromPolicy,
   resolveRequestedRuntimeToolNames,
+  resolveRuntimeToolSurfaceForAgent,
   shouldUsePlatformChatProvider,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../agent-runtime";
@@ -40,19 +43,41 @@ import {
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
 import { taskRunFunctionSchema } from "../ai/tools/agent/taskRunTool";
-import { prepareTaskWorktree } from "./taskWorktree";
 import {
-  activateWorkspaceSession,
-  createWorkspaceSession,
-  formatWorkspaceSessionActivation,
-  type WorkspaceSession,
-} from "./workspaceSession";
+  MIMO_MONTH_AGENT_KEY,
+  NOLO_DEFAULT_AGENT_ID,
+  NOLO_DEFAULT_AGENT_KEY,
+} from "../agentAliases";
+import {
+  buildNoloWorkspaceCliToolExecutors,
+  buildNoloWorkspaceOpenAiTools,
+  filterNoloWorkspaceToolNames,
+  parseNoloWorkspaceToolArguments,
+} from "../agent-runtime/noloWorkspaceTools";
+import { executeCli as defaultExecuteCli, type CliExecuteResult, type CliImageInput } from "../ai/agent/cliExecutor";
+import { buildCliPrompt } from "../ai/agent/cliPrompt";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
+type LocalCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    yolo?: boolean;
+    env?: Record<string, string | undefined>;
+    imageInputs?: CliImageInput[];
+  }
+) => Promise<CliExecuteResult>;
 const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
 const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
+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");
 
 export type CliLocalRuntimeDb = CliKvDb;
 
@@ -64,10 +89,9 @@ 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> }>>;
+  executeCli?: LocalCliExecutor;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
 };
@@ -84,10 +108,6 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
-function shellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
-}
-
 function parseLocalToolBudgets(env: EnvLike) {
   const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
   if (!raw) return {};
@@ -242,36 +262,128 @@ function parseJsonObject(raw: string) {
   }
 }
 
+function isCliProviderAgent(agentConfig: AgentRuntimeAgentConfig) {
+  return Boolean(
+    agentConfig.apiSource === "cli" ||
+      agentConfig.provider === "cli" ||
+      agentConfig.cliProvider
+  );
+}
+
+function resolveCliProviderName(agentConfig: AgentRuntimeAgentConfig) {
+  return (agentConfig.cliProvider || agentConfig.provider || "codex").trim() || "codex";
+}
+
+function stringifyRuntimeMessageContent(content: AgentRuntimeChatMessage["content"]) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "text" in part) {
+          return String((part as any).text ?? "");
+        }
+        return JSON.stringify(part);
+      })
+      .filter((part) => part.trim())
+      .join("\n");
+  }
+  return content == null ? "" : String(content);
+}
+
+function buildPromptForCliProvider(messages: AgentRuntimeChatMessage[]) {
+  const systemPrompt = messages
+    .filter((message) => message.role === "system")
+    .map((message) => stringifyRuntimeMessageContent(message.content).trim())
+    .filter(Boolean)
+    .join("\n\n");
+  const taskPrompt = messages
+    .filter((message) => message.role !== "system")
+    .map((message) => {
+      const content = stringifyRuntimeMessageContent(message.content).trim();
+      if (!content) return "";
+      return `[${message.role}]\n${content}`;
+    })
+    .filter(Boolean)
+    .join("\n\n");
+  return buildCliPrompt(systemPrompt, taskPrompt);
+}
+
+function collectCliProviderImageInputs(messages: AgentRuntimeChatMessage[]) {
+  const urls: string[] = [];
+  for (const message of messages) {
+    if (!Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (
+        part &&
+        typeof part === "object" &&
+        (part as any).type === "image_url" &&
+        typeof (part as any).image_url?.url === "string" &&
+        (part as any).image_url.url.trim()
+      ) {
+        urls.push((part as any).image_url.url.trim());
+      }
+    }
+  }
+  return urls;
+}
+
 function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown>) {
+  if (
+    process.env.NOLO_LOCAL_RUNTIME_DEBUG !== "1" &&
+    process.env.NOLO_DEBUG !== "1"
+  ) {
+    return;
+  }
   console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
 }
 
-function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
+function summarizeOpenAiToolNames(tools: Array<Record<string, unknown>>) {
+  return tools
+    .map((tool) => {
+      const fn = tool.function;
+      return fn && typeof fn === "object" && "name" in fn && typeof fn.name === "string"
+        ? fn.name
+        : null;
+    })
+    .filter((name): name is string => Boolean(name));
+}
+
+function shouldExposeLocalPlatformTools(agentKey?: string) {
+  return agentKey !== MIMO_MONTH_AGENT_KEY;
+}
+
+function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
+  const exposePlatformTools = shouldExposeLocalPlatformTools(args.agentKey);
   return [
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
     }),
-    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+    ...(exposePlatformTools ? buildServerPlatformOpenAiTools({ toolNames: args.toolNames }) : []),
+    ...(exposePlatformTools ? buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }) : []),
   ];
 }
 
 function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
+  void args.env;
   const toolset = buildLocalWorkspaceToolset({
     declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled(args.env),
+    exposeShellTools: true,
   });
   return toolset;
 }
 
 function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
+  void args.env;
   return [
     ...buildLocalWorkspacePolicyToolNames({
       declaredToolNames: args.toolNames,
-      exposeShellTools: shellModeEnabled(args.env),
+      exposeShellTools: true,
     }),
     ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
@@ -287,13 +399,60 @@ function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
   ];
 }
 
-function parseToolArguments(raw: string) {
-  try {
-    const parsed = JSON.parse(raw || "{}");
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
+function buildCliWorkspaceToolExecutors(args: {
+  env: EnvLike;
+  cliEntrypoint?: string;
+}) {
+  return buildNoloWorkspaceCliToolExecutors({
+    cliEntrypoint: args.cliEntrypoint ?? CLI_ENTRYPOINT,
+    env: args.env,
+    metadataKind: "cliWorkspaceTool",
+  });
+}
+
+export function isBuiltinNoloAgentRef(ref: unknown) {
+  if (typeof ref !== "string") return false;
+  const normalized = ref.trim();
+  return (
+    normalized === BUILTIN_NOLO_AGENT_KEY ||
+    normalized === BUILTIN_NOLO_AGENT_ID ||
+    normalized.endsWith(`-${BUILTIN_NOLO_AGENT_ID}`)
+  );
+}
+
+function isBuiltinNoloAgentConfig(agentConfig: AgentRuntimeAgentConfig | null | undefined) {
+  const key = agentConfig?.key || agentConfig?.rawRecord?.dbKey || agentConfig?.rawRecord?.agentKey;
+  const id = agentConfig?.rawRecord?.id;
+  return isBuiltinNoloAgentRef(key) || isBuiltinNoloAgentRef(id);
+}
+
+function withResolvedRuntimeToolSurface(
+  agentConfig: AgentRuntimeAgentConfig | null,
+  env: EnvLike
+) {
+  if (!agentConfig) return agentConfig;
+  const currentUserId = resolveLocalUserId(env);
+  const rawRecord = (agentConfig as any).rawRecord ?? {};
+  const ownerId =
+    typeof rawRecord.userId === "string" && rawRecord.userId.trim()
+      ? rawRecord.userId.trim()
+      : null;
+  const toolSurface = resolveRuntimeToolSurfaceForAgent({
+    explicitToolNames: agentConfig.toolNames,
+    currentUserId,
+    agentOwnerId: ownerId,
+    agentKey: rawRecord.dbKey ?? agentConfig.key,
+    isPublic: !isBuiltinNoloAgentConfig(agentConfig) && rawRecord.isPublic === true,
+    sharingLevel: typeof rawRecord.sharingLevel === "string" ? rawRecord.sharingLevel : null,
+    trustedPrivateInvocation: isBuiltinNoloAgentConfig(agentConfig),
+    runtimeHost: "cli",
+  });
+  return {
+    ...agentConfig,
+    toolNames: toolSurface.finalToolNames,
+    toolSurface,
+    prompt: agentConfig.prompt,
+  };
 }
 
 function resolveRuntimeServerUrl(env: EnvLike) {
@@ -320,7 +479,7 @@ function buildServerPlatformToolExecutors(args: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${authToken}`,
         },
-        body: JSON.stringify(parseToolArguments(call.arguments)),
+        body: JSON.stringify(parseNoloWorkspaceToolArguments(call.arguments)),
       });
       const text = await response.text().catch(() => "");
       if (!response.ok) {
@@ -352,17 +511,13 @@ function buildLocalToolExecutors(args: {
       env: args.env,
       fetchImpl: args.fetchImpl,
     }),
+    ...buildCliWorkspaceToolExecutors({
+      env: args.env,
+    }),
     ...(args.localToolExecutors ?? {}),
   };
 }
 
-function readLocalWorkspaceMode(agentConfig: AgentRuntimeAgentConfig | null) {
-  if (agentConfig?.localWorkspaceMode === "task-worktree") return "task-worktree";
-  const runtimeBinding = agentConfig?.runtimeBinding;
-  const value = runtimeBinding?.localWorkspaceMode ?? runtimeBinding?.workspaceMode;
-  return value === "task-worktree" ? "task-worktree" : "current";
-}
-
 async function resolveStore(deps: CliLocalRuntimeAdapterDeps) {
   if (deps.store) return deps.store;
   return createCliHybridRecordStore({
@@ -437,51 +592,28 @@ export function createCliLocalRuntimeAdapter(
   const localToolBudgets = parseLocalToolBudgets(deps.env);
   const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
-  let workspaceSession: WorkspaceSession = createWorkspaceSession(
-    deps.useCwdAsTaskWorkspaceBase
-      ? { defaultCwd: deps.cwd }
-      : { cwd: deps.cwd }
-  );
+  const workspaceRoot = deps.cwd ?? process.cwd();
   let runtimeToolExecutionLimits: ReturnType<typeof resolveLocalWorkspaceExecutorOptionsFromPolicy> = {};
   let localToolExecutors = buildLocalToolExecutors({
-    workspaceRoot: workspaceSession.workspaceRoot,
+    workspaceRoot,
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
     ...runtimeToolExecutionLimits,
   });
 
-  async function activateAgentWorkspaceSession(args: {
-    agentRef: string;
-    agentConfig: AgentRuntimeAgentConfig | null;
-  }) {
-    const previousWorkspaceRoot = workspaceSession.workspaceRoot;
-    workspaceSession = await activateWorkspaceSession(workspaceSession, {
-      agentKey: args.agentConfig?.key ?? args.agentRef,
-      mode: readLocalWorkspaceMode(args.agentConfig),
-      env: deps.env,
-      prepareTaskWorkspace: deps.prepareTaskWorktree,
-    });
-    if (workspaceSession.workspaceRoot === previousWorkspaceRoot) return;
-    localToolExecutors = buildLocalToolExecutors({
-      workspaceRoot: workspaceSession.workspaceRoot,
-      env: deps.env,
-      fetchImpl,
-      localToolExecutors: deps.localToolExecutors,
-      ...runtimeToolExecutionLimits,
-    });
-    deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));
-  }
-
   return {
     host: "cli",
     capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
-      const agentConfig = await readAgentFromStore({
-        agentRef,
-        store: await resolveStore(deps),
-        userId,
-      });
+      const agentConfig = withResolvedRuntimeToolSurface(
+        await readAgentFromStore({
+          agentRef,
+          store: await resolveStore(deps),
+          userId,
+        }),
+        deps.env
+      );
       const requestedToolNames = agentConfig
         ? resolveRequestedRuntimeToolNames({ agentConfig })
         : [];
@@ -492,9 +624,8 @@ export function createCliLocalRuntimeAdapter(
       runtimeToolExecutionLimits = resolveLocalWorkspaceExecutorOptionsFromPolicy(
         resolveCurrentRunRuntimeToolPolicy(agentConfig),
       );
-      await activateAgentWorkspaceSession({ agentRef, agentConfig });
       localToolExecutors = buildLocalToolExecutors({
-        workspaceRoot: workspaceSession.workspaceRoot,
+        workspaceRoot,
         env: deps.env,
         fetchImpl,
         localToolExecutors: deps.localToolExecutors,
@@ -512,9 +643,53 @@ export function createCliLocalRuntimeAdapter(
       userId,
       now,
       createId,
-      cwd: workspaceSession.workspaceRoot,
+      cwd: workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
+      if (isCliProviderAgent(agentConfig)) {
+        const provider = resolveCliProviderName(agentConfig);
+        logLocalRuntimeDiagnostic("provider.selected", {
+          agentKey: agentConfig.key,
+          transport: "local-cli",
+          apiSource: agentConfig.apiSource ?? null,
+          provider,
+          model: agentConfig.model ?? null,
+          cwd: workspaceRoot,
+        });
+        return {
+          model: agentConfig.model || provider,
+          complete: async (messages, options) => {
+            const executeCli = deps.executeCli ?? (defaultExecuteCli as LocalCliExecutor);
+            const imageUrls = collectCliProviderImageInputs(messages);
+            const imageInputs: CliImageInput[] | undefined =
+              imageUrls.length > 0
+                ? imageUrls.map((url) => ({ source: url }))
+                : undefined;
+            const prompt = buildPromptForCliProvider(messages);
+            try {
+              const result = await executeCli(provider, prompt, {
+                ...(agentConfig.model ? { model: agentConfig.model } : {}),
+                ...(options?.timeoutMs ? { timeout: options.timeoutMs } : {}),
+                cwd: workspaceRoot,
+                yolo: true,
+                env: deps.env,
+                ...(imageInputs ? { imageInputs } : {}),
+              });
+              return {
+                content: result.text,
+                model: agentConfig.model || provider,
+                raw: result.raw,
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              throw new Error(
+                `Local CLI provider "${provider}" is unavailable or failed: ${message}`
+              );
+            }
+          },
+        };
+      }
+
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
         const providerConfig = resolvePlatformChatProviderConfig({
           agentConfig,
@@ -541,6 +716,7 @@ export function createCliLocalRuntimeAdapter(
               agentConfig,
             });
             const tools = buildOpenAiTools({
+              agentKey: agentConfig.key,
               toolNames: requestedToolNames,
               env: deps.env,
             });
@@ -558,6 +734,8 @@ export function createCliLocalRuntimeAdapter(
               model: providerConfig.model,
               messageCount: messages.length,
               toolCount: tools.length,
+              requestedToolNames,
+              openAiToolNames: summarizeOpenAiToolNames(tools),
               timeoutMs: options?.timeoutMs ?? null,
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -611,6 +789,7 @@ export function createCliLocalRuntimeAdapter(
             agentConfig,
           });
           const tools = buildOpenAiTools({
+            agentKey: agentConfig.key,
             toolNames: requestedToolNames,
             env: deps.env,
           });
@@ -627,6 +806,8 @@ export function createCliLocalRuntimeAdapter(
             model: providerConfig.model,
             messageCount: messages.length,
             toolCount: tools.length,
+            requestedToolNames,
+            openAiToolNames: summarizeOpenAiToolNames(tools),
             timeoutMs: options?.timeoutMs ?? null,
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -672,8 +853,8 @@ export function createCliLocalRuntimeAdapter(
         ...result,
         metadata: {
           ...(result.metadata ?? {}),
-          workspaceRoot: workspaceSession.workspaceRoot,
-          workspaceKind: workspaceSession.kind,
+          workspaceRoot,
+          workspaceKind: "current",
         },
       };
     },

package/client/localRuntimeDryRun.test.ts

@@ -7,6 +7,26 @@ import { runLocalAgentTurn } from "../agent-runtime/localLoop";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime dry run", () => {
+  const DEFAULT_PRIVATE_LOCAL_TOOL_NAMES = [
+    "listFiles",
+    "readFile",
+    "writeFile",
+    "editFile",
+    "searchFiles",
+    "execShell",
+    "listDialogs",
+    "readDialog",
+    "listAgents",
+    "readAgent",
+    "listSpaces",
+    "readSpace",
+    "readDoc",
+    "readSkillDoc",
+    "queryTableRows",
+    "cliWhoami",
+    "cliDoctor",
+  ];
+
   test("lets a declared workspace file tool write a file and save the tool trace", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-local-runtime-dry-run-"));
     try {
@@ -18,7 +38,7 @@ describe("CLI local runtime dry run", () => {
           prompt: "Use workspace file tools to edit files.",
           model: "qwen-coder",
           tools: [
-            { type: "function", function: { name: "writeWorkspaceFile" } },
+            { type: "function", function: { name: "writeFile" } },
           ],
         }],
       ]);
@@ -52,13 +72,7 @@ describe("CLI local runtime dry run", () => {
           const body = JSON.parse(String(init?.body));
           completeCount += 1;
           if (completeCount === 1) {
-            expect(body.tools.map((tool: any) => tool.function.name)).toEqual([
-              "writeWorkspaceFile",
-              "listFiles",
-              "readFile",
-              "editFile",
-              "searchFiles",
-            ]);
+            expect(body.tools.map((tool: any) => tool.function.name)).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
             return Response.json({
               model: "qwen-coder",
               choices: [{
@@ -68,7 +82,7 @@ describe("CLI local runtime dry run", () => {
                     id: "call-1",
                     type: "function",
                     function: {
-                      name: "writeWorkspaceFile",
+                      name: "writeFile",
                       arguments: JSON.stringify({
                         path: "src/notification.css",
                         content: ".notification { border-radius: 8px; }\n",

package/client/localToolPolicy.test.ts

@@ -3,20 +3,20 @@ import { describe, expect, test } from "bun:test";
 import { executeLocalToolWithPolicy, resolveLocalToolPolicy } from "./localToolPolicy";
 
 describe("CLI local tool policy", () => {
-  test("allows execShell in explicit worktree shell mode", () => {
+  test("allows execShell by default", () => {
     expect(resolveLocalToolPolicy({
-      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      env: {},
       agentToolNames: [],
       toolName: "execShell",
     })).toEqual({ allowed: true, toolName: "execShell" });
   });
 
-  test("blocks execShell unless explicit shell mode is enabled", () => {
+  test("allows execShell even without env allowlist", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "execShell" },
       agentToolNames: ["execShell"],
       toolName: "execShell",
-    })).toMatchObject({ allowed: false });
+    })).toEqual({ allowed: true, toolName: "execShell" });
   });
 
   test("requires both env allowlist and agent declaration", () => {

package/commandRegistry.ts

@@ -69,8 +69,8 @@ export function renderHelpText() {
     "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
     "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
     "  nolo table query --table 01ABCXYZ",
-    '  nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
-    '  nolo table update-row --table meta-b2e06f801f-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
+    '  nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
+    '  nolo table update-row --table meta-0e95801d90-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
     "  nolo task-run read-context --row-dbkey row-user-table-row",
     "  nolo llama status",
   ];

package/connectorRunArtifact.ts

@@ -32,7 +32,6 @@ export function resolveConnectorRunCwd(args: {
   const explicit =
     args.env?.NOLO_CONNECTOR_WORKDIR ||
     args.env?.NOLO_AGENT_WORKDIR ||
-    args.env?.NOLO_LOCAL_WORKTREE ||
     "";
   const candidate = explicit || args.policy.writableRoots[0] || args.fallbackCwd || process.cwd();
   const cwd = normalizePath(candidate);

package/database/server/db.ts

@@ -0,0 +1,99 @@
+// 文件路径: packages/database/server/db.ts
+
+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();
+
+console.log("数据库配置:");
+console.log("- 当前工作目录:", process.cwd());
+console.log("- 数据库路径:", DB_PATH);
+
+export function isServerDbLockError(error: unknown): boolean {
+  const queue: unknown[] = [error];
+  const seen = new Set<unknown>();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || seen.has(current)) continue;
+    seen.add(current);
+
+    const text = `${(current as any)?.code ?? ""} ${(current as any)?.message ?? current}`;
+    if (/LEVEL_LOCKED|Resource temporarily unavailable|\/LOCK|LOCK:/.test(text)) {
+      return true;
+    }
+
+    if ((current as any)?.cause) queue.push((current as any).cause);
+    if (Array.isArray((current as any)?.errors)) {
+      queue.push(...(current as any).errors);
+    }
+  }
+
+  return false;
+}
+
+const {
+  authorityStore,
+  serverDb,
+}: { authorityStore: AuthorityStore; serverDb: LegacyServerDb } =
+  getOrCreateServerStoreRuntime(DB_PATH);
+
+console.log("- LevelDB实际路径:", serverDb.location);
+
+// ✅ 保留默认导出：兼容现有的 import serverDb from "./db"
+export default serverDb;
+
+// 具名导出：需要的时候可以引用
+export { serverDb };
+export function getServerAuthorityStore() {
+  return authorityStore;
+}
+
+/**
+ * 确保数据库处于 open 状态。
+ * - 已 open / opening：直接返回
+ * - 其他状态：尝试 open，一旦失败抛错
+ */
+export async function ensureServerDbOpen() {
+  const status = authorityStore.status;
+  if (status === "open") return;
+
+  try {
+    await ensureDbOpen(authorityStore);
+    if (status !== "opening") {
+      console.log("✅ LevelDB 已打开");
+    }
+  } catch (err) {
+    if (isServerDbLockError(err)) {
+      console.error("❌ 打开 LevelDB 失败: 数据库已被其他进程占用");
+    } else {
+      console.error("❌ 打开 LevelDB 失败:", err);
+    }
+    throw err;
+  }
+}
+
+/**
+ * 兼容入口调用：启动时显式 open 一次
+ */
+export async function openServerDb() {
+  return ensureServerDbOpen();
+}
+
+/**
+ * 优雅关机时关闭 DB
+ */
+export async function closeServerDb() {
+  const status = authorityStore.status;
+  if (status !== "open") return;
+
+  try {
+    await authorityStore.close();
+    console.log("✅ LevelDB 已关闭");
+  } catch (err) {
+    console.error("❌ 关闭 LevelDB 失败:", err);
+  }
+}