nolo-cli 0.1.23 → 0.1.29

package/README.md

@@ -168,6 +168,7 @@ The preferred command model is Agent-first:
 nolo agent list
 nolo agent switch <agent>
 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>
@@ -183,6 +184,19 @@ nolo table add-column --table meta-b2e06f801f-NOLOTASKBOARD --schema-write-ok --
 `--schema-write-ok` and should be run serially per table. Row-level table writes
 do not require this flag.
 
+For agent config inspection and small config mutations, prefer the CLI-native
+commands instead of ad hoc scripts:
+
+- `nolo agent list` is CLI-native and prefers the local cache, then degrades to
+  remote query when the local LevelDB cache is unavailable or locked.
+- `nolo agent read <agent>` reads local cached agent records first, then falls
+  back to remote fetch + local cache refresh across known server candidates.
+- if the local LevelDB cache is unavailable or locked, `nolo agent read`
+  degrades to remote-only lookup instead of hard-failing on the local DB.
+- `nolo agent update <agent> ...` is CLI-native and supports small targeted
+  updates such as `--model`, `--cli-provider`, `--api-source`, and repeated
+  `--field key=value`.
+
 Inside the current TUI, examples of supported slash commands include:
 `/agent`, `/agents`, `/switch`, `/context` (alias `/ctx`), `/dialog`, `/doc`,
 `/help`, `/new`, `/customize`, `/login`, `/profile`, `/version`, `/quit`
@@ -216,13 +230,21 @@ This creates a `dist/` directory with:
 - Inlined workspace dependencies (copied as nested directories)
 - A modified package.json with workspace dependencies stripped
 
-The `dist/` directory can be published to npm:
+The `dist/` directory is the publish-safe artifact consumed by the CI npm
+publish workflow:
 
 ```bash
-cd dist
-npm publish
+bun ./scripts/release/prepareCliPublishPackage.ts --out-dir .tmp/nolo-cli-publish
+cd .tmp/nolo-cli-publish
+npm pack
 ```
 
+For this repository, the default release path for `nolo-cli` is the GitHub
+Actions workflow [`.github/workflows/cli-npm-publish.yml`](../../.github/workflows/cli-npm-publish.yml).
+Use local `npm pack` or tarball-based `npm install -g` as preflight verification.
+Do not treat manual local `npm publish` as the normal release route unless you
+are intentionally debugging the CI publish lane.
+
 Key differences between repo-local and published versions:
 - **Repo-local**: Runs from source (`packages/cli/index.ts`) with workspace
   dependencies resolved by the monorepo

package/agent-runtime/dialogStatus.ts

