nolo-cli 0.1.34 → 0.1.35

package/README.md

@@ -171,8 +171,11 @@ nolo agent read <agent>
 nolo agent update <agent> --model gpt-5.4 --cli-provider codex --api-source cli
 nolo agent run <agent> "检查最近失败任务"
 nolo agent run frontend-implementer --msg "修一个小的通知弹窗 CSS 问题"
-nolo dialog list --agent <agent>
+nolo agent list --space <space>
+nolo dialog list
+nolo dialog list --space <space>
 nolo dialog read <dialog>
+nolo dialog delete <dialog> --yes
 nolo doc list --agent <agent>
 nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --limit 20
 nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items
@@ -180,6 +183,13 @@ nolo table update-row --table meta-b2e06f801f-NOLOTASKBOARD --row 01ROWID --chan
 nolo table add-column --table meta-b2e06f801f-NOLOTASKBOARD --schema-write-ok --name "blockedBy" --label "Blocked By"
 ```
 
+`agent list`, `dialog list`, and record delete commands use global server
+candidates for the current CLI profile: the selected `--server` / `NOLO_SERVER`
+plus known Nolo cluster peers. List commands merge tombstones so a newer delete
+on one server hides older live records from another. Dialog, doc, skill-doc,
+space, and agent public-record deletes send the delete to all target servers;
+each server applies the normal tombstone/cascade behavior for that record type.
+
 `nolo table add-column` mutates table schema metadata, so it requires
 `--schema-write-ok` and should be run serially per table. Row-level table writes
 do not require this flag.

package/agent-runtime/localToolPolicy.ts

@@ -1,7 +1,7 @@
 import type {
   AgentRuntimeToolCallInput,
   AgentRuntimeToolResult,
-} from "./types";
+} from "./hostAdapter";
 import { canonicalizeToolName } from "../ai/tools/toolNameAliases";
 import { evaluateShellCommandPolicy } from "./shellCommandPolicy";
 

package/agent-runtime/localWorkspaceTools.ts

@@ -4,7 +4,7 @@ import { dirname, relative, resolve, sep } from "node:path";
 import type {
   AgentRuntimeToolCallInput,
   AgentRuntimeToolResult,
-} from "./types";
+} from "./hostAdapter";
 
 type LocalWorkspaceToolArgs = {
   workspaceRoot: string;
@@ -646,7 +646,10 @@ function readVisualStateCaptureArgs(args: WorkspaceFileArgs) {
   };
 }
 
-async function readWorkspacePackageScripts(workspaceRoot: string) {
+async function readWorkspacePackageScripts(workspaceRoot: string): Promise<{
+  scripts: string[];
+  error?: string;
+}> {
   try {
     const raw = await readFile(resolve(workspaceRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);

package/agent-runtime/providerResolution.ts

@@ -126,9 +126,7 @@ export function shouldUsePlatformProxyTransport(
   env: EnvLike,
   agentConfig?: AgentRuntimeAgentConfig
 ) {
-  if (agentConfig?.apiSource === "platform") return true;
-  if (agentConfig?.apiSource === "custom" || agentConfig?.customProviderUrl?.trim()) return false;
-  if (agentConfig?.useServerProxy === true) return true;
+  if (agentConfig?.apiSource === "platform" || agentConfig?.useServerProxy === true) return true;
   if (env.NOLO_LOCAL_LLM === "platform") return true;
   if (env.NOLO_LOCAL_LLM === "direct") return false;
   return !hasDirectOpenAiCompatibleProvider(env) && canUsePlatformChatProvider(env);

package/agentCommandSupport.ts

@@ -20,6 +20,10 @@ export type LocalCliExecutor = (
 export type LocalRuntimeProbeResult = {
   ok: boolean;
   dbPath: string;
+  authorityDriver?: string;
+  authorityEndpoint?: string;
+  authorityMetadataPath?: string;
+  authorityHealthPath?: string;
   agentFound: boolean;
   agentKey?: string;
   error?: string;

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

@@ -20,6 +20,10 @@ export type LocalCliExecutor = (
 export type LocalRuntimeProbeResult = {
   ok: boolean;
   dbPath: string;
+  authorityDriver?: string;
+  authorityEndpoint?: string;
+  authorityMetadataPath?: string;
+  authorityHealthPath?: string;
   agentFound: boolean;
   agentKey?: string;
   error?: string;

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;
+}