nolo-cli 0.1.34 → 0.1.36

package/cli/agentListCommands.ts

@@ -1,6 +1,8 @@
 import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
 import {
+  decorateAgentsWithPublicStatusAcrossServers,
   listLocalCachedAgents,
+  listRemoteAgentsAcrossServers,
   listRemoteAgents,
   parseAgentListArgs,
   type ListedAgent,
@@ -9,11 +11,15 @@ import {
   queryUserRecords,
   readDbRecord,
 } from "./agentRecordHelpers";
+import { buildSpaceLookup, getSpaceContentKeys } from "./cliSpaceHelpers";
 import {
   parseUserIdFromAuthToken,
+  readOption,
   resolveAuthToken,
+  resolveServerCandidates,
   resolveServerUrl,
 } from "./cliEnvHelpers";
+import { readLiveDbRecordAfterTombstoneMerge } from "./globalRecordOperations";
 
 export async function runAgentListCommand(
   args: string[],
@@ -22,6 +28,7 @@ export async function runAgentListCommand(
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
   const { wantJson, publicOnly, idsOnly, includeLegacy } = parseAgentListArgs(args);
+  const spaceInput = readOption(args, "--space") ?? readOption(args, "--space-id");
 
   const authToken = resolveAuthToken(args, env);
   if (!authToken) {
@@ -35,34 +42,79 @@ export async function runAgentListCommand(
     return 1;
   }
 
-  const db = deps.db ?? await getReadableCliDb(output);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const serverUrl = resolveServerUrl(args, env);
+  const serverUrls = resolveServerCandidates(args, env, serverUrl);
 
   try {
     let agents: ListedAgent[];
-    let source: "local-cache" | "remote-cache";
+    let source: "local-cache" | "remote-cache" | "global-cache";
+    let serverFailures: Array<{ serverUrl: string; error: string }> = [];
     try {
-      agents = await listLocalCachedAgents({ db, userId });
-      source = "local-cache";
-    } catch {
-      const serverUrl = resolveServerUrl(args, env);
-      agents = await listRemoteAgents({
+      const remoteResult = await listRemoteAgentsAcrossServers({
         authToken,
         fallbackFetchImpl,
         fetchImpl,
         includeLegacy,
-        serverUrl,
+        serverUrls,
         userId,
-        queryUserRecords,
-        readDbRecord,
       });
-      source = "remote-cache";
+      agents = remoteResult.agents;
+      serverFailures = remoteResult.failures;
+      source = "global-cache";
+    } catch {
+      try {
+        const db = deps.db ?? await getReadableCliDb(output);
+        agents = await listLocalCachedAgents({ db, userId });
+        source = "local-cache";
+      } catch {
+        agents = await listRemoteAgents({
+          authToken,
+          fallbackFetchImpl,
+          fetchImpl,
+          includeLegacy,
+          serverUrl,
+          userId,
+          queryUserRecords,
+          readDbRecord,
+        });
+        source = "remote-cache";
+      }
     }
 
     if (!includeLegacy) {
       agents = agents.filter((agent) => !agent.privateKey.startsWith("cybot-"));
     }
+    let resolvedSpaceId: string | null = null;
+    if (spaceInput) {
+      const { spaceId, spaceKey } = buildSpaceLookup(spaceInput);
+      resolvedSpaceId = spaceId;
+      const spaceRead = await readLiveDbRecordAfterTombstoneMerge({
+        authToken,
+        dbKey: spaceKey,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls,
+      });
+      serverFailures = [...serverFailures, ...spaceRead.failures];
+      const spaceRecord = spaceRead.record;
+      const spaceContentKeys = getSpaceContentKeys(spaceRecord);
+      agents = agents.filter((agent) =>
+        spaceContentKeys.has(agent.privateKey) ||
+        spaceContentKeys.has(agent.publicKey) ||
+        spaceContentKeys.has(agent.id)
+      );
+    }
+    if (source === "global-cache") {
+      await decorateAgentsWithPublicStatusAcrossServers({
+        agents,
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls,
+      });
+    }
     if (publicOnly) {
       agents = agents.filter((agent) => agent.publicRecordExists);
     }
@@ -75,6 +127,9 @@ export async function runAgentListCommand(
     if (wantJson) {
       output.write(JSON.stringify({
         userId,
+        ...(resolvedSpaceId ? { spaceId: resolvedSpaceId } : {}),
+        targetServers: serverUrls,
+        ...(serverFailures.length ? { serverFailures } : {}),
         total: agents.length,
         publicCount: agents.filter((agent) => agent.publicRecordExists).length,
         source,
@@ -85,6 +140,13 @@ export async function runAgentListCommand(
     }
 
     output.write(`userId: ${userId}\n`);
+    if (resolvedSpaceId) {
+      output.write(`spaceId: ${resolvedSpaceId}\n`);
+    }
+    output.write(`targetServers: ${serverUrls.join(", ")}\n`);
+    if (serverFailures.length) {
+      output.write(`serverFailures: ${serverFailures.length}\n`);
+    }
     output.write(`total agents: ${agents.length}\n`);
     output.write(`public agents: ${agents.filter((agent) => agent.publicRecordExists).length}\n`);
     output.write(`source: ${source}\n`);

package/cli/agentListHelpers.ts

@@ -1,4 +1,8 @@
 import type { CliKvDb } from "./client/hybridRecordStore";
+import {
+  listUserRecordsFromServers,
+  readLiveDbRecordAfterTombstoneMerge,
+} from "./globalRecordOperations";
 
 export type ListedAgent = {
   id: string;
@@ -93,7 +97,7 @@ export async function listLocalCachedAgents(args: {
 }) {
   const privateRecords = new Map<string, any>();
   const publicKeys = new Set<string>();
-  for await (const [key, value] of args.db.iterator()) {
+  for await (const [key, value] of args.db.iterator({ gte: "", lte: "\uffff" })) {
     if (typeof key !== "string" || !value || typeof value !== "object") continue;
     if (key.startsWith(`agent-${args.userId}-`) || key.startsWith(`cybot-${args.userId}-`)) {
       privateRecords.set(key, { ...(value as Record<string, unknown>), dbKey: key });
@@ -185,3 +189,54 @@ export async function listRemoteAgents(args: {
   );
   return agents;
 }
+
+export async function listRemoteAgentsAcrossServers(args: {
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  includeLegacy: boolean;
+  serverUrls: string[];
+  userId: string;
+}) {
+  const remoteResult = await listUserRecordsFromServers({
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    label: "agent query",
+    serverUrls: args.serverUrls,
+    type: args.includeLegacy ? ["agent", "cybot"] : "agent",
+    userId: args.userId,
+  });
+  const agents = sortListedAgents(
+    remoteResult.records
+      .map((record) => normalizeListedAgent(record))
+      .filter((agent): agent is ListedAgent => agent != null)
+  );
+  return { agents, failures: remoteResult.failures };
+}
+
+export async function decorateAgentsWithPublicStatusAcrossServers(args: {
+  agents: ListedAgent[];
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}) {
+  await Promise.all(
+    args.agents.map(async (agent) => {
+      try {
+        const result = await readLiveDbRecordAfterTombstoneMerge({
+          authToken: args.authToken,
+          dbKey: agent.publicKey,
+          fallbackFetchImpl: args.fallbackFetchImpl,
+          fetchImpl: args.fetchImpl,
+          serverUrls: args.serverUrls,
+        });
+        agent.publicRecordExists = result.record?.isPublic === true;
+      } catch {
+        agent.publicRecordExists = false;
+      }
+    })
+  );
+  return args.agents;
+}

package/cli/agentRecordHelpers.ts

@@ -125,10 +125,12 @@ export async function readDbRecord(args: {
   authToken: string;
   fallbackFetchImpl?: typeof fetch;
   fetchImpl: typeof fetch;
+  includeDeleted?: boolean;
   serverUrl: string;
 }) {
+  const query = args.includeDeleted ? "?includeDeleted=true" : "";
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}${query}`,
     {
       method: "GET",
       headers: { Authorization: `Bearer ${args.authToken}` },
@@ -146,19 +148,29 @@ export async function queryUserRecords(args: {
   authToken: string;
   fallbackFetchImpl?: typeof fetch;
   fetchImpl: typeof fetch;
+  limit?: number;
   serverUrl: string;
+  summary?: boolean;
+  includeDeleted?: boolean;
   userId: string;
-  type: "agent" | "cybot";
-}) {
+  type: string | string[];
+}): Promise<any[]> {
+  const query = typeof args.limit === "number" && args.limit > 0
+    ? `?limit=${Math.floor(args.limit)}`
+    : "";
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}`,
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}${query}`,
     {
       method: "POST",
       headers: {
         Authorization: `Bearer ${args.authToken}`,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({ type: args.type }),
+      body: JSON.stringify({
+        type: args.type,
+        ...(args.includeDeleted ? { includeDeleted: true } : {}),
+        ...(args.summary ? { summary: true } : {}),
+      }),
     },
     args
   );
@@ -173,6 +185,34 @@ export async function queryUserRecords(args: {
       : [];
 }
 
+export async function deleteDbRecord(args: {
+  dbKey: string;
+  deleteOptions?: { type?: "single" | "table" | "messages" };
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const type = args.deleteOptions?.type;
+  const query =
+    type && type !== "single"
+      ? `?type=${encodeURIComponent(type)}`
+      : "";
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.dbKey)}${query}`,
+    {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${args.authToken}` },
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`delete failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data;
+}
+
 export async function writeAgentRecord(args: {
   agentKey: string;
   authToken: string;

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