nolo-cli 0.1.34 → 0.1.36

package/dialogInternalCommandEntries.ts

@@ -0,0 +1,13 @@
+import type { CommandEntry } from "./cliCommandTypes";
+import { createEnvCommand } from "./cliCommandFactories";
+import {
+  runDialogDeleteCommand,
+  runDialogListCommand,
+} from "./dialogCommands";
+
+export function getDialogInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["dialog", "list"], "List dialogs", runDialogListCommand),
+    createEnvCommand(["dialog", "delete"], "Delete a dialog", runDialogDeleteCommand),
+  ];
+}

package/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/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/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/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/machineWsRunDispatch.ts

@@ -96,6 +96,37 @@ function logConnectorRun(message: string, fields: Record<string, unknown> = {})
   console.error(`[nolo-connector] ${message} ${JSON.stringify(fields)}`);
 }
 
+function summarizeEndpoint(value: unknown) {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  try {
+    const url = new URL(value);
+    return `${url.protocol}//${url.host}${url.pathname}`;
+  } catch {
+    return "invalid-url";
+  }
+}
+
+function summarizeAgentConfigForLogs(agentConfig: any) {
+  const runtimeBinding = isRecord(agentConfig?.runtimeBinding) ? agentConfig.runtimeBinding : {};
+  return {
+    apiSource: agentConfig?.apiSource ?? null,
+    provider: agentConfig?.provider ?? null,
+    cliProvider: agentConfig?.cliProvider ?? null,
+    model: agentConfig?.model ?? null,
+    customProviderEndpoint: summarizeEndpoint(agentConfig?.customProviderUrl) ?? null,
+    useServerProxy: agentConfig?.useServerProxy ?? null,
+    skipLocalRuntimeEnsure: agentConfig?.skipLocalRuntimeEnsure ?? null,
+    hasApiKey: typeof agentConfig?.apiKey === "string" && agentConfig.apiKey.length > 0,
+    apiKeyHeader: agentConfig?.apiKeyHeader ?? null,
+    hasApiKeyFromAgentKey:
+      typeof agentConfig?.apiKeyFromAgentKey === "string" &&
+      agentConfig.apiKeyFromAgentKey.length > 0,
+    runtimeBindingKind: runtimeBinding.kind ?? null,
+    runtimeMachineId: runtimeBinding.machineId ?? null,
+    connectorSurface: runtimeBinding.connectorSurface ?? runtimeBinding.surface ?? null,
+  };
+}
+
 function isRecord(value: unknown): value is Record<string, any> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -197,9 +228,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 } : {}),
   };
 }
@@ -572,6 +600,15 @@ export async function handleConnectorRunMessage(
     if (!requestsLocalWorkspaceRuntime(runtimePolicy) && !isMachineBoundLocalCustomProvider(agentConfig)) {
       throw new Error("Connector can only execute non-CLI agents when runtimeToolPolicySnapshot requests a local workspace runtime.");
     }
+    logConnectorRun("agent.run.local-runtime.start", {
+      requestId: parsed.requestId,
+      agentKey: parsed.payload?.agentKey,
+      cwd,
+      timeout,
+      machineBoundLocalCustomProvider: isMachineBoundLocalCustomProvider(agentConfig),
+      runtimePolicy: Boolean(runtimePolicy),
+      ...summarizeAgentConfigForLogs(agentConfig),
+    });
     baseSha = await readConnectorGitHead(cwd);
     const result = await runConnectorLocalRuntimeAgent({
       parsed,
@@ -610,6 +647,8 @@ export async function handleConnectorRunMessage(
     logConnectorRun("agent.run.error", {
       requestId: parsed.requestId,
       agentKey: parsed.payload?.agentKey,
+      ...summarizeAgentConfigForLogs(agentConfig),
+      errorName: error instanceof Error ? error.name : null,
       error: error instanceof Error ? error.message : String(error),
     });
     send(JSON.stringify({

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -27,11 +27,15 @@
     "cliCommandDispatch.ts",
     "cliCommandTypes.ts",
     "cliEnvHelpers.ts",
+    "cliSpaceHelpers.ts",
     "commandRegistry.ts",
     "connectorRunArtifact.ts",
     "connectorWebSocketTarget.ts",
     "defaultServer.ts",
     "agentInternalCommandEntries.ts",
+    "dialogCommands.ts",
+    "dialogInternalCommandEntries.ts",
+    "globalRecordOperations.ts",
     "internalCommandEntries.ts",
     "machineCommands.ts",
     "offlineMarxistsAgentCommand.ts",
@@ -86,6 +90,7 @@
     "machineWsSession.ts",
     "machineStatusCommands.ts",
     "machineWsPromptMaterialization.ts",
+    "localRuntimeAuthority.ts",
     "cli/commandRegistry.ts",
     "cli/client/profileConfig.ts",
     "cli/runtimeModeArgs.ts",
@@ -97,7 +102,10 @@
     "cli/agentCommandSupport.ts",
     "cli/agentListHelpers.ts",
     "cli/agentRecordHelpers.ts",
+    "cli/cliSpaceHelpers.ts",
+    "cli/globalRecordOperations.ts",
     "cli/client/localRuntimeAdapter.ts",
+    "cli/localRuntimeAuthority.ts",
     "cli/agentListCommands.ts",
     "cli/agentMachineCommands.ts",
     "cli/runtimeDoctorCommands.ts",
@@ -120,7 +128,9 @@
     "cli/agentRunCommand.ts",
     "cli/cliCommandFactories.ts",
     "cli/offlineMarxistsAgentCommand.ts",
+    "cli/dialogCommands.ts",
     "cli/agentInternalCommandEntries.ts",
+    "cli/dialogInternalCommandEntries.ts",
     "cli/systemInternalCommandEntries.ts",
     "cli/workflowInternalCommandEntries.ts",
     "cli/machineDaemonCommands.ts",
@@ -168,14 +178,16 @@
     "connector-experimental/capabilities.ts",
     "connector-experimental/codexBinary.ts",
     "database/server/dbPath.ts",
-    "database/server/db.ts",
     "database/config.ts",
-    "database/server/ensureDbOpen.ts",
-    "database/server/legacyServerDb.ts",
+    "database/tombstones.ts",
+    "database/userDataMerge.ts",
+    "database/server/cliAuthorityStoreDriver.ts",
+    "database/server/cliAuthorityBrokerClient.ts",
+    "database/server/cliAuthorityBrokerServer.ts",
     "database/server/authorityStoreTypes.ts",
-    "database/server/serverStoreFactory.ts",
     "database/server/levelAuthorityStore.ts",
-    "database/server/memoryAuthorityStore.ts",
+    "database/server/legacyServerDb.ts",
+    "database/server/cliAuthorityBrokerTypes.ts",
     "ai/agent/cliExecutor.ts",
     "ai/skills/skillDocProtocol.ts",
     "ai/tools/agent/taskRunTool.ts",