nolo-cli 0.1.33 → 0.1.34

package/database/server/levelAuthorityStore.ts

@@ -0,0 +1,75 @@
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+  AuthorityIteratorOptions,
+  AuthorityStore,
+} from "./authorityStoreTypes";
+
+type LevelBatchWriterLike = {
+  put(key: string, value: unknown): unknown;
+  del(key: string): unknown;
+  write(): Promise<void>;
+};
+
+type LevelLike = {
+  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(): LevelBatchWriterLike;
+  iterator(
+    options?: AuthorityIteratorOptions
+  ): AsyncIterableIterator<[string, unknown]>;
+};
+
+export function createLevelAuthorityStore(levelDb: LevelLike): AuthorityStore {
+  const createBatch = (): AuthorityBatchWriter => {
+    const batch = levelDb.batch();
+    return {
+      put(key: string, value: unknown) {
+        batch.put(key, value);
+      },
+      del(key: string) {
+        batch.del(key);
+      },
+      async write() {
+        await batch.write();
+      },
+    };
+  };
+
+  return {
+    get location() {
+      return levelDb.location;
+    },
+    get status() {
+      return levelDb.status;
+    },
+    async open() {
+      await levelDb.open?.();
+    },
+    async close() {
+      await levelDb.close?.();
+    },
+    async get<T = any>(key: string) {
+      return levelDb.get<T>(key);
+    },
+    async put(key: string, value: unknown) {
+      await levelDb.put(key, value);
+    },
+    async del(key: string) {
+      await levelDb.del(key);
+    },
+    async batchWrite(ops: AuthorityBatchOperation[]) {
+      await levelDb.batch(ops);
+    },
+    createBatch,
+    iterator(options: AuthorityIteratorOptions = {}) {
+      return levelDb.iterator(options);
+    },
+  };
+}

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

package/machineCommands.ts

@@ -95,7 +95,7 @@ function resolveConnectServerUrl(args: string[], env: EnvLike) {
 }
 
 function resolveConnectAuthToken(args: string[], env: EnvLike) {
-  return readOption(args, "--api-key") || readOption(args, "--token") || resolveAuthToken(env);
+  return readOption(args, "--machine-key") || readOption(args, "--token") || resolveAuthToken(env);
 }
 
 const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

package/machineWsRunDispatch.ts

