nolo-cli 0.1.34 → 0.1.36

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

@@ -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/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/client/localRuntimeAdapter.ts

@@ -221,6 +221,29 @@ function buildRequestTimeoutSignal(timeoutMs?: number) {
   return controller.signal;
 }
 
+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 parseJsonObject(raw: string) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown>) {
+  console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
+}
+
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
@@ -476,6 +499,20 @@ export function createCliLocalRuntimeAdapter(
           agentConfig,
           env: deps.env,
         });
+        logLocalRuntimeDiagnostic("provider.selected", {
+          agentKey: agentConfig.key,
+          transport: "platform-proxy",
+          apiSource: agentConfig.apiSource ?? null,
+          provider: providerConfig.provider,
+          model: providerConfig.model,
+          endpoint: summarizeEndpoint(providerConfig.endpoint) ?? null,
+          proxyServer: summarizeEndpoint(providerConfig.serverUrl) ?? null,
+          hasAuthToken: Boolean(providerConfig.authToken),
+          hasApiKey: Boolean(providerConfig.apiKey),
+          apiKeyHeader: providerConfig.apiKeyHeader ?? null,
+          useServerProxy: agentConfig.useServerProxy ?? null,
+          customProviderEndpoint: summarizeEndpoint(agentConfig.customProviderUrl) ?? null,
+        });
         return {
           model: providerConfig.model,
           complete: async (messages, options) => {
@@ -492,6 +529,16 @@ export function createCliLocalRuntimeAdapter(
               tools,
             });
             const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            logLocalRuntimeDiagnostic("provider.request.start", {
+              agentKey: agentConfig.key,
+              transport: "platform-proxy",
+              requestUrl: summarizeEndpoint(request.url) ?? null,
+              endpoint: summarizeEndpoint(providerConfig.endpoint) ?? null,
+              model: providerConfig.model,
+              messageCount: messages.length,
+              toolCount: tools.length,
+              timeoutMs: options?.timeoutMs ?? null,
+            });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
               ...request.init,
               ...(signal ? { signal } : {}),
@@ -499,7 +546,15 @@ export function createCliLocalRuntimeAdapter(
               sleep: deps.sleep,
               loopbackRequest,
             });
-            const data = parsePlatformChatCompletionData(await res.text().catch(() => ""));
+            const raw = await res.text().catch(() => "");
+            logLocalRuntimeDiagnostic("provider.request.result", {
+              agentKey: agentConfig.key,
+              transport: "platform-proxy",
+              status: res.status,
+              ok: res.ok,
+              responseBytes: raw.length,
+            });
+            const data = parsePlatformChatCompletionData(raw);
             if (!res.ok) {
               throw new Error(`platform provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
             }
@@ -516,6 +571,18 @@ export function createCliLocalRuntimeAdapter(
         agentConfig,
         env: deps.env,
       });
+      logLocalRuntimeDiagnostic("provider.selected", {
+        agentKey: agentConfig.key,
+        transport: "direct-openai-compatible",
+        apiSource: agentConfig.apiSource ?? null,
+        provider: providerConfig.provider,
+        model: providerConfig.model,
+        endpoint: summarizeEndpoint(providerConfig.endpoint) ?? null,
+        hasApiKey: Boolean(providerConfig.apiKey),
+        apiKeyHeader: providerConfig.apiKeyHeader ?? null,
+        useServerProxy: agentConfig.useServerProxy ?? null,
+        customProviderEndpoint: summarizeEndpoint(agentConfig.customProviderUrl) ?? null,
+      });
       return {
         model: providerConfig.model,
         complete: async (messages, options) => {
@@ -532,6 +599,15 @@ export function createCliLocalRuntimeAdapter(
             tools,
           });
           const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          logLocalRuntimeDiagnostic("provider.request.start", {
+            agentKey: agentConfig.key,
+            transport: "direct-openai-compatible",
+            requestUrl: summarizeEndpoint(request.url) ?? null,
+            model: providerConfig.model,
+            messageCount: messages.length,
+            toolCount: tools.length,
+            timeoutMs: options?.timeoutMs ?? null,
+          });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
             ...request.init,
             ...(signal ? { signal } : {}),
@@ -539,7 +615,15 @@ export function createCliLocalRuntimeAdapter(
             sleep: deps.sleep,
             loopbackRequest,
           });
-          const data = await res.json().catch(() => ({}));
+          const raw = await res.text().catch(() => "");
+          logLocalRuntimeDiagnostic("provider.request.result", {
+            agentKey: agentConfig.key,
+            transport: "direct-openai-compatible",
+            status: res.status,
+            ok: res.ok,
+            responseBytes: raw.length,
+          });
+          const data = parseJsonObject(raw);
           if (!res.ok) {
             throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
           }

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";