nolo-cli 0.1.34 → 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/machineWsRunDispatch.ts

@@ -197,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 } : {}),
   };
 }

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/runtimeDoctorCommands.ts

@@ -1,4 +1,10 @@
 import { resolveAgentRuntimeDecision } from "../agent-runtime/runtimeDecision";
+import {
+  resolveCliAuthorityBrokerEndpoint,
+  resolveCliAuthorityBrokerHealthPath,
+  resolveCliAuthorityBrokerMetadataPath,
+  resolveCliAuthorityStoreDriver,
+} from "../database/server/cliAuthorityStoreDriver";
 import {
   type AgentCommandDeps,
   type LocalRuntimeProbeResult,
@@ -39,23 +45,57 @@ function detectProviderLabel(env: EnvLike) {
 async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
   const { resolveCliLocalRuntimeDbPath } = await import("./localRuntimeDb");
   const dbPath = resolveCliLocalRuntimeDbPath({ env });
+  const authorityDriver = resolveCliAuthorityStoreDriver({ env });
+  const authorityEndpoint = resolveCliAuthorityBrokerEndpoint({ transport: "tcp", env });
+  const authorityMetadataPath = resolveCliAuthorityBrokerMetadataPath({ transport: "tcp", env });
+  const authorityHealthPath = resolveCliAuthorityBrokerHealthPath({ transport: "tcp", env });
   const agentKey = readLocalAgentKey(env);
   try {
     const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb");
-    const db = await getDefaultCliLocalRuntimeDb();
+    const db = await getDefaultCliLocalRuntimeDb({ env });
     if (!agentKey) {
-      return { ok: true, dbPath, agentFound: false };
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        agentFound: false,
+      };
     }
     try {
-      await db.get(agentKey);
-      return { ok: true, dbPath, agentFound: true, agentKey };
+      const record = await db.get(agentKey);
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        agentFound: record != null,
+        agentKey,
+      };
     } catch {
-      return { ok: true, dbPath, agentFound: false, agentKey };
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        agentFound: false,
+        agentKey,
+      };
     }
   } catch (error) {
     return {
       ok: false,
       dbPath,
+      authorityDriver,
+      authorityEndpoint,
+      authorityMetadataPath,
+      authorityHealthPath,
       agentFound: false,
       ...(agentKey ? { agentKey } : {}),
       error: error instanceof Error ? error.message : String(error),
@@ -101,6 +141,16 @@ export async function runDoctorRuntimeCommand(
   output.write(`Reason: ${decision.reason}\n`);
   output.write(`LevelDB: ${localProbe.ok ? "ok" : "failed"}\n`);
   output.write(`DB path: ${localProbe.dbPath}\n`);
+  output.write(`Authority driver: ${localProbe.authorityDriver ?? "unknown"}\n`);
+  if (localProbe.authorityEndpoint) {
+    output.write(`Authority endpoint: ${localProbe.authorityEndpoint}\n`);
+  }
+  if (localProbe.authorityMetadataPath) {
+    output.write(`Authority metadata: ${localProbe.authorityMetadataPath}\n`);
+  }
+  if (localProbe.authorityHealthPath) {
+    output.write(`Authority health: ${localProbe.authorityHealthPath}\n`);
+  }
   if (!localProbe.ok && localProbe.error) {
     output.write(`DB error: ${localProbe.error}\n`);
   }

package/cliSpaceHelpers.ts

@@ -0,0 +1,39 @@
+export function normalizeSpaceIdInput(rawInput: string) {
+  const raw = rawInput.trim();
+  if (!raw) return "";
+
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    const match = url.pathname.match(/^\/space\/([^/?#]+)/);
+    if (match?.[1]) return decodeURIComponent(match[1]);
+  }
+
+  return raw.startsWith("space-") ? raw.slice("space-".length) : raw;
+}
+
+export function buildSpaceLookup(rawInput: string) {
+  const spaceId = normalizeSpaceIdInput(rawInput);
+  return {
+    spaceId,
+    spaceKey: spaceId.startsWith("space-") ? spaceId : `space-${spaceId}`,
+  };
+}
+
+export function getSpaceContentKeys(spaceRecord: any): Set<string> {
+  const keys = new Set<string>();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+
+  for (const [entryKey, value] of Object.entries(contents)) {
+    if (typeof entryKey === "string" && entryKey.trim()) {
+      keys.add(entryKey.trim());
+    }
+    if (value && typeof value === "object") {
+      const contentKey = (value as any).contentKey;
+      if (typeof contentKey === "string" && contentKey.trim()) {
+        keys.add(contentKey.trim());
+      }
+    }
+  }
+  return keys;
+}

package/connectorWebSocketTarget.ts

@@ -49,14 +49,21 @@ function parseRetryAfterMs(response: Response, bodyRetryAfterMs?: unknown) {
 export async function resolveConnectorWebSocketTarget(input: {
   serverUrl: string;
   machineId: string;
+  connectorSurface?: string;
   headers: Record<string, string>;
   fetchImpl?: typeof fetch;
 }) {
   const directWsUrl = new URL(input.serverUrl);
   directWsUrl.protocol = directWsUrl.protocol === "https:" ? "wss:" : "ws:";
-  directWsUrl.pathname = "/api/connector/ws";
-  directWsUrl.search = "";
-  directWsUrl.searchParams.set("machineId", input.machineId);
+  directWsUrl.pathname = "/api/connector/ws";
+  directWsUrl.search = "";
+  directWsUrl.searchParams.set("machineId", input.machineId);
+  if (input.connectorSurface?.trim()) {
+    directWsUrl.searchParams.set(
+      "connectorSurface",
+      input.connectorSurface.trim().toLowerCase()
+    );
+  }
 
   const probeUrl = new URL(input.serverUrl);
   probeUrl.pathname = "/api/connector/ws";