nolo-cli 0.104.0-alpha.1 → 0.104.0

package/index.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
+import {
+  detectMode,
+  initializeDiagnostics
+} from "./chunk-YV25TM3R.js";
 import {
   consumeWindowsUpdateStartupNotice,
+  getWindowsUpdateStatus,
   readPackageInfo
-} from "./chunk-JEDZAO7L.js";
-import {
-  buildCliRuntimeEnv,
-  loadProfileConfig
-} from "./chunk-BYMV6QZG.js";
-import {
-  spawnProcess
-} from "./chunk-X7HHHIOZ.js";
+} from "./chunk-2SYTUTLI.js";
 import {
   isCompiledBinary
 } from "./chunk-A7GB5UGH.js";
 import "./chunk-OLZBQWZU.js";
+import "./chunk-TNIX77YM.js";
+import "./chunk-Y6ROFCZO.js";
 import "./chunk-LCBAMY2M.js";
 import "./chunk-4SN6J65J.js";
 import "./chunk-CF7PE763.js";
@@ -22,848 +22,25 @@ import "./chunk-4VNS5WPM.js";
 
 // packages/cli/index.ts
 import { dirname, join } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// packages/cli/cliCommandDispatch.ts
 import { fileURLToPath } from "node:url";
-async function runResolvedCommand(command2, originalArgs, ctx, deps) {
-  if (command2.kind === "internal") {
-    if (!command2.handler) {
-      throw new Error(`Internal command ${command2.path.join(" ")} is missing a handler.`);
-    }
-    return command2.handler(originalArgs.slice(command2.path.length), ctx);
-  }
-  if (!command2.script) {
-    throw new Error(`Script command ${command2.path.join(" ")} is missing a script.`);
-  }
-  const forwardedArgs = [...command2.fixedArgs ?? [], ...originalArgs.slice(command2.path.length)];
-  return deps.runScript(command2.script, forwardedArgs, ctx.env);
-}
-function readOption(args2, flag) {
-  const index = args2.indexOf(flag);
-  return index >= 0 ? args2[index + 1] : void 0;
-}
-function buildDaemonEnv(args2, runtimeEnv2) {
-  const serverUrl = readOption(args2, "--server-url") || readOption(args2, "--server");
-  const apiKey = readOption(args2, "--machine-key") || readOption(args2, "--token");
-  return {
-    ...runtimeEnv2,
-    ...serverUrl ? { NOLO_SERVER: serverUrl } : {},
-    ...apiKey ? { AUTH_TOKEN: apiKey } : {}
-  };
-}
-function looksLikeDaemonShortcut(args2) {
-  return args2.includes("--server-url") || args2.includes("--machine-key");
-}
-function createCliRuntimeContext(args2) {
-  return {
-    env: args2.env,
-    scriptDir: args2.scriptDir,
-    entrypointPath: args2.entrypointPath ?? fileURLToPath(import.meta.url),
-    packageInfo: args2.packageInfo
-  };
-}
-function withDaemonShortcutArgs(args2, runtimeEnv2) {
-  if (!looksLikeDaemonShortcut(args2)) return { commandArgs: args2, envOverride: null };
-  return {
-    commandArgs: ["daemon", ...args2],
-    envOverride: buildDaemonEnv(args2, runtimeEnv2)
-  };
-}
-
-// packages/cli/cliCommandAdapters.ts
-function withCliEnv(command2) {
-  return (args2, ctx) => command2(args2, { env: ctx.env });
-}
-function withCliEntrypointEnv(command2) {
-  return (args2, ctx) => command2(args2, {
-    env: ctx.env,
-    cliEntrypointPath: ctx.entrypointPath
-  });
-}
-
-// packages/cli/cliCommandTypes.ts
-function createScriptCommand(path, script, description, fixedArgs) {
-  return {
-    path,
-    kind: "script",
-    script,
-    description,
-    ...fixedArgs ? { fixedArgs } : {}
-  };
-}
-function createInternalCommand(path, description, handler) {
-  return {
-    path,
-    kind: "internal",
-    description,
-    handler
-  };
-}
-
-// packages/cli/cliCommandFactories.ts
-function createEnvCommand(path, description, command2) {
-  return createInternalCommand(path, description, withCliEnv(command2));
-}
-function createEntrypointEnvCommand(path, description, command2) {
-  return createInternalCommand(path, description, withCliEntrypointEnv(command2));
-}
-function createArgsCommand(path, description, command2) {
-  return createInternalCommand(path, description, (args2) => command2(args2));
-}
-function createContextCommand(path, description, command2) {
-  return createInternalCommand(path, description, command2);
-}
-function createDaemonShortcutCommand(path, description, command2) {
-  return createInternalCommand(path, description, (args2, ctx) => {
-    const normalized = withDaemonShortcutArgs(args2, ctx.env);
-    return command2(["--ws"], {
-      env: normalized.envOverride ?? ctx.env,
-      cliEntrypointPath: ctx.entrypointPath
-    });
-  });
-}
-
-// packages/cli/agentInternalCommandEntries.ts
-function getAgentInternalCommandEntries() {
-  const createAgentRunCommand = (path, description) => createContextCommand(path, description, async (args2, ctx) => {
-    const { runAgentRunCommand } = await import("./agentRunCommand-P7VHL4ZR.js");
-    return runAgentRunCommand(args2, {
-      env: ctx.env,
-      scriptDir: ctx.scriptDir,
-      cliEntrypointPath: ctx.entrypointPath,
-      commandPath: path
+var cliArgs = process.argv.slice(2);
+var diagnostics = initializeDiagnostics(detectMode(cliArgs, process.env), process.env);
+var logger = diagnostics.logger;
+if (process.platform === "win32") {
+  if (cliArgs[0] === "update" && cliArgs[1] === "status") {
+    const report = getWindowsUpdateStatus(process.env, {
+      currentVersion: readPackageInfo().version
     });
-  });
-  return [
-    createAgentRunCommand(["run"], "Run a no-login local agent in this workspace"),
-    createAgentRunCommand(["chat"], "Chat with an agent"),
-    createEnvCommand(["agent", "list"], "List owned agents", async (args2, deps) => {
-      const { runAgentListCommand } = await import("./agentListCommands-GUDMBDHZ.js");
-      return runAgentListCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "create"], "Create a new agent", async (args2, deps) => {
-      const { runAgentCreateCommand } = await import("./agentRecordCommands-RSS44XHC.js");
-      return runAgentCreateCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "models"], "List models available on an OpenAI-compatible provider", async (args2, deps) => {
-      const { runAgentModelsCommand } = await import("./agentProviderCommands-GNPTL5XR.js");
-      return runAgentModelsCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "providers"], "List agent-creation provider presets (subscription / metered / oauth)", async (args2, deps) => {
-      const { runAgentProvidersCommand } = await import("./agentProviderCommands-GNPTL5XR.js");
-      return runAgentProvidersCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "pull"], "Cache an agent for local runs", async (args2, deps) => {
-      const { runAgentPullCommand } = await import("./agentPullCommand-O5MPVJ5E.js");
-      return runAgentPullCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "read"], "Read a single agent", async (args2, deps) => {
-      const { runAgentReadCommand } = await import("./agentRecordCommands-RSS44XHC.js");
-      return runAgentReadCommand(args2, deps);
-    }),
-    createAgentRunCommand(["agent", "run"], "Run an agent"),
-    createEnvCommand(["agent", "ps"], "List active and recent local agent runs (--json for machine-readable output)", async (_args, deps) => {
-      const { runAgentPsCommand } = await import("./agentRunControl-AVJR4JW4.js");
-      return runAgentPsCommand(_args, { ...deps, output: process.stdout });
-    }),
-    createEnvCommand(["agent", "status"], "Show status of a local agent run (--json, --watch, --interval-ms N)", async (args2, deps) => {
-      const { runAgentStatusCommand } = await import("./agentRunControl-AVJR4JW4.js");
-      return runAgentStatusCommand(args2, { ...deps, output: process.stdout });
-    }),
-    createEnvCommand(["agent", "logs"], "Show logs of a local agent run", async (args2, deps) => {
-      const { runAgentLogsCommand } = await import("./agentRunControl-AVJR4JW4.js");
-      return runAgentLogsCommand(args2, { ...deps, output: process.stdout });
-    }),
-    createEnvCommand(["agent", "stop"], "Stop a local agent run", async (args2, deps) => {
-      const { runAgentStopCommand } = await import("./agentRunControl-AVJR4JW4.js");
-      return runAgentStopCommand(args2, { ...deps, output: process.stdout });
-    }),
-    createEnvCommand(["agent", "kill"], "Kill a local agent run", async (args2, deps) => {
-      const { runAgentKillCommand } = await import("./agentRunControl-AVJR4JW4.js");
-      return runAgentKillCommand(args2, { ...deps, output: process.stdout });
-    }),
-    createEnvCommand(["agent", "setup-offline-marxists"], "Create or update the Marxists.org offline book agent", async (args2, deps) => {
-      const { runSetupOfflineMarxistsAgentCommand } = await import("./offlineMarxistsAgentCommand-HGXZV4XJ.js");
-      return runSetupOfflineMarxistsAgentCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "update"], "Update agent fields", async (args2, deps) => {
-      const { runAgentUpdateCommand } = await import("./agentRecordCommands-RSS44XHC.js");
-      return runAgentUpdateCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "email", "provision"], "Provision a controlled inbox for an agent", async (args2, deps) => {
-      const { runAgentEmailProvisionCommand } = await import("./agentEmailCommands-O2KH4G7U.js");
-      return runAgentEmailProvisionCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "email", "bind"], "Bind an existing email address to an agent", async (args2, deps) => {
-      const { runAgentEmailBindCommand } = await import("./agentEmailCommands-O2KH4G7U.js");
-      return runAgentEmailBindCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "email", "transfer"], "Transfer an email identity from one agent to another (cross-account)", async (args2, deps) => {
-      const { runAgentEmailTransferCommand } = await import("./agentEmailCommands-O2KH4G7U.js");
-      return runAgentEmailTransferCommand(args2, deps);
-    }),
-    createEnvCommand(
-      ["agent", "email", "create-and-provision"],
-      "Create an agent and provision its controlled inbox",
-      async (args2, deps) => {
-        const { runAgentEmailCreateAndProvisionCommand } = await import("./agentEmailCommands-O2KH4G7U.js");
-        return runAgentEmailCreateAndProvisionCommand(args2, deps);
-      }
-    ),
-    createEnvCommand(["agent", "delete"], "Hard-delete an agent's private and public records", async (args2, deps) => {
-      const { runAgentDeleteCommand } = await import("./agentDeleteCommand-2YAHAZFJ.js");
-      return runAgentDeleteCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "grant"], "Grant another user access to this agent's owner credentials", async (args2, deps) => {
-      const { runAgentGrantCommand } = await import("./agentGrantCommands-M3XFO6EN.js");
-      return runAgentGrantCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "grants"], "List active credential grants for an agent", async (args2, deps) => {
-      const { runAgentGrantsListCommand } = await import("./agentGrantCommands-M3XFO6EN.js");
-      return runAgentGrantsListCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "revoke-grant"], "Revoke a credential grant for an agent", async (args2, deps) => {
-      const { runAgentRevokeGrantCommand } = await import("./agentGrantCommands-M3XFO6EN.js");
-      return runAgentRevokeGrantCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "bind-current"], "Bind an agent to this machine", async (args2, deps) => {
-      const { runAgentBindCurrentCommand } = await import("./agentMachineCommands-5I5CCUBM.js");
-      return runAgentBindCurrentCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "smoke-current"], "Smoke test a bound agent through this machine", async (args2, deps) => {
-      const { runAgentSmokeCurrentCommand } = await import("./agentMachineCommands-5I5CCUBM.js");
-      return runAgentSmokeCurrentCommand(args2, deps);
-    }),
-    createEnvCommand(["agent", "runtime-doctor"], "Diagnose current machine runtime compatibility", async (args2, deps) => {
-      const { runAgentRuntimeDoctorCommand } = await import("./agentMachineCommands-5I5CCUBM.js");
-      return runAgentRuntimeDoctorCommand(args2, deps);
-    }),
-    createAgentRunCommand(["agent", "chat"], "Chat with an agent")
-  ];
-}
-
-// packages/cli/appInternalCommandEntries.ts
-function getAppInternalCommandEntries() {
-  return [
-    createEnvCommand(["app", "list"], "List your apps", async (args2, deps) => {
-      const { runAppListCommand } = await import("./appListCommands-EKUBDRUO.js");
-      return runAppListCommand(args2, deps);
-    }),
-    createEnvCommand(["app", "get"], "Get app details", async (args2, deps) => {
-      const { runAppGetCommand } = await import("./appGetCommands-SFAPP5PB.js");
-      return runAppGetCommand(args2, deps);
-    }),
-    createEnvCommand(["app", "deploy"], "Deploy an app", async (args2, deps) => {
-      const { runAppDeployCommand } = await import("./appDeployCommands-WCQOUSOB.js");
-      return runAppDeployCommand(args2, deps);
-    }),
-    createEnvCommand(["app", "deploy", "status"], "Check app deploy status", async (args2, deps) => {
-      const { runAppDeployStatusCommand } = await import("./appDeployStatusCommands-6QKB7DYN.js");
-      return runAppDeployStatusCommand(args2, deps);
-    }),
-    createEnvCommand(["app", "delete"], "Delete an app", async (args2, deps) => {
-      const { runAppDeleteCommand } = await import("./appDeleteCommands-32MHLR4L.js");
-      return runAppDeleteCommand(args2, deps);
-    })
-  ];
-}
-
-// packages/cli/chromeInternalCommandEntries.ts
-var CHROME_OPS_SUBCOMMANDS = [
-  { name: "list-tabs", summary: "List controllable Chrome tabs" },
-  { name: "open-tab", summary: "Open a URL in a new tab (--url <url> [--active])" },
-  { name: "close-tab", summary: "Close a tab (--tab <id>)" },
-  {
-    name: "read-page",
-    summary: "Read a tab's text and interactive elements as elementRefs (--tab <id>)"
-  },
-  { name: "click", summary: "Click an element (--tab <id> --ref|--selector)" },
-  {
-    name: "type",
-    summary: "Type text into an element (--tab <id> --ref|--selector --text <text>)"
-  },
-  {
-    name: "upload",
-    summary: "Upload files to a file input element (--tab <id> --ref|--selector --file <path>)"
-  },
-  { name: "press", summary: "Press a keyboard key (--tab <id> --key <key>)" },
-  { name: "scroll", summary: "Scroll a tab (--tab <id> [--delta-x N] [--delta-y N])" },
-  { name: "screenshot", summary: "Capture a screenshot (--tab <id> [--out <path>])" },
-  { name: "read-console", summary: "Read recent console entries (--tab <id>)" },
-  { name: "read-network", summary: "Read recent network entries (--tab <id>)" }
-];
-function getChromeInternalCommandEntries() {
-  return [
-    createEnvCommand(
-      ["chrome", "status"],
-      "Show Nolo Chrome connector status (native host manifest, token, live connection)",
-      async (args2, deps) => {
-        const { runChromeStatusCommand } = await import("./chromeCommands-FZYAU75D.js");
-        return runChromeStatusCommand(args2, deps);
-      }
-    ),
-    createEnvCommand(
-      ["chrome", "install"],
-      "Install the Chrome native messaging host manifest for this user",
-      async (args2, deps) => {
-        const { runChromeInstallCommand } = await import("./chromeCommands-FZYAU75D.js");
-        return runChromeInstallCommand(args2, deps);
-      }
-    ),
-    createEnvCommand(
-      ["chrome", "reload"],
-      "Reload the connector extension through the running native host",
-      async (args2, deps) => {
-        const { runChromeReloadCommand } = await import("./chromeCommands-FZYAU75D.js");
-        return runChromeReloadCommand(args2, deps);
-      }
-    ),
-    ...CHROME_OPS_SUBCOMMANDS.map(
-      ({ name, summary }) => createArgsCommand(["chrome", name], summary, async (args2) => {
-        const { runChromeOpsCommand } = await import("./chromeOpsCommands-62P2Q2YB.js");
-        return runChromeOpsCommand(name, args2);
-      })
-    )
-  ];
-}
-
-// packages/cli/dialogInternalCommandEntries.ts
-function getDialogInternalCommandEntries() {
-  return [
-    createEnvCommand(["dialog", "search"], "Search dialog messages across dialogs", async (args2, deps) => {
-      const { runDialogSearchCommand } = await import("./dialogCommands-5J56DFWN.js");
-      return runDialogSearchCommand(args2, deps);
-    }),
-    createEnvCommand(["dialog", "list"], "List dialogs (default --limit 50; --all/--limit 0 full; --jsonl streams)", async (args2, deps) => {
-      const { runDialogListCommand } = await import("./dialogCommands-5J56DFWN.js");
-      return runDialogListCommand(args2, deps);
-    }),
-    createEnvCommand(["dialog", "delete"], "Delete one or more dialogs", async (args2, deps) => {
-      const { runDialogDeleteCommand } = await import("./dialogCommands-5J56DFWN.js");
-      return runDialogDeleteCommand(args2, deps);
-    }),
-    createEnvCommand(["dialog", "query"], "Query dialogs by subject refs (default --limit 50; --all full; --jsonl streams)", async (args2, deps) => {
-      const { runDialogQueryCommand } = await import("./dialogCommands-5J56DFWN.js");
-      return runDialogQueryCommand(args2, deps);
-    }),
-    createEnvCommand(["dialog", "read"], "Read a dialog", async (args2, deps) => {
-      const { runDialogReadCommand } = await import("./dialogCommands-5J56DFWN.js");
-      return runDialogReadCommand(args2, deps);
-    }),
-    createEnvCommand(["dialog", "status"], "Read compact dialog status", async (args2, deps) => {
-      const { runDialogStatusCommand } = await import("./dialogCommands-5J56DFWN.js");
-      return runDialogStatusCommand(args2, deps);
-    })
-  ];
-}
-
-// packages/cli/docInternalCommandEntries.ts
-function getDocInternalCommandEntries() {
-  return [
-    createEnvCommand(["doc", "create"], "Create a normal doc", async (args2, deps) => {
-      const { runDocCreateCommand } = await import("./docCreateCommands-KYI2DC2U.js");
-      return runDocCreateCommand(args2, deps);
-    }),
-    createEnvCommand(["doc", "read"], "Read a normal doc", async (args2, deps) => {
-      const { runDocReadCommand } = await import("./docReadCommands-HOSVSBDJ.js");
-      return runDocReadCommand(args2, deps);
-    }),
-    createEnvCommand(["doc", "update"], "Update a normal doc", async (args2, deps) => {
-      const { runDocUpdateCommand } = await import("./docUpdateCommands-EMGCSMXY.js");
-      return runDocUpdateCommand(args2, deps);
-    }),
-    createEnvCommand(["doc", "delete"], "Delete a normal doc", async (args2, deps) => {
-      const { runDocDeleteCommand } = await import("./docDeleteCommands-67REUSRY.js");
-      return runDocDeleteCommand(args2, deps);
-    }),
-    createEnvCommand(["skill-doc", "create"], "Create a skill-backed doc", async (args2, deps) => {
-      const { runSkillDocCreateCommand } = await import("./docCreateCommands-KYI2DC2U.js");
-      return runSkillDocCreateCommand(args2, deps);
-    }),
-    createEnvCommand(["skill", "create-doc"], "Create a skill-backed doc", async (args2, deps) => {
-      const { runSkillDocCreateCommand } = await import("./docCreateCommands-KYI2DC2U.js");
-      return runSkillDocCreateCommand(args2, deps);
-    }),
-    createEnvCommand(["skill-doc", "read"], "Read a skill doc", async (args2, deps) => {
-      const { runSkillDocReadCommand } = await import("./docReadCommands-HOSVSBDJ.js");
-      return runSkillDocReadCommand(args2, deps);
-    }),
-    createEnvCommand(["skill-doc", "update"], "Update a skill doc", async (args2, deps) => {
-      const { runSkillDocUpdateCommand } = await import("./docUpdateCommands-EMGCSMXY.js");
-      return runSkillDocUpdateCommand(args2, deps);
-    }),
-    createEnvCommand(["skill-doc", "delete"], "Delete a skill doc", async (args2, deps) => {
-      const { runSkillDocDeleteCommand } = await import("./docDeleteCommands-67REUSRY.js");
-      return runSkillDocDeleteCommand(args2, deps);
-    })
-  ];
-}
-
-// packages/cli/memoryInternalCommandEntries.ts
-function getMemoryInternalCommandEntries() {
-  return [
-    createEnvCommand(["memory", "list"], "List long-term memories by filter", async (args2, deps) => {
-      const { runMemoryListCommand } = await import("./memoryCommands-CUNBFRVS.js");
-      return runMemoryListCommand(args2, deps);
-    }),
-    createEnvCommand(["memory", "remember"], "Store a long-term memory", async (args2, deps) => {
-      const { runMemoryRememberCommand } = await import("./memoryCommands-CUNBFRVS.js");
-      return runMemoryRememberCommand(args2, deps);
-    }),
-    createEnvCommand(["memory", "delete"], "Delete long-term memories by filter", async (args2, deps) => {
-      const { runMemoryDeleteCommand } = await import("./memoryCommands-CUNBFRVS.js");
-      return runMemoryDeleteCommand(args2, deps);
-    })
-  ];
-}
-
-// packages/cli/spaceInternalCommandEntries.ts
-function getSpaceInternalCommandEntries() {
-  return [
-    createEnvCommand(["space", "create"], "Create a space", async (args2, deps) => {
-      const { runSpaceCreateCommand } = await import("./spaceCommands-NKJVJCQQ.js");
-      return runSpaceCreateCommand(args2, deps);
-    }),
-    createEnvCommand(["space", "invite"], "Invite an existing user to a space", async (args2, deps) => {
-      const { runSpaceInviteCommand } = await import("./spaceCommands-NKJVJCQQ.js");
-      return runSpaceInviteCommand(args2, deps);
-    }),
-    createEnvCommand(["space", "accept-invite"], "Accept a space invite", async (args2, deps) => {
-      const { runSpaceAcceptInviteCommand } = await import("./spaceCommands-NKJVJCQQ.js");
-      return runSpaceAcceptInviteCommand(args2, deps);
-    }),
-    createEnvCommand(["space", "upload"], "Upload a file to a space", async (args2, deps) => {
-      const { runSpaceUploadCommand } = await import("./spaceCommands-NKJVJCQQ.js");
-      return runSpaceUploadCommand(args2, deps);
-    })
-  ];
-}
-
-// packages/cli/systemInternalCommandEntries.ts
-function getSystemInternalCommandEntries(renderHelpText2) {
-  return [
-    createContextCommand(["auth", "cooldown"], "List / clear credential availability cooldowns", async (_args, ctx) => {
-      const { runAuthCooldownCommand } = await import("./cooldownCommands-REAWYVTY.js");
-      return runAuthCooldownCommand(_args, ctx.env);
-    }),
-    createArgsCommand(["auth", "cloudflare"], "Authorize Cloudflare OAuth", async (args2) => {
-      const { runAuthCloudflareCommand } = await import("./authCommand-F4EFRRX6.js");
-      return runAuthCloudflareCommand(args2);
-    }),
-    createArgsCommand(["auth", "chatgpt"], "Authorize ChatGPT / OpenAI Codex OAuth", async (args2) => {
-      const { runAuthChatgptCommand } = await import("./authCommand-F4EFRRX6.js");
-      return runAuthChatgptCommand(args2);
-    }),
-    createArgsCommand(["auth", "xai"], "Authorize xAI Grok OAuth (SuperGrok subscription)", async (args2) => {
-      const { runAuthXaiCommand } = await import("./authCommand-F4EFRRX6.js");
-      return runAuthXaiCommand(args2);
-    }),
-    createArgsCommand(["auth", "antigravity"], "Authorize Google Antigravity OAuth", async (args2) => {
-      const { runAuthAntigravityCommand } = await import("./authCommand-F4EFRRX6.js");
-      return runAuthAntigravityCommand(args2);
-    }),
-    createArgsCommand(["auth", "claude"], "Authorize Claude Pro/Max OAuth", async (args2) => {
-      const { runAuthClaudeCommand } = await import("./authCommand-F4EFRRX6.js");
-      return runAuthClaudeCommand(args2);
-    }),
-    createArgsCommand(["auth", "cursor"], "Authorize Cursor Pro OAuth", async (args2) => {
-      const { runAuthCursorCommand } = await import("./authCommand-F4EFRRX6.js");
-      return runAuthCursorCommand(args2);
-    }),
-    createArgsCommand(["auth", "devin"], "Authorize Devin OAuth (Free SWE-2)", async (args2) => {
-      const { runAuthDevinCommand } = await import("./authCommand-F4EFRRX6.js");
-      return runAuthDevinCommand(args2);
-    }),
-    createArgsCommand(["login"], "Log in to Nolo", async (args2) => {
-      const { runLoginCommand } = await import("./authCommands-RGOGCPP6.js");
-      return runLoginCommand(args2);
-    }),
-    createContextCommand(["logout"], "Log out of Nolo", async (args2, ctx) => {
-      const { runLogoutCommand } = await import("./authCommands-RGOGCPP6.js");
-      return runLogoutCommand({ args: args2, env: ctx.env });
-    }),
-    createContextCommand(["whoami"], "Show the current login state", async (args2, ctx) => {
-      const { runWhoamiCommand } = await import("./authCommands-RGOGCPP6.js");
-      return runWhoamiCommand({ args: args2, env: ctx.env });
-    }),
-    createEntrypointEnvCommand(["connect"], "Send machine heartbeats or hold a connector websocket", async (args2, deps) => {
-      const { runMachineConnectCommand } = await import("./machineCommands-G5J754EH.js");
-      return runMachineConnectCommand(args2, deps);
-    }),
-    createDaemonShortcutCommand(["daemon"], "Run the connector daemon shortcut", async (args2, deps) => {
-      const { runMachineConnectCommand } = await import("./machineCommands-G5J754EH.js");
-      return runMachineConnectCommand(args2, deps);
-    }),
-    createEnvCommand(["machine", "status"], "List machines registered to the current profile", async (args2, deps) => {
-      const { runMachineStatusCommand } = await import("./machineCommands-G5J754EH.js");
-      return runMachineStatusCommand(args2, deps);
-    }),
-    createEnvCommand(["doctor", "runtime"], "Diagnose local-first agent runtime selection", async (args2, deps) => {
-      const { runDoctorRuntimeCommand } = await import("./runtimeDoctorCommands-X6WDBEQX.js");
-      return runDoctorRuntimeCommand(args2, deps);
-    }),
-    createContextCommand(["doctor"], "Show CLI doctor information", async (_args, ctx) => {
-      const { buildCliDoctorText, getCliInstallChannel, resolveSelfUpdateServerUrl } = await import("./updateCommands-2M74UL7P.js");
-      const { isCompiledBinary: isCompiledBinary2 } = await import("./cliEnvHelpers-ZXNMX7VV.js");
-      const serverUrl = resolveSelfUpdateServerUrl(ctx.env);
-      console.log(
-        buildCliDoctorText({
-          packageName: ctx.packageInfo.name,
-          version: ctx.packageInfo.version,
-          entrypoint: ctx.entrypointPath,
-          serverUrl,
-          profileName: ctx.env.NOLO_PROFILE || "local",
-          installKind: isCompiledBinary2() ? "standalone-bundle" : "npm-global",
-          updateChannel: getCliInstallChannel(serverUrl)
-        })
-      );
-      return 0;
-    }),
-    createContextCommand(["update"], "Update the CLI", async (_args, ctx) => {
-      const { resolveSelfUpdateServerUrl, runSelfUpdate } = await import("./updateCommands-2M74UL7P.js");
-      return runSelfUpdate({
-        entrypointPath: ctx.entrypointPath,
-        serverUrl: resolveSelfUpdateServerUrl(ctx.env),
-        env: ctx.env
-      });
-    }),
-    createContextCommand(["version"], "Show CLI version", async (_args, ctx) => {
-      const { buildCliVersionText } = await import("./updateCommands-2M74UL7P.js");
-      console.log(buildCliVersionText(ctx.packageInfo));
-      return 0;
-    }),
-    createContextCommand(["--version"], "Show CLI version", async (_args, ctx) => {
-      const { buildCliVersionText } = await import("./updateCommands-2M74UL7P.js");
-      console.log(buildCliVersionText(ctx.packageInfo));
-      return 0;
-    }),
-    createContextCommand(["-v"], "Show CLI version", async (_args, ctx) => {
-      const { buildCliVersionText } = await import("./updateCommands-2M74UL7P.js");
-      console.log(buildCliVersionText(ctx.packageInfo));
-      return 0;
-    }),
-    createArgsCommand(["--help"], "Show help", async () => {
-      console.log(renderHelpText2());
-      return 0;
-    }),
-    createArgsCommand(["-h"], "Show help", async () => {
-      console.log(renderHelpText2());
-      return 0;
-    })
-  ];
-}
-
-// packages/cli/tableInternalCommandEntries.ts
-function renderTableHelpText() {
-  return [
-    "nolo table \u2014 table metadata and row commands",
-    "",
-    "Usage:",
-    "  nolo table list [--limit <n>] [--all] [--output items|json|jsonl]",
-    "  nolo table query --table <tableId|metaKey> [--row <rowId|rowDbKey>] [--limit <n>] [--offset <n>] [--all] [--output items|json|jsonl]",
-    "    Defaults: list --limit 50, query --limit 20. Full dump: --all or --limit 0 (prefer --output jsonl).",
-    "  nolo table meta --name <name> [--table <tableId|metaKey>] [--columns <json-array>]",
-    "  nolo table add-row --table <tableId|metaKey> --values <json-object>",
-    "  nolo table update-row --table <tableId|metaKey> --row <rowId|rowDbKey> --changes <json-object>",
-    "  nolo table update-rows --table <tableId|metaKey> --updates <json-array>",
-    "  nolo table delete-row --table <tableId|metaKey> --row <rowId|rowDbKey>",
-    "  nolo table delete-rows --table <tableId|metaKey> (--row-ids <json-array> | --row-dbkeys <json-array> | --filters <json-object>)",
-    "  nolo table purge-rows --table <exact-meta-dbKey> --row-dbkeys <json-array> [--yes] [--json]",
-    "  nolo table remove-row-fields --table <exact-meta-dbKey> --row-dbkeys <json-array> --fields <json-array> [--yes] [--json]",
-    "",
-    "Examples:",
-    `  nolo table query --table meta-0e95801d90-01KWSK4Q4TESXQ06SW39JN2TTJ --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items`,
-    '  nolo table meta --table meta-0e95801d90-01KWSK4Q4TESXQ06SW39JN2TTJ --name "01KWSK4Q4TESXQ06SW39JN2TTJ"',
-    `  nolo table add-row --table meta-0e95801d90-01KWSK4Q4TESXQ06SW39JN2TTJ --values '{"title":"Task","status":"todo"}'`,
-    ""
-  ].join("\n");
-}
-function isTableHelpArgs(args2) {
-  return args2.length === 0 || args2.every((arg) => arg === "--help" || arg === "-h");
-}
-function getTableInternalCommandEntries() {
-  return [
-    createArgsCommand(["table"], "Show table command help", async (args2) => {
-      if (!isTableHelpArgs(args2)) {
-        console.error(`Unknown command: table ${args2.join(" ")}`);
-        return 1;
-      }
-      console.log(renderTableHelpText());
-      return 0;
-    }),
-    createArgsCommand(["table", "delete-rows"], "Delete table rows", async (args2) => {
-      const { runTableDeleteRowsCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableDeleteRowsCommand(args2);
-    }),
-    createEnvCommand(["table", "purge-rows"], "Permanently purge table rows", async (args2, deps) => {
-      const { runTablePurgeRowsCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTablePurgeRowsCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "remove-row-fields"], "Remove fields from table rows", async (args2, deps) => {
-      const { runTableRemoveRowFieldsCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableRemoveRowFieldsCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "add-column"], "Add a table column", async (args2, deps) => {
-      const { runTableAddColumnCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableAddColumnCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "add-row"], "Add a table row", async (args2, deps) => {
-      const { runTableAddRowCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableAddRowCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "add-rows"], "Add table rows", async (args2, deps) => {
-      const { runTableAddRowsCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableAddRowsCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "update-row"], "Update a table row", async (args2, deps) => {
-      const { runTableUpdateRowCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableUpdateRowCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "update-rows"], "Update table rows", async (args2, deps) => {
-      const { runTableUpdateRowsCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableUpdateRowsCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "delete-row"], "Delete a table row", async (args2, deps) => {
-      const { runTableDeleteRowCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableDeleteRowCommand(args2, deps);
-    })
-  ];
-}
-
-// packages/cli/workflowInternalCommandEntries.ts
-function getWorkflowInternalCommandEntries() {
-  return [
-    createEnvCommand(["table", "list"], "List table metadata", async (args2, deps) => {
-      const { runTableListCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableListCommand(args2, deps);
-    }),
-    createEnvCommand(["table", "query"], "Query table rows", async (args2, deps) => {
-      const { runTableQueryCommand } = await import("./tableCommands-O6NWHFKV.js");
-      return runTableQueryCommand(args2, deps);
-    })
-  ];
-}
-
-// packages/cli/internalCommandEntries.ts
-function getInternalCommandEntries(renderHelpText2) {
-  return [
-    ...getAgentInternalCommandEntries(),
-    ...getDialogInternalCommandEntries(),
-    ...getDocInternalCommandEntries(),
-    ...getMemoryInternalCommandEntries(),
-    ...getSpaceInternalCommandEntries(),
-    ...getTableInternalCommandEntries(),
-    ...getAppInternalCommandEntries(),
-    ...getWorkflowInternalCommandEntries(),
-    // nolo chrome — connector setup (status|install|reload) + live-Chrome operations.
-    ...getChromeInternalCommandEntries(),
-    ...getSystemInternalCommandEntries(renderHelpText2)
-  ];
-}
-
-// packages/cli/scriptCommandEntries.ts
-function getDocScriptCommands() {
-  return [];
-}
-function getSpaceScriptCommands() {
-  return [
-    createScriptCommand(["space", "list"], "listSpaces.ts", "List joined spaces"),
-    createScriptCommand(["space", "read"], "readSpace.ts", "Read a space"),
-    createScriptCommand(["space", "delete"], "deleteSpaces.ts", "Delete spaces by safe filters"),
-    createScriptCommand(["space", "category"], "upsertSpaceCategory.ts", "Create or update a space category"),
-    createScriptCommand(["space", "content-category"], "setSpaceContentCategory.ts", "Move content into a space category")
-  ];
-}
-function getTableScriptCommands() {
-  return [
-    createScriptCommand(["table", "meta"], "upsertTableMeta.ts", "Create or update table metadata")
-  ];
-}
-function getAgentScriptCommands() {
-  return [
-    createScriptCommand(["agent", "unpublish"], "unpublishAgent.ts", "Remove an agent's public record"),
-    createScriptCommand(["agent", "dialogs"], "queryAgentDialogs.ts", "Inspect recent dialogs for an agent"),
-    createScriptCommand(["agent", "doctor"], "doctorAgentWorkspace.ts", "Audit agent workspace health"),
-    createScriptCommand(["agent", "create-custom"], "createCustomCodingAgent.ts", "Create a custom coding agent"),
-    createScriptCommand(["agent", "create-space"], "createSpaceAgents.ts", "Create or attach shared-space agents"),
-    createScriptCommand(["agent", "setup-demo"], "setupDemoAgent.ts", "Bootstrap demo publisher agents")
-  ];
-}
-function getRuntimeScriptCommands() {
-  return [
-    createScriptCommand(["dev"], "devControl.ts", "Manage the local dev environment")
-  ];
-}
-function getScriptCommandEntries() {
-  return [
-    ...getDocScriptCommands(),
-    ...getSpaceScriptCommands(),
-    ...getTableScriptCommands(),
-    ...getAgentScriptCommands(),
-    ...getRuntimeScriptCommands()
-  ];
-}
-
-// packages/cli/commandRegistry.ts
-var COMMANDS = [
-  ...getInternalCommandEntries(renderHelpText),
-  ...getScriptCommandEntries()
-];
-var GROUP_ORDER = [
-  "run",
-  "chat",
-  "auth",
-  "doc",
-  "skill-doc",
-  "skill",
-  "agent",
-  "machine",
-  "chrome",
-  "doctor",
-  "dialog",
-  "memory",
-  "space",
-  "table",
-  "app",
-  "llama",
-  "model-runtime",
-  "dev"
-];
-function renderHelpText() {
-  const lines = [
-    "nolo \u2014 Agent-first terminal workspace",
-    "",
-    "Usage:",
-    "  nolo",
-    "  nolo <command> [subcommand] [...args]",
-    "  nolo doctor",
-    "  nolo update",
-    "",
-    "Examples:",
-    "  nolo",
-    "  nolo chat",
-    "  nolo login",
-    "  nolo login --no-browser",
-    "  nolo login --token <auth-token>",
-    "  nolo whoami",
-    "  nolo connect",
-    "  nolo connect --watch",
-    "  nolo connect --ws",
-    "  nolo connect --ws --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
-    "  nolo connect --daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
-    "  nolo machine status",
-    "  nolo chrome install",
-    "  nolo chrome status",
-    '  nolo chrome upload --tab 1 --selector "#upload" --file ./photo.jpg',
-    "  nolo doctor",
-    "  nolo doctor runtime",
-    "  nolo update",
-    '  nolo run "review this repository"  # no Nolo login required; uses local Codex CLI',
-    '  nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run',
-    '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --sync local,main,us',
-    "  nolo agent list --json",
-    "  nolo space list --json",
-    "  nolo agent pull agent-pub-01APPBUILDER00000001YAII3I",
-    "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
-    '  nolo agent run frontend-implementer --msg "polish notifications"',
-    '  nolo agent run agent-0e95801d90-example --msg "Reply PONG only" --local --ephemeral',
-    "  nolo agent ps",
-    "  nolo agent status <runId>",
-    "  nolo agent logs <runId> --tail 20",
-    "  nolo agent stop <runId>",
-    "  nolo agent bind-current agent-user-1-agent-1",
-    "  nolo agent runtime-doctor agent-user-1-agent-1",
-    '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
-    '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "\u4F60\u597D"',
-    "  nolo memory delete --source-dialog 01ABC... --yes --json",
-    "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
-    "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
-    "  nolo table query --table 01ABCXYZ",
-    `  nolo table query --table meta-0e95801d90-01KWSK4Q4TESXQ06SW39JN2TTJ --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items`,
-    `  nolo table update-row --table meta-0e95801d90-01KWSK4Q4TESXQ06SW39JN2TTJ --row 01ROWID --changes '{"status":"\u5DF2\u5B8C\u6210"}'`,
-    "  nolo llama status",
-    "  nolo app list --json",
-    "  nolo app get --name my-app",
-    "  nolo app deploy --name my-app --code-file ./worker.js"
-  ];
-  for (const group of GROUP_ORDER) {
-    const commands = COMMANDS.filter((entry) => entry.path[0] === group);
-    if (commands.length === 0) continue;
-    lines.push("", group);
-    for (const entry of commands) {
-      lines.push(`  ${entry.path.join(" ")}  ${entry.description}`);
-    }
-  }
-  return lines.join("\n");
-}
-function isHelpOnlyArgs(args2) {
-  return args2.length === 0 || args2.every((arg) => arg === "--help" || arg === "-h");
-}
-function renderCommandGroupHelpText(group) {
-  const commands = COMMANDS.filter((entry) => entry.path[0] === group);
-  if (commands.length === 0) return "";
-  return [
-    `nolo ${group} commands`,
-    "",
-    "Usage:",
-    ...commands.map((entry) => `  nolo ${entry.path.join(" ")}  ${entry.description}`),
-    ""
-  ].join("\n");
-}
-function createCommandGroupHelpEntry(group) {
-  return {
-    path: [group],
-    description: `Show ${group} command help`,
-    kind: "internal",
-    handler: async () => {
-      console.log(renderCommandGroupHelpText(group));
-      return 0;
-    }
-  };
-}
-function resolveCommand(args2) {
-  const sorted = [...COMMANDS].sort((a, b) => b.path.length - a.path.length);
-  const command2 = sorted.find(
-    (entry) => entry.path.every((part, index) => args2[index] === part)
-  );
-  if (command2) return command2;
-  const group = args2[0];
-  if (group && GROUP_ORDER.includes(group) && isHelpOnlyArgs(args2.slice(1)) && COMMANDS.some((entry) => entry.path[0] === group)) {
-    return createCommandGroupHelpEntry(group);
-  }
-  return void 0;
-}
-
-// packages/cli/runtimeModeArgs.ts
-function runtimeModeFromFlag(flag) {
-  if (flag === "--local") return "local";
-  if (flag === "--server") return "server";
-  if (flag === "--auto") return "auto";
-  return "";
-}
-function resolveTuiLaunchMode(args2) {
-  const command2 = args2[0];
-  if (command2 !== "chat" && command2 !== "tui") {
-    return { shouldStartTui: false, envPatch: {} };
-  }
-  if (args2.length === 1) {
-    return { shouldStartTui: true, envPatch: {} };
+    process.stdout.write(`${report.text}
+`);
+    process.exit(0);
   }
-  if (args2.length === 2) {
-    const mode = runtimeModeFromFlag(args2[1] ?? "");
-    if (mode) {
-      return {
-        shouldStartTui: true,
-        envPatch: { NOLO_RUNTIME_MODE: mode }
-      };
-    }
+  if (cliArgs.length === 1 && (cliArgs[0] === "-v" || cliArgs[0] === "--version")) {
+    const info = readPackageInfo();
+    process.stdout.write(`${info.name} ${info.version}
+`);
+    process.exit(0);
   }
-  return { shouldStartTui: false, envPatch: {} };
-}
-
-// packages/cli/index.ts
-if (process.platform === "win32") {
   const updateNotice = consumeWindowsUpdateStartupNotice(process.env, {
     ownerUpdateId: process.env.NOLO_UPDATE_OWNER_ID
   });
@@ -875,12 +52,14 @@ if (process.platform === "win32") {
     }
   }
 }
-var SOURCE_CLI_DIR = dirname(fileURLToPath2(import.meta.url));
+var SOURCE_CLI_DIR = dirname(fileURLToPath(import.meta.url));
 var CLI_DIR = isCompiledBinary() ? dirname(process.execPath) : SOURCE_CLI_DIR;
 var ROOT_DIR = join(CLI_DIR, "..", "..");
 var SCRIPT_DIR = join(ROOT_DIR, "scripts");
 var packageInfo = readPackageInfo();
+var args = cliArgs;
 async function runScript(script, forwardedArgs, env) {
+  const { spawnProcess } = await import("./processSpawn-SOAV3FEV.js");
   const scriptPath = join(SCRIPT_DIR, script);
   const proc = spawnProcess({
     cmd: [process.execPath, scriptPath, ...forwardedArgs],
@@ -892,8 +71,8 @@ async function runScript(script, forwardedArgs, env) {
   return proc.exited;
 }
 async function launchTuiWorkspace(args2) {
-  const { startTuiWorkspace } = await import("./readlineWorkspace-TGCYJFEB.js");
-  const { createTuiSummaryLlmCaller } = await import("./tuiSummaryLlmCaller-WFRWERGK.js");
+  const { startTuiWorkspace } = await import("./readlineWorkspace-7Q6MITLV.js");
+  const { createTuiSummaryLlmCaller } = await import("./tuiSummaryLlmCaller-7S5HJ3MT.js");
   return startTuiWorkspace({
     ...args2,
     // Big dialogs produce ~300KB+ summary prompts that routinely take 25–30s+;
@@ -901,42 +80,66 @@ async function launchTuiWorkspace(args2) {
     summaryLlmCaller: createTuiSummaryLlmCaller(args2.env, { timeoutMs: 9e4 })
   });
 }
-var args = process.argv.slice(2);
-var runtimeEnv = {
-  ...buildCliRuntimeEnv(process.env, loadProfileConfig()),
-  NOLO_CLI_VERSION: packageInfo.version
-};
-var runtimeContext = createCliRuntimeContext({
-  env: runtimeEnv,
-  scriptDir: SCRIPT_DIR,
-  entrypointPath: isCompiledBinary() ? process.execPath : fileURLToPath2(import.meta.url),
-  packageInfo
-});
-if (args.length === 0) {
-  if (process.stdin.isTTY) {
-    await launchTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
-  } else {
-    console.log(renderHelpText());
-  }
-  process.exit(0);
-}
-var tuiLaunchMode = resolveTuiLaunchMode(args);
-if (tuiLaunchMode.shouldStartTui) {
-  await launchTuiWorkspace({
+async function main() {
+  const { createCliRuntimeContext, looksLikeDaemonShortcut, renderHelpText, resolveCommand, runResolvedCommand } = await import("./commandRegistry-QU62WJQX.js");
+  const { buildCliRuntimeEnv, loadProfileConfig } = await import("./profileConfig-ZGOFORWV.js");
+  const { resolveTuiLaunchMode } = await import("./runtimeModeArgs-2Y7BALTO.js");
+  const runtimeEnv = {
+    ...buildCliRuntimeEnv(process.env, loadProfileConfig()),
+    NOLO_CLI_VERSION: packageInfo.version
+  };
+  const runtimeContext = createCliRuntimeContext({
+    env: runtimeEnv,
     scriptDir: SCRIPT_DIR,
-    env: { ...runtimeEnv, ...tuiLaunchMode.envPatch }
+    entrypointPath: isCompiledBinary() ? process.execPath : fileURLToPath(import.meta.url),
+    packageInfo
   });
-  process.exit(0);
-}
-var commandArgs = looksLikeDaemonShortcut(args) ? ["daemon", ...args] : args;
-var command = resolveCommand(commandArgs);
-if (!command) {
-  console.error(`Unknown command: ${args.join(" ")}`);
-  console.error("");
-  console.log(renderHelpText());
-  process.exit(1);
+  if (args.length === 0) {
+    if (process.stdin.isTTY) {
+      await launchTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
+    } else {
+      process.stdout.write(`${renderHelpText()}
+`);
+    }
+    process.exit(0);
+  }
+  const tuiLaunchMode = resolveTuiLaunchMode(args);
+  if (tuiLaunchMode.shouldStartTui) {
+    await launchTuiWorkspace({
+      scriptDir: SCRIPT_DIR,
+      env: { ...runtimeEnv, ...tuiLaunchMode.envPatch }
+    });
+    process.exit(0);
+  }
+  const commandArgs = looksLikeDaemonShortcut(args) ? ["daemon", ...args] : args;
+  const command = resolveCommand(commandArgs);
+  if (!command) {
+    process.stderr.write(`Unknown command: ${args.join(" ")}
+
+`);
+    process.stdout.write(`${renderHelpText()}
+`);
+    process.exit(1);
+  }
+  const exitCode = await runResolvedCommand(command, commandArgs, runtimeContext, {
+    runScript
+  });
+  process.exit(exitCode);
 }
-var exitCode = await runResolvedCommand(command, commandArgs, runtimeContext, {
-  runScript
+main().catch((error) => {
+  try {
+    logger.fatal("unhandled error in CLI main", error);
+  } catch {
+  }
+  try {
+    const msg = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    process.stderr.write(`${msg}
+`);
+  } catch {
+    try {
+      process.stderr.write("fatal: unhandled error\n");
+    } catch {
+    }
+  }
+  process.exit(70);
 });
-process.exit(exitCode);