deepline 0.3.294 → 0.3.296

package/dist/cli/setup-DHGERXPZ.js

@@ -0,0 +1,1257 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+var _chunkZDOC4HFLjs = require('./chunk-ZDOC4HFL.js');
+
+
+
+var _chunkL4HBNHFWjs = require('./chunk-L4HBNHFW.js');
+
+
+
+
+var _chunk4Y6CG4GEjs = require('./chunk-4Y6CG4GE.js');
+require('./chunk-WJYPBHTE.js');
+
+
+
+var _chunk7D6QG5KFjs = require('./chunk-7D6QG5KF.js');
+
+
+
+
+
+
+
+
+
+var _chunk6HPEDBSJjs = require('./chunk-6HPEDBSJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-LIKFCE7Z.js');
+
+
+
+
+var _chunkJNNOCMQYjs = require('./chunk-JNNOCMQY.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+// src/cli/commands/setup.ts
+var _child_process = require('child_process');
+
+
+
+
+
+
+
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('path');
+
+// src/cli/installation-lifecycle.ts
+
+
+
+
+
+
+
+
+var nodeFileSystem = {
+  exists: _fs.existsSync,
+  isSymbolicLink(path) {
+    try {
+      return _fs.lstatSync.call(void 0, path).isSymbolicLink();
+    } catch (e) {
+      return false;
+    }
+  },
+  read(path) {
+    try {
+      return _fs.readFileSync.call(void 0, path, "utf8");
+    } catch (e2) {
+      return "";
+    }
+  },
+  realpath(path) {
+    try {
+      return _fs.realpathSync.call(void 0, path);
+    } catch (e3) {
+      return null;
+    }
+  },
+  remove(path) {
+    _fs.rmSync.call(void 0, path, { force: true });
+  }
+};
+function inspectLauncher(path, fileSystem = nodeFileSystem) {
+  if (!fileSystem.exists(path)) {
+    return { ownership: "missing", resolvedPath: null };
+  }
+  const resolvedPath = fileSystem.realpath(path);
+  if (CliInstallation.isNpmPackagePath(resolvedPath)) {
+    return { ownership: "npm", resolvedPath };
+  }
+  if (fileSystem.isSymbolicLink(path)) {
+    return { ownership: "symlink", resolvedPath };
+  }
+  const content = fileSystem.read(path);
+  if (content.includes("DEEPLINE_REAL_BINARY") && content.includes("DEEPLINE_ACTIVE_FILE")) {
+    return { ownership: "installer_legacy", resolvedPath };
+  }
+  return { ownership: "user", resolvedPath };
+}
+var CliInstallation = class _CliInstallation {
+  constructor(input) {
+    this.input = input;
+  }
+  static forUser(input) {
+    return new _CliInstallation({
+      ...input,
+      fileSystem: _nullishCoalesce(input.fileSystem, () => ( nodeFileSystem))
+    });
+  }
+  static isNpmPackagePath(path) {
+    return _nullishCoalesce(_optionalChain([path, 'optionalAccess', _ => _.includes, 'call', _2 => _2(`${_path.join.call(void 0, "node_modules", "deepline")}`)]), () => ( false));
+  }
+  launcher(path) {
+    return inspectLauncher(path, this.input.fileSystem);
+  }
+  retiredArtifacts() {
+    const hostDir = _path.join.call(void 0, 
+      this.input.home,
+      ".local",
+      "deepline",
+      this.input.baseUrlSlug
+    );
+    const legacyLauncherPath = _path.join.call(void 0, 
+      this.input.home,
+      ".local",
+      "bin",
+      "deepline"
+    );
+    const installerCommandPath = this.input.fileSystem.read(_path.join.call(void 0, hostDir, "sdk", ".command-path")).trim();
+    const ownedInstallerCommand = isOwnedInstallerCommandPath({
+      hostDir,
+      commandPath: installerCommandPath
+    });
+    const legacyLauncher = this.launcher(legacyLauncherPath);
+    const candidates = [
+      ...legacyLauncher.ownership === "installer_legacy" ? [legacyLauncherPath] : [],
+      _path.join.call(void 0, this.input.home, ".local", "bin", "deepline-real"),
+      _path.join.call(void 0, hostDir, "bin", "deepline"),
+      _path.join.call(void 0, hostDir, "bin", "deepline-real"),
+      _path.join.call(void 0, hostDir, "cli", ".install-method"),
+      _path.join.call(void 0, hostDir, "cli", ".version"),
+      _path.join.call(void 0, hostDir, "sdk", ".install-method"),
+      _path.join.call(void 0, hostDir, "sdk", ".command-path"),
+      ...ownedInstallerCommand ? [
+        installerCommandPath,
+        _path.join.call(void 0, _path.dirname.call(void 0, installerCommandPath), "deepline-sdk")
+      ] : []
+    ];
+    return {
+      paths: candidates.filter((path) => {
+        if (!this.input.fileSystem.exists(path)) return false;
+        return this.launcher(path).ownership !== "npm";
+      })
+    };
+  }
+  removeRetiredArtifacts() {
+    return removeArtifacts(this.retiredArtifacts(), this.input.fileSystem);
+  }
+};
+function isNpmCliPath(path) {
+  return CliInstallation.isNpmPackagePath(path);
+}
+function removeArtifacts(plan, fileSystem) {
+  for (const path of plan.paths) {
+    fileSystem.remove(path);
+  }
+  return plan.paths;
+}
+function isOwnedInstallerCommandPath(input) {
+  if (!input.commandPath || _path.basename.call(void 0, input.commandPath) !== "deepline") {
+    return false;
+  }
+  const commandPath = _path.resolve.call(void 0, input.commandPath);
+  const fromHost = _path.relative.call(void 0, _path.resolve.call(void 0, input.hostDir), commandPath);
+  return fromHost !== "" && fromHost !== ".." && !fromHost.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
+}
+
+// src/cli/commands/setup.ts
+var SETUP_PHASE_NAMES = [
+  "cli",
+  "cleanup",
+  "skills",
+  "auth",
+  "verify"
+];
+function initialSetupPhases() {
+  return {
+    cli: { status: "pending" },
+    cleanup: { status: "pending" },
+    skills: { status: "pending" },
+    auth: { status: "pending" },
+    verify: { status: "pending" }
+  };
+}
+function isSetupPhaseStatus(value) {
+  return value === "pending" || value === "in_progress" || value === "complete" || value === "waiting" || value === "failed";
+}
+function parseSetupPhases(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const source = value;
+  const phases = initialSetupPhases();
+  for (const name of SETUP_PHASE_NAMES) {
+    const phase = source[name];
+    if (!phase || typeof phase !== "object" || Array.isArray(phase)) {
+      return null;
+    }
+    const record = phase;
+    if (!isSetupPhaseStatus(record.status)) return null;
+    switch (record.status) {
+      case "pending":
+      case "in_progress":
+        phases[name] = { status: record.status };
+        break;
+      case "complete":
+        phases[name] = {
+          status: "complete",
+          ...typeof record.outcome === "string" ? { outcome: record.outcome } : {}
+        };
+        break;
+      case "waiting":
+        if (typeof record.outcome !== "string") return null;
+        phases[name] = { status: "waiting", outcome: record.outcome };
+        break;
+      case "failed":
+        if (typeof record.code !== "string") return null;
+        phases[name] = { status: "failed", code: record.code };
+        break;
+    }
+  }
+  return phases;
+}
+function phasesFromLegacyStatus(status) {
+  const phases = initialSetupPhases();
+  if (status === "skills_installed" || status === "authorization_pending" || status === "complete") {
+    phases.cli = { status: "complete" };
+    phases.cleanup = { status: "complete" };
+    phases.skills = { status: "complete" };
+  }
+  if (status === "authorization_pending") {
+    phases.auth = { status: "waiting", outcome: "authorization_pending" };
+  } else if (status === "complete") {
+    phases.auth = { status: "complete" };
+    phases.verify = { status: "complete" };
+  }
+  return phases;
+}
+function readSetupState(input) {
+  try {
+    const parsed = JSON.parse(
+      _fs.readFileSync.call(void 0, 
+        setupStatePath(input.baseUrl, input.scope, input.root),
+        "utf8"
+      )
+    );
+    if (parsed.host !== input.baseUrl || parsed.scope !== input.scope || parsed.root !== input.root || typeof parsed.status !== "string") {
+      return null;
+    }
+    return {
+      status: parsed.status,
+      phases: _nullishCoalesce(parseSetupPhases(parsed.phases), () => ( phasesFromLegacyStatus(parsed.status)))
+    };
+  } catch (e4) {
+    return null;
+  }
+}
+function selectSetupProgress(previousState) {
+  const resumed = Boolean(previousState && previousState.status !== "complete");
+  return {
+    resumed,
+    phases: resumed ? previousState.phases : initialSetupPhases()
+  };
+}
+function normalizeScope(value) {
+  if (!value || value === "global") return "global";
+  if (value === "local") return "local";
+  throw new Error("--scope must be one of: global, local");
+}
+function resolveScopeRoot(scope) {
+  if (scope === "global") return null;
+  const target = _chunk6HPEDBSJjs.resolveProjectPinTarget.call(void 0, );
+  if (!target.ok) {
+    throw new Error(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ", "
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder.`
+    );
+  }
+  return target.dir;
+}
+function authScopeForSetup(scope) {
+  return scope === "local" ? "folder" : "global";
+}
+function openSetupAuthorization(authorizationUrl, options = {}) {
+  const url = authorizationUrl.trim();
+  if (!url) return "failed";
+  if (options.open) return options.open(url);
+  const result = _chunk7D6QG5KFjs.openInBrowser.call(void 0, url, { deduplicate: false });
+  return result === "opened" ? "opened" : "failed";
+}
+function buildPendingAuthorizationOutput(input) {
+  const authorizationUrl = input.authorizationUrl.trim();
+  if (input.browserOpenStatus === "existing_claim" && authorizationUrl) {
+    return {
+      authorizationUrl,
+      next: `The existing approval is still pending. Use its authorization URL if needed, then run: ${input.resumeCommand}`,
+      lines: [
+        "Deepline did not open another browser tab. Use the existing approval page or this link:",
+        authorizationUrl
+      ]
+    };
+  }
+  if (input.browserOpenStatus === "timed_out" && authorizationUrl) {
+    return {
+      authorizationUrl,
+      next: `Approval is still pending after five minutes. Use the authorization URL if needed, then run: ${input.resumeCommand}`,
+      lines: [
+        "Approval is still pending. Use this link if the tab was missed:",
+        authorizationUrl
+      ]
+    };
+  }
+  if (authorizationUrl) {
+    return {
+      authorizationUrl,
+      next: `Open the authorization URL, approve it, then run: ${input.resumeCommand}`,
+      lines: [
+        "Browser launch failed. Open the authorization URL to continue.",
+        authorizationUrl
+      ]
+    };
+  }
+  return {
+    authorizationUrl: null,
+    next: `Authorization is pending without a browser URL. Retry: ${input.resumeCommand}`,
+    lines: ["Authorization is pending, but no browser URL was returned."]
+  };
+}
+function setupStatePath(baseUrl, scope, root) {
+  return scope === "local" && root ? _path.join.call(void 0, root, ".deepline", "setup", "state.json") : _path.join.call(void 0, _chunk6HPEDBSJjs.sdkCliStateDirPath.call(void 0, baseUrl), "setup.json");
+}
+async function captureStdout(run) {
+  let stdout = "";
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = ((chunk) => {
+    stdout += typeof chunk === "string" ? chunk : String(chunk);
+    return true;
+  });
+  try {
+    return { exitCode: await run(), stdout, error: null };
+  } catch (error) {
+    return { exitCode: 4, stdout, error };
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+}
+function parseCapturedJson(stdout) {
+  try {
+    return JSON.parse(stdout.trim());
+  } catch (e5) {
+    return null;
+  }
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function safeRead(path) {
+  try {
+    return _fs.readFileSync.call(void 0, path, "utf8");
+  } catch (e6) {
+    return "";
+  }
+}
+function isNpmManagedDeeplinePath(path) {
+  try {
+    return isNpmCliPath(_fs.realpathSync.call(void 0, path));
+  } catch (e7) {
+    return false;
+  }
+}
+function removeKnownLegacyPaths(baseUrl) {
+  return CliInstallation.forUser({
+    baseUrlSlug: _chunk6HPEDBSJjs.baseUrlSlug.call(void 0, baseUrl),
+    home: _os.homedir.call(void 0, )
+  }).removeRetiredArtifacts();
+}
+function resolvePathCommands(command) {
+  const lookup = _child_process.spawnSync.call(void 0, 
+    process.platform === "win32" ? "where" : "which",
+    process.platform === "win32" ? [command] : ["-a", command],
+    { encoding: "utf8", shell: process.platform === "win32" }
+  );
+  return [
+    ...new Set(
+      String(_nullishCoalesce(lookup.stdout, () => ( ""))).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => _path.resolve.call(void 0, path))
+    )
+  ];
+}
+function resolvePathCommand(command) {
+  return _nullishCoalesce(resolvePathCommands(command)[0], () => ( null));
+}
+function isHomebrewFormulaCommand(path) {
+  let resolvedPath = path;
+  try {
+    resolvedPath = _fs.realpathSync.call(void 0, path);
+  } catch (e8) {
+    return false;
+  }
+  const parts = resolvedPath.split(/[\\/]+/);
+  const cellarIndex = parts.lastIndexOf("Cellar");
+  return cellarIndex >= 0 && parts[cellarIndex + 1] === "deepline" && parts.slice(cellarIndex + 3).includes("libexec");
+}
+function resolvePersistentGlobalCommand(dependencies = {}) {
+  const platform = _nullishCoalesce(dependencies.platform, () => ( process.platform));
+  const run = _nullishCoalesce(dependencies.spawn, () => ( _child_process.spawnSync));
+  const pathExists = _nullishCoalesce(dependencies.exists, () => ( _fs.existsSync));
+  const pathClis = _nullishCoalesce(dependencies.pathClis, () => ( resolvePathCommands("deepline")));
+  const homebrewCommand = pathClis.find(isHomebrewFormulaCommand);
+  if (homebrewCommand) return homebrewCommand;
+  for (const manager of ["npm", "pnpm"]) {
+    const plan = _chunk4Y6CG4GEjs.resolveShellSpawn.call(void 0, 
+      manager,
+      manager === "npm" ? ["prefix", "-g"] : ["bin", "-g"],
+      platform
+    );
+    const result = run(plan.command, plan.args, {
+      encoding: "utf8",
+      shell: plan.shell,
+      cwd: manager === "pnpm" ? _os.homedir.call(void 0, ) : void 0,
+      timeout: 1e4
+    });
+    if (result.status !== 0) continue;
+    const root = String(_nullishCoalesce(result.stdout, () => ( ""))).trim();
+    if (!root) continue;
+    const bin = manager === "npm" && platform !== "win32" ? _path.join.call(void 0, root, "bin") : root;
+    const candidates = platform === "win32" ? [_path.join.call(void 0, bin, "deepline.cmd"), _path.join.call(void 0, bin, "deepline")] : [_path.join.call(void 0, bin, "deepline")];
+    const command = candidates.find((candidate) => pathExists(candidate));
+    if (command) return command;
+  }
+  return null;
+}
+function inspectGlobalCliAvailability(input) {
+  const pathClis = _nullishCoalesce(_optionalChain([input, 'optionalAccess', _3 => _3.pathClis]), () => ( resolvePathCommands("deepline")));
+  const persistentPath = input && "persistentGlobalCli" in input ? _nullishCoalesce(input.persistentGlobalCli, () => ( null)) : resolvePersistentGlobalCommand({ pathClis });
+  const path = persistentPath ? _nullishCoalesce(pathClis.find(
+    (candidate) => pathsResolveToSameFile(candidate, persistentPath)
+  ), () => ( null)) : null;
+  return { ok: Boolean(path), persistentPath, path };
+}
+function pathsResolveToSameFile(left, right) {
+  try {
+    return _fs.realpathSync.call(void 0, left) === _fs.realpathSync.call(void 0, right);
+  } catch (e9) {
+    return _path.resolve.call(void 0, left) === _path.resolve.call(void 0, right);
+  }
+}
+function isKnownDeeplineCommand(path) {
+  const entrypoint = process.argv[1] ? _path.resolve.call(void 0, process.argv[1]) : "";
+  let resolvedPath = path;
+  try {
+    resolvedPath = _fs.realpathSync.call(void 0, path);
+  } catch (e10) {
+  }
+  if (entrypoint && resolvedPath === entrypoint) return true;
+  if (resolvedPath.includes(`${_path.join.call(void 0, "node_modules", "deepline")}`)) return true;
+  const content = safeRead(path);
+  return content.includes("node_modules/deepline") || content.includes("node_modules\\deepline") || content.includes("DEEPLINE_CONFIG_SCOPE") || content.includes("deepline-real");
+}
+function inspectPathConflict() {
+  const commandPath = resolvePathCommand("deepline");
+  if (!commandPath || isKnownDeeplineCommand(commandPath)) return null;
+  try {
+    if (_fs.lstatSync.call(void 0, commandPath).isSymbolicLink()) {
+      const target = _fs.realpathSync.call(void 0, commandPath);
+      if (target.includes(`${_path.join.call(void 0, "node_modules", "deepline")}`)) return null;
+    }
+  } catch (e11) {
+  }
+  return commandPath;
+}
+function writeSetupState(input) {
+  const path = setupStatePath(input.baseUrl, input.scope, input.root);
+  _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+  _fs.writeFileSync.call(void 0, 
+    path,
+    `${JSON.stringify(
+      {
+        schemaVersion: 2,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cliVersion: _chunk6HPEDBSJjs.SDK_VERSION,
+        host: input.baseUrl,
+        scope: input.scope,
+        root: input.root,
+        status: input.status,
+        phases: input.phases
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+  return path;
+}
+function persistSetupProgress(input) {
+  return writeSetupState({
+    ...input,
+    status: _nullishCoalesce(input.status, () => ( "in_progress"))
+  });
+}
+function completeSetupPhase(phases, phase, outcome) {
+  phases[phase] = {
+    status: "complete",
+    ...outcome ? { outcome } : {}
+  };
+}
+function beginSetupPhase(phases, phase) {
+  phases[phase] = { status: "in_progress" };
+}
+function failSetupPhase(phases, phase, code) {
+  phases[phase] = { status: "failed", code };
+}
+function rollbackCommand(scope, root) {
+  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(_path.join.call(void 0, root, ".deepline", "runtime"))}` : "";
+  const allowScriptsFlag = _chunkL4HBNHFWjs.npmSupportsAllowScripts.call(void 0, _chunkL4HBNHFWjs.readNpmVersion.call(void 0, process.env)) ? " --allow-scripts=esbuild" : "";
+  return `npm install -g${prefix} --no-audit --no-fund --include=optional${allowScriptsFlag} deepline@${_chunk6HPEDBSJjs.SDK_VERSION}`;
+}
+function setupResumeCommand(baseUrl, scope, orgName) {
+  const hostPrefix = baseUrl === "https://code.deepline.com" ? "" : `DEEPLINE_HOST_URL=${JSON.stringify(baseUrl)} `;
+  const quotedOrgName = orgName ? process.platform === "win32" ? ` --org-name "${orgName.replace(/"/g, '""')}"` : ` --org-name '${orgName.replace(/'/g, `'\\''`)}'` : "";
+  return `${hostPrefix}deepline setup --scope ${scope}${quotedOrgName} --json`;
+}
+function setupRetry(input) {
+  return {
+    phase: input.phase,
+    command: setupResumeCommand(input.baseUrl, input.scope, input.orgName),
+    automatic: _nullishCoalesce(input.retryAutomatic, () => ( true))
+  };
+}
+function reportSetupPhaseFailure(input) {
+  failSetupPhase(input.phases, input.phase, input.code);
+  const statePath = persistSetupProgress({
+    baseUrl: input.baseUrl,
+    scope: input.scope,
+    root: input.root,
+    phases: input.phases,
+    status: "failed"
+  });
+  const retry = setupRetry(input);
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    {
+      ok: false,
+      status: "failed",
+      code: input.code,
+      exitCode: input.exitCode,
+      scope: input.scope,
+      message: input.message,
+      phases: input.phases,
+      failedPhase: input.phase,
+      retry,
+      statePath,
+      next: _nullishCoalesce(input.next, () => ( retry.command)),
+      ..._nullishCoalesce(input.extra, () => ( {}))
+    },
+    { json: input.json }
+  );
+  return input.exitCode;
+}
+async function readAuthStatus(authScope) {
+  try {
+    const captured = await captureStdout(
+      () => _chunkZDOC4HFLjs.handleStatus.call(void 0, [
+        "--json",
+        ...authScope ? ["--auth-scope", authScope] : []
+      ])
+    );
+    return {
+      exitCode: captured.exitCode,
+      payload: parseCapturedJson(captured.stdout),
+      error: captured.error
+    };
+  } catch (error) {
+    return { exitCode: 4, payload: null, error };
+  }
+}
+function reportSetupAuthStatusFailure(input) {
+  if (!input.auth.error) return null;
+  return reportSetupPhaseFailure({
+    baseUrl: input.baseUrl,
+    scope: input.scope,
+    root: input.root,
+    phases: input.phases,
+    orgName: input.orgName,
+    phase: "auth",
+    code: "AUTH_STATUS_FAILED",
+    exitCode: 4,
+    message: "Deepline could not verify authorization with the configured host.",
+    json: input.json,
+    extra: { authScope: input.authScope }
+  });
+}
+function buildDoctorAssessment(input) {
+  const skillsStatePath = _chunk4Y6CG4GEjs.skillsStatePathForScope.call(void 0, 
+    input.baseUrl,
+    input.scope,
+    input.root
+  );
+  const skillsState = parseCapturedJson(safeRead(skillsStatePath));
+  const apiKey = input.scope === "local" ? _chunk6HPEDBSJjs.resolveProjectApiKeyForBaseUrl.call(void 0, input.baseUrl) : _chunk6HPEDBSJjs.resolveGlobalApiKeyForBaseUrl.call(void 0, input.baseUrl);
+  const projectAuth = input.scope === "local" && apiKey ? _chunk6HPEDBSJjs.getResolvedProjectAuthSource.call(void 0, input.baseUrl, apiKey) : null;
+  const connected = _optionalChain([input, 'access', _4 => _4.authStatus, 'access', _5 => _5.payload, 'optionalAccess', _6 => _6.connected]) === true;
+  const authScopeOk = input.scope === "local" ? Boolean(projectAuth) : Boolean(apiKey && !projectAuth);
+  const skillsOk = _optionalChain([skillsState, 'optionalAccess', _7 => _7.scope]) === input.scope && typeof skillsState.skillsVersion === "string" && Array.isArray(skillsState.agents) && skillsState.agents.length > 0;
+  const runningCliPath = process.argv[1] ? _path.resolve.call(void 0, process.argv[1]) : null;
+  const globalCli = input.scope === "global" ? inspectGlobalCliAvailability() : null;
+  const pathGlobalCli = _nullishCoalesce(_optionalChain([globalCli, 'optionalAccess', _8 => _8.path]), () => ( null));
+  const cliPath = input.scope === "global" ? pathGlobalCli : runningCliPath;
+  const cliScopeOk = input.scope === "global" ? Boolean(pathGlobalCli) : Boolean(
+    input.root && _optionalChain([runningCliPath, 'optionalAccess', _9 => _9.includes, 'call', _10 => _10(_path.join.call(void 0, input.root, ".deepline", "runtime"))])
+  );
+  const checks = {
+    cli: {
+      ok: Boolean(cliPath) && cliScopeOk,
+      version: _chunk6HPEDBSJjs.SDK_VERSION,
+      path: cliPath,
+      scope: input.scope
+    },
+    skills: {
+      ok: skillsOk,
+      statePath: skillsStatePath,
+      version: _nullishCoalesce(_optionalChain([skillsState, 'optionalAccess', _11 => _11.skillsVersion]), () => ( null)),
+      agents: _nullishCoalesce(_optionalChain([skillsState, 'optionalAccess', _12 => _12.agents]), () => ( []))
+    },
+    auth: {
+      ok: connected && authScopeOk,
+      scope: projectAuth ? "local" : apiKey ? "global" : null,
+      status: _nullishCoalesce(_optionalChain([input, 'access', _13 => _13.authStatus, 'access', _14 => _14.payload, 'optionalAccess', _15 => _15.status]), () => ( "not_connected"))
+    },
+    api: {
+      ok: connected && input.authStatus.exitCode === 0,
+      host: input.baseUrl,
+      workspace: _nullishCoalesce(_optionalChain([input, 'access', _16 => _16.authStatus, 'access', _17 => _17.payload, 'optionalAccess', _18 => _18.workspace]), () => ( null)),
+      providerSpend: false
+    }
+  };
+  return {
+    ok: Object.values(checks).every((check) => check.ok),
+    checks
+  };
+}
+async function runDoctorCommand(options) {
+  let scope;
+  let root;
+  try {
+    scope = normalizeScope(options.scope);
+    root = resolveScopeRoot(scope);
+  } catch (error) {
+    _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: false,
+        status: "failed",
+        code: "INVALID_SETUP_SCOPE",
+        exitCode: 2,
+        message: error instanceof Error ? error.message : String(error)
+      },
+      { json: options.json }
+    );
+    return 2;
+  }
+  const baseUrl = _chunk6HPEDBSJjs.autoDetectBaseUrl.call(void 0, ).replace(/\/$/, "");
+  const authScope = authScopeForSetup(scope);
+  const authStatus = await readAuthStatus(authScope);
+  const { ok, checks } = buildDoctorAssessment({
+    baseUrl,
+    scope,
+    root,
+    authStatus
+  });
+  const gettingStarted = _chunkJNNOCMQYjs.deeplineGtmGettingStartedPayload.call(void 0, );
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    {
+      ok,
+      status: ok ? "complete" : "failed",
+      code: ok ? "DOCTOR_OK" : "DOCTOR_FAILED",
+      exitCode: ok ? 0 : 7,
+      checks,
+      next: ok ? _chunkJNNOCMQYjs.DEEPLINE_GTM_SKILL : "Review failed checks, then rerun: deepline doctor --json",
+      ...ok ? { gettingStarted } : {},
+      render: {
+        sections: [
+          {
+            title: "doctor",
+            lines: Object.entries(checks).map(
+              ([name, check]) => `${check.ok ? "pass" : "fail"} ${name}`
+            )
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+  return ok ? 0 : 7;
+}
+function pendingResult(input) {
+  input.phases.auth = {
+    status: "waiting",
+    outcome: "authorization_pending"
+  };
+  const statePath = writeSetupState({
+    baseUrl: input.baseUrl,
+    scope: input.scope,
+    root: input.root,
+    status: "authorization_pending",
+    phases: input.phases
+  });
+  const pendingOutput = buildPendingAuthorizationOutput({
+    authorizationUrl: input.authorizationUrl,
+    browserOpenStatus: input.browserOpenStatus,
+    resumeCommand: setupResumeCommand(
+      input.baseUrl,
+      input.scope,
+      input.orgName
+    )
+  });
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    {
+      ok: true,
+      status: "authorization_pending",
+      complete: false,
+      scope: input.scope,
+      authorizationUrl: pendingOutput.authorizationUrl,
+      browserOpened: input.browserOpenStatus === "timed_out",
+      browserOpenStatus: input.browserOpenStatus,
+      authClaimSource: input.authClaimSource,
+      statePath,
+      phases: input.phases,
+      currentPhase: "auth",
+      resumed: input.resumed,
+      retry: setupRetry({
+        baseUrl: input.baseUrl,
+        scope: input.scope,
+        phase: "auth",
+        orgName: input.orgName
+      }),
+      next: pendingOutput.next,
+      render: {
+        sections: [
+          {
+            title: "setup",
+            lines: pendingOutput.lines
+          }
+        ]
+      }
+    },
+    { json: input.json }
+  );
+  return 0;
+}
+async function runSetupCommand(options) {
+  let orgName = _optionalChain([options, 'access', _19 => _19.orgName, 'optionalAccess', _20 => _20.trim, 'call', _21 => _21()]);
+  if (options.orgName !== void 0 && !orgName) {
+    _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: false,
+        status: "failed",
+        code: "INVALID_ORG_NAME",
+        exitCode: 2,
+        message: "Workspace name cannot be empty."
+      },
+      { json: options.json }
+    );
+    return 2;
+  }
+  let scope;
+  let root;
+  try {
+    scope = normalizeScope(options.scope);
+    root = resolveScopeRoot(scope);
+  } catch (error) {
+    _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: false,
+        status: "failed",
+        code: "INVALID_SETUP_SCOPE",
+        exitCode: 2,
+        message: error instanceof Error ? error.message : String(error),
+        phases: {
+          ...initialSetupPhases(),
+          cli: { status: "failed", code: "INVALID_SETUP_SCOPE" }
+        },
+        failedPhase: "cli"
+      },
+      { json: options.json }
+    );
+    return 2;
+  }
+  const baseUrl = _chunk6HPEDBSJjs.autoDetectBaseUrl.call(void 0, ).replace(/\/$/, "");
+  const previousState = readSetupState({ baseUrl, scope, root });
+  const { resumed, phases } = selectSetupProgress(previousState);
+  if (phases.cli.status !== "complete") {
+    beginSetupPhase(phases, "cli");
+    persistSetupProgress({ baseUrl, scope, root, phases });
+    if (scope === "global") {
+      const globalCli = inspectGlobalCliAvailability();
+      if (!globalCli.ok) {
+        const installedButUnreachable = Boolean(globalCli.persistentPath);
+        const code = installedButUnreachable ? "GLOBAL_CLI_NOT_ON_PATH" : "GLOBAL_CLI_NOT_INSTALLED";
+        return reportSetupPhaseFailure({
+          baseUrl,
+          scope,
+          root,
+          phases,
+          phase: "cli",
+          code,
+          exitCode: 7,
+          message: installedButUnreachable ? `The global Deepline executable is not reachable on PATH: ${globalCli.persistentPath}` : "No persistent global Deepline executable was found.",
+          json: options.json,
+          orgName,
+          extra: {
+            persistentPath: globalCli.persistentPath,
+            fallback: "https://code.deepline.com/INSTALL.md"
+          }
+        });
+      }
+    }
+    const conflict = inspectPathConflict();
+    if (conflict) {
+      return reportSetupPhaseFailure({
+        baseUrl,
+        scope,
+        root,
+        phases,
+        phase: "cli",
+        code: "PATH_CONFLICT",
+        exitCode: 7,
+        message: `An unknown executable named deepline is first on PATH: ${conflict}`,
+        json: options.json,
+        orgName,
+        extra: { path: conflict }
+      });
+    }
+    completeSetupPhase(phases, "cli", "available");
+    persistSetupProgress({ baseUrl, scope, root, phases });
+  }
+  if (phases.cleanup.status !== "complete") {
+    beginSetupPhase(phases, "cleanup");
+    persistSetupProgress({ baseUrl, scope, root, phases });
+    try {
+      const removedLegacyPaths = removeKnownLegacyPaths(baseUrl);
+      if (removedLegacyPaths.length > 0) {
+        process.stderr.write(
+          `Removed ${removedLegacyPaths.length} known legacy Deepline path(s).
+`
+        );
+      }
+      completeSetupPhase(
+        phases,
+        "cleanup",
+        removedLegacyPaths.length > 0 ? "removed_legacy_paths" : "clean"
+      );
+      persistSetupProgress({ baseUrl, scope, root, phases });
+    } catch (error) {
+      return reportSetupPhaseFailure({
+        baseUrl,
+        scope,
+        root,
+        phases,
+        phase: "cleanup",
+        code: "LEGACY_CLEANUP_FAILED",
+        exitCode: 5,
+        message: error instanceof Error ? error.message : String(error),
+        json: options.json,
+        orgName
+      });
+    }
+  }
+  let skillsPayload = null;
+  if (phases.skills.status !== "complete") {
+    beginSetupPhase(phases, "skills");
+    persistSetupProgress({ baseUrl, scope, root, phases });
+    process.stderr.write(`Installing Deepline skills (${scope})...
+`);
+    const skills = await captureStdout(
+      () => _chunk4Y6CG4GEjs.runSkillsCommand.call(void 0, { scope, json: true })
+    );
+    skillsPayload = parseCapturedJson(skills.stdout);
+    if (skills.exitCode !== 0) {
+      if (scope === "global") {
+        phases.skills = { status: "failed", code: "SKILLS_INSTALL_FAILED" };
+        persistSetupProgress({ baseUrl, scope, root, phases });
+        process.stderr.write(
+          "Global skill setup failed. Trying project-local skills instead.\n"
+        );
+        return runSetupCommand({ scope: "local", json: options.json, orgName });
+      }
+      return reportSetupPhaseFailure({
+        baseUrl,
+        scope,
+        root,
+        phases,
+        phase: "skills",
+        code: "SKILLS_INSTALL_FAILED",
+        exitCode: skills.exitCode,
+        message: typeof _optionalChain([skillsPayload, 'optionalAccess', _22 => _22.message]) === "string" ? skillsPayload.message : "Deepline skills could not be installed.",
+        json: options.json,
+        orgName,
+        next: `! ${setupResumeCommand(baseUrl, scope, orgName)}`,
+        extra: { detail: skillsPayload }
+      });
+    }
+    completeSetupPhase(
+      phases,
+      "skills",
+      _optionalChain([skillsPayload, 'optionalAccess', _23 => _23.status]) === "current" ? "current" : "installed"
+    );
+    writeSetupState({
+      baseUrl,
+      scope,
+      root,
+      status: "skills_installed",
+      phases
+    });
+  } else {
+    skillsPayload = parseCapturedJson(
+      safeRead(_chunk4Y6CG4GEjs.skillsStatePathForScope.call(void 0, baseUrl, scope, root))
+    );
+  }
+  const authScope = authScopeForSetup(scope);
+  const pendingAtStart = _chunkZDOC4HFLjs.readPendingAuthClaim.call(void 0, baseUrl, authScope);
+  const replacingPendingClaim = Boolean(
+    pendingAtStart && orgName && _optionalChain([pendingAtStart, 'access', _24 => _24.orgName, 'optionalAccess', _25 => _25.toLowerCase, 'call', _26 => _26()]) !== orgName.toLowerCase()
+  );
+  if (pendingAtStart && !replacingPendingClaim) {
+    if (pendingAtStart.orgName) orgName = pendingAtStart.orgName;
+  }
+  beginSetupPhase(phases, "auth");
+  persistSetupProgress({ baseUrl, scope, root, phases });
+  let auth = await readAuthStatus(authScope);
+  const initialAuthFailure = reportSetupAuthStatusFailure({
+    auth,
+    baseUrl,
+    authScope,
+    scope,
+    root,
+    phases,
+    orgName,
+    json: options.json
+  });
+  if (initialAuthFailure !== null) return initialAuthFailure;
+  const connectedToRequestedWorkspace = () => {
+    if (_optionalChain([auth, 'access', _27 => _27.payload, 'optionalAccess', _28 => _28.connected]) !== true) return false;
+    if (!orgName) return true;
+    const workspace = asRecord(auth.payload.workspace);
+    return typeof _optionalChain([workspace, 'optionalAccess', _29 => _29.name]) === "string" && workspace.name.trim().toLowerCase() === orgName.toLowerCase();
+  };
+  let pending = replacingPendingClaim ? null : _chunkZDOC4HFLjs.readPendingAuthClaim.call(void 0, baseUrl, authScope);
+  if (replacingPendingClaim && connectedToRequestedWorkspace()) {
+    _chunkZDOC4HFLjs.clearPendingClaim.call(void 0, baseUrl, authScope);
+  }
+  let authClaimSource = "none";
+  if (pending || !connectedToRequestedWorkspace()) {
+    const reusedClaim = Boolean(pending);
+    authClaimSource = reusedClaim ? "existing" : "new";
+    if (!pending) {
+      process.stderr.write("Starting Deepline browser authorization...\n");
+      const registered = await captureStdout(
+        () => _chunkZDOC4HFLjs.handleRegister.call(void 0, [
+          "--wait",
+          "no",
+          "--auth-scope",
+          authScope,
+          ...orgName ? ["--org-name", orgName] : []
+        ])
+      );
+      if (registered.exitCode !== 0) {
+        return reportSetupPhaseFailure({
+          baseUrl,
+          scope,
+          root,
+          phases,
+          phase: "auth",
+          code: "AUTH_REGISTER_FAILED",
+          exitCode: registered.exitCode,
+          message: "Deepline browser authorization could not be started.",
+          orgName,
+          json: options.json,
+          extra: { detail: parseCapturedJson(registered.stdout), authScope }
+        });
+      }
+      pending = _chunkZDOC4HFLjs.readPendingAuthClaim.call(void 0, baseUrl, authScope);
+      if (!_optionalChain([pending, 'optionalAccess', _30 => _30.claimUrl])) {
+        return reportSetupPhaseFailure({
+          baseUrl,
+          scope,
+          root,
+          phases,
+          phase: "auth",
+          code: "AUTH_CLAIM_URL_MISSING",
+          exitCode: 4,
+          message: "Deepline authorization did not return a usable claim URL.",
+          orgName,
+          json: options.json
+        });
+      }
+      const browserOpenStatus = openSetupAuthorization(pending.claimUrl);
+      if (browserOpenStatus === "failed") {
+        return pendingResult({
+          baseUrl,
+          scope,
+          root,
+          phases,
+          authorizationUrl: pending.claimUrl,
+          browserOpenStatus: "failed",
+          authClaimSource,
+          orgName,
+          resumed,
+          json: options.json
+        });
+      }
+      process.stderr.write("Opened Deepline sign-in in the browser.\n");
+    }
+    process.stderr.write(
+      "Waiting up to five minutes for Deepline approval...\n"
+    );
+    const waited = await captureStdout(
+      () => _chunkZDOC4HFLjs.handleWait.call(void 0, ["--timeout", "300", "--auth-scope", authScope])
+    );
+    auth = await readAuthStatus(authScope);
+    const authFailure = reportSetupAuthStatusFailure({
+      auth,
+      baseUrl,
+      authScope,
+      scope,
+      root,
+      phases,
+      orgName,
+      json: options.json
+    });
+    if (authFailure !== null) return authFailure;
+    if (waited.exitCode === _chunkZDOC4HFLjs.EXIT_WORKSPACE_MISMATCH) {
+      return reportSetupPhaseFailure({
+        baseUrl,
+        scope,
+        root,
+        phases,
+        phase: "auth",
+        code: "REQUESTED_WORKSPACE_NOT_IN_ACCOUNT",
+        exitCode: _chunkZDOC4HFLjs.EXIT_WORKSPACE_MISMATCH,
+        message: `The requested workspace${orgName ? ` ${orgName}` : ""} does not exist in this account. Connect to an existing workspace first; then use deepline org create if you need a new one.`,
+        orgName,
+        retryAutomatic: false,
+        next: "Ask the user which existing workspace or account to use. Sign in with an account that can access it, then rerun setup with --org-name set to the confirmed workspace.",
+        json: options.json
+      });
+    }
+    if (!connectedToRequestedWorkspace()) {
+      const stillPending = _chunkZDOC4HFLjs.readPendingAuthClaim.call(void 0, baseUrl, authScope);
+      if (_optionalChain([stillPending, 'optionalAccess', _31 => _31.claimUrl])) {
+        return pendingResult({
+          baseUrl,
+          scope,
+          root,
+          phases,
+          authorizationUrl: stillPending.claimUrl,
+          browserOpenStatus: reusedClaim ? "existing_claim" : "timed_out",
+          authClaimSource,
+          orgName,
+          resumed,
+          json: options.json
+        });
+      }
+      return reportSetupPhaseFailure({
+        baseUrl,
+        scope,
+        root,
+        phases,
+        phase: "auth",
+        code: orgName && _optionalChain([auth, 'access', _32 => _32.payload, 'optionalAccess', _33 => _33.connected]) ? "AUTH_WORKSPACE_MISMATCH" : "AUTH_WAIT_FAILED",
+        exitCode: waited.exitCode || 4,
+        message: orgName && _optionalChain([auth, 'access', _34 => _34.payload, 'optionalAccess', _35 => _35.connected]) ? `Deepline is connected to a different workspace than ${orgName}.` : "Deepline authorization did not complete.",
+        orgName,
+        ...orgName && _optionalChain([auth, 'access', _36 => _36.payload, 'optionalAccess', _37 => _37.connected]) ? {
+          retryAutomatic: false,
+          next: "Ask the user which existing workspace or account to use. Rerun setup with --org-name set to the confirmed workspace."
+        } : {},
+        json: options.json
+      });
+    }
+  }
+  completeSetupPhase(phases, "auth", "connected");
+  beginSetupPhase(phases, "verify");
+  persistSetupProgress({ baseUrl, scope, root, phases });
+  const assessment = buildDoctorAssessment({
+    baseUrl,
+    scope,
+    root,
+    authStatus: auth
+  });
+  const gettingStarted = _chunkJNNOCMQYjs.deeplineGtmGettingStartedPayload.call(void 0, );
+  const doctorPayload = {
+    ok: assessment.ok,
+    status: assessment.ok ? "complete" : "failed",
+    code: assessment.ok ? "DOCTOR_OK" : "DOCTOR_FAILED",
+    exitCode: assessment.ok ? 0 : 7,
+    checks: assessment.checks,
+    next: assessment.ok ? _chunkJNNOCMQYjs.DEEPLINE_GTM_SKILL : `deepline doctor --scope ${scope} --json`,
+    ...assessment.ok ? { gettingStarted } : {}
+  };
+  if (!assessment.ok) {
+    return reportSetupPhaseFailure({
+      baseUrl,
+      scope,
+      root,
+      phases,
+      phase: "verify",
+      code: "DOCTOR_FAILED",
+      exitCode: 7,
+      message: "Deepline setup verification found one or more failed checks.",
+      orgName,
+      json: options.json,
+      extra: {
+        doctor: doctorPayload,
+        diagnostic: {
+          command: `deepline doctor --scope ${scope} --json`
+        }
+      }
+    });
+  }
+  completeSetupPhase(phases, "verify", "verified");
+  const statePath = writeSetupState({
+    baseUrl,
+    scope,
+    root,
+    status: "complete",
+    phases
+  });
+  const installedAgents = Array.isArray(_optionalChain([skillsPayload, 'optionalAccess', _38 => _38.agents])) ? skillsPayload.agents.filter(
+    (agent) => typeof agent === "string"
+  ) : [];
+  await _chunkZDOC4HFLjs.reportSetupCompleted.call(void 0, {
+    baseUrl,
+    authScope,
+    scope,
+    resumed,
+    installedAgentCount: installedAgents.length
+  });
+  const doctorChecks = asRecord(_optionalChain([doctorPayload, 'optionalAccess', _39 => _39.checks]));
+  const apiCheck = asRecord(_optionalChain([doctorChecks, 'optionalAccess', _40 => _40.api]));
+  const workspaceRecord = asRecord(_optionalChain([apiCheck, 'optionalAccess', _41 => _41.workspace]));
+  const workspaceName = typeof _optionalChain([workspaceRecord, 'optionalAccess', _42 => _42.name]) === "string" && workspaceRecord.name.trim() ? workspaceRecord.name.trim() : null;
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    {
+      ok: true,
+      status: "complete",
+      complete: true,
+      scope,
+      cliVersion: _chunk6HPEDBSJjs.SDK_VERSION,
+      agents: installedAgents,
+      workspace: _nullishCoalesce(_optionalChain([apiCheck, 'optionalAccess', _43 => _43.workspace]), () => ( null)),
+      businessDomain: typeof _optionalChain([auth, 'access', _44 => _44.payload, 'optionalAccess', _45 => _45.businessDomain]) === "string" ? auth.payload.businessDomain : null,
+      authClaimSource,
+      browserOpened: authClaimSource === "new",
+      rollbackCommand: rollbackCommand(scope, root),
+      statePath,
+      doctor: doctorPayload,
+      phases,
+      currentPhase: null,
+      failedPhase: null,
+      resumed,
+      next: _chunkJNNOCMQYjs.DEEPLINE_GTM_SKILL,
+      gettingStarted,
+      render: {
+        sections: [
+          {
+            title: "setup",
+            lines: [
+              workspaceName ? `Deepline is installed and connected to ${workspaceName}.` : "Deepline is installed and connected.",
+              ...workspaceName ? ["To link a different workspace, run: deepline auth register"] : [],
+              `Use ${_chunkJNNOCMQYjs.DEEPLINE_GTM_SKILL} in your agent.`,
+              gettingStarted.question,
+              ..._chunkJNNOCMQYjs.DEEPLINE_GTM_STARTER_PROMPTS.map(
+                (example, index) => `${index + 1}. ${example.title}: ${example.prompt}`
+              ),
+              `4. ${gettingStarted.customOption}`
+            ]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+  return 0;
+}
+function registerSetupCommands(program) {
+  program.command("setup").description("Install skills, authenticate, and verify Deepline.").option("--scope <scope>", "Setup scope: global or local", "global").option(
+    "--org-name <name>",
+    "Connect to an existing workspace, or name your first workspace"
+  ).option("--json", "Emit one final JSON result envelope").addHelpText(
+    "after",
+    `
+Notes:
+  Setup is idempotent. Bare setup resumes the first incomplete or failed phase.
+  It installs skills before auth and does not run a starter workflow.
+  JSON output includes phase status and an exact retry command.
+
+Examples:
+  deepline setup --json
+  deepline setup --org-name Acme --json
+  deepline setup --scope local --json
+`
+  ).action(async (options) => {
+    process.exitCode = await runSetupCommand(options);
+  });
+  program.command("doctor").description("Verify CLI, skills, auth, workspace, and API connectivity.").option(
+    "--scope <scope>",
+    "Expected setup scope: global or local",
+    "global"
+  ).option("--json", "Emit one JSON result envelope").addHelpText(
+    "after",
+    `
+Notes:
+  Doctor is read-only and makes no paid provider calls. It reports repairs but
+  does not apply them automatically.
+
+Examples:
+  deepline doctor --json
+  deepline doctor --scope local --json
+`
+  ).action(async (options) => {
+    process.exitCode = await runDoctorCommand(options);
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.buildPendingAuthorizationOutput = buildPendingAuthorizationOutput; exports.initialSetupPhases = initialSetupPhases; exports.inspectGlobalCliAvailability = inspectGlobalCliAvailability; exports.inspectPathConflict = inspectPathConflict; exports.isNpmManagedDeeplinePath = isNpmManagedDeeplinePath; exports.openSetupAuthorization = openSetupAuthorization; exports.registerSetupCommands = registerSetupCommands; exports.removeKnownLegacyPaths = removeKnownLegacyPaths; exports.reportSetupAuthStatusFailure = reportSetupAuthStatusFailure; exports.resolvePersistentGlobalCommand = resolvePersistentGlobalCommand; exports.runDoctorCommand = runDoctorCommand; exports.runSetupCommand = runSetupCommand; exports.selectSetupProgress = selectSetupProgress;