nolo-cli 0.1.33 → 0.1.35

package/cli/globalRecordOperations.ts

@@ -0,0 +1,258 @@
+import {
+  deleteDbRecord,
+  queryUserRecords,
+  readDbRecord,
+} from "./agentRecordHelpers";
+import { isTombstoneRecord } from "../database/tombstones";
+import { mergeAndDedupUserData } from "../database/userDataMerge";
+
+export type GlobalRecordFailure = {
+  serverUrl: string;
+  error: string;
+};
+
+export type GlobalDeleteResult = {
+  serverUrl: string;
+  ok: boolean;
+  result?: any;
+  error?: string;
+};
+
+export type GlobalRecordTarget = {
+  serverUrl: string;
+  authToken?: string;
+};
+
+export type DbDeleteOptions = {
+  type?: "single" | "table" | "messages";
+};
+
+export async function listUserRecordsFromServers(args: {
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  limit?: number;
+  serverUrls: string[];
+  summary?: boolean;
+  type: string | string[];
+  userId: string;
+  label?: string;
+}) {
+  const remoteResults: Array<{ data: { data: any[] } }> = [];
+  const failures: GlobalRecordFailure[] = [];
+
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const records = await queryUserRecords({
+        authToken: args.authToken,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        limit: args.limit,
+        serverUrl,
+        summary: args.summary,
+        type: args.type,
+        userId: args.userId,
+      });
+      remoteResults.push({
+        data: {
+          data: records.map((record: any) => ({
+            ...record,
+            serverOrigin:
+              typeof record?.serverOrigin === "string" && record.serverOrigin.trim()
+                ? record.serverOrigin
+                : serverUrl,
+          })),
+        },
+      });
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  if (remoteResults.length === 0 && failures.length > 0) {
+    const label = args.label ?? "record query";
+    throw new Error(
+      `${label} failed on all candidate servers: ${failures
+        .map((failure) => `${failure.serverUrl}: ${failure.error}`)
+        .join("; ")}`
+    );
+  }
+
+  const merged = mergeAndDedupUserData([], remoteResults, { includeDeleted: true });
+  return {
+    records: merged.filter((record) => !isTombstoneRecord(record)),
+    failures,
+  };
+}
+
+export async function readDbRecordFromServers(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  includeDeleted?: boolean;
+  serverUrls: string[];
+  label?: string;
+}) {
+  const failures: GlobalRecordFailure[] = [];
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: args.includeDeleted,
+        serverUrl,
+      });
+      return { record, serverUrl, failures };
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  const label = args.label ?? `record ${args.dbKey}`;
+  throw new Error(
+    `${label} is unreadable on all candidate servers: ${failures
+      .map((failure) => `${failure.serverUrl}: ${failure.error}`)
+      .join("; ")}`
+  );
+}
+
+export async function readDbRecordVersionsFromServers(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}) {
+  const records: any[] = [];
+  const failures: GlobalRecordFailure[] = [];
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        serverUrl,
+      });
+      records.push({
+        ...record,
+        dbKey: typeof record?.dbKey === "string" && record.dbKey.trim()
+          ? record.dbKey
+          : args.dbKey,
+        serverOrigin:
+          typeof record?.serverOrigin === "string" && record.serverOrigin.trim()
+            ? record.serverOrigin
+            : serverUrl,
+      });
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  return { records, failures };
+}
+
+export async function readLiveDbRecordAfterTombstoneMerge(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+  label?: string;
+}) {
+  const result = await readDbRecordVersionsFromServers(args);
+  const merged = mergeAndDedupUserData(
+    [],
+    [{ data: { data: result.records } }],
+    { includeDeleted: true }
+  );
+  const record = merged.find((item) => item?.dbKey === args.dbKey);
+  if (record && !isTombstoneRecord(record)) {
+    return {
+      record,
+      serverUrl: typeof record.serverOrigin === "string" ? record.serverOrigin : "",
+      failures: result.failures,
+    };
+  }
+
+  const label = args.label ?? `record ${args.dbKey}`;
+  const failureText = result.failures.length
+    ? ` Failures: ${result.failures
+        .map((failure) => `${failure.serverUrl}: ${failure.error}`)
+        .join("; ")}`
+    : "";
+  throw new Error(`${label} is deleted or unreadable after global tombstone merge.${failureText}`);
+}
+
+export async function recordExistsAfterTombstoneMerge(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}) {
+  try {
+    await readLiveDbRecordAfterTombstoneMerge(args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function deleteDbRecordOnServers(args: {
+  authToken: string;
+  dbKey: string;
+  deleteOptions?: DbDeleteOptions;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}): Promise<GlobalDeleteResult[]> {
+  return deleteDbRecordOnTargets({
+    ...args,
+    targets: args.serverUrls.map((serverUrl) => ({ serverUrl })),
+  });
+}
+
+export async function deleteDbRecordOnTargets(args: {
+  authToken: string;
+  dbKey: string;
+  deleteOptions?: DbDeleteOptions;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  targets: GlobalRecordTarget[];
+}): Promise<GlobalDeleteResult[]> {
+  const results: GlobalDeleteResult[] = [];
+  for (const target of args.targets) {
+    try {
+      const result = await deleteDbRecord({
+        authToken: target.authToken ?? args.authToken,
+        dbKey: args.dbKey,
+        deleteOptions: args.deleteOptions,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl: target.serverUrl,
+      });
+      results.push({ serverUrl: target.serverUrl, ok: true, result });
+    } catch (error) {
+      results.push({
+        serverUrl: target.serverUrl,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  return results;
+}

package/cli/internalCommandEntries.ts

@@ -1,4 +1,5 @@
 import { getAgentInternalCommandEntries } from "./agentInternalCommandEntries";
+import { getDialogInternalCommandEntries } from "./dialogInternalCommandEntries";
 import type { CommandEntry } from "./cliCommandTypes";
 import { getSystemInternalCommandEntries } from "./systemInternalCommandEntries";
 import { getWorkflowInternalCommandEntries } from "./workflowInternalCommandEntries";
@@ -6,6 +7,7 @@ import { getWorkflowInternalCommandEntries } from "./workflowInternalCommandEntr
 export function getInternalCommandEntries(renderHelpText: () => string): CommandEntry[] {
   return [
     ...getAgentInternalCommandEntries(),
+    ...getDialogInternalCommandEntries(),
     ...getWorkflowInternalCommandEntries(),
     ...getSystemInternalCommandEntries(renderHelpText),
   ];

package/cli/localRuntimeAuthority.ts

@@ -0,0 +1,182 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  createCliAuthorityBrokerClient,
+  createCliAuthorityBrokerSocketInvoker,
+  isCliAuthorityBrokerUnavailableError,
+} from "../database/server/cliAuthorityBrokerClient";
+import type { CliAuthorityBrokerClientOptions } from "../database/server/cliAuthorityBrokerClient";
+import {
+  getOrCreateCliAuthorityBrokerServer,
+} from "../database/server/cliAuthorityBrokerServer";
+import type { CliAuthorityBrokerServerOptions } from "../database/server/cliAuthorityBrokerServer";
+import {
+  resolveCliAuthorityBrokerEndpoint,
+  resolveCliAuthorityBrokerHealthPath,
+  resolveCliAuthorityBrokerMetadataPath,
+} from "../database/server/cliAuthorityStoreDriver";
+import { resolveNoloHome } from "../database/server/dbPath";
+import type { AuthorityStore } from "../database/server/authorityStoreTypes";
+import { createLevelAuthorityStore } from "../database/server/levelAuthorityStore";
+import { createLegacyServerDb } from "../database/server/legacyServerDb";
+
+type EnvLike = Record<string, string | undefined>;
+
+type ResolveCliLocalRuntimeAuthorityOptions = {
+  env?: EnvLike;
+  homeDir?: string;
+};
+
+function ensureDbParentDir(dbPath: string) {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+}
+
+function isCliAuthorityLockError(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /LEVEL_LOCKED|Resource temporarily unavailable|\/LOCK|LOCK:|Database failed to open|EADDRINUSE|Failed to listen/i.test(message);
+}
+
+async function sleep(ms: number) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function resolveCliLocalRuntimeDbPath(options: ResolveCliLocalRuntimeAuthorityOptions = {}) {
+  return path.join(
+    resolveNoloHome({
+      env: options.env,
+      homeDir: options.homeDir,
+    }),
+    "data",
+    "leveldb"
+  );
+}
+
+type CliAuthorityBrokerConnectDeps = {
+  createClient: (options: CliAuthorityBrokerClientOptions) => AuthorityStore;
+  startBroker: (options: CliAuthorityBrokerServerOptions) => Promise<unknown>;
+  sleep: (ms: number) => Promise<void>;
+};
+
+const defaultCliAuthorityBrokerConnectDeps: CliAuthorityBrokerConnectDeps = {
+  createClient: (options) => createCliAuthorityBrokerClient(options),
+  startBroker: (options) => getOrCreateCliAuthorityBrokerServer(options),
+  sleep,
+};
+
+export async function connectCliAuthorityBroker(args: {
+  endpoint: string;
+  metadataPath: string;
+  healthPath: string;
+  dbPath: string;
+  deps?: Partial<CliAuthorityBrokerConnectDeps>;
+}) {
+  const deps: CliAuthorityBrokerConnectDeps = {
+    ...defaultCliAuthorityBrokerConnectDeps,
+    ...args.deps,
+  };
+  const client = deps.createClient({
+    endpoint: args.endpoint,
+    invoke: createCliAuthorityBrokerSocketInvoker({ endpoint: args.endpoint }),
+  });
+
+  async function attachToExistingBroker(attempts: number) {
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      await deps.sleep(100);
+      try {
+        await client.open();
+        return true;
+      } catch (error) {
+        if (!isCliAuthorityBrokerUnavailableError(error)) throw error;
+      }
+    }
+    return false;
+  }
+
+  try {
+    await deps.startBroker({
+      endpoint: args.endpoint,
+      metadataPath: args.metadataPath,
+      healthPath: args.healthPath,
+      createStore: () => createLevelAuthorityStore(args.dbPath),
+    });
+    await client.open();
+    return client;
+  } catch (error) {
+    if (!isCliAuthorityLockError(error)) throw error;
+
+    if (await attachToExistingBroker(5)) {
+      return client;
+    }
+
+    let lastError: unknown = error;
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      await deps.sleep(100);
+      try {
+        await deps.startBroker({
+          endpoint: args.endpoint,
+          metadataPath: args.metadataPath,
+          healthPath: args.healthPath,
+          createStore: () => createLevelAuthorityStore(args.dbPath),
+        });
+        await client.open();
+        return client;
+      } catch (retryError) {
+        lastError = retryError;
+        if (isCliAuthorityLockError(retryError)) {
+          if (await attachToExistingBroker(2)) {
+            return client;
+          }
+          continue;
+        }
+        if (isCliAuthorityBrokerUnavailableError(retryError)) {
+          continue;
+        }
+        throw retryError;
+      }
+    }
+    throw new Error(`CLI authority broker could not attach or take ownership for ${args.endpoint}`, {
+      cause: lastError,
+    });
+  }
+
+}
+
+export async function getDefaultCliLocalRuntimeAuthority(
+  options: ResolveCliLocalRuntimeAuthorityOptions = {}
+) {
+  const env = options.env ?? process.env;
+  const dbPath = resolveCliLocalRuntimeDbPath({
+    env,
+    homeDir: options.homeDir,
+  });
+  ensureDbParentDir(dbPath);
+  const endpoint = resolveCliAuthorityBrokerEndpoint({
+    transport: "tcp",
+    env,
+    homeDir: options.homeDir,
+  });
+  const metadataPath = resolveCliAuthorityBrokerMetadataPath({
+    transport: "tcp",
+    env,
+    homeDir: options.homeDir,
+  });
+  const healthPath = resolveCliAuthorityBrokerHealthPath({
+    transport: "tcp",
+    env,
+    homeDir: options.homeDir,
+  });
+  return connectCliAuthorityBroker({
+    endpoint,
+    metadataPath,
+    healthPath,
+    dbPath,
+  });
+}
+
+export async function getDefaultCliLocalRuntimeDb(
+  options: ResolveCliLocalRuntimeAuthorityOptions = {}
+) {
+  const authorityStore = await getDefaultCliLocalRuntimeAuthority(options);
+  return createLegacyServerDb(authorityStore);
+}

package/cli/localRuntimeDb.ts

@@ -21,8 +21,6 @@ export function buildCliLocalRuntimeDbEnv(env: EnvLike = process.env) {
 }
 
 export async function getDefaultCliLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
-  process.env.NOLO_SERVER_DB_PATH = buildCliLocalRuntimeDbEnv(process.env).NOLO_SERVER_DB_PATH;
-  const { default: serverDb, ensureServerDbOpen } = await import("../database/server/db");
-  await ensureServerDbOpen();
-  return serverDb as CliLocalRuntimeDb;
+  const { getDefaultCliLocalRuntimeDb: getAuthorityBackedDb } = await import("./localRuntimeAuthority");
+  return getAuthorityBackedDb();
 }

package/cli/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/cli/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],
   };
 }
@@ -193,9 +197,6 @@ function mergeToolNames(...values: unknown[]) {
 function localRuntimeEnvFromPolicy(runtimeEnv: EnvLike, policy?: ConnectorRuntimePolicy): EnvLike {
   return {
     ...runtimeEnv,
-    ...(policy?.shell?.enabled && policy.shell.mode === "worktree"
-      ? { NOLO_LOCAL_SHELL_MODE: "worktree" }
-      : {}),
     ...(policy?.workspace?.cwd ? { NOLO_LOCAL_WORKTREE: policy.workspace.cwd } : {}),
   };
 }
@@ -445,7 +446,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 +500,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 +572,7 @@ export async function handleConnectorRunMessage(
     baseSha = await readConnectorGitHead(cwd);
     const result = await runConnectorLocalRuntimeAgent({
       parsed,
-      runtimeEnv,
+      runtimeEnv: withForwardedUserAuthToken(runtimeEnv, parsed),
       cwd,
       fetchImpl,
       onProgress: sendProgress,

package/cli/machineWsSession.ts

@@ -119,6 +119,7 @@ export async function runMachineWsSession(options: {
   resolveConnectorWebSocketTarget: (args: {
     serverUrl: string;
     machineId: string;
+    connectorSurface?: string;
     headers: Record<string, string>;
   }) => Promise<string>;
   connectWebSocket: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
@@ -149,6 +150,7 @@ export async function runMachineWsSession(options: {
     const wsTarget = await options.resolveConnectorWebSocketTarget({
       serverUrl: options.serverUrl,
       machineId: options.machine.machineId,
+      connectorSurface: "cli",
       headers: { Authorization: `Bearer ${options.authToken}` },
     });
     websocketPromise = options.connectWebSocket(wsTarget, {

package/cli/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";