@@ -0,0 +1,139 @@
+export type DialogStatusSnapshot = {
+  dialogId: string;
+  dialogKey?: string;
+  base?: string;
+  title?: string | null;
+  status?: string | null;
+  parentDialogId?: string | null;
+  rootDialogId?: string | null;
+  subjectRefs?: Array<{ kind?: string; id?: string; role?: string }>;
+  runtimeCheckpoint?: Record<string, any> | null;
+  artifacts?: any;
+  writtenFiles?: string[];
+  toolsUsed?: string[];
+  toolErrors?: string[];
+  durationMs?: number | null;
+  updatedAt?: string | number | null;
+  finishedAt?: string | number | null;
+};
+
+const ACTIVE_STALE_AFTER_MS = 5 * 60_000;
+
+function compact(value: unknown, max = 180) {
+  const text = typeof value === "string" ? value.trim() : "";
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+
+function list(values: unknown, max = 8) {
+  if (!Array.isArray(values)) return [];
+  return values
+    .map((value) => (typeof value === "string" ? value.trim() : ""))
+    .filter(Boolean)
+    .slice(0, max);
+}
+
+function artifactFiles(artifacts: any) {
+  if (!artifacts || typeof artifacts !== "object") return [];
+  return list(artifacts.changedFiles ?? artifacts.writtenFiles ?? artifacts.files);
+}
+
+function formatSubjectRefs(refs: DialogStatusSnapshot["subjectRefs"], max = 8) {
+  if (!Array.isArray(refs)) return [];
+  return refs
+    .map((ref) => {
+      const kind = typeof ref?.kind === "string" ? ref.kind.trim() : "";
+      const id = typeof ref?.id === "string" ? ref.id.trim() : "";
+      if (!kind || !id) return "";
+      const role = typeof ref?.role === "string" && ref.role.trim() ? `#${ref.role.trim()}` : "";
+      return `${kind}:${id}${role}`;
+    })
+    .filter(Boolean)
+    .slice(0, max);
+}
+
+export function resolveDialogTerminalState(snapshot: DialogStatusSnapshot) {
+  const checkpointStatus =
+    typeof snapshot.runtimeCheckpoint?.status === "string"
+      ? snapshot.runtimeCheckpoint.status
+      : null;
+  if (checkpointStatus === "done" || checkpointStatus === "completed") return "done";
+  if (checkpointStatus === "failed" || checkpointStatus === "error") return "failed";
+
+  const status = snapshot.status ?? checkpointStatus ?? "unknown";
+  if (status === "done" || status === "completed") return "done";
+  if (status === "failed" || status === "error") return "failed";
+  if (status === "running" || status === "pending" || status === "queued") return "active";
+  return "unknown";
+}
+
+function parseTimeMs(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+export function resolveDialogActiveHealth(snapshot: DialogStatusSnapshot, nowMs = Date.now()) {
+  if (resolveDialogTerminalState(snapshot) !== "active") return null;
+  const checkpointUpdatedAt = parseTimeMs(snapshot.runtimeCheckpoint?.updatedAt);
+  const dialogUpdatedAt = parseTimeMs(snapshot.updatedAt);
+  const latest = checkpointUpdatedAt ?? dialogUpdatedAt;
+  if (!snapshot.runtimeCheckpoint) return "no-checkpoint";
+  if (!checkpointUpdatedAt) return "checkpoint-without-updatedAt";
+  if (latest && nowMs - latest > ACTIVE_STALE_AFTER_MS) return "stale-running";
+  return "running";
+}
+
+export function renderDialogStatus(snapshot: DialogStatusSnapshot) {
+  const checkpoint = snapshot.runtimeCheckpoint ?? {};
+  const files = list(snapshot.writtenFiles).length
+    ? list(snapshot.writtenFiles)
+    : artifactFiles(snapshot.artifacts);
+  const tools = list(snapshot.toolsUsed).length
+    ? list(snapshot.toolsUsed)
+    : list(checkpoint.lastToolNames);
+  const errors = list(snapshot.toolErrors);
+  const errorMessage = compact(checkpoint.errorMessage ?? (snapshot as any).errorMessage);
+  const subjectRefs = formatSubjectRefs(snapshot.subjectRefs);
+  const terminal = resolveDialogTerminalState(snapshot);
+  const activeHealth = resolveDialogActiveHealth(snapshot);
+  const lines = [
+    `dialog: ${snapshot.dialogId}`,
+    ...(snapshot.base ? [`base: ${snapshot.base}`] : []),
+    ...(snapshot.title ? [`title: ${snapshot.title}`] : []),
+    ...(snapshot.parentDialogId ? [`parentDialogId: ${snapshot.parentDialogId}`] : []),
+    ...(snapshot.rootDialogId ? [`rootDialogId: ${snapshot.rootDialogId}`] : []),
+    `status: ${snapshot.status ?? "unknown"}`,
+    ...(typeof checkpoint.status === "string" ? [`checkpoint: ${checkpoint.status}`] : []),
+    `state: ${terminal}`,
+    ...(activeHealth ? [`activeHealth: ${activeHealth}`] : []),
+    ...(typeof snapshot.durationMs === "number" ? [`durationMs: ${snapshot.durationMs}`] : []),
+    ...(snapshot.updatedAt ? [`updatedAt: ${snapshot.updatedAt}`] : []),
+    ...(snapshot.finishedAt ? [`finishedAt: ${snapshot.finishedAt}`] : []),
+    ...(compact(checkpoint.lastUserInput) ? [`lastUserInput: ${compact(checkpoint.lastUserInput)}`] : []),
+    ...(compact(checkpoint.lastAssistantText) ? [`lastAssistantText: ${compact(checkpoint.lastAssistantText)}`] : []),
+    ...(errorMessage ? [`error: ${errorMessage}`] : []),
+    ...(tools.length ? [`tools: ${tools.join(", ")}`] : []),
+    ...(files.length ? [`files: ${files.join(", ")}`] : []),
+    ...(subjectRefs.length ? [`subjects: ${subjectRefs.join(", ")}`] : []),
+    ...(errors.length ? [`toolErrors: ${errors.join(", ")}`] : []),
+    "",
+    "next:",
+    `- read full dialog: nolo dialog read ${snapshot.dialogId} 120`,
+  ];
+
+  if (terminal === "active") {
+    lines.push(`- poll again: nolo dialog status ${snapshot.dialogId}`);
+  } else if (terminal === "failed") {
+    lines.push(`- inspect failure and rerun/continue with: nolo agent run <agent> --continue ${snapshot.dialogId} --msg "..."`);
+  } else if (terminal === "done") {
+    lines.push("- use artifacts/files above for review, handoff, or alpha integration.");
+  } else {
+    lines.push("- inspect meta/messages before deciding whether to continue or rerun.");
+  }
+
+  return `${lines.join("\n")}\n`;
+}

package/agent-runtime/hybridRecordStore.ts

@@ -15,6 +15,7 @@ export type HybridRecordStore = {
 type HybridRecordStoreDeps = {
   db: HybridRecordKvDb;
   defaultServer: string;
+  fallbackServers?: string[];
   authToken?: string;
   fetchImpl?: typeof fetch;
 };
@@ -23,10 +24,15 @@ function normalizeHybridServer(value: string) {
   return value.trim().replace(/\/+$/, "");
 }
 
-function resolveHybridServers(defaultServer: string, preferredServerOrigin?: string | null) {
+function resolveHybridServers(
+  defaultServer: string,
+  preferredServerOrigin?: string | null,
+  fallbackServers: string[] = []
+) {
   const raw = [
     preferredServerOrigin || "",
     defaultServer,
+    ...fallbackServers,
   ].filter((value) => value.trim().length > 0);
   return [...new Set(raw.map(normalizeHybridServer))];
 }
@@ -72,10 +78,16 @@ function shouldReplaceWithHybridRecord(nextRecord: any, currentRecord: any): boo
   return isHybridTombstoneRecord(nextRecord) && !isHybridTombstoneRecord(currentRecord);
 }
 
+function isHybridNotFoundError(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /not found|notfound|leveldb: not found|key not found/i.test(message);
+}
+
 async function readHybridLocalRecord(db: HybridRecordKvDb, dbKey: string) {
   try {
     return await db.get(dbKey);
-  } catch {
+  } catch (error) {
+    if (!isHybridNotFoundError(error)) throw error;
     return null;
   }
 }
@@ -117,13 +129,22 @@ export function createHybridRecordStore(
       if (localRecord) return { ...localRecord, dbKey };
       if (options?.remote === false) return null;
 
-      for (const server of resolveHybridServers(deps.defaultServer, options?.preferredServerOrigin)) {
-        const remoteRecord = await fetchHybridRemoteRecord({
-          dbKey,
-          server,
-          authToken: deps.authToken,
-          fetchImpl,
-        });
+      for (const server of resolveHybridServers(
+        deps.defaultServer,
+        options?.preferredServerOrigin,
+        deps.fallbackServers
+      )) {
+        let remoteRecord = null;
+        try {
+          remoteRecord = await fetchHybridRemoteRecord({
+            dbKey,
+            server,
+            authToken: deps.authToken,
+            fetchImpl,
+          });
+        } catch {
+          continue;
+        }
         if (!remoteRecord) continue;
         if (shouldCacheHybridRemoteRecord(remoteRecord, localRecord)) {
           await deps.db.put(dbKey, remoteRecord);

package/agent-runtime/index.ts

@@ -27,6 +27,11 @@ export {
 } from "./agentRecordKeys";
 export { resolveAgentRuntimeConfigFromRecord } from "./agentRecordConfig";
 export { dialogMessageRecordToAgentRuntimeMessage } from "./dialogMessageRecord";
+export {
+  renderDialogStatus,
+  resolveDialogActiveHealth,
+  resolveDialogTerminalState,
+} from "./dialogStatus";
 export { buildAgentRuntimeDialogWritePlan } from "./dialogWritePlan";
 export {
   createHybridRecordStore,
@@ -90,6 +95,9 @@ export type {
 export type {
   PlatformChatProviderConfig,
 } from "./platformChatProvider";
+export type {
+  DialogStatusSnapshot,
+} from "./dialogStatus";
 export type {
   AgentRuntimeChatMessage,
   AgentRuntimeDecision,

package/agent-runtime/localLoop.ts

@@ -29,7 +29,8 @@ export type LocalAgentToolEvent = {
   metadata?: Record<string, unknown>;
 };
 
-const DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS = 16;
+export const DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS = 128;
+export const LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
 
 function formatToolExecutionError(args: {
   toolName: string;
@@ -55,9 +56,10 @@ function buildMessages(args: {
   history: AgentRuntimeChatMessage[];
   input: AgentRuntimeMessageContent;
 }): AgentRuntimeChatMessage[] {
+  const systemContent = args.prompt?.trim();
   return [
-    ...(args.prompt?.trim()
-      ? [{ role: "system" as const, content: args.prompt.trim() }]
+    ...(systemContent
+      ? [{ role: "system" as const, content: systemContent }]
       : []),
     ...args.history,
     { role: "user" as const, content: args.input },
@@ -69,7 +71,13 @@ export async function runLocalAgentTurn(
 ): Promise<LocalAgentTurnResult> {
   const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
   if (!agentConfig) {
-    throw new Error(`Local agent config not found: ${input.agentRef}`);
+    const error = new Error(`Local agent config not found: ${input.agentRef}`) as Error & {
+      code?: string;
+      agentRef?: string;
+    };
+    error.code = LOCAL_AGENT_CONFIG_MISSING_CODE;
+    error.agentRef = input.agentRef;
+    throw error;
   }
 
   const history = input.continueDialogId

package/agent-runtime/localToolPolicy.ts

@@ -16,6 +16,15 @@ const NEVER_LOCAL_TOOLS = new Set([
   "createAgent",
 ]);
 
+const REMOVED_LOCAL_TOOLS = new Set([
+  "gitStatus",
+  "gitDiff",
+  "gitCreateBranch",
+  "gitAdd",
+  "gitCommit",
+  "commitWorkspace",
+]);
+
 const DEFAULT_LOCAL_TOOLS = new Set([
   "listWorkspaceFiles",
   "readWorkspaceFile",
@@ -24,16 +33,12 @@ const DEFAULT_LOCAL_TOOLS = new Set([
   "listFiles",
   "readFile",
   "writeFile",
+  "editFile",
+  "searchFiles",
   "searchWorkspace",
   "applyPatch",
-  "gitStatus",
-  "gitDiff",
-  "gitCreateBranch",
-  "gitAdd",
-  "gitCommit",
-  "commitWorkspace",
   "runPackageScript",
-  "execBash",
+  "execShell",
 ]);
 
 function parseToolAllowlist(value: string | undefined) {
@@ -68,15 +73,14 @@ export function resolveLocalToolPolicy(args: {
   toolName: string;
 }): LocalToolPolicyDecision {
   const restrictedMode = isRestrictedLocalToolMode(args.env);
-  const isShellTool = args.toolName === "execShell" || args.toolName === "execBash";
-  if (isShellTool) {
+  if (args.toolName === "execShell") {
     if (isLocalShellModeEnabled(args.env)) {
       return { allowed: true, toolName: args.toolName };
     }
     return {
       allowed: false,
       toolName: args.toolName,
-      reason: `${args.toolName} requires NOLO_LOCAL_SHELL_MODE=worktree.`,
+      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
     };
   }
 
@@ -88,6 +92,14 @@ export function resolveLocalToolPolicy(args: {
     };
   }
 
+  if (REMOVED_LOCAL_TOOLS.has(args.toolName)) {
+    return {
+      allowed: false,
+      toolName: args.toolName,
+      reason: `${args.toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`,
+    };
+  }
+
   const allowedByEnv = new Set(parseToolAllowlist(args.env.NOLO_LOCAL_ALLOWED_TOOLS));
   const agentTools = new Set(args.agentToolNames ?? []);
   if (!restrictedMode && agentTools.has(args.toolName)) {