@@ -148,6 +148,7 @@ function hasExplicitMachinePermissions(agentConfig: any) {
 
 function runtimeWorkspacePermissionPolicy(
   runtimePolicy: ConnectorRuntimePolicy | undefined,
+  runtimeEnv: EnvLike,
   cwd: string
 ): PermissionPolicy | null {
   if (!requestsTaskWorktree(runtimePolicy)) return null;
@@ -155,7 +156,10 @@ function runtimeWorkspacePermissionPolicy(
     mode: "full_access",
     allowFilesystemRead: true,
     allowFilesystemWrite: true,
-    allowShell: runtimePolicy?.shell?.enabled !== false,
+    allowShell:
+      ["worktree", "dangerous", "1", "true"].includes(runtimeEnv.NOLO_LOCAL_SHELL_MODE || "") &&
+      Array.isArray(runtimePolicy?.runtimeTools) &&
+      runtimePolicy.runtimeTools.includes("execShell"),
     writableRoots: [cwd],
   };
 }
@@ -445,7 +449,7 @@ export async function handleConnectorRunMessage(
         artifactCwd = prepared.path;
       }
       const runtimePermissionPolicy = !hasExplicitMachinePermissions(agentConfig)
-        ? runtimeWorkspacePermissionPolicy(runtimePolicy, cwd)
+        ? runtimeWorkspacePermissionPolicy(runtimePolicy, runtimeEnv, cwd)
         : null;
       const effectivePermissionPolicy = scopePermissionPolicyToRuntimeWorkspace(
         runtimePermissionPolicy ?? machinePermissionPolicy,
@@ -499,21 +503,37 @@ export async function handleConnectorRunMessage(
       const heartbeat = setInterval(() => {
         sendProgress({
           ...progressBase,
-          message: "cli-running",
+        message: "cli-running",
           updatedAt: Date.now(),
         });
       }, 15_000);
+      const effectiveRuntimeEnv = withForwardedUserAuthToken(runtimeEnv, parsed);
       const result = await executeCli(provider, materializedPrompt.prompt, {
         model: agentConfig.model || undefined,
         timeout,
         cwd,
         yolo: true,
         env: {
-          NOLO_SERVER: runtimeEnv.NOLO_SERVER || runtimeEnv.NOLO_SERVER_URL || runtimeEnv.BASE_URL,
-          NOLO_SERVER_URL: runtimeEnv.NOLO_SERVER_URL || runtimeEnv.NOLO_SERVER || runtimeEnv.BASE_URL,
-          BASE_URL: runtimeEnv.BASE_URL || runtimeEnv.NOLO_SERVER || runtimeEnv.NOLO_SERVER_URL,
-          AUTH_TOKEN: runtimeEnv.AUTH_TOKEN || runtimeEnv.AUTH || runtimeEnv.NOLO_MACHINE_API_KEY,
-          NOLO_MACHINE_API_KEY: runtimeEnv.NOLO_MACHINE_API_KEY || runtimeEnv.AUTH_TOKEN || runtimeEnv.AUTH,
+          NOLO_SERVER:
+            effectiveRuntimeEnv.NOLO_SERVER ||
+            effectiveRuntimeEnv.NOLO_SERVER_URL ||
+            effectiveRuntimeEnv.BASE_URL,
+          NOLO_SERVER_URL:
+            effectiveRuntimeEnv.NOLO_SERVER_URL ||
+            effectiveRuntimeEnv.NOLO_SERVER ||
+            effectiveRuntimeEnv.BASE_URL,
+          BASE_URL:
+            effectiveRuntimeEnv.BASE_URL ||
+            effectiveRuntimeEnv.NOLO_SERVER ||
+            effectiveRuntimeEnv.NOLO_SERVER_URL,
+          AUTH_TOKEN:
+            effectiveRuntimeEnv.AUTH_TOKEN ||
+            effectiveRuntimeEnv.AUTH ||
+            effectiveRuntimeEnv.NOLO_MACHINE_API_KEY,
+          NOLO_MACHINE_API_KEY:
+            effectiveRuntimeEnv.NOLO_MACHINE_API_KEY ||
+            effectiveRuntimeEnv.AUTH_TOKEN ||
+            effectiveRuntimeEnv.AUTH,
         },
       }).finally(() => clearInterval(heartbeat));
       logConnectorRun("agent.run.cli.result", {
@@ -555,7 +575,7 @@ export async function handleConnectorRunMessage(
     baseSha = await readConnectorGitHead(cwd);
     const result = await runConnectorLocalRuntimeAgent({
       parsed,
-      runtimeEnv,
+      runtimeEnv: withForwardedUserAuthToken(runtimeEnv, parsed),
       cwd,
       fetchImpl,
       onProgress: sendProgress,

package/offlineMarxistsAgentCommand.ts

@@ -28,7 +28,7 @@ type ParsedArgs = {
 
 const DEFAULT_USER_ID = "b2e06f801f";
 const DEFAULT_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
-const DEFAULT_SOURCE_AGENT_ID = "01MIMO25MONTH00000001PGT4X";
+const DEFAULT_SOURCE_AGENT_ID = "01MIMO25MONTH0000000NEW001";
 const DEFAULT_TARGET_AGENT_ID = "01OFFMARXBOOK000000010AHL1";
 const DEFAULT_AGENT_NAME = "离线马克思主义文库书籍转换助手";
 const TOOL_NAME = "convertMarxistsBookToOfflineHtml";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -104,8 +104,8 @@
     "cli/connectorWebSocketTarget.ts",
     "cli/agentAliases.ts",
     "cli/machineCommands.ts",
-    "cli/defaultServer.ts",
     "cli/client/localAgentRecords.ts",
+    "cli/defaultServer.ts",
     "cli/client/agentRun.ts",
     "cli/agentRuntimeLocal.ts",
     "cli/client/taskWorktree.ts",
@@ -153,6 +153,7 @@
     "agent-runtime/agentConfigOptions.ts",
     "agent-runtime/openAiCompatibleProvider.ts",
     "agent-runtime/openAiCompatibleProviderConfig.ts",
+    "agent-runtime/providerResolution.ts",
     "agent-runtime/platformChatProvider.ts",
     "agent-runtime/runtimeFacts.ts",
     "agent-runtime/agentRecordKeys.ts",
@@ -161,6 +162,7 @@
     "agent-runtime/dialogWritePlan.ts",
     "agent-runtime/hybridRecordStore.ts",
     "agent-runtime/localToolPolicy.ts",
+    "agent-runtime/shellCommandPolicy.ts",
     "agent-runtime/runtimeToolPolicy.ts",
     "connector-experimental/heartbeatLoop.ts",
     "connector-experimental/capabilities.ts",
@@ -169,10 +171,16 @@
     "database/server/db.ts",
     "database/config.ts",
     "database/server/ensureDbOpen.ts",
+    "database/server/legacyServerDb.ts",
+    "database/server/authorityStoreTypes.ts",
+    "database/server/serverStoreFactory.ts",
+    "database/server/levelAuthorityStore.ts",
+    "database/server/memoryAuthorityStore.ts",
     "ai/agent/cliExecutor.ts",
     "ai/skills/skillDocProtocol.ts",
     "ai/tools/agent/taskRunTool.ts",
     "ai/agent/cliPrompt.ts",
+    "ai/tools/toolNameAliases.ts",
     "render/table/activityColumns.ts"
   ],
   "publishConfig": {

package/runtimeDoctorCommands.ts

@@ -64,13 +64,13 @@ async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbe
 }
 
 export async function runDoctorRuntimeCommand(
-  _args: string[],
+  args: string[],
   deps: AgentCommandDeps = {}
 ) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
-  const authToken = resolveAuthToken(env);
-  const serverUrl = resolveServerUrl(env);
+  const authToken = resolveAuthToken(args, env);
+  const serverUrl = resolveServerUrl(args, env);
   const localProbe = await (deps.localRuntimeProbe ?? defaultLocalRuntimeProbe)(env);
   const hasLocalAgentConfig = detectLocalAgentConfig(env) && localProbe.ok && localProbe.agentFound;
   const hasLocalProvider = detectLocalProvider(env);
@@ -88,7 +88,13 @@ export async function runDoctorRuntimeCommand(
     hasLocalPersistence: true,
     missingLocalCapabilities,
     requiresServer: false,
-    serverFallbackAvailable: Boolean(authToken || env.NOLO_SERVER || env.BASE_URL),
+    serverFallbackAvailable: Boolean(
+      authToken ||
+      args.includes("--server") ||
+      args.includes("--server-url") ||
+      env.NOLO_SERVER ||
+      env.BASE_URL
+    ),
   });
 
   output.write(`Runtime: ${decision.mode}\n`);

package/tableCommands.ts

@@ -80,7 +80,7 @@ function resolveServerUrl(args: string[], env: EnvLike): string {
 
 function resolveAuthToken(args: string[], env: EnvLike): string {
   return (
-    readOption(args, "--api-key") ||
+    readOption(args, "--machine-key") ||
     readOption(args, "--token") ||
     env.AUTH_TOKEN ||
     env.AUTH ||

package/taskRunCommand.ts

@@ -82,7 +82,7 @@ function resolveServerUrl(args: string[], env: EnvLike) {
 
 function resolveAuthToken(args: string[], env: EnvLike) {
   return (
-    readOption(args, "--api-key") ||
+    readOption(args, "--machine-key") ||
     readOption(args, "--token") ||
     env.NOLO_TASK_RUN_TOKEN ||
     env.NOLO_MACHINE_API_KEY ||