nolo-cli 0.1.23 → 0.1.29

package/agentRuntimeCommands.ts

@@ -1,701 +1,7 @@
-import type { MachineHeartbeat } from "./connector-experimental/protocol";
-import { detectMachineInfo } from "./connector-experimental/machineInfo";
-import { resolveAgentRuntimeDecision } from "./agent-runtime/runtimeDecision";
-import { resolveCliLocalRuntimeDbPath } from "./localRuntimeDb";
-import { resolveMachineRunPermissionPolicy } from "./ai/agent/machineRunPermissions";
-import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
-import { resolveCliAgentKeyInput } from "./agentAliases";
-import { handleConnectorRunMessage } from "./machineCommands";
-
-type EnvLike = Record<string, string | undefined>;
-type OutputLike = { write(chunk: string): unknown };
-type SmokeWebSocketOptions = {
-  headers: Record<string, string>;
-  onMessage: (message: string) => void | Promise<void>;
-  onOpen: () => void | Promise<void>;
-  sentMessages: string[];
-};
-type LocalCliExecutor = (
-  provider: string,
-  prompt: string,
-  options: { model?: string; timeout?: number; cwd?: string; yolo?: boolean }
-) => Promise<{ text: string; raw?: string; elapsed?: number }>;
-type LocalRuntimeProbeResult = {
-  ok: boolean;
-  dbPath: string;
-  agentFound: boolean;
-  agentKey?: string;
-  error?: string;
-};
-
-type AgentRuntimeCommandDeps = {
-  env?: EnvLike;
-  output?: OutputLike;
-  fetchImpl?: typeof fetch;
-  fallbackFetchImpl?: typeof fetch;
-  machineInfo?: () => MachineHeartbeat;
-  connectWebSocket?: (url: string, options: SmokeWebSocketOptions) => Promise<void>;
-  executeCli?: LocalCliExecutor;
-  localRuntimeProbe?: (env: EnvLike) => Promise<LocalRuntimeProbeResult>;
-};
-
-function resolveServerUrl(env: EnvLike) {
-  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
-}
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || "";
-}
-
-function detectLocalAgentConfig(env: EnvLike) {
-  return Boolean(readLocalAgentKey(env) || env.NOLO_AGENT_CACHE_READY);
-}
-
-function readLocalAgentKey(env: EnvLike) {
-  return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
-}
-
-function detectLocalProvider(env: EnvLike) {
-  return Boolean(
-    env.OPENAI_API_KEY ||
-    env.ANTHROPIC_API_KEY ||
-    env.GOOGLE_API_KEY ||
-    env.NOLO_LOCAL_OPENAI_BASE_URL ||
-    env.OLLAMA_BASE_URL
-  );
-}
-
-function detectProviderLabel(env: EnvLike) {
-  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";
-  return "missing";
-}
-
-async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
-  const dbPath = resolveCliLocalRuntimeDbPath({ env });
-  const agentKey = readLocalAgentKey(env);
-  try {
-    const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb");
-    const db = await getDefaultCliLocalRuntimeDb();
-    if (!agentKey) {
-      return { ok: true, dbPath, agentFound: false };
-    }
-    try {
-      await db.get(agentKey);
-      return { ok: true, dbPath, agentFound: true, agentKey };
-    } catch {
-      return { ok: true, dbPath, agentFound: false, agentKey };
-    }
-  } catch (error) {
-    return {
-      ok: false,
-      dbPath,
-      agentFound: false,
-      ...(agentKey ? { agentKey } : {}),
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-function parseUserIdFromAuthToken(token: string) {
-  const payload = token.trim().split(".")[0];
-  if (!payload) return "";
-  try {
-    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
-    return typeof parsed?.userId === "string" ? parsed.userId : "";
-  } catch {
-    return "";
-  }
-}
-
-function readOption(args: string[], flag: string) {
-  const index = args.indexOf(flag);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-async function defaultExecuteCli(
-  provider: string,
-  prompt: string,
-  options: { model?: string; timeout?: number; cwd?: string; yolo?: boolean }
-) {
-  const { executeCli } = await import("./ai/agent/cliExecutor");
-  return executeCli(provider as any, prompt, options);
-}
-
-function detectLaunchableMachineInfo() {
-  return detectMachineInfo({ probeLaunchable: true });
-}
-
-function requiredCapabilityForAgent(agent: any) {
-  if (agent?.apiSource !== "cli") return "";
-  const cliProvider = String(agent?.cliProvider || "").trim();
-  const capabilityByProvider: Record<string, string> = {
-    codex: "codex-cli",
-    claude: "claude-code",
-    copilot: "copilot-cli",
-    gemini: "gemini-cli",
-    kimi: "kimi-cli",
-  };
-  return capabilityByProvider[cliProvider] ?? "";
-}
-
-function classifyAgentRuntime(agent: any) {
-  if (agent?.apiSource === "cli") return "cli-machine";
-  if (agent?.apiSource === "platform" || agent?.useServerProxy) return "platform-local-loop";
-  if (agent?.apiSource === "local") return "local-provider-loop";
-  return "unknown";
-}
-
-function shouldRuntimeDoctorPass(args: {
-  runtimeClass: string;
-  requiredCapability: string;
-  hasCapability: boolean;
-}) {
-  if (args.runtimeClass !== "cli-machine") return args.runtimeClass !== "unknown";
-  return Boolean(args.requiredCapability && args.hasCapability);
-}
-
-function assertSmokeCompatible(agent: any, machine: MachineHeartbeat) {
-  if (agent?.apiSource !== "cli") {
-    throw new Error(`Agent ${agent?.name ?? agent?.dbKey ?? "unknown"} is not a CLI agent.`);
-  }
-  const requiredCapability = requiredCapabilityForAgent(agent);
-  if (!requiredCapability) {
-    throw new Error(`Agent ${agent?.name ?? agent?.dbKey ?? "unknown"} has unsupported cliProvider: ${agent?.cliProvider ?? "missing"}.`);
-  }
-  if (!machine.capabilities.includes(requiredCapability)) {
-    const currentCapabilities = machine.capabilities.length
-      ? machine.capabilities.join(", ")
-      : "none";
-    throw new Error(
-      `Agent ${agent?.name ?? agent?.dbKey ?? "unknown"} requires ${requiredCapability}; current machine capabilities: ${currentCapabilities}.`
-    );
-  }
-}
-
-const CONNECTOR_WS_KEEPALIVE_MS = 25_000;
-
-function buildConnectorKeepaliveMessage() {
-  return JSON.stringify({ type: "connector.keepalive", sentAt: Date.now() });
-}
-
-async function defaultConnectWebSocket(url: string, options: SmokeWebSocketOptions) {
-  const WebSocketCtor = globalThis.WebSocket;
-  if (!WebSocketCtor) {
-    throw new Error("WebSocket is not available in this runtime");
-  }
-  await new Promise<void>((resolve, reject) => {
-    const ws = new WebSocketCtor(url, { headers: options.headers } as any);
-    let keepalive: ReturnType<typeof setInterval> | null = null;
-    const clearKeepalive = () => {
-      if (keepalive) {
-        clearInterval(keepalive);
-        keepalive = null;
-      }
-    };
-    ws.addEventListener("open", () => {
-      keepalive = setInterval(() => {
-        try {
-          ws.send(buildConnectorKeepaliveMessage());
-        } catch {
-          clearKeepalive();
-        }
-      }, CONNECTOR_WS_KEEPALIVE_MS);
-      Promise.resolve(options.onOpen())
-        .then(() => ws.close())
-        .catch((error) => {
-          ws.close();
-          reject(error);
-        });
-    }, { once: true });
-    ws.addEventListener("error", () => {
-      clearKeepalive();
-      reject(new Error("connector websocket failed"));
-    });
-    ws.addEventListener("close", () => {
-      clearKeepalive();
-      resolve();
-    }, { once: true });
-    ws.addEventListener("message", (event) => {
-      const startIndex = options.sentMessages.length;
-      Promise.resolve(options.onMessage(String(event.data))).then(() => {
-        for (const message of options.sentMessages.slice(startIndex)) {
-          ws.send(message);
-        }
-      }).catch(reject);
-    });
-  });
-}
-
-async function readAgentRecord(args: {
-  agentKey: string;
-  authToken: string;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  serverUrl: string;
-}) {
-  const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.agentKey)}`,
-    {
-      method: "GET",
-      headers: { Authorization: `Bearer ${args.authToken}` },
-    },
-    args
-  );
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    throw new Error(`read failed: HTTP ${res.status} ${JSON.stringify(data)}`);
-  }
-  return data?.data ?? data;
-}
-
-async function writeAgentRecord(args: {
-  agentKey: string;
-  authToken: string;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  serverUrl: string;
-  userId: string;
-  record: Record<string, any>;
-}) {
-  const res = await fetchWithTransportFallback(`${args.serverUrl}/api/v1/db/write/`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${args.authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      customKey: args.agentKey,
-      userId: args.userId,
-      data: {
-        ...args.record,
-        dbKey: args.agentKey,
-      },
-    }),
-  }, args);
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    throw new Error(`write failed: HTTP ${res.status} ${JSON.stringify(data)}`);
-  }
-}
-
-function shouldUseCurlTransportFallback(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
-  return /Unable to connect|ConnectionRefused|ECONNREFUSED|Failed to connect|Was there a typo|timed out|Timeout|handshake|certificate|ECONNRESET|socket|network/i.test(message);
-}
-
-async function curlFetch(url: string, init?: RequestInit): Promise<Response> {
-  const method = init?.method ?? "GET";
-  const headers = new Headers(init?.headers ?? {});
-  const command = ["curl", "-sS", "-L", "-X", method];
-
-  headers.forEach((value, key) => {
-    command.push("-H", `${key}: ${value}`);
-  });
-
-  if (typeof init?.body === "string" && init.body.length > 0) {
-    command.push("--data", init.body);
-  }
-
-  command.push("-w", "\n__NOLO_STATUS__:%{http_code}", url);
-  const proc = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-  if (exitCode !== 0) {
-    throw new Error(stderr.trim() || `curl failed for ${url}`);
-  }
-
-  const marker = "\n__NOLO_STATUS__:";
-  const markerIndex = stdout.lastIndexOf(marker);
-  const body = markerIndex >= 0 ? stdout.slice(0, markerIndex) : stdout;
-  const statusText = markerIndex >= 0 ? stdout.slice(markerIndex + marker.length).trim() : "0";
-  const status = Number(statusText);
-  return new Response(body, {
-    status: Number.isFinite(status) ? status : 0,
-    headers: { "Content-Type": headers.get("Content-Type") ?? "application/json" },
-  });
-}
-
-async function fetchWithTransportFallback(
-  url: string,
-  init: RequestInit,
-  options: { fallbackFetchImpl?: typeof fetch; fetchImpl: typeof fetch }
-): Promise<Response> {
-  try {
-    return await options.fetchImpl(url, init);
-  } catch (error) {
-    if (!shouldUseCurlTransportFallback(error)) throw error;
-    if (options.fallbackFetchImpl) {
-      return options.fallbackFetchImpl(url, init);
-    }
-    if (options.fetchImpl !== fetch) throw error;
-    return curlFetch(url, init);
-  }
-}
-
-async function heartbeatCurrentMachine(args: {
-  authToken: string;
-  fetchImpl: typeof fetch;
-  machine: MachineHeartbeat;
-  serverUrl: string;
-}) {
-  const res = await args.fetchImpl(`${args.serverUrl}/api/machines/heartbeat`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${args.authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(args.machine),
-  });
-  const text = await res.text().catch(() => "");
-  if (!res.ok) {
-    throw new Error(`heartbeat failed: HTTP ${res.status} ${text}`);
-  }
-}
-
-export async function runAgentBindCurrentCommand(
-  args: string[],
-  deps: AgentRuntimeCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const agentKey = args[0]?.trim();
-  if (!agentKey || agentKey === "--help" || agentKey === "-h") {
-    output.write("Usage: nolo agent bind-current <agentKey>\n");
-    return agentKey ? 0 : 1;
-  }
-
-  const authToken = resolveAuthToken(env);
-  if (!authToken) {
-    output.write("[nolo] agent bind-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
-    return 1;
-  }
-
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    output.write("[nolo] agent bind-current could not read userId from AUTH_TOKEN.\n");
-    return 1;
-  }
-
-  const serverUrl = resolveServerUrl(env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
-
-  try {
-    await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
-    const updated = {
-      ...existing,
-      runtimeBinding: {
-        ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
-          ? existing.runtimeBinding
-          : {}),
-        machineId: machine.machineId,
-        ownerUserId: userId,
-      },
-      updatedAt: Date.now(),
-    };
-    await writeAgentRecord({
-      agentKey,
-      authToken,
-      fallbackFetchImpl,
-      fetchImpl,
-      serverUrl,
-      userId,
-      record: updated,
-    });
-  } catch (error) {
-    output.write(
-      `[nolo] agent bind-current failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-
-  output.write(`Bound agent ${agentKey} to this machine: ${machine.name} (${machine.machineId})\n`);
-  return 0;
-}
-
-export async function runAgentReadCommand(
-  args: string[],
-  deps: AgentRuntimeCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const agentInput = args[0]?.trim();
-  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent read <agent>\n");
-    return agentInput ? 0 : 1;
-  }
-
-  const authToken = resolveAuthToken(env);
-  if (!authToken) {
-    output.write("[nolo] agent read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
-    return 1;
-  }
-
-  const agentKey = resolveCliAgentKeyInput(agentInput);
-  const serverUrl = resolveServerUrl(env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-
-  try {
-    const agent = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
-    output.write(JSON.stringify({
-      agentKey,
-      baseUrl: serverUrl,
-      name: agent?.name,
-      greeting: agent?.greeting,
-      model: agent?.model,
-      provider: agent?.provider ?? agent?.apiSource ?? null,
-      customProviderUrl: agent?.customProviderUrl ?? null,
-      tools: agent?.tools ?? [],
-      isPublic: agent?.isPublic,
-      authUserId: parseUserIdFromAuthToken(authToken),
-      userId: agent?.userId,
-      record: agent,
-    }, null, 2));
-    output.write("\n");
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] agent read failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}
-
-export async function runAgentSmokeCurrentCommand(
-  args: string[],
-  deps: AgentRuntimeCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const agentInput = args[0]?.trim();
-  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent smoke-current <agent> --msg \"hello\"\n");
-    return agentInput ? 0 : 1;
-  }
-  const agentKey = resolveCliAgentKeyInput(agentInput);
-
-  const authToken = resolveAuthToken(env);
-  if (!authToken) {
-    output.write("[nolo] agent smoke-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
-    return 1;
-  }
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    output.write("[nolo] agent smoke-current could not read userId from AUTH_TOKEN.\n");
-    return 1;
-  }
-
-  const userInput = readOption(args, "--msg") ?? "Smoke test from nolo connector.";
-  const serverUrl = resolveServerUrl(env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
-  const sentMessages: string[] = [];
-
-  try {
-    await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
-    assertSmokeCompatible(existing, machine);
-    await writeAgentRecord({
-      agentKey,
-      authToken,
-      fallbackFetchImpl,
-      fetchImpl,
-      serverUrl,
-      userId,
-      record: {
-        ...existing,
-        runtimeBinding: {
-          ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
-            ? existing.runtimeBinding
-            : {}),
-          machineId: machine.machineId,
-          ownerUserId: userId,
-        },
-        updatedAt: Date.now(),
-      },
-    });
-
-    let runResponse: any = null;
-    const wsTarget = await resolveConnectorWebSocketTarget({
-      serverUrl,
-      machineId: machine.machineId,
-      headers: { Authorization: `Bearer ${authToken}` },
-      fetchImpl,
-    });
-    await (deps.connectWebSocket ?? defaultConnectWebSocket)(
-      wsTarget,
-      {
-        headers: { Authorization: `Bearer ${authToken}` },
-        sentMessages,
-        onMessage: (message) => handleConnectorRunMessage(
-          machine,
-          message,
-          (response) => sentMessages.push(response),
-          deps.executeCli ?? defaultExecuteCli,
-          {
-            ...env,
-            NOLO_SERVER: serverUrl,
-            NOLO_SERVER_URL: serverUrl,
-            BASE_URL: serverUrl,
-            AUTH_TOKEN: authToken,
-            NOLO_MACHINE_API_KEY: authToken,
-          },
-          fetchImpl
-        ),
-        onOpen: async () => {
-          const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${authToken}`,
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-              agentKey,
-              userInput,
-              stream: false,
-            }),
-          });
-          runResponse = await res.json().catch(() => ({}));
-          if (!res.ok) {
-            throw new Error(`agent run failed: HTTP ${res.status} ${JSON.stringify(runResponse)}`);
-          }
-        },
-      }
-    );
-    output.write(`Smoke OK: ${runResponse?.dialogId ?? "no-dialog"}\n`);
-    if (runResponse?.content) output.write(`${runResponse.content}\n`);
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] agent smoke-current failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}
-
-export async function runAgentRuntimeDoctorCommand(
-  args: string[],
-  deps: AgentRuntimeCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const agentInput = args[0]?.trim();
-  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent runtime-doctor <agentKey>\n");
-    return agentInput ? 0 : 1;
-  }
-  const agentKey = resolveCliAgentKeyInput(agentInput);
-
-  const authToken = resolveAuthToken(env);
-  if (!authToken) {
-    output.write("[nolo] agent runtime-doctor requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
-    return 1;
-  }
-
-  const serverUrl = resolveServerUrl(env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
-
-  try {
-    const agent = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
-    const requiredCapability = requiredCapabilityForAgent(agent);
-    const runtimeClass = classifyAgentRuntime(agent);
-    const isBoundToCurrent = agent?.runtimeBinding?.machineId === machine.machineId;
-    const hasCapability = requiredCapability
-      ? machine.capabilities.includes(requiredCapability)
-      : false;
-    output.write(`Agent runtime doctor: ${agent?.name ?? agentKey}\n`);
-    if (agentInput !== agentKey) output.write(`Agent input: ${agentInput}\n`);
-    output.write(`Agent key: ${agentKey}\n`);
-    output.write(`Runtime class: ${runtimeClass}\n`);
-    output.write(`API source: ${agent?.apiSource ?? "unknown"}\n`);
-    output.write(`CLI provider: ${agent?.cliProvider ?? "none"}\n`);
-    output.write(`Required capability: ${requiredCapability || "none"}\n`);
-    output.write(`Current machine: ${machine.name} (${machine.machineId})\n`);
-    output.write(`Current machine capabilities: ${machine.capabilities.length ? machine.capabilities.join(", ") : "none"}\n`);
-    output.write(`Current machine binding: ${runtimeClass === "cli-machine" ? (isBoundToCurrent ? "yes" : "no") : "not required"}\n`);
-    output.write(`Current machine has required capability: ${requiredCapability ? (hasCapability ? "yes" : "no") : "not required"}\n`);
-
-    return shouldRuntimeDoctorPass({ runtimeClass, requiredCapability, hasCapability }) ? 0 : 1;
-  } catch (error) {
-    output.write(
-      `[nolo] agent runtime-doctor failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}
-
-export async function runDoctorRuntimeCommand(
-  _args: string[],
-  deps: AgentRuntimeCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const authToken = resolveAuthToken(env);
-  const serverUrl = resolveServerUrl(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"]),
-    ...(hasLocalAgentConfig ? [] : ["agent-config"]),
-    ...(hasLocalProvider ? [] : ["provider"]),
-  ];
-  const decision = resolveAgentRuntimeDecision({
-    requestedMode: "auto",
-    syncRequested: false,
-    host: "cli",
-    hasLocalAgentConfig,
-    hasLocalProvider,
-    hasLocalPersistence: true,
-    missingLocalCapabilities,
-    requiresServer: false,
-    serverFallbackAvailable: Boolean(authToken || 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`);
-  if (!localProbe.ok && localProbe.error) {
-    output.write(`DB error: ${localProbe.error}\n`);
-  }
-  if (localProbe.agentKey) {
-    output.write(`Agent config: ${localProbe.agentFound ? "found" : "missing"} (${localProbe.agentKey})\n`);
-  } else {
-    output.write("Agent config: missing (no local agent key)\n");
-  }
-  output.write(`Provider: ${hasLocalProvider ? "available" : "missing"} (${detectProviderLabel(env)})\n`);
-  output.write("Persistence: LevelDB local store\n");
-  output.write(`Sync: ${authToken ? "available" : "unavailable"}${authToken ? "" : " (not authenticated)"}\n`);
-  output.write(`Server fallback: ${decision.runnable && decision.mode === "server" ? serverUrl : authToken || env.NOLO_SERVER || env.BASE_URL ? serverUrl : "unavailable"}\n`);
-  if (decision.missingLocalCapabilities.length > 0) {
-    output.write("Missing local capabilities:\n");
-    for (const capability of decision.missingLocalCapabilities) {
-      output.write(`- ${capability}\n`);
-    }
-  }
-
-  return decision.runnable ? 0 : 1;
-}
+export { runAgentListCommand } from "./agentListCommands";
+export {
+  runAgentBindCurrentCommand,
+  runAgentRuntimeDoctorCommand,
+  runAgentSmokeCurrentCommand,
+} from "./agentMachineCommands";
+export { runDoctorRuntimeCommand } from "./runtimeDoctorCommands";