nolo-cli 0.6.1 → 0.8.0-alpha.10

package/agentListCommands-FATQEUYT.js

@@ -0,0 +1,219 @@
+import {
+  decorateAgentsWithPublicStatusAcrossServers,
+  listLocalCachedAgents,
+  listRemoteAgents,
+  listRemoteAgentsAcrossServers,
+  parseAgentListArgs
+} from "./chunk-OOYVBFM7.js";
+import {
+  buildSpaceLookup,
+  getSpaceContentKeys
+} from "./chunk-4CQLVGRV.js";
+import {
+  readLiveDbRecordAfterTombstoneMerge
+} from "./chunk-QUWDTOUP.js";
+import {
+  getReadableCliDb
+} from "./chunk-W4NVOSFF.js";
+import {
+  queryUserRecords,
+  readDbRecord
+} from "./chunk-FQZWM5YX.js";
+import "./chunk-HD63YREL.js";
+import "./chunk-VHBWHNVT.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-IDZTNRP2.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import "./chunk-6P2WX5IA.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-TILFE6LV.js";
+import "./chunk-NEMRK4EK.js";
+import "./chunk-XDVAYP26.js";
+import "./chunk-LM25IZBJ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-572EKYLF.js";
+import "./chunk-TDIQFT2F.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-DWLEOOGR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.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 "./chunk-4VNS5WPM.js";
+
+// packages/cli/agentListCommands.ts
+async function runAgentListCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const { wantJson, publicOnly, idsOnly } = parseAgentListArgs(args);
+  const spaceInput = readOption(args, "--space") ?? readOption(args, "--space-id");
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent list requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent list could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const serverUrl = resolveServerUrl(args, env);
+  const serverUrls = resolveServerCandidates(args, env, serverUrl);
+  try {
+    let agents;
+    let source;
+    let serverFailures = [];
+    try {
+      const remoteResult = await listRemoteAgentsAcrossServers({
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls,
+        userId
+      });
+      agents = remoteResult.agents;
+      serverFailures = remoteResult.failures;
+      source = "global-cache";
+    } catch {
+      try {
+        const db = deps.db ?? await getReadableCliDb(output);
+        agents = await listLocalCachedAgents({ db, userId });
+        source = "local-cache";
+      } catch {
+        agents = await listRemoteAgents({
+          authToken,
+          fallbackFetchImpl,
+          fetchImpl,
+          serverUrl,
+          userId,
+          queryUserRecords,
+          readDbRecord
+        });
+        source = "remote-cache";
+      }
+    }
+    agents = agents.filter((agent) => agent.privateKey.startsWith("agent-"));
+    let resolvedSpaceId = null;
+    if (spaceInput) {
+      const { spaceId, spaceKey } = buildSpaceLookup(spaceInput);
+      resolvedSpaceId = spaceId;
+      const spaceRead = await readLiveDbRecordAfterTombstoneMerge({
+        authToken,
+        dbKey: spaceKey,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls
+      });
+      serverFailures = [...serverFailures, ...spaceRead.failures];
+      const spaceRecord = spaceRead.record;
+      const spaceContentKeys = getSpaceContentKeys(spaceRecord);
+      agents = agents.filter(
+        (agent) => spaceContentKeys.has(agent.privateKey) || spaceContentKeys.has(agent.publicKey) || spaceContentKeys.has(agent.id)
+      );
+    }
+    if (source === "global-cache") {
+      await decorateAgentsWithPublicStatusAcrossServers({
+        agents,
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls
+      });
+    }
+    if (publicOnly) {
+      agents = agents.filter((agent) => agent.publicRecordExists);
+    }
+    if (idsOnly) {
+      output.write(`${agents.map((agent) => agent.id).join("\n")}
+`);
+      return 0;
+    }
+    if (wantJson) {
+      output.write(JSON.stringify({
+        userId,
+        ...resolvedSpaceId ? { spaceId: resolvedSpaceId } : {},
+        targetServers: serverUrls,
+        ...serverFailures.length ? { serverFailures } : {},
+        total: agents.length,
+        publicCount: agents.filter((agent) => agent.publicRecordExists).length,
+        source,
+        agents
+      }, null, 2));
+      output.write("\n");
+      return 0;
+    }
+    output.write(`userId: ${userId}
+`);
+    if (resolvedSpaceId) {
+      output.write(`spaceId: ${resolvedSpaceId}
+`);
+    }
+    output.write(`targetServers: ${serverUrls.join(", ")}
+`);
+    if (serverFailures.length) {
+      output.write(`serverFailures: ${serverFailures.length}
+`);
+    }
+    output.write(`total agents: ${agents.length}
+`);
+    output.write(`public agents: ${agents.filter((agent) => agent.publicRecordExists).length}
+`);
+    output.write(`source: ${source}
+`);
+    if (agents.length === 0) {
+      output.write("\n(no agents found)\n");
+      return 0;
+    }
+    for (const agent of agents) {
+      const status = agent.publicRecordExists ? "public" : "private";
+      const flagMismatch = agent.isPublicFlag !== agent.publicRecordExists ? ` flag=${agent.isPublicFlag}` : "";
+      const credentialLine = agent.credentialConfigured ? `credentialConfigured=true${agent.credentialRef ? ` credentialRef=${agent.credentialRef}` : ""}${agent.apiKeyRef ? ` apiKeyRef=${agent.apiKeyRef}` : ""}` : "credentialConfigured=false";
+      output.write(
+        [
+          `
+[${status}] ${agent.name}`,
+          `id=${agent.id}`,
+          `type=${agent.type ?? "-"}`,
+          `model=${agent.model}`,
+          `updatedAt=${agent.updatedAt ?? "-"}`,
+          `privateKey=${agent.privateKey}`,
+          `publicKey=${agent.publicKey}${flagMismatch}`,
+          `tools=${agent.tools.join(", ") || "-"}`,
+          credentialLine
+        ].join("\n")
+      );
+      output.write("\n");
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent list failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+export {
+  runAgentListCommand
+};

package/agentMachineCommands-6LZWF4GL.js

@@ -0,0 +1,421 @@
+import {
+  resolveConnectorWebSocketTarget
+} from "./chunk-AVMKZHBC.js";
+import {
+  getReadableCliDb
+} from "./chunk-W4NVOSFF.js";
+import {
+  readAgentRecord,
+  resolveAgentRecordFromHybridStore,
+  writeAgentRecord
+} from "./chunk-FQZWM5YX.js";
+import "./chunk-HD63YREL.js";
+import {
+  resolveCliAgentKeyInput
+} from "./chunk-VHBWHNVT.js";
+import "./chunk-GAKEBQD6.js";
+import "./chunk-IDZTNRP2.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import "./chunk-6P2WX5IA.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-TILFE6LV.js";
+import "./chunk-NEMRK4EK.js";
+import "./chunk-XDVAYP26.js";
+import "./chunk-LM25IZBJ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-572EKYLF.js";
+import "./chunk-TDIQFT2F.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-DWLEOOGR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.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 "./chunk-4VNS5WPM.js";
+
+// packages/cli/agentMachineCommands.ts
+async function defaultExecuteCli(provider, prompt, options) {
+  const { executeCli } = await import("./cliExecutor-DNE7TCC4.js");
+  return executeCli(provider, prompt, options);
+}
+async function forwardConnectorRunMessage(machine, message, pushMessage, executeCli, env, fetchImpl) {
+  const { handleConnectorRunMessage } = await import("./machineWsRunDispatch-GWCAPPCM.js");
+  return handleConnectorRunMessage(message, pushMessage, executeCli, env, fetchImpl);
+}
+async function detectLaunchableMachineInfo() {
+  const { detectMachineInfo } = await import("./machineInfo-M6KB6HZN.js");
+  return detectMachineInfo({ probeLaunchable: true });
+}
+function requiredCapabilityForAgent(agent) {
+  if (agent?.apiSource !== "cli") return "";
+  const cliProvider = asTrimmedLowercaseString(agent?.cliProvider || agent?.provider);
+  const capabilityByProvider = {
+    codex: "codex-cli",
+    claude: "claude-code",
+    copilot: "copilot-cli",
+    gemini: "gemini-cli",
+    kimi: "kimi-cli",
+    agy: "agy-cli",
+    qoder: "qoder-cli",
+    opencode: "opencode-cli",
+    grok: "grok-cli"
+  };
+  return capabilityByProvider[cliProvider] ?? "";
+}
+function resolveAgentCliProvider(agent) {
+  return asTrimmedLowercaseString(agent?.cliProvider || agent?.provider);
+}
+function classifyAgentRuntime(agent) {
+  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) {
+  if (args.runtimeClass !== "cli-machine") return args.runtimeClass !== "unknown";
+  return Boolean(args.requiredCapability && args.hasCapability);
+}
+function assertSmokeCompatible(agent, machine) {
+  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}.`
+    );
+  }
+}
+var CONNECTOR_WS_KEEPALIVE_MS = 25e3;
+function buildConnectorKeepaliveMessage() {
+  return JSON.stringify({ type: "connector.keepalive", sentAt: Date.now() });
+}
+async function defaultConnectWebSocket(url, options) {
+  const WebSocketCtor = globalThis.WebSocket;
+  if (!WebSocketCtor) {
+    throw new Error("WebSocket is not available in this runtime");
+  }
+  await new Promise((resolve, reject) => {
+    const ws = new WebSocketCtor(url, { headers: options.headers });
+    let keepalive = 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 heartbeatCurrentMachine(args) {
+  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}`);
+  }
+}
+async function runAgentBindCurrentCommand(args, deps = {}) {
+  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 bind-current <agentKey|handle>\n");
+    return agentInput ? 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 = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
+  let boundAgentKey = "";
+  try {
+    await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
+    const db = deps.db ?? await getReadableCliDb(output);
+    const resolved = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    if (!resolved) {
+      throw new Error(`agent not found: ${resolveCliAgentKeyInput(agentInput)}`);
+    }
+    const agentKey = resolved.agentKey;
+    boundAgentKey = agentKey;
+    const existing = resolved.record;
+    const updated = {
+      ...existing,
+      runtimeBinding: {
+        ...asRecordOrEmpty(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: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+  output.write(`Bound agent ${boundAgentKey} to this machine: ${machine.name} (${machine.machineId})
+`);
+  return 0;
+}
+async function runAgentSmokeCurrentCommand(args, deps = {}) {
+  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 = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
+  const sentMessages = [];
+  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: {
+          ...asRecordOrEmpty(existing?.runtimeBinding),
+          machineId: machine.machineId,
+          ownerUserId: userId
+        },
+        updatedAt: Date.now()
+      }
+    });
+    let runResponse = 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) => (deps.connectorRunMessageHandler ?? forwardConnectorRunMessage)(
+          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"}
+`);
+    if (runResponse?.content) output.write(`${runResponse.content}
+`);
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent smoke-current failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentRuntimeDoctorCommand(args, deps = {}) {
+  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 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 = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
+  try {
+    const db = deps.db ?? await getReadableCliDb(output);
+    const resolved = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    if (!resolved) {
+      throw new Error(`agent not found: ${resolveCliAgentKeyInput(agentInput)}`);
+    }
+    const agentKey = resolved.agentKey;
+    const agent = resolved.record;
+    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}
+`);
+    if (agentInput !== agentKey) output.write(`Agent input: ${agentInput}
+`);
+    output.write(`Agent key: ${agentKey}
+`);
+    output.write(`Runtime class: ${runtimeClass}
+`);
+    output.write(`API source: ${agent?.apiSource ?? "unknown"}
+`);
+    output.write(`CLI provider: ${resolveAgentCliProvider(agent) || "none"}
+`);
+    output.write(`Required capability: ${requiredCapability || "none"}
+`);
+    output.write(`Current machine: ${machine.name} (${machine.machineId})
+`);
+    output.write(`Current machine capabilities: ${machine.capabilities.length ? machine.capabilities.join(", ") : "none"}
+`);
+    output.write(`Current machine binding: ${runtimeClass === "cli-machine" ? isBoundToCurrent ? "yes" : "no" : "not required"}
+`);
+    output.write(`Current machine has required capability: ${requiredCapability ? hasCapability ? "yes" : "no" : "not required"}
+`);
+    return shouldRuntimeDoctorPass({ runtimeClass, requiredCapability, hasCapability }) ? 0 : 1;
+  } catch (error) {
+    output.write(
+      `[nolo] agent runtime-doctor failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+export {
+  runAgentBindCurrentCommand,
+  runAgentRuntimeDoctorCommand,
+  runAgentSmokeCurrentCommand
+};