nolo-cli 0.1.38 → 0.1.39

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,
@@ -40,19 +42,28 @@ 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";
+  NOLO_DEFAULT_AGENT_ID,
+  NOLO_DEFAULT_AGENT_KEY,
+} from "../agentAliases";
+import {
+  buildNoloWorkspaceCliToolExecutors,
+  buildNoloWorkspaceOpenAiTools,
+  filterNoloWorkspaceToolNames,
+  NOLO_WORKSPACE_TOOL_NAMES,
+  NOLO_WORKSPACE_TOOL_PROMPT,
+  parseNoloWorkspaceToolArguments,
+} from "../agent-runtime/noloWorkspaceTools";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
 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,9 +75,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> }>>;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
@@ -85,7 +94,7 @@ function resolveLocalUserId(env: EnvLike) {
 }
 
 function shellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+  return env.NOLO_LOCAL_SHELL_MODE === "worktree";
 }
 
 function parseLocalToolBudgets(env: EnvLike) {
@@ -246,6 +255,17 @@ function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown
   console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
 }
 
+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 buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
@@ -254,6 +274,7 @@ function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
       exposeShellTools: toolset.exposeShellTools,
     }),
     ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+    ...buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }),
   ];
 }
 
@@ -272,6 +293,7 @@ function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike })
       exposeShellTools: shellModeEnabled(args.env),
     }),
     ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
@@ -287,13 +309,44 @@ 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 withBuiltinNoloCliTools(agentConfig: AgentRuntimeAgentConfig | null) {
+  if (!agentConfig || !isBuiltinNoloAgentConfig(agentConfig)) return agentConfig;
+  const toolNames = [...new Set([...(agentConfig.toolNames ?? []), ...NOLO_WORKSPACE_TOOL_NAMES])];
+  return {
+    ...agentConfig,
+    toolNames,
+    prompt: [
+      agentConfig.prompt?.trim() ?? "",
+      NOLO_WORKSPACE_TOOL_PROMPT,
+    ].filter(Boolean).join("\n\n"),
+  };
 }
 
 function resolveRuntimeServerUrl(env: EnvLike) {
@@ -320,7 +373,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 +405,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 +486,25 @@ 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({
+      const agentConfig = withBuiltinNoloCliTools(await readAgentFromStore({
         agentRef,
         store: await resolveStore(deps),
         userId,
-      });
+      }));
       const requestedToolNames = agentConfig
         ? resolveRequestedRuntimeToolNames({ agentConfig })
         : [];
@@ -492,9 +515,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,7 +534,7 @@ export function createCliLocalRuntimeAdapter(
       userId,
       now,
       createId,
-      cwd: workspaceSession.workspaceRoot,
+      cwd: workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
@@ -558,6 +580,9 @@ export function createCliLocalRuntimeAdapter(
               model: providerConfig.model,
               messageCount: messages.length,
               toolCount: tools.length,
+              requestedToolNames,
+              openAiToolNames: summarizeOpenAiToolNames(tools),
+              shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
               timeoutMs: options?.timeoutMs ?? null,
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -627,6 +652,9 @@ export function createCliLocalRuntimeAdapter(
             model: providerConfig.model,
             messageCount: messages.length,
             toolCount: tools.length,
+            requestedToolNames,
+            openAiToolNames: summarizeOpenAiToolNames(tools),
+            shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
             timeoutMs: options?.timeoutMs ?? null,
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -672,8 +700,8 @@ export function createCliLocalRuntimeAdapter(
         ...result,
         metadata: {
           ...(result.metadata ?? {}),
-          workspaceRoot: workspaceSession.workspaceRoot,
-          workspaceKind: workspaceSession.kind,
+          workspaceRoot,
+          workspaceKind: "current",
         },
       };
     },

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);
+  }
+}

package/database/server/ensureDbOpen.ts

@@ -0,0 +1,12 @@
+export type DbWithOpenStatus = {
+  status?: string | null;
+  open(): Promise<unknown>;
+};
+
+export async function ensureDbOpen(db: DbWithOpenStatus) {
+  if (db.status === "open") {
+    return;
+  }
+
+  await db.open();
+}

package/database/server/memoryAuthorityStore.ts

