nolo-cli 0.1.34 → 0.1.36

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

@@ -14,6 +14,8 @@ export {
   buildProviderAuthHeaders,
   buildProviderExecutionPlan,
   resolveAgentProviderMode,
+  resolveAgentRuntimeLocation,
+  resolveProviderTransportDecision,
 } from "./providerResolution";
 export {
   buildPlatformChatCompletionRequest,

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

@@ -7,9 +7,10 @@ import {
   buildProviderExecutionPlan,
   canUsePlatformChatProvider as canUsePlatformChatProviderFromEnv,
   hasDirectOpenAiCompatibleProvider as hasDirectOpenAiCompatibleProviderFromEnv,
+  resolveAgentRuntimeLocation,
   resolvePlatformAuthToken,
   resolvePlatformServerUrl,
-  shouldUsePlatformProxyTransport,
+  resolveProviderTransportDecision,
 } from "./providerResolution";
 
 type EnvLike = Record<string, string | undefined>;
@@ -206,16 +207,23 @@ export function hasDirectOpenAiCompatibleProvider(env: EnvLike) {
   return hasDirectOpenAiCompatibleProviderFromEnv(env);
 }
 
-function agentRequiresPlatformChatProvider(agentConfig?: AgentRuntimeAgentConfig) {
-  if (agentConfig?.apiSource === "platform") return true;
-  if (agentConfig?.apiSource === "custom" || agentConfig?.customProviderUrl?.trim()) return false;
-  return agentConfig?.useServerProxy === true;
-}
-
 export function shouldUsePlatformChatProvider(
   env: EnvLike,
   agentConfig?: AgentRuntimeAgentConfig
 ) {
-  if (agentRequiresPlatformChatProvider(agentConfig)) return true;
-  return shouldUsePlatformProxyTransport(env, agentConfig);
+  if (!agentConfig) {
+    return resolveProviderTransportDecision({
+      agentConfig: { key: "default-platform" },
+      env,
+      runtimeLocation: "local-host",
+    }).transport === "proxy";
+  }
+  return resolveProviderTransportDecision({
+    agentConfig,
+    env,
+    runtimeLocation: resolveAgentRuntimeLocation({
+      agentConfig,
+      runtimeKind: "local",
+    }),
+  }).transport === "proxy";
 }

package/agent-runtime/providerResolution.ts

@@ -16,6 +16,21 @@ const PROVIDER_ENDPOINTS: Record<string, string> = {
 
 export type AgentProviderMode = "cli" | "platform" | "custom";
 export type ProviderExecutionTransport = "direct" | "proxy";
+export type AgentRuntimeLocation = "server" | "bound-machine" | "local-host";
+
+export type ProviderTransportDecision = {
+  mode: AgentProviderMode;
+  transport: ProviderExecutionTransport;
+  reason:
+    | "cli-provider"
+    | "custom-provider"
+    | "custom-server-proxy"
+    | "platform-agent"
+    | "forced-platform-env"
+    | "forced-direct-env"
+    | "direct-provider-env"
+    | "platform-proxy-fallback";
+};
 
 type ProviderExecutionPlanBase = {
   mode: AgentProviderMode;
@@ -122,16 +137,50 @@ export function resolveAgentProviderMode(agentConfig: AgentRuntimeAgentConfig):
   return "platform";
 }
 
-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 (env.NOLO_LOCAL_LLM === "platform") return true;
-  if (env.NOLO_LOCAL_LLM === "direct") return false;
-  return !hasDirectOpenAiCompatibleProvider(env) && canUsePlatformChatProvider(env);
+export function resolveAgentRuntimeLocation(args: {
+  agentConfig: AgentRuntimeAgentConfig;
+  runtimeKind: "local" | "desktop" | "server";
+}): AgentRuntimeLocation {
+  const runtimeBinding = args.agentConfig.runtimeBinding;
+  const machineId = typeof runtimeBinding?.machineId === "string"
+    ? runtimeBinding.machineId.trim()
+    : "";
+  if (machineId) return "bound-machine";
+  if (args.runtimeKind === "server") return "server";
+  return "local-host";
+}
+
+export function resolveProviderTransportDecision(args: {
+  agentConfig: AgentRuntimeAgentConfig;
+  env: EnvLike;
+  runtimeLocation: AgentRuntimeLocation;
+}): ProviderTransportDecision {
+  const mode = resolveAgentProviderMode(args.agentConfig);
+  if (mode === "cli") {
+    return { mode, transport: "direct", reason: "cli-provider" };
+  }
+  if (mode === "custom") {
+    if (args.runtimeLocation === "server" && args.agentConfig.useServerProxy === true) {
+      return { mode, transport: "proxy", reason: "custom-server-proxy" };
+    }
+    return { mode, transport: "direct", reason: "custom-provider" };
+  }
+  if (args.agentConfig.apiSource === "platform" || args.agentConfig.useServerProxy === true) {
+    return { mode, transport: "proxy", reason: "platform-agent" };
+  }
+  if (args.env.NOLO_LOCAL_LLM === "platform") {
+    return { mode, transport: "proxy", reason: "forced-platform-env" };
+  }
+  if (args.env.NOLO_LOCAL_LLM === "direct") {
+    return { mode, transport: "direct", reason: "forced-direct-env" };
+  }
+  if (hasDirectOpenAiCompatibleProvider(args.env)) {
+    return { mode, transport: "direct", reason: "direct-provider-env" };
+  }
+  if (canUsePlatformChatProvider(args.env)) {
+    return { mode, transport: "proxy", reason: "platform-proxy-fallback" };
+  }
+  return { mode, transport: "direct", reason: "direct-provider-env" };
 }
 
 export function resolveProviderAuthHeaderName(args: {
@@ -163,6 +212,15 @@ export function buildProviderExecutionPlan(args: {
 }): ProviderExecutionPlan {
   const { agentConfig, env } = args;
   const mode = resolveAgentProviderMode(agentConfig);
+  const runtimeLocation = resolveAgentRuntimeLocation({
+    agentConfig,
+    runtimeKind: args.runtimeKind,
+  });
+  const transportDecision = resolveProviderTransportDecision({
+    agentConfig,
+    env,
+    runtimeLocation,
+  });
   const model = agentConfig.model || "gpt-4.1-mini";
   const requestOptions = pickAgentRuntimeInferenceOptions(agentConfig);
 
@@ -184,7 +242,7 @@ export function buildProviderExecutionPlan(args: {
       endpoint,
       apiKeyHeader: agentConfig.apiKeyHeader,
     });
-    if (agentConfig.useServerProxy) {
+    if (transportDecision.transport === "proxy") {
       return {
         mode,
         transport: "proxy",
@@ -213,10 +271,10 @@ export function buildProviderExecutionPlan(args: {
   }
 
   const provider = agentConfig.provider || agentConfig.apiSource || "openai";
-  const endpoint = shouldUsePlatformProxyTransport(env, agentConfig)
+  const endpoint = transportDecision.transport === "proxy"
     ? resolvePlatformProviderEndpoint(agentConfig)
     : resolveChatCompletionsEndpoint(resolveOpenAiCompatibleBaseUrl(env));
-  if (shouldUsePlatformProxyTransport(env, agentConfig)) {
+  if (transportDecision.transport === "proxy") {
     return {
       mode,
       transport: "proxy",

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;