nolo-cli 0.1.33 → 0.1.35

package/runtimeDoctorCommands.ts

@@ -1,4 +1,10 @@
 import { resolveAgentRuntimeDecision } from "./agent-runtime/runtimeDecision";
+import {
+  resolveCliAuthorityBrokerEndpoint,
+  resolveCliAuthorityBrokerHealthPath,
+  resolveCliAuthorityBrokerMetadataPath,
+  resolveCliAuthorityStoreDriver,
+} from "./database/server/cliAuthorityStoreDriver";
 import {
   type AgentCommandDeps,
   type LocalRuntimeProbeResult,
@@ -39,23 +45,57 @@ function detectProviderLabel(env: EnvLike) {
 async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
   const { resolveCliLocalRuntimeDbPath } = await import("./localRuntimeDb");
   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 { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb");
-    const db = await getDefaultCliLocalRuntimeDb();
+    const db = await getDefaultCliLocalRuntimeDb({ env });
     if (!agentKey) {
-      return { ok: true, dbPath, agentFound: false };
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        agentFound: false,
+      };
     }
     try {
-      await db.get(agentKey);
-      return { ok: true, dbPath, agentFound: true, agentKey };
+      const record = await db.get(agentKey);
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        agentFound: record != null,
+        agentKey,
+      };
     } catch {
-      return { ok: true, dbPath, agentFound: false, agentKey };
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        agentFound: false,
+        agentKey,
+      };
     }
   } catch (error) {
     return {
       ok: false,
       dbPath,
+      authorityDriver,
+      authorityEndpoint,
+      authorityMetadataPath,
+      authorityHealthPath,
       agentFound: false,
       ...(agentKey ? { agentKey } : {}),
       error: error instanceof Error ? error.message : String(error),
@@ -64,13 +104,13 @@ async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbe
 }
 
 export async function runDoctorRuntimeCommand(
-  _args: string[],
+  args: string[],
   deps: AgentCommandDeps = {}
 ) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
-  const authToken = resolveAuthToken(env);
-  const serverUrl = resolveServerUrl(env);
+  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);
@@ -88,13 +128,29 @@ export async function runDoctorRuntimeCommand(
     hasLocalPersistence: true,
     missingLocalCapabilities,
     requiresServer: false,
-    serverFallbackAvailable: Boolean(authToken || env.NOLO_SERVER || env.BASE_URL),
+    serverFallbackAvailable: Boolean(
+      authToken ||
+      args.includes("--server") ||
+      args.includes("--server-url") ||
+      env.NOLO_SERVER ||
+      env.BASE_URL
+    ),
   });
 
   output.write(`Runtime: ${decision.mode}\n`);
   output.write(`Reason: ${decision.reason}\n`);
   output.write(`LevelDB: ${localProbe.ok ? "ok" : "failed"}\n`);
   output.write(`DB path: ${localProbe.dbPath}\n`);
+  output.write(`Authority driver: ${localProbe.authorityDriver ?? "unknown"}\n`);
+  if (localProbe.authorityEndpoint) {
+    output.write(`Authority endpoint: ${localProbe.authorityEndpoint}\n`);
+  }
+  if (localProbe.authorityMetadataPath) {
+    output.write(`Authority metadata: ${localProbe.authorityMetadataPath}\n`);
+  }
+  if (localProbe.authorityHealthPath) {
+    output.write(`Authority health: ${localProbe.authorityHealthPath}\n`);
+  }
   if (!localProbe.ok && localProbe.error) {
     output.write(`DB error: ${localProbe.error}\n`);
   }

package/tableCommands.ts

