nolo-cli 0.8.0 → 0.9.1

package/removeDialogAgentAction-GJQJNDW6.js

@@ -0,0 +1,73 @@
+import {
+  cleanupCliSessionForDialog
+} from "./chunk-KTVVPRJS.js";
+import {
+  getPrimaryDialogAgentId,
+  removeDialogAgentId
+} from "./chunk-Z4NR32XR.js";
+import {
+  require_date_fns
+} from "./chunk-M76ECQRD.js";
+import {
+  getActiveDialogKey
+} from "./chunk-3ASDTTEI.js";
+import "./chunk-TSS3XJY4.js";
+import "./chunk-Y5GCAMGP.js";
+import {
+  patch,
+  selectById
+} from "./chunk-COMXDWNM.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-SH2CFQOH.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/chat/dialog/actions/removeDialogAgentAction.ts
+var import_date_fns = __toESM(require_date_fns());
+var removeDialogAgentAction = async (agentId, thunkApi) => {
+  const { dispatch, getState } = thunkApi;
+  const state = getState();
+  const currentDialogKey = getActiveDialogKey();
+  if (!currentDialogKey) {
+    throw new Error("No current dialog selected");
+  }
+  const dialogConfig = selectById(
+    state,
+    currentDialogKey
+  );
+  if (!dialogConfig) {
+    throw new Error("Dialog configuration not found");
+  }
+  if (getPrimaryDialogAgentId(dialogConfig) === agentId) {
+    await cleanupCliSessionForDialog({ dispatch, getState }, dialogConfig);
+  }
+  return await dispatch(
+    patch({
+      dbKey: currentDialogKey,
+      changes: {
+        cybots: removeDialogAgentId(dialogConfig.cybots || [], agentId),
+        updatedAt: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date())
+      }
+    })
+  ).unwrap();
+};
+export {
+  removeDialogAgentAction
+};

package/runAgentClientLoop-U5Q6NDTJ.js

