nolo-cli 0.1.33 → 0.1.35

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

@@ -31,7 +31,7 @@ function readOption(args: string[], flag: string) {
 
 function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
   const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
-  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
+  const apiKey = readOption(args, "--machine-key") || readOption(args, "--token");
   return {
     ...runtimeEnv,
     ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
@@ -40,7 +40,7 @@ function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
 }
 
 export function looksLikeDaemonShortcut(args: string[]) {
-  return args.includes("--server-url") || args.includes("--api-key");
+  return args.includes("--server-url") || args.includes("--machine-key");
 }
 
 export function createCliRuntimeContext(args: {

package/cliEnvHelpers.ts

@@ -3,19 +3,17 @@ import { NOLO_CLUSTER_SERVERS } from "./database/config";
 
 export type EnvLike = Record<string, string | undefined>;
 
-export function resolveServerUrl(env: EnvLike) {
+export function resolveServerUrlFromEnv(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-export function resolveServerCandidates(env: EnvLike, preferred?: string | null) {
-  const values = [
-    preferred?.trim(),
-    env.NOLO_SERVER,
-    env.BASE_URL,
-    env.NOLO_SERVER_URL,
-    DEFAULT_NOLO_SERVER_URL,
-    ...NOLO_CLUSTER_SERVERS,
-  ];
+type ResolverInput = string[] | EnvLike;
+
+function isCliArgs(value: ResolverInput): value is string[] {
+  return Array.isArray(value);
+}
+
+function buildServerCandidates(values: Array<string | null | undefined>) {
   return [...new Set(
     values
       .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
@@ -23,8 +21,78 @@ export function resolveServerCandidates(env: EnvLike, preferred?: string | null)
   )];
 }
 
-export function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || "";
+export function resolveServerUrl(env: EnvLike): string;
+export function resolveServerUrl(args: string[], env: EnvLike): string;
+export function resolveServerUrl(input: ResolverInput, env?: EnvLike) {
+  if (isCliArgs(input)) {
+    const explicit =
+      readOption(input, "--server-url") ||
+      readOption(input, "--server");
+    return explicit?.replace(/\/+$/, "") || resolveServerUrlFromEnv(env ?? {});
+  }
+  return resolveServerUrlFromEnv(input);
+}
+
+export function resolveServerCandidates(env: EnvLike, preferred?: string | null): string[];
+export function resolveServerCandidates(
+  args: string[],
+  env: EnvLike,
+  preferred?: string | null,
+): string[];
+export function resolveServerCandidates(
+  input: ResolverInput,
+  envOrPreferred?: EnvLike | string | null,
+  preferred?: string | null,
+) {
+  if (isCliArgs(input)) {
+    const env = (envOrPreferred ?? {}) as EnvLike;
+    const explicitServer = resolveServerUrl(input, env);
+    return buildServerCandidates([
+      explicitServer,
+      preferred?.trim(),
+      env.NOLO_SERVER,
+      env.BASE_URL,
+      env.NOLO_SERVER_URL,
+      DEFAULT_NOLO_SERVER_URL,
+      ...NOLO_CLUSTER_SERVERS,
+    ]);
+  }
+
+  const env = input;
+  return buildServerCandidates([
+    typeof envOrPreferred === "string" ? envOrPreferred.trim() : undefined,
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+  ]);
+}
+
+export function resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {
+  for (const key of ["AUTH_TOKEN", "AUTH", ...extraEnvKeys]) {
+    const value = env[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+}
+
+export function resolveAuthToken(env: EnvLike, extraEnvKeys?: string[]): string;
+export function resolveAuthToken(args: string[], env: EnvLike, extraEnvKeys?: string[]): string;
+export function resolveAuthToken(
+  input: ResolverInput,
+  envOrExtraEnvKeys?: EnvLike | string[],
+  extraEnvKeys: string[] = [],
+) {
+  if (isCliArgs(input)) {
+    const env = (envOrExtraEnvKeys ?? {}) as EnvLike;
+    return (
+      readOption(input, "--token") ||
+      readOption(input, "--machine-key") ||
+      resolveAuthTokenFromEnv(env, extraEnvKeys)
+    );
+  }
+  return resolveAuthTokenFromEnv(input, (envOrExtraEnvKeys as string[] | undefined) ?? []);
 }
 
 export function parseUserIdFromAuthToken(token: string) {

package/cliSpaceHelpers.ts

@@ -0,0 +1,39 @@
+export function normalizeSpaceIdInput(rawInput: string) {
+  const raw = rawInput.trim();
+  if (!raw) return "";
+
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    const match = url.pathname.match(/^\/space\/([^/?#]+)/);
+    if (match?.[1]) return decodeURIComponent(match[1]);
+  }
+
+  return raw.startsWith("space-") ? raw.slice("space-".length) : raw;
+}
+
+export function buildSpaceLookup(rawInput: string) {
+  const spaceId = normalizeSpaceIdInput(rawInput);
+  return {
+    spaceId,
+    spaceKey: spaceId.startsWith("space-") ? spaceId : `space-${spaceId}`,
+  };
+}
+
+export function getSpaceContentKeys(spaceRecord: any): Set<string> {
+  const keys = new Set<string>();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+
+  for (const [entryKey, value] of Object.entries(contents)) {
+    if (typeof entryKey === "string" && entryKey.trim()) {
+      keys.add(entryKey.trim());
+    }
+    if (value && typeof value === "object") {
+      const contentKey = (value as any).contentKey;
+      if (typeof contentKey === "string" && contentKey.trim()) {
+        keys.add(contentKey.trim());
+      }
+    }
+  }
+  return keys;
+}

package/client/agentRun.ts

@@ -778,6 +778,7 @@ async function runLocalAgentTurnForCli(
       background: options.background,
       noStream: options.noStream,
       maxToolRounds: options.maxToolRounds,
+      ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
       ...(traceLocalTools || collectToolEvidence
         ? {
             onToolEvent: (event) => {

package/client/localProviderResolver.test.ts

@@ -11,15 +11,18 @@ describe("CLI local provider resolver", () => {
         provider: "custom",
         apiSource: "custom",
         customProviderUrl: "https://provider.example/v1/chat/completions",
+        apiKey: "sk-agent-custom",
+        apiKeyHeader: "api-key",
       },
       env: {
-        OPENAI_API_KEY: "sk-env",
+        OPENAI_API_KEY: "sk-env-should-not-win",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
       },
     })).toEqual({
       model: "qwen-coder",
       endpoint: "https://provider.example/v1/chat/completions",
-      apiKey: "sk-env",
+      apiKey: "sk-agent-custom",
+      apiKeyHeader: "api-key",
       provider: "custom",
       requestOptions: {},
     });
@@ -53,6 +56,27 @@ describe("CLI local provider resolver", () => {
     });
   });
 
+  test("defaults Xiaomi custom endpoints to api-key auth header", () => {
+    expect(resolveCliOpenAiProviderConfig({
+      agentConfig: {
+        key: "agent-user-1-mimo",
+        provider: "custom",
+        apiSource: "custom",
+        model: "mimo-v2.5-pro",
+        customProviderUrl: "https://token-plan-cn.xiaomimimo.com/v1",
+        apiKey: "mimo-monthly-key",
+      },
+      env: {},
+    })).toEqual({
+      model: "mimo-v2.5-pro",
+      endpoint: "https://token-plan-cn.xiaomimimo.com/v1/chat/completions",
+      apiKey: "mimo-monthly-key",
+      apiKeyHeader: "api-key",
+      provider: "custom",
+      requestOptions: {},
+    });
+  });
+
   test("carries explicit agent inference options for request body construction", () => {
     expect(resolveCliOpenAiProviderConfig({
       agentConfig: {