@@ -80,7 +80,7 @@ function resolveServerUrl(args: string[], env: EnvLike): string {
 
 function resolveAuthToken(args: string[], env: EnvLike): string {
   return (
-    readOption(args, "--api-key") ||
+    readOption(args, "--machine-key") ||
     readOption(args, "--token") ||
     env.AUTH_TOKEN ||
     env.AUTH ||

package/taskRunCommand.ts

@@ -82,7 +82,7 @@ function resolveServerUrl(args: string[], env: EnvLike) {
 
 function resolveAuthToken(args: string[], env: EnvLike) {
   return (
-    readOption(args, "--api-key") ||
+    readOption(args, "--machine-key") ||
     readOption(args, "--token") ||
     env.NOLO_TASK_RUN_TOKEN ||
     env.NOLO_MACHINE_API_KEY ||

package/database/server/db.ts

@@ -1,118 +0,0 @@
-// 文件路径: packages/database/server/db.ts
-
-import { Level } from "level";
-import path from "path";
-import fs from "fs";
-import { ensureDbOpen } from "./ensureDbOpen";
-import { resolveServerDbPath } from "./dbPath";
-
-const DB_PATH = resolveServerDbPath();
-
-// 确保目录存在
-if (!fs.existsSync(path.dirname(DB_PATH))) {
-  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
-}
-
-console.log("数据库配置:");
-console.log("- 当前工作目录:", process.cwd());
-console.log("- 数据库路径:", DB_PATH);
-
-// 安全 JSON 编码：解码失败时返回 null 而非抛异常，防止损坏记录导致进程崩溃
-const safeJsonEncoding = {
-  name: "safe-json",
-  format: "utf8" as const,
-  encode: (data: any) => JSON.stringify(data),
-  decode: (data: string) => {
-    try {
-      return JSON.parse(data);
-    } catch {
-      console.warn("[LevelDB] Corrupted value:", data?.substring?.(0, 60));
-      return null;
-    }
-  },
-};
-
-export function isServerDbLockError(error: unknown): boolean {
-  const queue: unknown[] = [error];
-  const seen = new Set<unknown>();
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || seen.has(current)) continue;
-    seen.add(current);
-
-    const text = `${(current as any)?.code ?? ""} ${(current as any)?.message ?? current}`;
-    if (/LEVEL_LOCKED|Resource temporarily unavailable|\/LOCK|LOCK:/.test(text)) {
-      return true;
-    }
-
-    if ((current as any)?.cause) queue.push((current as any).cause);
-    if (Array.isArray((current as any)?.errors)) {
-      queue.push(...(current as any).errors);
-    }
-  }
-
-  return false;
-}
-
-// 单例实例：挂在 globalThis 上，--hot 模式下模块重新求值时复用同一实例，避免 LevelDB 锁冲突
-if (!(globalThis as any).__serverDb) {
-  (globalThis as any).__serverDb = new Level<string, any>(DB_PATH, {
-    valueEncoding: safeJsonEncoding,
-  });
-}
-const serverDb: Level<string, any> = (globalThis as any).__serverDb;
-
-console.log("- LevelDB实际路径:", serverDb.location);
-
-// ✅ 保留默认导出：兼容现有的 import serverDb from "./db"
-export default serverDb;
-
-// 具名导出：需要的时候可以引用
-export { serverDb };
-
-/**
- * 确保数据库处于 open 状态。
- * - 已 open / opening：直接返回
- * - 其他状态：尝试 open，一旦失败抛错
- */
-export async function ensureServerDbOpen() {
-  const status = (serverDb as any).status;
-  if (status === "open") return;
-
-  try {
-    await ensureDbOpen(serverDb);
-    if (status !== "opening") {
-      console.log("✅ LevelDB 已打开");
-    }
-  } catch (err) {
-    if (isServerDbLockError(err)) {
-      console.error("❌ 打开 LevelDB 失败: 数据库已被其他进程占用");
-    } else {
-      console.error("❌ 打开 LevelDB 失败:", err);
-    }
-    throw err;
-  }
-}
-
-/**
- * 兼容入口调用：启动时显式 open 一次
- */
-export async function openServerDb() {
-  return ensureServerDbOpen();
-}
-
-/**
- * 优雅关机时关闭 DB
- */
-export async function closeServerDb() {
-  const status = (serverDb as any).status;
-  if (status !== "open") return;
-
-  try {
-    await serverDb.close();
-    console.log("✅ LevelDB 已关闭");
-  } catch (err) {
-    console.error("❌ 关闭 LevelDB 失败:", err);
-  }
-}

package/database/server/ensureDbOpen.ts

@@ -1,12 +0,0 @@
-export type DbWithOpenStatus = {
-  status?: string | null;
-  open(): Promise<unknown>;
-};
-
-export async function ensureDbOpen(db: DbWithOpenStatus) {
-  if (db.status === "open") {
-    return;
-  }
-
-  await db.open();
-}