@@ -0,0 +1,291 @@
+import {
+  fetchAgentContexts
+} from "./chunk-3WYQEUBI.js";
+import {
+  generateRequestBody,
+  mergeReferences,
+  performFetchRequest
+} from "./chunk-SBR32ZZS.js";
+import "./chunk-KKY4B2Q2.js";
+import "./chunk-C3RUNRHT.js";
+import {
+  findToolExecutor,
+  getToolResultErrorData
+} from "./chunk-MKMWT7SA.js";
+import "./chunk-GAKEBQD6.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-XKIMRZO2.js";
+import "./chunk-3LY4F7SV.js";
+import "./chunk-VP4WJWKW.js";
+import "./chunk-63W5N6P3.js";
+import "./chunk-UUJDGGAK.js";
+import "./chunk-PG5PNA7Y.js";
+import "./chunk-ZQ2UM4KG.js";
+import "./chunk-Q2YZULBH.js";
+import {
+  updateTokensAction
+} from "./chunk-ZIG5LJ7X.js";
+import "./chunk-4ZDM73SD.js";
+import "./chunk-MRC4Q34M.js";
+import "./chunk-PCWC3JTN.js";
+import "./chunk-CWMSB67P.js";
+import "./chunk-4K2KKCSD.js";
+import "./chunk-KTVVPRJS.js";
+import "./chunk-Z4NR32XR.js";
+import "./chunk-M76ECQRD.js";
+import "./chunk-YYUCRDOK.js";
+import "./chunk-MGOJ5R6J.js";
+import "./chunk-UAD2WT54.js";
+import "./chunk-DCOA4QSN.js";
+import "./chunk-PAKN26FP.js";
+import "./chunk-JRKKFRAV.js";
+import {
+  canonicalizeToolName
+} from "./chunk-AUQ747NZ.js";
+import "./chunk-5MMAK75Q.js";
+import {
+  getApiEndpoint
+} from "./chunk-BBYVOSU2.js";
+import "./chunk-5CS33IBL.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-IWX4UW2E.js";
+import "./chunk-5MIDPSSK.js";
+import {
+  extractCustomId
+} from "./chunk-DFFIZ25G.js";
+import "./chunk-3ASDTTEI.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-HNMXYYJR.js";
+import "./chunk-63SLEOLK.js";
+import {
+  selectCurrentServer
+} from "./chunk-TSS3XJY4.js";
+import "./chunk-Y5GCAMGP.js";
+import {
+  read
+} from "./chunk-COMXDWNM.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-SH2CFQOH.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import {
+  selectIdentityToken
+} from "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/ai/agent/executeToolCall.ts
+async function executeToolCall(tc, thunkApi, context) {
+  const toolName = tc.function?.name ?? "";
+  const toolArgs = (() => {
+    try {
+      return JSON.parse(tc.function?.arguments ?? "{}");
+    } catch {
+      return {};
+    }
+  })();
+  try {
+    const toolDefinition = findToolExecutor(toolName);
+    if (!toolDefinition) {
+      return `[\u5DE5\u5177 "${toolName}" \u672A\u627E\u5230]`;
+    }
+    const result = await toolDefinition.executor(toolArgs, thunkApi, {
+      parentMessageId: context?.parentMessageId ?? ""
+    });
+    const raw = result?.rawData ?? result;
+    return typeof raw === "string" ? raw : JSON.stringify(raw);
+  } catch (err) {
+    console.error(`[executeToolCall] tool "${toolName}" \u6267\u884C\u5931\u8D25:`, err);
+    const structured = getToolResultErrorData(err);
+    if (structured?.rawData !== void 0) {
+      const raw = structured.rawData;
+      return typeof raw === "string" ? raw : JSON.stringify(raw);
+    }
+    return `[\u5DE5\u5177 "${toolName}" \u6267\u884C\u5931\u8D25: ${err?.message ?? err}]`;
+  }
+}
+
+// packages/ai/agent/toolFailureGuard.ts
+function parseToolResult(content) {
+  if (typeof content !== "string" || !content.trim()) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function pickString(value) {
+  return asOptionalTrimmedString(value) ?? null;
+}
+function getToolError(parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  const error = pickString(parsed.error);
+  if (error) return error;
+  const message = pickString(parsed.message);
+  if (message && (parsed.ok === false || parsed.success === false || parsed.status === "error")) {
+    return message;
+  }
+  if (parsed.ok === false) return "tool returned ok=false";
+  if (parsed.success === false) return "tool returned success=false";
+  return null;
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (isRecord(value)) {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function normalizeToolArgumentsForFailureSignature(rawArguments) {
+  if (typeof rawArguments !== "string") return stableStringify(rawArguments ?? null);
+  const trimmed = rawArguments.trim();
+  if (!trimmed) return "";
+  try {
+    return stableStringify(JSON.parse(trimmed));
+  } catch {
+    return trimmed;
+  }
+}
+function recordConsecutiveToolFailure(guard, toolCall, toolResult, maxConsecutiveFailures = 3) {
+  const parsed = parseToolResult(toolResult);
+  const error = getToolError(parsed);
+  if (!error) {
+    guard.signature = null;
+    guard.count = 0;
+    return null;
+  }
+  const toolName = canonicalizeToolName(toolCall.function.name);
+  const signature = stableStringify({
+    toolName,
+    arguments: normalizeToolArgumentsForFailureSignature(toolCall.function.arguments),
+    error
+  });
+  if (signature === guard.signature) {
+    guard.count += 1;
+  } else {
+    guard.signature = signature;
+    guard.count = 1;
+  }
+  if (guard.count < maxConsecutiveFailures) return null;
+  return [
+    `\u5DF2\u505C\u6B62\u5DE5\u5177\u5FAA\u73AF\uFF1A${toolName} \u4F7F\u7528\u540C\u4E00\u7EC4\u53C2\u6570\u8FDE\u7EED ${guard.count} \u6B21\u8FD4\u56DE\u540C\u4E00\u4E2A\u9519\u8BEF\u3002`,
+    `\u9519\u8BEF\uFF1A${error}`,
+    "\u8BF7\u5148\u8C03\u6574\u53C2\u6570\u3001\u6362\u4E00\u79CD\u64CD\u4F5C\u8DEF\u5F84\uFF0C\u6216\u5411\u7528\u6237\u786E\u8BA4\u540E\u518D\u7EE7\u7EED\uFF1B\u4E0D\u8981\u7EE7\u7EED\u91CD\u590D\u540C\u4E00\u4E2A\u5931\u8D25\u8C03\u7528\u3002"
+  ].join("\n");
+}
+
+// packages/ai/agent/runAgentClientLoop.ts
+async function runAgentClientLoop(args, thunkApi) {
+  const { agentKey, content, parentMessageId, billingDialogKey } = args;
+  const { getState, dispatch } = thunkApi;
+  const state = getState();
+  const agentConfig = await dispatch(read({ dbKey: agentKey })).unwrap();
+  const agentContexts = await fetchAgentContexts(
+    mergeReferences(agentConfig.references, args.extraReferences),
+    dispatch
+  );
+  const initialMessages = [{ role: "user", content }];
+  const body = generateRequestBody({
+    agentConfig,
+    messages: initialMessages,
+    userInput: typeof content === "string" ? content : JSON.stringify(content),
+    contexts: agentContexts
+  });
+  body.stream = false;
+  const messages = body.messages;
+  const api = getApiEndpoint(agentConfig);
+  const currentServer = selectCurrentServer(state);
+  const token = selectIdentityToken(state) ?? "";
+  let finalContent = "";
+  let toolCallCount = 0;
+  const toolFailureGuard = {
+    signature: null,
+    count: 0
+  };
+  loop:
+    for (; ; ) {
+      body.messages = messages;
+      const response = await performFetchRequest({
+        agentConfig,
+        api,
+        bodyData: body,
+        currentServer,
+        token,
+        dialogId: billingDialogKey ? extractCustomId(billingDialogKey) || void 0 : void 0
+      });
+      const data = await response.json();
+      const choice = data.choices?.[0];
+      if (billingDialogKey && data?.usage) {
+        await updateTokensAction(
+          {
+            dialogId: extractCustomId(billingDialogKey),
+            dialogKey: billingDialogKey,
+            usage: data.usage,
+            agentConfig
+          },
+          thunkApi
+        );
+      }
+      if (!choice) {
+        console.warn("[runAgentClientLoop] \u54CD\u5E94\u4E2D\u627E\u4E0D\u5230 choices[0]\uFF0C\u505C\u6B62");
+        break;
+      }
+      const assistantMsg = choice.message;
+      const finishReason = choice.finish_reason ?? "";
+      messages.push(assistantMsg);
+      if (typeof assistantMsg.content === "string" && assistantMsg.content) {
+        finalContent = assistantMsg.content;
+      }
+      if (!assistantMsg.tool_calls?.length || finishReason === "stop") {
+        break;
+      }
+      for (const tc of assistantMsg.tool_calls) {
+        toolCallCount++;
+        const toolResultContent = await executeToolCall(tc, thunkApi, {
+          parentMessageId,
+          agentKey
+        });
+        const stopReason = recordConsecutiveToolFailure(
+          toolFailureGuard,
+          tc,
+          toolResultContent
+        );
+        if (stopReason) {
+          finalContent = stopReason;
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: toolResultContent
+          });
+          break loop;
+        }
+        messages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: toolResultContent
+        });
+      }
+    }
+  return { content: finalContent, toolCallCount };
+}
+export {
+  runAgentClientLoop
+};