@@ -0,0 +1,133 @@
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+  AuthorityIteratorOptions,
+  AuthorityStore,
+} from "./authorityStoreTypes";
+
+type MemoryEntry = {
+  key: string;
+  value: unknown;
+};
+
+const createNotFoundError = () => {
+  const error = new Error("NotFound") as Error & { notFound: true };
+  error.notFound = true;
+  return error;
+};
+
+class MemoryAuthorityBacking {
+  readonly location: string;
+  status: "closed" | "open" = "closed";
+  private readonly data = new Map<string, unknown>();
+
+  constructor(location: string) {
+    this.location = location;
+  }
+
+  async open() {
+    this.status = "open";
+  }
+
+  async close() {
+    this.status = "closed";
+  }
+
+  async get<T = any>(key: string): Promise<T> {
+    if (!this.data.has(key)) {
+      throw createNotFoundError();
+    }
+    return this.data.get(key) as T;
+  }
+
+  async put(key: string, value: unknown) {
+    this.data.set(key, value);
+  }
+
+  async del(key: string) {
+    this.data.delete(key);
+  }
+
+  async batchWrite(ops: AuthorityBatchOperation[]) {
+    for (const op of ops) {
+      if (op.type === "put") {
+        this.data.set(op.key, op.value);
+      } else {
+        this.data.delete(op.key);
+      }
+    }
+  }
+
+  createBatch(): AuthorityBatchWriter {
+    const buffered: AuthorityBatchOperation[] = [];
+    return {
+      put(key: string, value: unknown) {
+        buffered.push({ type: "put", key, value });
+      },
+      del(key: string) {
+        buffered.push({ type: "del", key });
+      },
+      write: async () => {
+        await this.batchWrite(buffered);
+      },
+    };
+  }
+
+  async *iterator(
+    options: AuthorityIteratorOptions = {}
+  ): AsyncIterableIterator<[string, unknown]> {
+    const entries: MemoryEntry[] = Array.from(this.data.entries())
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, value]) => ({ key, value }));
+
+    if (options.reverse) {
+      entries.reverse();
+    }
+
+    for (const entry of entries) {
+      if (options.gte && entry.key < options.gte) continue;
+      if (options.lte && entry.key > options.lte) continue;
+      if (options.lt && entry.key >= options.lt) continue;
+      yield [entry.key, entry.value];
+    }
+  }
+}
+
+export function createMemoryAuthorityStore(
+  location = ":memory:"
+): AuthorityStore {
+  const backing = new MemoryAuthorityBacking(location);
+
+  return {
+    get location() {
+      return backing.location;
+    },
+    get status() {
+      return backing.status;
+    },
+    async open() {
+      await backing.open();
+    },
+    async close() {
+      await backing.close();
+    },
+    async get<T = any>(key: string) {
+      return backing.get<T>(key);
+    },
+    async put(key: string, value: unknown) {
+      await backing.put(key, value);
+    },
+    async del(key: string) {
+      await backing.del(key);
+    },
+    async batchWrite(ops: AuthorityBatchOperation[]) {
+      await backing.batchWrite(ops);
+    },
+    createBatch() {
+      return backing.createBatch();
+    },
+    iterator(options: AuthorityIteratorOptions = {}) {
+      return backing.iterator(options);
+    },
+  };
+}

package/database/server/serverStoreFactory.ts

@@ -0,0 +1,118 @@
+import fs from "fs";
+import path from "path";
+import { Level } from "level";
+
+import type { AuthorityStore } from "./authorityStoreTypes";
+import { createLegacyServerDb, type LegacyServerDb } from "./legacyServerDb";
+import { createLevelAuthorityStore } from "./levelAuthorityStore";
+import { createMemoryAuthorityStore } from "./memoryAuthorityStore";
+
+export type ServerStoreDriver = "level" | "memory";
+
+export type ServerStoreFactoryEnv = {
+  NOLO_SERVER_AUTHORITY_DRIVER?: string | undefined;
+};
+
+export 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 type ServerStoreRuntime = {
+  authorityStore: AuthorityStore;
+  serverDb: LegacyServerDb;
+};
+
+export type ServerStoreFactoryOptions = {
+  driver?: ServerStoreDriver;
+  env?: ServerStoreFactoryEnv;
+  globalScope?: Record<string, unknown>;
+};
+
+export function ensureServerDbDirectory(dbPath: string) {
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function createLevelBackedAuthorityStore(dbPath: string): AuthorityStore {
+  const levelDb = new Level<string, any>(dbPath, {
+    valueEncoding: safeJsonEncoding,
+  });
+  return createLevelAuthorityStore(levelDb);
+}
+
+export function resolveServerStoreDriver(
+  env: ServerStoreFactoryEnv = process.env
+): ServerStoreDriver {
+  const rawDriver = env.NOLO_SERVER_AUTHORITY_DRIVER?.trim().toLowerCase();
+  if (!rawDriver) return "level";
+  if (rawDriver === "level") return "level";
+  if (rawDriver === "memory") return "memory";
+  throw new Error(`Unsupported server authority store driver: ${rawDriver}`);
+}
+
+export function createAuthorityStoreForDriver(
+  driver: ServerStoreDriver,
+  dbPath: string
+): AuthorityStore {
+  switch (driver) {
+    case "level":
+      return createLevelBackedAuthorityStore(dbPath);
+    case "memory":
+      return createMemoryAuthorityStore(dbPath);
+  }
+}
+
+export function getOrCreateServerStoreRuntime(
+  dbPath: string,
+  options: ServerStoreFactoryOptions = {}
+): ServerStoreRuntime {
+  const globalScope =
+    options.globalScope ?? (globalThis as Record<string, unknown>);
+  const driver = options.driver ?? resolveServerStoreDriver(options.env);
+  const cachedDriver = globalScope.__serverAuthorityStoreDriver;
+
+  ensureServerDbDirectory(dbPath);
+
+  if (
+    globalScope.__serverAuthorityStore &&
+    typeof cachedDriver === "string" &&
+    cachedDriver !== driver
+  ) {
+    throw new Error(
+      `Server authority store already initialized with driver ${cachedDriver}, cannot reuse it for ${driver}`
+    );
+  }
+
+  if (!globalScope.__serverAuthorityStore) {
+    globalScope.__serverAuthorityStore = createAuthorityStoreForDriver(
+      driver,
+      dbPath
+    );
+    globalScope.__serverAuthorityStoreDriver = driver;
+  } else if (!cachedDriver) {
+    globalScope.__serverAuthorityStoreDriver = driver;
+  }
+
+  const authorityStore = globalScope.__serverAuthorityStore as AuthorityStore;
+
+  if (!globalScope.__serverDb) {
+    globalScope.__serverDb = createLegacyServerDb(authorityStore);
+  }
+
+  return {
+    authorityStore,
+    serverDb: globalScope.__serverDb as LegacyServerDb,
+  };
+}