@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/upgrade-OXJXOGEF.js

@@ -0,0 +1,243 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  getWorkflowTemplatesDir
+} from "./chunk-OPTEQKBB.js";
+import {
+  createUpgradeProgress
+} from "./chunk-W3JLYKKY.js";
+import "./chunk-J3ZFM3UQ.js";
+import "./chunk-GZFVDR44.js";
+import "./chunk-ULN4OKQQ.js";
+import {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/upgrade.ts
+import { resolve } from "node:path";
+import { CleoError, diagnoseUpgrade, runUpgrade, upgradeWorkflows } from "@cleocode/core/internal";
+var workflowsSubcommand = defineCommand({
+  meta: {
+    name: "workflows",
+    description: "Re-render the four release-pipeline workflow templates and report drift (T9536)."
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Print the per-template diff without writing.",
+      default: false
+    },
+    check: {
+      type: "boolean",
+      description: "Exit 1 if drift is detected. Implies --dry-run for write semantics.",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite drifted files (excluding `.workflow-overrides.yml` keys).",
+      default: false
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    try {
+      const dryRun = args["dry-run"] === true || args.check === true;
+      const force = args.force === true && !dryRun;
+      const result = await upgradeWorkflows({
+        projectRoot: resolve(process.cwd()),
+        templatesDir: getWorkflowTemplatesDir(),
+        dryRun,
+        force
+      });
+      cliOutput(
+        {
+          outcomes: result.outcomes.map((o) => ({
+            template: o.template,
+            targetPath: o.targetPath,
+            status: o.status,
+            overrideDeclared: o.overrideDeclared
+          })),
+          resolvedTools: result.resolvedTools,
+          hasDrift: result.hasDrift,
+          ...dryRun ? {
+            rendered: result.outcomes.map((o) => ({
+              template: o.template,
+              rendered: o.rendered
+            }))
+          } : {}
+        },
+        { command: "upgrade", operation: "upgrade.workflows" }
+      );
+      if (args.check === true && result.hasDrift) {
+        process.exit(1);
+      }
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var upgradeCommand = defineCommand({
+  meta: {
+    name: "upgrade",
+    description: "Unified project maintenance (storage migration, schema repair, structural fixes, doc refresh)"
+  },
+  subCommands: {
+    workflows: workflowsSubcommand
+  },
+  args: {
+    status: {
+      type: "boolean",
+      description: "Show what needs updating without making changes"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without applying"
+    },
+    diagnose: {
+      type: "boolean",
+      description: "Deep inspection of schema, columns, and migration journals"
+    },
+    "include-global": {
+      type: "boolean",
+      description: "Also check global ~/.cleo data"
+    },
+    "no-auto-migrate": {
+      type: "boolean",
+      description: "Skip automatic JSON->SQLite migration"
+    },
+    detect: {
+      type: "boolean",
+      description: "Force re-detection of project type (ignores staleness)"
+    },
+    "map-codebase": {
+      type: "boolean",
+      description: "Run full codebase analysis and store findings to brain.db"
+    },
+    name: {
+      type: "string",
+      description: "Update project name in project-info and nexus registry"
+    },
+    // Global output format flags — read directly from args (no optsWithGlobals in citty)
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    },
+    human: {
+      type: "boolean",
+      description: "Force human-readable output"
+    },
+    quiet: {
+      type: "boolean",
+      description: "Suppress non-essential output"
+    }
+  },
+  async run({ args, cmd, rawArgs }) {
+    const firstPositional = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstPositional && cmd.subCommands && firstPositional in cmd.subCommands) return;
+    const isHuman = args.human === true || !!process.stdout.isTTY && args.json !== true;
+    const progress = createUpgradeProgress(isHuman);
+    try {
+      if (args.diagnose) {
+        progress.start();
+        progress.step(0, "Running deep schema/migration diagnostics");
+        const result2 = await diagnoseUpgrade();
+        progress.step(4, "Diagnostics complete");
+        cliOutput(result2, { command: "upgrade", operation: "upgrade.diagnose" });
+        if (!result2.success) {
+          progress.error(`${result2.summary.errors} error(s) found`);
+          process.exit(1);
+        }
+        progress.complete(
+          `Diagnostics complete: ${result2.summary.ok} ok, ${result2.summary.warnings} warning(s), ${result2.summary.errors} error(s)`
+        );
+        return;
+      }
+      const isDryRun = !!args["dry-run"] || !!args.status;
+      const includeGlobal = !!args["include-global"];
+      const autoMigrate = !negatedFlag(args, "auto-migrate");
+      const forceDetect = !!args.detect;
+      const mapCodebase = !!args["map-codebase"];
+      const projectName = args.name;
+      progress.start();
+      progress.step(0, "Analyzing current state");
+      if (includeGlobal) {
+        progress.step(1, "Checking global ~/.cleo data");
+      } else {
+        progress.step(1, "Checking storage migration needs");
+      }
+      progress.step(2, "Validating schemas");
+      progress.step(3, isDryRun ? "Previewing changes" : "Applying fixes");
+      const result = await runUpgrade({
+        dryRun: isDryRun,
+        includeGlobal,
+        autoMigrate,
+        forceDetect,
+        mapCodebase,
+        projectName
+      });
+      progress.step(4, "Verifying results");
+      cliOutput(
+        {
+          upToDate: result.upToDate,
+          dryRun: result.dryRun,
+          actions: result.actions,
+          applied: result.applied,
+          errors: result.errors.length > 0 ? result.errors : void 0,
+          summary: result.summary,
+          storageMigration: result.storageMigration
+        },
+        { command: "upgrade" }
+      );
+      if (!result.success) {
+        progress.error("Upgrade failed with errors");
+        process.exit(1);
+      }
+      progress.complete(isDryRun ? "Preview complete" : "Upgrade complete");
+    } catch (err) {
+      if (err instanceof CleoError) {
+        progress.error(err.message);
+        cliError(
+          err.message,
+          err.code,
+          { name: "CleoError", fix: err.fix },
+          { operation: "upgrade" }
+        );
+        process.exit(err.code);
+      }
+      progress.error("Unexpected error during upgrade");
+      throw err;
+    }
+  }
+});
+export {
+  upgradeCommand
+};
+//# sourceMappingURL=upgrade-OXJXOGEF.js.map

package/dist/cli/verify-LYLDHPT2.js

@@ -0,0 +1,190 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/verify.ts
+import { ExitCode } from "@cleocode/contracts";
+var verifyCommand = defineCommand({
+  meta: { name: "verify", description: "View or modify verification gates for a task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to inspect or update",
+      required: false
+    },
+    gate: {
+      type: "string",
+      description: "Set a specific gate by name"
+    },
+    value: {
+      type: "string",
+      description: "Gate value: true or false",
+      default: "true"
+    },
+    agent: {
+      type: "string",
+      description: "Agent setting the gate"
+    },
+    all: {
+      type: "boolean",
+      description: "Mark all required gates as passed"
+    },
+    reset: {
+      type: "boolean",
+      description: "Reset verification to initial state"
+    },
+    evidence: {
+      type: "string",
+      description: `Evidence for the gate (T832/ADR-051). Semicolon-separated atoms: 'commit:<sha>', 'files:<p1,p2>', 'test-run:<report.json>' (a runner's JSON report with test counts: vitest --reporter=json / jest --json numTotalTests,numPassedTests,numFailedTests; or a runner's summary {total,passed,failed,skipped}, e.g. {"total":43,"passed":42,"failed":0,"skipped":1}; or node --test {tests,pass,fail,skipped}; counts must be non-negative integers that add up to the total, and any failure refuses. It proves only what the file says: tool:test or ci:<pr> prove the run), 'tool:<name>' (e.g. tool:test, tool:test-affected, tool:lint), 'url:<url>', 'note:<text>', 'ci:<pr>' (required CI green on the merged PR's merge commit; testsPassed/qaPassed, opt-in via evidence.ciSatisfies).`
+    },
+    explain: {
+      type: "boolean",
+      description: "Enrich read-only view with per-gate evidence breakdown, re-validation status, and blockers[] preventing `cleo complete` (T1013 / ADR-051)."
+    },
+    run: {
+      type: "boolean",
+      description: "Execute the task's typed acceptance gates and report the results. Records no verification, so use `--evidence` to attest (T12308); passing results are cached so the attesting write reuses them instead of re-running (T12621). With a write, `--no-run` executes no typed gate and uses only cached passes, refusing with E_GATE_NOT_CACHED when one is missing."
+    },
+    auto: {
+      type: "boolean",
+      description: "Derive the evidence and record every required gate in one write, exactly as `cleo done` does, without completing the task (T12625). Takes --satisfies and --pr."
+    },
+    satisfies: {
+      type: "string",
+      description: 'With --auto: criteria this work satisfies, e.g. "AC1,AC3" or "all"'
+    },
+    pr: {
+      type: "string",
+      description: "With --auto: the merged PR that implements the task"
+    },
+    fresh: {
+      type: "boolean",
+      description: "Bypass the ADR-061 tool cache and re-run every tool: atom (same as CLEO_EVIDENCE_FRESH=1, which still works). Use only when a cached result is suspect, e.g. after adding an untracked file (T12964)."
+    },
+    "shared-evidence": {
+      type: "boolean",
+      description: "Acknowledge that the same evidence atom is applied to >3 distinct tasks in this session (T1502 / ADR-059). Without this flag, such reuse triggers a warning; in strict mode (CLEO_STRICT_EVIDENCE=1) it is a hard reject."
+    }
+  },
+  async run({ args, cmd }) {
+    if (!args.taskId) {
+      await showUsage(cmd);
+      return;
+    }
+    const isWrite = !!(args.gate || args.all || args.reset);
+    const priorFresh = process.env["CLEO_EVIDENCE_FRESH"];
+    if (args.fresh === true) process.env["CLEO_EVIDENCE_FRESH"] = "1";
+    try {
+      if (args.auto === true) {
+        if (isWrite || args.evidence || args.run === true) {
+          cliError(
+            "--auto derives its own evidence; drop --gate/--all/--reset/--evidence/--run",
+            "E_INVALID_INPUT"
+          );
+          process.exitCode = ExitCode.VALIDATION_ERROR;
+          return;
+        }
+        const { parseDoneOptions } = await import("@cleocode/core/tasks/done-plan.js");
+        const parsed = parseDoneOptions(args.satisfies, args.pr);
+        if (!parsed.ok) {
+          cliError(parsed.message, "E_INVALID_INPUT");
+          process.exitCode = ExitCode.VALIDATION_ERROR;
+          return;
+        }
+        const { recordTaskDone } = await import("@cleocode/core/tasks/done-record.js");
+        const { getProjectRoot } = await import("@cleocode/core/paths.js");
+        const r = await recordTaskDone(args.taskId, {
+          projectRoot: getProjectRoot(),
+          ...parsed.options,
+          ...args.agent ? { agent: args.agent } : {}
+        });
+        if (!r.success) {
+          cliError(r.error.message, r.error.code, { fix: r.error.fix, details: r.error.details });
+          process.exitCode = r.error.exitCode ?? 1;
+          return;
+        }
+        const { plan: _plan, ...summary } = r.data;
+        cliOutput(summary, { command: "verify", operation: "check.gate.auto" });
+        return;
+      }
+      if (args.satisfies !== void 0 || args.pr !== void 0) {
+        cliError("--satisfies and --pr apply only with --auto (or cleo done)", "E_INVALID_INPUT");
+        process.exitCode = ExitCode.VALIDATION_ERROR;
+        return;
+      }
+      if (args.run === true && isWrite) {
+        cliError(
+          "--run reports typed gate results and records nothing; it cannot be combined with --gate/--all/--reset.",
+          ExitCode.VALIDATION_ERROR,
+          {
+            name: "E_VALIDATION",
+            fix: "Run `cleo verify <id> --run` first, then attest with `cleo verify <id> --gate <name> --evidence <atoms>`"
+          },
+          { operation: "check.gate.run" }
+        );
+        process.exitCode = ExitCode.VALIDATION_ERROR;
+        return;
+      }
+      const useExplain = !isWrite && args.explain === true;
+      const operation = isWrite ? "gate.set" : args.run === true ? "gate.run" : useExplain ? "verify.explain" : "gate.status";
+      await dispatchFromCli(
+        isWrite ? "mutate" : "query",
+        "check",
+        operation,
+        {
+          taskId: args.taskId,
+          gate: args.gate,
+          value: args.value === "false" ? false : args.gate ? true : void 0,
+          agent: args.agent,
+          all: args.all,
+          reset: args.reset,
+          evidence: args.evidence,
+          sharedEvidence: args["shared-evidence"] ?? false,
+          // T12621: citty turns `--no-run` into `run: false`; read it through the helper.
+          ...isWrite && negatedFlag(args, "run") ? { noRun: true } : {}
+        },
+        { command: "verify" }
+      );
+    } finally {
+      if (args.fresh === true) {
+        if (priorFresh === void 0) delete process.env["CLEO_EVIDENCE_FRESH"];
+        else process.env["CLEO_EVIDENCE_FRESH"] = priorFresh;
+      }
+    }
+  }
+});
+export {
+  verifyCommand
+};
+//# sourceMappingURL=verify-LYLDHPT2.js.map

package/dist/cli/web-QP2RP266.js

@@ -0,0 +1,275 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  GATEWAY_DEFAULT_HOST,
+  GATEWAY_DEFAULT_PORT,
+  shouldAutoStartGateway,
+  spawnGatewayIfDown
+} from "./chunk-LVGIFMCV.js";
+import {
+  WEB_DEFAULT_HOST,
+  WEB_DEFAULT_PORT,
+  createWebSubsystem,
+  getWebPaths,
+  getWebStatus
+} from "./chunk-GH37QXW5.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/web.ts
+import { spawn } from "node:child_process";
+import { rm } from "node:fs/promises";
+import { ExitCode } from "@cleocode/contracts";
+import { CleoError, formatError } from "@cleocode/core";
+function buildStudioUrl(port, host) {
+  return `http://${host}:${port}`;
+}
+function openBrowser(url) {
+  try {
+    if (process.platform === "linux") {
+      spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+    } else if (process.platform === "darwin") {
+      spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+    } else if (process.platform === "win32") {
+      spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+    }
+  } catch {
+  }
+}
+var startCommand = defineCommand({
+  meta: { name: "start", description: "Start the web server" },
+  args: {
+    port: {
+      type: "string",
+      description: "Server port",
+      default: String(WEB_DEFAULT_PORT)
+    },
+    host: {
+      type: "string",
+      description: "Server host",
+      default: WEB_DEFAULT_HOST
+    }
+  },
+  async run({ args }) {
+    try {
+      const port = Number.parseInt(args.port, 10);
+      const host = args.host;
+      const subsystem = createWebSubsystem({ port, host });
+      const ctx = await subsystem.start();
+      const { logFile } = getWebPaths();
+      cliOutput(
+        {
+          pid: ctx.pid,
+          port: ctx.port,
+          host: ctx.host,
+          url: `http://${ctx.host}:${ctx.port}`,
+          logFile
+        },
+        { command: "web", message: `CLEO Web UI running on port ${ctx.port}` }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        console.error(formatError(err));
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var stopCommand = defineCommand({
+  meta: { name: "stop", description: "Stop the web server" },
+  async run() {
+    try {
+      const { pidFile, logFile } = getWebPaths();
+      const status = await getWebStatus();
+      if (!status.running || status.pid === null) {
+        await rm(pidFile, { force: true });
+        cliOutput({ running: false }, { command: "web", message: "Server is not running" });
+        return;
+      }
+      const subsystem = createWebSubsystem({
+        port: status.port ?? WEB_DEFAULT_PORT,
+        host: status.host ?? WEB_DEFAULT_HOST
+      });
+      await subsystem.shutdown({
+        pid: status.pid,
+        pidFile,
+        logFile,
+        port: status.port ?? WEB_DEFAULT_PORT,
+        host: status.host ?? WEB_DEFAULT_HOST
+      });
+      cliOutput({ stopped: true }, { command: "web", message: "CLEO Web UI stopped" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        console.error(formatError(err));
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var restartCommand = defineCommand({
+  meta: { name: "restart", description: "Restart the web server" },
+  args: {
+    port: {
+      type: "string",
+      description: "Server port",
+      default: String(WEB_DEFAULT_PORT)
+    },
+    host: {
+      type: "string",
+      description: "Server host",
+      default: WEB_DEFAULT_HOST
+    }
+  },
+  async run({ args }) {
+    try {
+      const port = Number.parseInt(args.port, 10);
+      const host = args.host;
+      const { pidFile, logFile } = getWebPaths();
+      const status = await getWebStatus();
+      if (status.running && status.pid !== null) {
+        const stopSubsystem = createWebSubsystem({
+          port: status.port ?? port,
+          host: status.host ?? host
+        });
+        await stopSubsystem.shutdown({
+          pid: status.pid,
+          pidFile,
+          logFile,
+          port: status.port ?? port,
+          host: status.host ?? host
+        });
+      }
+      const startSubsystem = createWebSubsystem({ port, host });
+      const ctx = await startSubsystem.start();
+      cliOutput(
+        {
+          pid: ctx.pid,
+          port: ctx.port,
+          host: ctx.host,
+          url: `http://${ctx.host}:${ctx.port}`,
+          logFile
+        },
+        { command: "web", message: `CLEO Web UI running on port ${ctx.port}` }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        console.error(formatError(err));
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Check server status" },
+  async run() {
+    try {
+      const status = await getWebStatus();
+      cliOutput(status, { command: "web" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        console.error(formatError(err));
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var openCommand = defineCommand({
+  meta: { name: "open", description: "Open browser to the UI" },
+  async run() {
+    try {
+      const status = await getWebStatus();
+      if (!status.running || !status.url) {
+        throw new CleoError(
+          ExitCode.GENERAL_ERROR,
+          "Web server is not running. Start with: cleo web start"
+        );
+      }
+      const url = status.url;
+      openBrowser(url);
+      cliOutput({ url }, { command: "web", message: `Open browser to: ${url}` });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        console.error(formatError(err));
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var webCommand = defineCommand({
+  meta: { name: "web", description: "Open CLEO Studio in the browser (starts gateway on demand)" },
+  args: {
+    port: {
+      type: "string",
+      description: `Gateway port (default ${GATEWAY_DEFAULT_PORT})`
+    },
+    host: {
+      type: "string",
+      description: `Gateway host (default ${GATEWAY_DEFAULT_HOST})`
+    }
+  },
+  subCommands: {
+    start: startCommand,
+    stop: stopCommand,
+    restart: restartCommand,
+    status: statusCommand,
+    open: openCommand
+  },
+  async run({ cmd, rawArgs, args }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    const portArg = args.port;
+    const hostArg = args.host;
+    const port = portArg !== void 0 && portArg.length > 0 ? Number.parseInt(portArg, 10) : GATEWAY_DEFAULT_PORT;
+    const host = hostArg ?? GATEWAY_DEFAULT_HOST;
+    let autoStart = true;
+    try {
+      const { getRawConfig } = await import("@cleocode/core");
+      const cfg = await getRawConfig();
+      autoStart = shouldAutoStartGateway(cfg);
+    } catch {
+    }
+    const studioUrl = buildStudioUrl(port, host);
+    if (autoStart) {
+      await spawnGatewayIfDown({ port, host });
+    }
+    openBrowser(studioUrl);
+    const urlNotice = `Opening Studio: ${studioUrl}
+`;
+    process.stderr.write(urlNotice);
+    const installNote = "  Note: Studio static bundle ships in T11979 (parallel lane).\n  If the page is blank, the bundle may not yet be deployed in this install.\n";
+    process.stderr.write(installNote);
+    cliOutput(
+      { url: studioUrl, port, host, gatewayAutoStart: autoStart },
+      { command: "web", message: `Studio URL: ${studioUrl}` }
+    );
+  }
+});
+export {
+  buildStudioUrl,
+  openBrowser,
+  webCommand
+};
+//# sourceMappingURL=web-QP2RP266.js.map