package/runtimeDoctorCommands-LRHLPDRC.js

@@ -0,0 +1,289 @@
+import {
+  resolveAuthToken,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import {
+  resolveAgentRuntimeDecision
+} from "./chunk-ZNFJWEN4.js";
+import {
+  createCliAuthorityBrokerClient,
+  createCliAuthorityBrokerSocketInvoker,
+  resolveCliAuthorityBrokerEndpoint,
+  resolveCliAuthorityBrokerHealthPath,
+  resolveCliAuthorityBrokerMetadataPath,
+  resolveCliAuthorityStoreDriver
+} from "./chunk-U4TRT5V4.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import "./chunk-LM6IYQ3F.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/cli/cliAuthorityBrokerHealth.ts
+import fs from "node:fs/promises";
+var defaultCliAuthorityBrokerHealthDeps = {
+  async readJson(filePath) {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  },
+  isPidAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  },
+  async openEndpoint(endpoint) {
+    const client = createCliAuthorityBrokerClient({
+      endpoint,
+      invoke: createCliAuthorityBrokerSocketInvoker({ endpoint })
+    });
+    await client.open();
+  }
+};
+function asBrokerHealthRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+async function probeCliAuthorityBrokerHealth(args) {
+  const deps = {
+    ...defaultCliAuthorityBrokerHealthDeps,
+    ...args.deps
+  };
+  let metadata;
+  let health;
+  try {
+    [metadata, health] = await Promise.all([
+      deps.readJson(args.metadataPath).then(asBrokerHealthRecord),
+      deps.readJson(args.healthPath).then(asBrokerHealthRecord)
+    ]);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `authority broker health artifacts are unavailable: ${toErrorMessage(error)}`
+    };
+  }
+  if (health.ok !== true) {
+    return { ok: false, error: "authority broker health artifact is not ok" };
+  }
+  if (typeof metadata.endpoint !== "string" || metadata.endpoint !== args.endpoint || health.endpoint !== args.endpoint) {
+    return { ok: false, error: "authority broker endpoint metadata does not match" };
+  }
+  if (typeof metadata.pid !== "number" || !Number.isInteger(metadata.pid) || metadata.pid <= 0 || health.pid !== metadata.pid) {
+    return { ok: false, error: "authority broker pid metadata is invalid" };
+  }
+  if (!deps.isPidAlive(metadata.pid)) {
+    return {
+      ok: false,
+      error: `authority broker metadata pid ${metadata.pid} is not alive`
+    };
+  }
+  try {
+    await deps.openEndpoint(args.endpoint);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `authority broker endpoint is unreachable: ${toErrorMessage(error)}`
+    };
+  }
+  return { ok: true };
+}
+
+// packages/cli/runtimeDoctorCommands.ts
+function detectLocalAgentConfig(env) {
+  return Boolean(readLocalAgentKey(env) || env.NOLO_AGENT_CACHE_READY);
+}
+function readLocalAgentKey(env) {
+  return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
+}
+function detectLocalProvider(env) {
+  return Boolean(
+    env.OPENAI_API_KEY || env.ANTHROPIC_API_KEY || env.GOOGLE_API_KEY || env.GEMINI_API_KEY || env.NOLO_LOCAL_OPENAI_BASE_URL || env.OLLAMA_BASE_URL
+  );
+}
+function detectProviderLabel(env) {
+  if (env.NOLO_LOCAL_OPENAI_BASE_URL) return `openai-compatible endpoint ${env.NOLO_LOCAL_OPENAI_BASE_URL}`;
+  if (env.OLLAMA_BASE_URL) return `ollama-compatible endpoint ${env.OLLAMA_BASE_URL}`;
+  if (env.OPENAI_API_KEY) return "openai via env OPENAI_API_KEY";
+  if (env.ANTHROPIC_API_KEY) return "anthropic via env ANTHROPIC_API_KEY";
+  if (env.GOOGLE_API_KEY) return "google via env GOOGLE_API_KEY";
+  if (env.GEMINI_API_KEY) return "google via env GEMINI_API_KEY";
+  return "missing";
+}
+async function defaultLocalRuntimeProbe(env, deps = {}) {
+  const { resolveCliLocalRuntimeDbPath } = await import("./localRuntimeDb-LGDF6FQP.js");
+  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 db = deps.getDb ? await deps.getDb() : await import("./localRuntimeDb-LGDF6FQP.js").then(
+      ({ getDefaultCliLocalRuntimeDb }) => getDefaultCliLocalRuntimeDb({ env })
+    );
+    const authorityHealth = await (deps.probeAuthorityHealth ?? probeCliAuthorityBrokerHealth)({
+      endpoint: authorityEndpoint,
+      metadataPath: authorityMetadataPath,
+      healthPath: authorityHealthPath
+    });
+    if (!authorityHealth.ok) {
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        authorityHealthy: false,
+        authorityError: authorityHealth.error,
+        agentFound: false,
+        ...agentKey ? { agentKey } : {}
+      };
+    }
+    if (!agentKey) {
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        authorityHealthy: true,
+        agentFound: false
+      };
+    }
+    try {
+      const record = await db.get(agentKey);
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        authorityHealthy: true,
+        agentFound: record != null,
+        agentKey
+      };
+    } catch {
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        authorityHealthy: true,
+        agentFound: false,
+        agentKey
+      };
+    }
+  } catch (error) {
+    const errorMessage = toErrorMessage(error);
+    return {
+      ok: false,
+      dbPath,
+      authorityDriver,
+      authorityEndpoint,
+      authorityMetadataPath,
+      authorityHealthPath,
+      authorityHealthy: false,
+      authorityError: errorMessage,
+      agentFound: false,
+      ...agentKey ? { agentKey } : {},
+      error: errorMessage
+    };
+  }
+}
+async function runDoctorRuntimeCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveAuthToken(args, env);
+  const serverUrl = resolveServerUrl(args, env);
+  const localProbe = await (deps.localRuntimeProbe ?? defaultLocalRuntimeProbe)(env);
+  const hasLocalAgentConfig = detectLocalAgentConfig(env) && localProbe.ok && localProbe.agentFound;
+  const hasLocalProvider = detectLocalProvider(env);
+  const missingLocalCapabilities = [
+    ...localProbe.ok ? [] : ["leveldb"],
+    ...localProbe.authorityHealthy === false ? ["authority-broker"] : [],
+    ...hasLocalAgentConfig ? [] : ["agent-config"],
+    ...hasLocalProvider ? [] : ["provider"]
+  ];
+  const decision = resolveAgentRuntimeDecision({
+    requestedMode: "auto",
+    syncRequested: false,
+    host: "cli",
+    hasLocalAgentConfig,
+    hasLocalProvider,
+    hasLocalPersistence: true,
+    missingLocalCapabilities,
+    requiresServer: false,
+    serverFallbackAvailable: Boolean(
+      authToken || args.includes("--server") || args.includes("--server-url") || env.NOLO_SERVER || env.BASE_URL
+    )
+  });
+  output.write(`Runtime: ${decision.mode}
+`);
+  output.write(`Reason: ${decision.reason}
+`);
+  output.write(`LevelDB: ${localProbe.ok ? "ok" : "failed"}
+`);
+  output.write(`DB path: ${localProbe.dbPath}
+`);
+  output.write(`Authority driver: ${localProbe.authorityDriver ?? "unknown"}
+`);
+  if (localProbe.authorityEndpoint) {
+    output.write(`Authority endpoint: ${localProbe.authorityEndpoint}
+`);
+  }
+  if (localProbe.authorityMetadataPath) {
+    output.write(`Authority metadata: ${localProbe.authorityMetadataPath}
+`);
+  }
+  if (localProbe.authorityHealthPath) {
+    output.write(`Authority health: ${localProbe.authorityHealthPath}
+`);
+  }
+  output.write(
+    `Authority broker: ${localProbe.authorityHealthy === true ? "healthy" : localProbe.authorityHealthy === false ? "unhealthy" : "unknown"}
+`
+  );
+  if (localProbe.authorityHealthy === false && localProbe.authorityError) {
+    output.write(`Authority error: ${localProbe.authorityError}
+`);
+  }
+  if (!localProbe.ok && localProbe.error) {
+    output.write(`DB error: ${localProbe.error}
+`);
+  }
+  if (localProbe.agentKey) {
+    output.write(`Agent config: ${localProbe.agentFound ? "found" : "missing"} (${localProbe.agentKey})
+`);
+  } else {
+    output.write("Agent config: missing (no local agent key)\n");
+  }
+  output.write(`Provider: ${hasLocalProvider ? "available" : "missing"} (${detectProviderLabel(env)})
+`);
+  output.write("Persistence: LevelDB local store\n");
+  output.write(`Sync: ${authToken ? "available" : "unavailable"}${authToken ? "" : " (not authenticated)"}
+`);
+  output.write(`Server fallback: ${decision.runnable && decision.mode === "server" ? serverUrl : authToken || env.NOLO_SERVER || env.BASE_URL ? serverUrl : "unavailable"}
+`);
+  if (decision.missingLocalCapabilities.length > 0) {
+    output.write("Missing local capabilities:\n");
+    for (const capability of decision.missingLocalCapabilities) {
+      output.write(`- ${capability}
+`);
+    }
+  }
+  return decision.runnable ? 0 : 1;
+}
+export {
+  defaultLocalRuntimeProbe,
+  runDoctorRuntimeCommand
+};