@h-rig/cli-surface-plugin 0.0.6-alpha.146

package/dist/src/commands/init.js

@@ -0,0 +1,1449 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/cli-surface-plugin/src/commands/_spinner.ts
+function createTtySpinner(input) {
+  const output = input.output ?? process.stdout;
+  const isTty = output.isTTY === true;
+  const frames = input.frames && input.frames.length > 0 ? input.frames : SPINNER_FRAMES;
+  let label = input.label;
+  let frame = 0;
+  let paused = false;
+  let stopped = false;
+  let lastPrintedLabel = "";
+  const render = () => {
+    if (stopped || paused)
+      return;
+    if (!isTty) {
+      if (label !== lastPrintedLabel) {
+        output.write(`${label}
+`);
+        lastPrintedLabel = label;
+      }
+      return;
+    }
+    frame = (frame + 1) % frames.length;
+    const glyph = frames[frame] ?? frames[0] ?? "";
+    output.write(`\r\x1B[2K${input.styleFrame ? input.styleFrame(glyph) : glyph} ${label}`);
+  };
+  const clearLine = () => {
+    if (isTty)
+      output.write("\r\x1B[2K");
+  };
+  render();
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  return {
+    setLabel(next) {
+      label = next;
+      render();
+    },
+    pause() {
+      paused = true;
+      clearLine();
+    },
+    resume() {
+      if (stopped)
+        return;
+      paused = false;
+      render();
+    },
+    stop(finalLine) {
+      if (stopped)
+        return;
+      stopped = true;
+      if (timer)
+        clearInterval(timer);
+      clearLine();
+      if (finalLine)
+        output.write(`${finalLine}
+`);
+    }
+  };
+}
+var SPINNER_FRAMES;
+var init__spinner = __esm(() => {
+  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+});
+
+// packages/cli-surface-plugin/src/app/drone-ui.ts
+var exports_drone_ui = {};
+__export(exports_drone_ui, {
+  droneWarn: () => droneWarn,
+  droneText: () => droneText,
+  droneStep: () => droneStep,
+  droneSpinner: () => droneSpinner,
+  droneSelect: () => droneSelect,
+  droneOutro: () => droneOutro,
+  droneNote: () => droneNote,
+  droneIntro: () => droneIntro,
+  droneInfo: () => droneInfo,
+  droneError: () => droneError,
+  droneConfirm: () => droneConfirm,
+  droneCancel: () => droneCancel
+});
+import { Input, matchesKey, ProcessTerminal, SelectList, Text, TUI } from "@oh-my-pi/pi-tui";
+function hexToRgb(hex) {
+  const value = hex.charCodeAt(0) === 35 ? hex.slice(1) : hex;
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
+}
+function fg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
+}
+function bold(text) {
+  return `\x1B[1m${text}\x1B[22m`;
+}
+function renderMicroDroneFrame(frame) {
+  const tick = Math.max(0, MICRO_DRONE_FRAMES.indexOf(frame));
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `${ink4("(")}${cyan(blade)}${ink4(")")}${bold(accent(eye))}${ink4("(")}${cyan(blade)}${ink4(")")}`;
+}
+function hairline(width = Math.min(process.stdout.columns ?? 80, 100)) {
+  return ink4("\u2500".repeat(Math.max(10, width)));
+}
+function droneIntro(title, subtitle) {
+  console.log("");
+  console.log(` ${accent("\u258D")}${bold(ink(title))}${subtitle ? ink3(` \u2014 ${subtitle}`) : ""}`);
+  console.log(hairline());
+}
+function droneOutro(text) {
+  console.log(hairline());
+  console.log(` ${accent("\u25C6")} ${ink2(text)}`);
+  console.log("");
+}
+function droneNote(message, title) {
+  if (title)
+    console.log(` ${accentDim("\u25C7")} ${bold(ink2(title))}`);
+  for (const line of message.split(`
+`))
+    console.log(` ${ink4("\u2502")} ${line}`);
+}
+function droneStep(text) {
+  console.log(` ${accent("\u203A")} ${ink(text)}`);
+}
+function droneInfo(text) {
+  console.log(` ${cyan("\xB7")} ${ink2(text)}`);
+}
+function droneWarn(text) {
+  console.log(` ${yellow("\u25B2")} ${ink2(text)}`);
+}
+function droneError(text) {
+  console.log(` ${red("\u2716")} ${ink2(text)}`);
+}
+function droneCancel(text) {
+  console.log(` ${red("\u2716")} ${ink3(text)}`);
+}
+function droneSpinner() {
+  let active = null;
+  return {
+    start(message) {
+      active = createTtySpinner({
+        label: message,
+        frames: MICRO_DRONE_FRAMES,
+        styleFrame: renderMicroDroneFrame
+      });
+    },
+    stop(message) {
+      active?.stop(message ? ` ${accent("\u25C6")} ${ink2(message)}` : undefined);
+      active = null;
+    },
+    error(message) {
+      active?.stop(message ? ` ${red("\u2716")} ${ink2(message)}` : undefined);
+      active = null;
+    }
+  };
+}
+async function runMiniTui(build) {
+  const tui = new TUI(new ProcessTerminal);
+  let settled = false;
+  return await new Promise((resolve5) => {
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      tui.stop();
+      resolve5(result);
+    };
+    build(tui, finish);
+    tui.start();
+  });
+}
+async function droneSelect(input) {
+  if (!process.stdout.isTTY || input.options.length === 0)
+    return input.initialValue ?? input.options[0]?.value ?? null;
+  return runMiniTui((tui, finish) => {
+    tui.addChild(new Text(` ${accent("\u258D")}${bold(ink(input.message))}`));
+    const items = input.options.map((option) => ({
+      value: option.value,
+      label: option.label,
+      ...option.hint ? { description: option.hint } : {}
+    }));
+    const list = new SelectList(items, Math.min(items.length, 12), DRONE_SELECT_THEME);
+    const initialIndex = input.initialValue ? items.findIndex((item) => item.value === input.initialValue) : -1;
+    if (initialIndex > 0)
+      list.setSelectedIndex(initialIndex);
+    list.onSelect = (item) => finish(item.value);
+    list.onCancel = () => finish(null);
+    tui.addChild(list);
+    tui.addChild(new Text(ink4(" \u2191\u2193 navigate \xB7 enter select \xB7 esc cancel")));
+    tui.setFocus(list);
+    tui.addInputListener((data) => {
+      if (matchesKey(data, "ctrl+c") || matchesKey(data, "escape")) {
+        finish(null);
+        return { consume: true };
+      }
+      return;
+    });
+  });
+}
+async function droneText(input) {
+  if (!process.stdout.isTTY)
+    return input.initialValue ?? null;
+  return runMiniTui((tui, finish) => {
+    tui.addChild(new Text(` ${accent("\u258D")}${bold(ink(input.message))}${input.placeholder ? ink4(`  (${input.placeholder})`) : ""}`));
+    const field = new Input;
+    if (input.initialValue)
+      field.setValue(input.initialValue);
+    field.onSubmit = (value) => finish(value);
+    field.onEscape = () => finish(null);
+    tui.addChild(field);
+    tui.addChild(new Text(ink4(" enter submit \xB7 esc cancel")));
+    tui.setFocus(field);
+    tui.addInputListener((data) => {
+      if (matchesKey(data, "ctrl+c")) {
+        finish(null);
+        return { consume: true };
+      }
+      return;
+    });
+  });
+}
+async function droneConfirm(input) {
+  const answer = await droneSelect({
+    message: input.message,
+    options: [
+      { value: "yes", label: "Yes" },
+      { value: "no", label: "No" }
+    ],
+    initialValue: input.initialValue === false ? "no" : "yes"
+  });
+  return answer === null ? null : answer === "yes";
+}
+var PALETTE, ink, ink2, ink3, ink4, accent, accentDim, cyan, red, yellow, MICRO_BLADES, EYE_FRAMES, MICRO_DRONE_FRAMES, DRONE_SYMBOLS, DRONE_SELECT_THEME;
+var init_drone_ui = __esm(() => {
+  init__spinner();
+  PALETTE = {
+    ink: "#f2f3f6",
+    ink2: "#aeb0ba",
+    ink3: "#6c6e79",
+    ink4: "#44464f",
+    accent: "#ccff4d",
+    accentDim: "#a9d63f",
+    cyan: "#56d8ff",
+    red: "#ff5d5d",
+    yellow: "#ffd24d"
+  };
+  ink = fg(PALETTE.ink);
+  ink2 = fg(PALETTE.ink2);
+  ink3 = fg(PALETTE.ink3);
+  ink4 = fg(PALETTE.ink4);
+  accent = fg(PALETTE.accent);
+  accentDim = fg(PALETTE.accentDim);
+  cyan = fg(PALETTE.cyan);
+  red = fg(PALETTE.red);
+  yellow = fg(PALETTE.yellow);
+  MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
+  EYE_FRAMES = ["@", "o", "."];
+  MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => {
+    const blade = MICRO_BLADES[index % MICRO_BLADES.length];
+    const eye = EYE_FRAMES[Math.floor(index / 2) % EYE_FRAMES.length];
+    return `(${blade})${eye}(${blade})`;
+  });
+  DRONE_SYMBOLS = {
+    cursor: "\u2192",
+    inputCursor: "\u258F",
+    boxRound: { topLeft: "\u256D", topRight: "\u256E", bottomLeft: "\u2570", bottomRight: "\u256F", horizontal: "\u2500", vertical: "\u2502" },
+    boxSharp: { topLeft: "\u250C", topRight: "\u2510", bottomLeft: "\u2514", bottomRight: "\u2518", horizontal: "\u2500", vertical: "\u2502", teeDown: "\u252C", teeUp: "\u2534", teeLeft: "\u2524", teeRight: "\u251C", cross: "\u253C" },
+    table: { topLeft: "\u250C", topRight: "\u2510", bottomLeft: "\u2514", bottomRight: "\u2518", horizontal: "\u2500", vertical: "\u2502", teeDown: "\u252C", teeUp: "\u2534", teeLeft: "\u2524", teeRight: "\u251C", cross: "\u253C" },
+    quoteBorder: "\u2502",
+    hrChar: "\u2500",
+    spinnerFrames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+  };
+  DRONE_SELECT_THEME = {
+    selectedPrefix: (text) => accent(text),
+    selectedText: (text) => bold(ink(text)),
+    description: (text) => ink3(text),
+    scrollInfo: (text) => ink4(text),
+    noMatch: (text) => ink3(text),
+    symbols: DRONE_SYMBOLS,
+    hovered: (text) => bold(ink(text))
+  };
+});
+
+// packages/cli-surface-plugin/src/commands/init.ts
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { spawnSync } from "child_process";
+import { basename, resolve as resolve5 } from "path";
+
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+
+// packages/cli-surface-plugin/src/commands/init.ts
+import { buildRigInitConfigSource } from "@rig/core";
+
+// packages/cli-surface-plugin/src/commands/_connection-state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "connection.json");
+}
+function readJsonFile(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
+  }
+}
+function writeJsonFile(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function readRepoConnection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  return {
+    selected,
+    project: typeof record.project === "string" ? record.project : undefined,
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
+    serverProjectRootAlias: typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined,
+    serverProjectRootBaseUrl: typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined
+  };
+}
+function writeRepoConnection(projectRoot, state) {
+  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
+}
+
+// packages/cli-surface-plugin/src/commands/init.ts
+import { upsertManagedRemoteEndpoint } from "@rig/runtime/control-plane/remote-config";
+import { loadConfig } from "@rig/core/load-config";
+
+// packages/cli-surface-plugin/src/commands/_inprocess-services.ts
+import { resolve as resolve2 } from "path";
+import {
+  beginGitHubDeviceFlow,
+  checkGitHubRepoPermissions,
+  createGitHubAuthStore,
+  listGitHubProjects,
+  pollGitHubDeviceFlow,
+  resolveGitHubAuthStatus,
+  resolveProjectStatusField,
+  saveGitHubTokenForProject
+} from "@rig/runtime/control-plane/github/index";
+var scopedGitHubBearerTokens = new Map;
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function cleanString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function oauthClientId() {
+  return cleanToken(process.env.RIG_GITHUB_OAUTH_CLIENT_ID);
+}
+function tokenForProject(projectRoot, override) {
+  const scoped = scopedGitHubBearerTokens.get(resolve2(projectRoot));
+  return cleanToken(override) ?? scoped ?? createGitHubAuthStore(projectRoot).readToken() ?? cleanToken(process.env.RIG_GITHUB_TOKEN);
+}
+function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
+  scopedGitHubBearerTokens.set(resolve2(projectRoot ?? process.cwd()), cleanToken(token));
+}
+async function getGitHubAuthStatusInProcess(context) {
+  return { ok: true, ...resolveGitHubAuthStatus({ projectRoot: context.projectRoot, oauthConfigured: Boolean(oauthClientId()) }) };
+}
+async function postGitHubTokenInProcess(context, token, options = {}) {
+  const targetRoot = options.projectRoot?.trim() || context.projectRoot;
+  const result = await saveGitHubTokenForProject({
+    projectRoot: targetRoot,
+    token,
+    tokenSource: "manual-token",
+    selectedRepo: options.selectedRepo ?? null
+  });
+  const store = createGitHubAuthStore(targetRoot);
+  const session = store.createApiSession();
+  if (targetRoot !== context.projectRoot) {
+    store.copyToLocalProjectRoot(context.projectRoot);
+  }
+  return { ...result, authenticated: result.signedIn, apiSessionToken: session.token };
+}
+async function listGitHubProjectsInProcess(context, owner, options = {}) {
+  const token = tokenForProject(context.projectRoot, options.authToken);
+  if (!token)
+    return { ok: false, error: "missing-token", projects: [] };
+  const projects = await listGitHubProjects({ owner, token });
+  return { ok: true, projects };
+}
+async function getGitHubProjectStatusFieldInProcess(context, projectId, options = {}) {
+  const token = tokenForProject(context.projectRoot, options.authToken);
+  if (!token)
+    return { ok: false, error: "missing-token" };
+  const field = await resolveProjectStatusField({ projectId, token });
+  return { ok: true, field };
+}
+async function requestGitHubAuthJsonInProcess(context, pathname, init = {}) {
+  const method = (init.method ?? "GET").toUpperCase();
+  if (pathname === "/api/github/auth/status")
+    return getGitHubAuthStatusInProcess(context);
+  if (pathname === "/api/github/repo/permissions") {
+    return checkGitHubRepoPermissions({ projectRoot: context.projectRoot, oauthConfigured: Boolean(oauthClientId()) });
+  }
+  if (pathname === "/api/github/auth/device/start" && method === "POST") {
+    const clientId = oauthClientId();
+    if (!clientId)
+      return { ok: false, oauthConfigured: false, error: "RIG_GITHUB_OAUTH_CLIENT_ID is not configured." };
+    const body = init.body ? JSON.parse(String(init.body)) : {};
+    return beginGitHubDeviceFlow({
+      projectRoot: context.projectRoot,
+      clientId,
+      ...cleanString(body.scope) ? { scope: cleanString(body.scope) } : {},
+      selectedRepo: cleanString(body.repoSlug)
+    });
+  }
+  if (pathname === "/api/github/auth/device/poll" && method === "POST") {
+    const clientId = oauthClientId();
+    if (!clientId)
+      return { ok: false, oauthConfigured: false, error: "RIG_GITHUB_OAUTH_CLIENT_ID is not configured." };
+    const body = init.body ? JSON.parse(String(init.body)) : {};
+    const pollId = cleanString(body.pollId);
+    if (!pollId)
+      return { ok: false, status: "error", error: "pollId is required" };
+    return pollGitHubDeviceFlow({ projectRoot: context.projectRoot, clientId, pollId, selectedRepo: cleanString(body.repoSlug) });
+  }
+  throw new Error(`No in-process GitHub auth API for ${method} ${pathname}`);
+}
+
+// packages/cli-surface-plugin/src/commands/_pi-install.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { resolve as resolve3 } from "path";
+var PI_RIG_PACKAGE_NAME = "@h-rig/pi-rig";
+async function defaultCommandRunner(command, options = {}) {
+  const proc = Bun.spawn(command, { cwd: options.cwd, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { exitCode, stdout, stderr };
+}
+function resolvePiRigExtensionPath(homeDir) {
+  return resolve3(homeDir, ".pi", "agent", "extensions", "pi-rig");
+}
+function resolvePiRigPackageSource(projectRoot, exists = existsSync2) {
+  const localPackage = resolve3(projectRoot, "packages", "pi-rig");
+  if (exists(resolve3(localPackage, "package.json")))
+    return localPackage;
+  return `npm:${PI_RIG_PACKAGE_NAME}`;
+}
+function resolvePiHomeDir(inputHomeDir) {
+  return inputHomeDir ?? process.env.RIG_PI_HOME_DIR?.trim() ?? homedir();
+}
+function piListContainsPiRig(output) {
+  return output.split(/\r?\n/).some((line) => {
+    const normalized = line.trim();
+    return normalized.includes(PI_RIG_PACKAGE_NAME) || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(normalized);
+  });
+}
+async function safeRun(runner, command, options) {
+  try {
+    return await runner(command, options);
+  } catch (error) {
+    return { exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
+  }
+}
+function splitInstallCommand(value) {
+  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
+}
+async function ensurePiBinaryAvailable(input) {
+  const current = await safeRun(input.runner, ["pi", "--version"]);
+  if (current.exitCode === 0) {
+    const updateCommand = process.env.RIG_PI_UPDATE_COMMAND?.trim();
+    if (updateCommand) {
+      const parts2 = splitInstallCommand(updateCommand);
+      if (parts2.length > 0)
+        await safeRun(input.runner, parts2, input.projectRoot ? { cwd: input.projectRoot } : undefined);
+    }
+    return { ok: true, detail: (current.stdout || current.stderr).trim() || undefined };
+  }
+  const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim();
+  if (!installCommand) {
+    return {
+      ok: false,
+      error: `${(current.stderr || current.stdout).trim() || "pi --version failed"}. Set RIG_PI_INSTALL_COMMAND to a supported installer or install Pi manually.`
+    };
+  }
+  const parts = splitInstallCommand(installCommand);
+  if (parts.length === 0) {
+    return { ok: false, error: (current.stderr || current.stdout).trim() || "pi --version failed" };
+  }
+  const install = await safeRun(input.runner, parts, input.projectRoot ? { cwd: input.projectRoot } : undefined);
+  if (install.exitCode !== 0) {
+    return { ok: false, installedOrUpdated: true, error: (install.stderr || install.stdout).trim() || `Pi install command failed (${install.exitCode})` };
+  }
+  const next = await safeRun(input.runner, ["pi", "--version"]);
+  return {
+    ok: next.exitCode === 0,
+    installedOrUpdated: true,
+    detail: (next.stdout || next.stderr).trim() || undefined,
+    ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
+  };
+}
+async function checkPiRigInstall(input = {}) {
+  const home = resolvePiHomeDir(input.homeDir);
+  const extensionPath = resolvePiRigExtensionPath(home);
+  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
+    return {
+      extensionPath,
+      pi: { ok: true, label: "pi", detail: "fake-pi" },
+      piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
+    };
+  }
+  const runner = input.commandRunner ?? defaultCommandRunner;
+  const piResult = await safeRun(runner, ["pi", "--version"]);
+  const piListResult = piResult.exitCode === 0 ? await safeRun(runner, ["pi", "list"]) : { exitCode: 1, stdout: "", stderr: "" };
+  const hasPiRig = piListResult.exitCode === 0 && piListContainsPiRig(`${piListResult.stdout}
+${piListResult.stderr}`);
+  const hasLegacyBridgeScaffold = !hasPiRig && (input.exists ?? existsSync2)(extensionPath);
+  return {
+    extensionPath,
+    pi: {
+      ok: piResult.exitCode === 0,
+      label: "pi",
+      detail: (piResult.stdout || piResult.stderr).trim() || undefined,
+      hint: piResult.exitCode === 0 ? undefined : "Install Pi/OMP manually or set RIG_PI_INSTALL_COMMAND before verifying with bare `rig` / Cockpit \u2192 Doctor."
+    },
+    piRig: {
+      ok: hasPiRig,
+      label: "pi-rig global extension",
+      detail: hasPiRig ? piListResult.stdout.trim() || PI_RIG_PACKAGE_NAME : hasLegacyBridgeScaffold ? `legacy bridge scaffold at ${extensionPath}` : undefined,
+      hint: hasPiRig ? undefined : `Install the Rig OMP extension with \`pi install ${PI_RIG_PACKAGE_NAME}\`, then verify with bare \`rig\` / Cockpit \u2192 Doctor.`
+    }
+  };
+}
+async function ensurePiRigInstalled(input) {
+  const home = resolvePiHomeDir(input.homeDir);
+  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
+    const status = await checkPiRigInstall({ homeDir: home, commandRunner: input.commandRunner });
+    return { ...status, installedPath: status.extensionPath };
+  }
+  const runner = input.commandRunner ?? defaultCommandRunner;
+  const piAvailable = await ensurePiBinaryAvailable({ runner, projectRoot: input.projectRoot });
+  if (!piAvailable.ok) {
+    throw new Error(`Pi install/update failed: ${piAvailable.error ?? "pi unavailable"}`);
+  }
+  const packageSource = resolvePiRigPackageSource(input.projectRoot);
+  const install = await runner(["pi", "install", packageSource], { cwd: input.projectRoot });
+  if (install.exitCode !== 0) {
+    throw new Error(`pi-rig install failed: ${(install.stderr || install.stdout).trim() || `exit ${install.exitCode}`}`);
+  }
+  const next = await checkPiRigInstall({ homeDir: home, commandRunner: runner });
+  return { ...next, installedPath: packageSource };
+}
+
+// packages/cli-surface-plugin/src/commands/_doctor-checks.ts
+import { countDoctorFailures, runDoctorChecks } from "@rig/client";
+var runRigDoctorChecks = runDoctorChecks;
+
+// packages/cli-surface-plugin/src/version.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve4 } from "path";
+import { fileURLToPath } from "url";
+import { readBuildConfig } from "@rig/runtime/build-time-config";
+var SOURCE_CLI_VERSION = "0.0.0-alpha.1";
+var DEV_CLI_VERSION = "0.0.0-dev";
+function resolveInstalledCliVersion() {
+  const buildConfig = readBuildConfig();
+  const envVersion = process.env.RIG_CLI_VERSION?.trim();
+  const buildVersion = buildConfig.RIG_CLI_VERSION?.trim();
+  let version = envVersion || buildVersion || "";
+  if (!version) {
+    try {
+      const execPath = process.execPath || "";
+      const moduleDir = dirname2(fileURLToPath(import.meta.url));
+      const candidates = [
+        execPath ? resolve4(dirname2(execPath), "..", "manifest.json") : "",
+        resolve4(moduleDir, "..", "package.json"),
+        resolve4(moduleDir, "..", "..", "package.json"),
+        resolve4(process.cwd(), "packages/cli/package.json")
+      ].filter(Boolean);
+      for (const candidate of candidates) {
+        if (!existsSync3(candidate))
+          continue;
+        const parsed = JSON.parse(readFileSync2(candidate, "utf-8"));
+        const candidateVersion = parsed.version?.trim();
+        if (candidateVersion) {
+          version = candidateVersion;
+          break;
+        }
+      }
+    } catch {}
+  }
+  return version || DEV_CLI_VERSION;
+}
+function isPublishedCliVersion(version) {
+  const normalized = version.trim();
+  return normalized.length > 0 && normalized !== SOURCE_CLI_VERSION && normalized !== DEV_CLI_VERSION;
+}
+
+// packages/cli-surface-plugin/src/rig-config-package-deps.ts
+var REQUIRED_RIG_CONFIG_PACKAGE_NAMES = ["core", "standard-plugin"];
+function resolveRigConfigPackageVersion() {
+  const explicit = process.env.RIG_CONFIG_PACKAGE_VERSION?.trim();
+  if (explicit)
+    return explicit;
+  const installed = resolveInstalledCliVersion();
+  return isPublishedCliVersion(installed) ? installed : "latest";
+}
+function rigConfigDevDependencies() {
+  const version = resolveRigConfigPackageVersion();
+  return Object.fromEntries(REQUIRED_RIG_CONFIG_PACKAGE_NAMES.map((name) => [`@rig/${name}`, rigPackageSpec(name, version)]));
+}
+function rigPackageSpec(packageName, version = resolveRigConfigPackageVersion()) {
+  return `npm:@h-rig/${packageName}@${version}`;
+}
+
+// packages/cli-surface-plugin/src/commands/init.ts
+function parseRepoSlugFromRemote(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  const gitHubMatch = trimmed.match(/github\.com[:/]([^/]+)\/([^/.]+)(?:\.git)?$/i);
+  return gitHubMatch ? `${gitHubMatch[1]}/${gitHubMatch[2]}` : null;
+}
+function detectOriginRepoSlug(projectRoot) {
+  const result = spawnSync("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf8" });
+  if (result.status !== 0)
+    return null;
+  return parseRepoSlugFromRemote(result.stdout.trim());
+}
+function parseRepoSlug(value) {
+  const match = value.trim().match(/^([^/\s]+)\/([^/\s]+)$/);
+  if (!match)
+    throw new CliError(`Invalid GitHub repo slug: ${value}. Expected owner/repo.`, 1, { hint: "Pass the slug as owner/repo, e.g. `rig init --repo acme/widgets`." });
+  return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
+}
+function ensureRigPrivateDirs(projectRoot) {
+  const rigDir = resolve5(projectRoot, ".rig");
+  mkdirSync2(resolve5(rigDir, "state"), { recursive: true });
+  mkdirSync2(resolve5(rigDir, "logs"), { recursive: true });
+  mkdirSync2(resolve5(rigDir, "runs"), { recursive: true });
+  mkdirSync2(resolve5(rigDir, "tmp"), { recursive: true });
+  mkdirSync2(resolve5(projectRoot, "artifacts"), { recursive: true });
+  const taskConfigPath = resolve5(rigDir, "task-config.json");
+  if (!existsSync4(taskConfigPath))
+    writeFileSync2(taskConfigPath, `{}
+`, "utf-8");
+}
+function ensureGitignoreEntries(projectRoot) {
+  const path = resolve5(projectRoot, ".gitignore");
+  const existing = existsSync4(path) ? readFileSync3(path, "utf8") : "";
+  const entries = [".rig/state/", ".rig/logs/", ".rig/runs/", ".rig/tmp/"];
+  const missing = entries.filter((entry) => !existing.split(/\r?\n/).includes(entry));
+  if (missing.length === 0)
+    return;
+  const prefix = existing.length > 0 && !existing.endsWith(`
+`) ? `
+` : "";
+  appendFileSync(path, `${prefix}${missing.join(`
+`)}
+`, "utf8");
+}
+function ensureRigConfigPackageDependencies(projectRoot) {
+  const path = resolve5(projectRoot, "package.json");
+  const existing = existsSync4(path) ? JSON.parse(readFileSync3(path, "utf8")) : {};
+  const devDependencies = existing.devDependencies && typeof existing.devDependencies === "object" && !Array.isArray(existing.devDependencies) ? { ...existing.devDependencies } : {};
+  for (const [name, spec] of Object.entries(rigConfigDevDependencies())) {
+    devDependencies[name] = spec;
+  }
+  const next = {
+    ...existsSync4(path) ? existing : { name: "rig-project", private: true },
+    devDependencies
+  };
+  writeFileSync2(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+}
+function applyGitHubProjectConfig(source, options) {
+  if (!options.githubProject || options.githubProject === "off")
+    return source;
+  const projectId = JSON.stringify(options.githubProject);
+  const statusFieldId = JSON.stringify(options.githubProjectStatusField ?? "Status");
+  const statuses = options.githubProjectStatuses && Object.keys(options.githubProjectStatuses).length > 0 ? `
+      statuses: ${JSON.stringify(options.githubProjectStatuses, null, 8).replace(/\n/g, `
+      `)},` : "";
+  return source.replace(`    projects: { enabled: false },`, [
+    `    projects: {`,
+    `      enabled: true,`,
+    `      projectId: ${projectId},`,
+    `      statusFieldId: ${statusFieldId},${statuses}`,
+    `    },`
+  ].join(`
+`));
+}
+function checkoutForInit(projectRoot, options) {
+  if (options.server === "remote") {
+    return {
+      kind: "remote",
+      strategy: "existing-path",
+      path: options.remoteCheckout?.trim() || null,
+      alias: options.remoteAlias ?? options.remoteHost ?? null
+    };
+  }
+  return { kind: "local", path: projectRoot };
+}
+function detectGhLogin() {
+  const result = spawnSync("gh", ["api", "user", "--jq", ".login"], { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
+  return result.status === 0 && result.stdout.trim() ? result.stdout.trim() : null;
+}
+function readGhAuthToken() {
+  const result = spawnSync("gh", ["auth", "token"], { encoding: "utf8" });
+  if (result.status !== 0 || !result.stdout.trim()) {
+    throw new CliError(result.stderr.trim() || "Could not read GitHub token from `gh auth token`.", result.status || 1, { hint: "Sign in with `gh auth login`, or pass a token directly: `rig init --github-auth token --github-token <token>`." });
+  }
+  return result.stdout.trim();
+}
+function refreshGhProjectScopesAndReadToken() {
+  const result = spawnSync("gh", ["auth", "refresh", "--scopes", "read:project"], {
+    encoding: "utf8",
+    stdio: ["inherit", "pipe", "pipe"]
+  });
+  if (result.status !== 0)
+    return null;
+  try {
+    return readGhAuthToken();
+  } catch {
+    return null;
+  }
+}
+var DRONE_CANCEL = Symbol("drone-cancel");
+async function loadClackPrompts() {
+  const drone = await Promise.resolve().then(() => (init_drone_ui(), exports_drone_ui));
+  return {
+    intro: (message) => drone.droneIntro(message),
+    outro: (message) => drone.droneOutro(message),
+    cancel: (message) => drone.droneCancel(message),
+    isCancel: (value) => value === DRONE_CANCEL,
+    text: async (options) => {
+      const prefill = (options.initialValue ?? options.defaultValue ?? "").trim();
+      const value = await drone.droneText({
+        message: options.message,
+        ...options.placeholder ? { placeholder: options.placeholder } : {},
+        ...prefill ? { initialValue: prefill } : {}
+      });
+      return value === null ? DRONE_CANCEL : value;
+    },
+    select: async (options) => {
+      const value = await drone.droneSelect({
+        message: options.message,
+        options: options.options,
+        ...options.initialValue ? { initialValue: options.initialValue } : {}
+      });
+      return value === null ? DRONE_CANCEL : value;
+    },
+    confirm: async (options) => {
+      const value = await drone.droneConfirm(options);
+      return value === null ? DRONE_CANCEL : value;
+    }
+  };
+}
+async function promptRequiredText(prompts, options) {
+  const value = await prompts.text(options);
+  if (prompts.isCancel(value))
+    throw new CliError("Init cancelled.", 1);
+  const text = String(value ?? "").trim();
+  if (!text)
+    throw new CliError(`${options.message} is required.`, 1);
+  return text;
+}
+async function promptOptionalText(prompts, options) {
+  const value = await prompts.text(options);
+  if (prompts.isCancel(value))
+    throw new CliError("Init cancelled.", 1);
+  return String(value ?? "").trim();
+}
+async function promptSelect(prompts, options) {
+  const value = await prompts.select(options);
+  if (prompts.isCancel(value))
+    throw new CliError("Init cancelled.", 1);
+  return String(value);
+}
+function repoOwnerFromSlug(repoSlug) {
+  return repoSlug.trim().match(/^([^/]+)\/[^/]+$/)?.[1] ?? null;
+}
+function recordArray(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return [];
+  const raw = value[key];
+  return Array.isArray(raw) ? raw.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+}
+async function listGitHubProjectsForInit(context, owner, token, serverBaseUrl) {
+  return listGitHubProjectsInProcess(context, owner, { authToken: token, baseUrl: serverBaseUrl });
+}
+async function getGitHubProjectStatusFieldForInit(context, projectId, token, serverBaseUrl) {
+  return getGitHubProjectStatusFieldInProcess(context, projectId, { authToken: token, baseUrl: serverBaseUrl });
+}
+var PROJECT_STATUS_PROMPTS = {
+  running: "Running/In progress",
+  prOpen: "PR open/review",
+  ciFixing: "CI/review fixing",
+  merging: "Merging",
+  done: "Done",
+  needsAttention: "Needs attention"
+};
+var DEFAULT_PROJECT_STATUS_OPTIONS = {
+  running: "In Progress",
+  prOpen: "In Review",
+  ciFixing: "In Review",
+  merging: "Merging",
+  done: "Done",
+  needsAttention: "Needs Attention"
+};
+async function promptManualProjectStatusMapping(prompts) {
+  const statuses = {};
+  for (const [key, label] of Object.entries(PROJECT_STATUS_PROMPTS)) {
+    const defaultLabel = DEFAULT_PROJECT_STATUS_OPTIONS[key] ?? label;
+    const value = await promptOptionalText(prompts, {
+      message: `Project status option id/name for ${label} (blank for ${defaultLabel})`,
+      placeholder: defaultLabel
+    });
+    statuses[key] = value || defaultLabel;
+  }
+  return statuses;
+}
+function projectScopeError(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
+  return /INSUFFICIENT_SCOPES|read:project|required scopes/i.test(text);
+}
+function optionName(option) {
+  return String(option.name ?? option.label ?? option.id ?? "").trim();
+}
+function autoProjectStatusValue(options, key, label) {
+  const candidates = [DEFAULT_PROJECT_STATUS_OPTIONS[key], label].filter((value) => Boolean(value)).map((value) => value.trim().toLowerCase());
+  const match = options.find((option) => candidates.includes(optionName(option).toLowerCase()));
+  if (!match)
+    return null;
+  return String(match.id ?? match.name);
+}
+async function promptGitHubProjectConfig(context, prompts, repoSlug, githubToken, refreshProjectToken, serverBaseUrl) {
+  const projectChoice = await promptSelect(prompts, {
+    message: "GitHub Projects status sync",
+    initialValue: "select",
+    options: [
+      { value: "select", label: "Select accessible ProjectV2" },
+      { value: "off", label: "Off" },
+      { value: "manual", label: "Enter ProjectV2 ids manually" }
+    ]
+  });
+  if (projectChoice === "off")
+    return { githubProject: "off" };
+  if (projectChoice === "manual") {
+    return {
+      githubProject: await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }),
+      githubProjectStatusField: await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" }),
+      githubProjectStatuses: await promptManualProjectStatusMapping(prompts)
+    };
+  }
+  const owner = repoOwnerFromSlug(repoSlug);
+  if (!owner)
+    throw new CliError(`Cannot derive GitHub owner from repo slug ${repoSlug}.`, 1, { hint: "Pass the slug as owner/repo, e.g. `rig init --repo acme/widgets`." });
+  let activeToken = githubToken?.trim() || null;
+  let projectsPayload = await listGitHubProjectsForInit(context, owner, activeToken, serverBaseUrl).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), projects: [] }));
+  let projects = recordArray(projectsPayload, "projects");
+  if (projects.length === 0 && projectScopeError(projectsPayload.error) && refreshProjectToken) {
+    prompts.outro?.("GitHub token is missing read:project; refreshing gh auth scopes and retrying Projects.");
+    const refreshedToken = refreshProjectToken();
+    if (refreshedToken) {
+      activeToken = refreshedToken;
+      projectsPayload = await listGitHubProjectsForInit(context, owner, activeToken, serverBaseUrl).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), projects: [] }));
+      projects = recordArray(projectsPayload, "projects");
+    }
+  }
+  if (projects.length === 0) {
+    const error = typeof projectsPayload.error === "string" ? ` (${String(projectsPayload.error).replace(/\s+/g, " ").slice(0, 240)})` : "";
+    prompts.outro?.(`No accessible GitHub Projects were returned${error}; continuing with GitHub Projects status sync off.`);
+    return { githubProject: "off", ...activeToken ? { githubToken: activeToken } : {} };
+  }
+  const selectedProjectId = await promptSelect(prompts, {
+    message: "GitHub ProjectV2 project",
+    options: [
+      ...projects.map((project) => ({
+        value: String(project.id),
+        label: `${String(project.title ?? "Untitled project")} (#${String(project.number ?? "?")})`,
+        hint: typeof project.url === "string" ? project.url : undefined
+      })),
+      { value: "manual", label: "Enter ProjectV2 id manually" }
+    ]
+  });
+  const projectId = selectedProjectId === "manual" ? await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }) : selectedProjectId;
+  const fieldPayload = await getGitHubProjectStatusFieldForInit(context, projectId, activeToken, serverBaseUrl).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+  const fieldPayloadRecord = fieldPayload && typeof fieldPayload === "object" && !Array.isArray(fieldPayload) ? fieldPayload : {};
+  const rawField = fieldPayloadRecord.field;
+  const field = rawField && typeof rawField === "object" && !Array.isArray(rawField) ? rawField : null;
+  const fieldId = typeof field?.id === "string" && field.id.trim() ? field.id : await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" });
+  const options = Array.isArray(field?.options) ? field.options.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  if (options.length === 0) {
+    return {
+      githubProject: projectId,
+      githubProjectStatusField: fieldId,
+      githubProjectStatuses: await promptManualProjectStatusMapping(prompts),
+      ...activeToken ? { githubToken: activeToken } : {}
+    };
+  }
+  const statuses = {};
+  for (const [key, label] of Object.entries(PROJECT_STATUS_PROMPTS)) {
+    const auto = autoProjectStatusValue(options, key, label);
+    statuses[key] = auto ?? await promptSelect(prompts, {
+      message: `Project status option for ${label}`,
+      options: options.map((option) => ({ value: String(option.id ?? option.name), label: optionName(option) }))
+    });
+  }
+  return {
+    githubProject: projectId,
+    githubProjectStatusField: fieldId,
+    githubProjectStatuses: Object.keys(statuses).length > 0 ? statuses : undefined,
+    ...activeToken ? { githubToken: activeToken } : {}
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+function positiveIntFromEnv(name, fallback) {
+  const value = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function apiSessionTokenFrom(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const token = payload.apiSessionToken;
+  return typeof token === "string" && token.trim() ? token.trim() : null;
+}
+async function pollDeviceAuthUntilComplete(context, pollId, firstPayload) {
+  if (typeof pollId !== "string" || !pollId.trim())
+    return null;
+  const intervalSeconds = typeof firstPayload.interval === "number" && Number.isFinite(firstPayload.interval) && firstPayload.interval > 0 ? firstPayload.interval : 5;
+  const timeoutMs = positiveIntFromEnv("RIG_DEVICE_AUTH_POLL_TIMEOUT_MS", 300000);
+  const intervalMs = positiveIntFromEnv("RIG_DEVICE_AUTH_POLL_INTERVAL_MS", Math.max(1000, intervalSeconds * 1000));
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  do {
+    const payload = await requestGitHubAuthJsonInProcess(context, "/api/github/auth/device/poll", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ pollId })
+    }).catch(() => null);
+    last = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+    const status = typeof last?.status === "string" ? last.status : null;
+    if (status === "signed-in" || status === "expired" || status === "cancelled" || status === "failed") {
+      return last;
+    }
+    if (timeoutMs <= 0)
+      return last;
+    await sleep(intervalMs);
+  } while (Date.now() < deadline);
+  return last;
+}
+function runLocalFilesInit(context, options) {
+  const projectRoot = context.projectRoot;
+  ensureRigPrivateDirs(projectRoot);
+  ensureGitignoreEntries(projectRoot);
+  writeRepoConnection(projectRoot, { selected: "local", linkedAt: new Date().toISOString() });
+  const configTsPath = resolve5(projectRoot, "rig.config.ts");
+  const configExists = existsSync4(configTsPath) || existsSync4(resolve5(projectRoot, "rig.config.json"));
+  if (configExists && !options.repair) {
+    if (context.outputMode !== "json")
+      console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it.");
+  } else {
+    const projectName = basename(projectRoot) || "rig-project";
+    writeFileSync2(configTsPath, buildRigInitConfigSource({
+      projectName,
+      taskSource: { kind: "files", path: "tasks" },
+      useStandardPlugin: true
+    }), "utf-8");
+  }
+  ensureRigConfigPackageDependencies(projectRoot);
+  const tasksDir = resolve5(projectRoot, "tasks");
+  if (!existsSync4(tasksDir)) {
+    mkdirSync2(tasksDir, { recursive: true });
+    writeFileSync2(resolve5(tasksDir, "T-1.json"), `${JSON.stringify({ id: "T-1", title: "My first Rig task", body: "Describe the change you want an agent to make." }, null, 2)}
+`, "utf-8");
+  }
+  if (context.outputMode !== "json") {
+    console.log("Initialized a local files-source Rig project (no GitHub).");
+    console.log("  tasks live in tasks/*.json \xB7 server: local");
+    console.log("Next: `rig task list`, then `rig task run T-1`.");
+    console.log("To wire GitHub later: `rig init --repair --repo owner/repo --github-auth gh`.");
+  }
+  return { ok: true, group: "init", command: "init", details: { mode: "local-files", projectRoot, taskSourcePath: "tasks" } };
+}
+var DEMO_TASKS_RELATIVE_DIR = ".rig/demo-tasks";
+var DEMO_TASKS = [
+  {
+    id: "demo-1",
+    title: "Add a hello CLI script",
+    body: [
+      "Create `scripts/hello.ts` that prints `Hello from Rig!` plus the current date,",
+      "and add a `hello` script entry to package.json that runs it with bun.",
+      "Keep it dependency-free."
+    ].join(`
+`),
+    status: "ready",
+    labels: ["demo"]
+  },
+  {
+    id: "demo-2",
+    title: "Write a README section about this project",
+    body: [
+      "Add (or extend) README.md with a short `## What this is` section:",
+      "two or three sentences describing the repository and how to run it.",
+      "Plain prose, no badges."
+    ].join(`
+`),
+    status: "ready",
+    labels: ["demo"]
+  },
+  {
+    id: "demo-3",
+    title: "Add a unit test for the hello script",
+    body: [
+      "Add `scripts/hello.test.ts` with a bun test that imports the greeting",
+      "helper from the hello script and asserts it contains `Hello from Rig!`.",
+      "Refactor the script to export that helper if needed."
+    ].join(`
+`),
+    status: "ready",
+    labels: ["demo"]
+  }
+];
+function runDemoInit(context, options) {
+  const projectRoot = context.projectRoot;
+  ensureRigPrivateDirs(projectRoot);
+  ensureGitignoreEntries(projectRoot);
+  writeRepoConnection(projectRoot, { selected: "local", linkedAt: new Date().toISOString() });
+  const configTsPath = resolve5(projectRoot, "rig.config.ts");
+  const configExists = existsSync4(configTsPath) || existsSync4(resolve5(projectRoot, "rig.config.json"));
+  let configWritten = false;
+  if (configExists && !options.repair) {
+    if (context.outputMode !== "json") {
+      console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it for the demo.");
+    }
+  } else {
+    writeFileSync2(configTsPath, buildRigInitConfigSource({
+      projectName: basename(projectRoot) || "rig-demo",
+      taskSource: { kind: "files", path: DEMO_TASKS_RELATIVE_DIR },
+      useStandardPlugin: true
+    }), "utf-8");
+    configWritten = true;
+  }
+  ensureRigConfigPackageDependencies(projectRoot);
+  const demoTasksDir = resolve5(projectRoot, DEMO_TASKS_RELATIVE_DIR);
+  mkdirSync2(demoTasksDir, { recursive: true });
+  const taskIds = [];
+  for (const task of DEMO_TASKS) {
+    const id = String(task.id);
+    taskIds.push(id);
+    const taskPath = resolve5(demoTasksDir, `${id}.json`);
+    if (!existsSync4(taskPath)) {
+      writeFileSync2(taskPath, `${JSON.stringify(task, null, 2)}
+`, "utf-8");
+    }
+  }
+  if (context.outputMode !== "json") {
+    console.log(`Demo Rig project ready (offline, no GitHub).`);
+    console.log(`  config: rig.config.ts (files task source -> ${DEMO_TASKS_RELATIVE_DIR}/)`);
+    console.log(`  tasks:  ${taskIds.join(", ")}`);
+    console.log("Next steps:");
+    console.log("  1. run bare `rig`");
+    console.log("  2. use the OMP cockpit Start screen");
+  }
+  return {
+    ok: true,
+    group: "init",
+    command: "init",
+    details: {
+      mode: "demo",
+      projectRoot,
+      taskSourcePath: DEMO_TASKS_RELATIVE_DIR,
+      demoTasksDir,
+      tasks: taskIds,
+      configWritten
+    }
+  };
+}
+async function runControlPlaneInit(context, options) {
+  const projectRoot = context.projectRoot;
+  const existingRepoConnection = readRepoConnection(projectRoot);
+  const detectedSlug = options.repoSlug ?? existingRepoConnection?.project ?? detectOriginRepoSlug(projectRoot);
+  if (!detectedSlug) {
+    const authMethod2 = options.githubAuthMethod ?? (options.githubToken ? "token" : "skip");
+    if (authMethod2 === "skip") {
+      return runLocalFilesInit(context, options);
+    }
+    throw new CliError("Could not detect GitHub repo slug from origin. Current UX starts from bare `rig`; pass --repo owner/repo or use `rig init --yes --github-auth skip` for a local files-source project without GitHub.", 1);
+  }
+  const repo = parseRepoSlug(detectedSlug);
+  const placement = options.server ?? "local";
+  let connectionAlias = "local";
+  if (placement === "remote") {
+    const host = (options.remoteHost ?? "").trim();
+    const alias = (options.remoteAlias ?? host).trim();
+    if (!host || !alias) {
+      throw new CliError("Remote placement needs --remote-host <host>.", 1, {
+        hint: "rig init --server remote --remote-host rig.example.com [--remote-alias prod] [--remote-port 22] [--remote-checkout /srv/repo]"
+      });
+    }
+    upsertManagedRemoteEndpoint({ alias, host, port: options.remotePort ?? 22 }, undefined, projectRoot);
+    connectionAlias = alias;
+  }
+  const remoteCheckoutPath = placement === "remote" ? options.remoteCheckout?.trim() || null : null;
+  writeRepoConnection(projectRoot, {
+    selected: connectionAlias,
+    project: repo.slug,
+    linkedAt: new Date().toISOString(),
+    ...remoteCheckoutPath ? { serverProjectRoot: remoteCheckoutPath, serverProjectRootAlias: connectionAlias } : {}
+  });
+  ensureRigPrivateDirs(projectRoot);
+  ensureGitignoreEntries(projectRoot);
+  const configTsPath = resolve5(projectRoot, "rig.config.ts");
+  const configJsonPath = resolve5(projectRoot, "rig.config.json");
+  const configExists = existsSync4(configTsPath) || existsSync4(configJsonPath);
+  if (!options.privateStateOnly) {
+    if (configExists && !options.repair) {
+      if (context.outputMode !== "json")
+        console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it.");
+    } else {
+      const source = applyGitHubProjectConfig(buildRigInitConfigSource({
+        projectName: repo.slug,
+        projectRepo: repo.slug,
+        taskSource: { kind: "github-issues", owner: repo.owner, repo: repo.repo },
+        useStandardPlugin: true
+      }), options);
+      writeFileSync2(configTsPath, source, "utf-8");
+    }
+    ensureRigConfigPackageDependencies(projectRoot);
+  }
+  writeFileSync2(resolve5(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
+`, "utf8");
+  const checkout = checkoutForInit(projectRoot, options);
+  let githubAuth = null;
+  let deviceAuth = null;
+  const authMethod = options.githubAuthMethod ?? (options.githubToken ? "token" : "skip");
+  const token = authMethod === "gh" && !options.githubToken ? readGhAuthToken() : options.githubToken?.trim();
+  if (token) {
+    githubAuth = await postGitHubTokenInProcess(context, token, { selectedRepo: repo.slug });
+    const apiSessionToken = apiSessionTokenFrom(githubAuth);
+    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token, projectRoot);
+  } else if (authMethod === "device") {
+    const payload = await requestGitHubAuthJsonInProcess(context, "/api/github/auth/device/start", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ repoSlug: repo.slug })
+    });
+    deviceAuth = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    if (context.outputMode !== "json") {
+      const verificationUri = String(deviceAuth.verificationUri ?? deviceAuth.verification_uri ?? deviceAuth.verification_uri_complete ?? "the verification URL returned by GitHub");
+      const userCode = String(deviceAuth.userCode ?? deviceAuth.user_code ?? "the returned user code");
+      console.log(`GitHub device flow: open ${verificationUri} and enter ${userCode}. Waiting for authorization...`);
+    }
+    const completed = await pollDeviceAuthUntilComplete(context, deviceAuth.pollId, deviceAuth);
+    if (completed) {
+      const apiSessionToken = apiSessionTokenFrom(completed);
+      if (apiSessionToken) {
+        setGitHubBearerTokenForCurrentProcess(apiSessionToken, projectRoot);
+      }
+      deviceAuth = { ...deviceAuth, poll: completed, completed: completed.status === "signed-in" };
+    }
+  }
+  const labelSetup = {
+    ok: false,
+    ready: false,
+    labelsReady: false,
+    skipped: true,
+    reason: "retired-server-label-bootstrap"
+  };
+  const pi = await ensurePiRigInstalled({ projectRoot, homeDir: process.env.RIG_PI_HOME_DIR }).catch((error) => ({
+    pi: { ok: false, label: "pi", hint: error instanceof Error ? error.message : String(error) },
+    piRig: { ok: false, label: "pi-rig global extension", hint: "Local pi-rig installation failed." },
+    extensionPath: null,
+    installedPath: null
+  }));
+  const doctor = await runRigDoctorChecks({ projectRoot }).then((checks) => ({
+    ok: countDoctorFailures(checks) === 0,
+    failures: countDoctorFailures(checks),
+    checks
+  }));
+  const details = {
+    repoSlug: repo.slug,
+    server: placement,
+    connection: connectionAlias,
+    githubProject: options.githubProject ?? "off",
+    checkout,
+    githubAuth,
+    deviceAuth,
+    labelSetup,
+    pi,
+    doctor
+  };
+  if (context.outputMode === "text")
+    console.log(`Initialized Rig control-plane project ${repo.slug} (${placement} placement). Next: rig doctor && rig task list`);
+  return { ok: true, group: "init", command: "init", details };
+}
+function parseInitOptions(args) {
+  let rest = [...args];
+  const demo = takeFlag(rest, "--demo");
+  rest = demo.rest;
+  const yes = takeFlag(rest, "--yes");
+  rest = yes.rest;
+  const repair = takeFlag(rest, "--repair");
+  rest = repair.rest;
+  const privateStateOnly = takeFlag(rest, "--private-state-only");
+  rest = privateStateOnly.rest;
+  const repoSlug = takeOption(rest, "--repo");
+  rest = repoSlug.rest;
+  const githubToken = takeOption(rest, "--github-token");
+  rest = githubToken.rest;
+  const githubProject = takeOption(rest, "--github-project");
+  rest = githubProject.rest;
+  const githubProjectStatusField = takeOption(rest, "--github-project-status-field");
+  rest = githubProjectStatusField.rest;
+  const githubAuth = takeOption(rest, "--github-auth");
+  rest = githubAuth.rest;
+  const server = takeOption(rest, "--server");
+  rest = server.rest;
+  const remoteHost = takeOption(rest, "--remote-host");
+  rest = remoteHost.rest;
+  const remoteUrl = takeOption(rest, "--remote-url");
+  rest = remoteUrl.rest;
+  const remoteAlias = takeOption(rest, "--remote-alias");
+  rest = remoteAlias.rest;
+  const remotePort = takeOption(rest, "--remote-port");
+  rest = remotePort.rest;
+  const remoteCheckout = takeOption(rest, "--remote-checkout");
+  rest = remoteCheckout.rest;
+  if (server.value && !["local", "remote"].includes(server.value)) {
+    throw new CliError("--server must be local or remote.", 1);
+  }
+  if (githubAuth.value && !["gh", "token", "device", "skip"].includes(githubAuth.value)) {
+    throw new CliError("--github-auth must be gh, token, device, or skip.", 1);
+  }
+  const portValue = remotePort.value ? Number(remotePort.value) : undefined;
+  if (portValue !== undefined && !Number.isFinite(portValue)) {
+    throw new CliError("--remote-port must be a number.", 1);
+  }
+  const hostFromUrl = remoteUrl.value ? remoteUrl.value.replace(/^[a-z]+:\/\//i, "").replace(/[/:].*$/, "").trim() : undefined;
+  const options = {
+    demo: demo.value,
+    yes: yes.value,
+    repair: repair.value,
+    privateStateOnly: privateStateOnly.value,
+    repoSlug: repoSlug.value,
+    githubToken: githubToken.value,
+    githubAuthMethod: githubAuth.value,
+    githubProject: githubProject.value,
+    githubProjectStatusField: githubProjectStatusField.value,
+    server: server.value === "remote" ? "remote" : server.value === "local" ? "local" : undefined,
+    remoteAlias: remoteAlias.value,
+    remoteHost: remoteHost.value ?? hostFromUrl,
+    remotePort: portValue,
+    remoteCheckout: remoteCheckout.value
+  };
+  return { options, rest };
+}
+async function runInteractiveControlPlaneInit(context, prompts) {
+  prompts.intro?.("Initialize a Rig control-plane project");
+  const projectRoot = context.projectRoot;
+  const existingConfig = existsSync4(resolve5(projectRoot, "rig.config.ts")) || existsSync4(resolve5(projectRoot, "rig.config.json"));
+  let repair = false;
+  let privateStateOnly = false;
+  if (existingConfig) {
+    const action = await promptSelect(prompts, {
+      message: "rig.config already exists. What should rig init do?",
+      options: [
+        { value: "repair", label: "Verify/repair generated config" },
+        { value: "reconfigure", label: "Reconfigure project and rewrite config" },
+        { value: "private-state-only", label: "Leave config unchanged; update private connection/auth state only" },
+        { value: "cancel", label: "Cancel" }
+      ]
+    });
+    if (action === "cancel") {
+      prompts.cancel?.("Init cancelled.");
+      return { ok: false, group: "init", command: "init", details: { cancelled: true } };
+    }
+    repair = action === "repair" || action === "reconfigure";
+    privateStateOnly = action === "private-state-only";
+  }
+  const detectedRepo = detectOriginRepoSlug(projectRoot) ?? undefined;
+  const repoSlug = await promptRequiredText(prompts, {
+    message: "GitHub repo slug",
+    placeholder: "owner/repo",
+    defaultValue: detectedRepo
+  });
+  const placement = await promptSelect(prompts, {
+    message: "Execution placement",
+    initialValue: "local",
+    options: [
+      { value: "local", label: "Local", hint: "runs execute on this machine (tmux)" },
+      { value: "remote", label: "Remote", hint: "runs execute on an SSH host" }
+    ]
+  });
+  let remoteAlias;
+  let remoteHost;
+  let remotePort;
+  let remoteCheckout;
+  if (placement === "remote") {
+    let existingServer = {};
+    if (existingConfig) {
+      try {
+        const cfg = await loadConfig(projectRoot);
+        existingServer = cfg.runtime?.server ?? {};
+      } catch {}
+    }
+    remoteHost = await promptRequiredText(prompts, { message: "Remote host (ssh)", placeholder: "rig.example.com", ...existingServer.sshTarget ? { defaultValue: existingServer.sshTarget } : {} });
+    remoteAlias = await promptOptionalText(prompts, { message: "Alias for this remote", placeholder: "prod", initialValue: remoteHost }) || remoteHost;
+    const portText = await promptOptionalText(prompts, { message: "SSH port", placeholder: "22", initialValue: "22" });
+    remotePort = portText && Number.isFinite(Number(portText)) ? Number(portText) : 22;
+    remoteCheckout = await promptOptionalText(prompts, { message: "Remote working directory (existing checkout path)", placeholder: "/srv/rig/<repo>", ...existingServer.checkout ? { defaultValue: existingServer.checkout } : {} }) || undefined;
+  }
+  const detectedGhLogin = detectGhLogin();
+  const authMethod = await promptSelect(prompts, {
+    message: `GitHub auth method${detectedGhLogin ? ` (detected gh login: ${detectedGhLogin})` : ""}`,
+    options: [
+      { value: "gh", label: "Import token from gh auth token", hint: "recommended for local" },
+      { value: "device", label: "Start GitHub device flow" },
+      { value: "token", label: "Paste token" },
+      { value: "skip", label: "Skip for now" }
+    ]
+  });
+  const githubToken = authMethod === "token" ? await promptRequiredText(prompts, { message: "GitHub token", placeholder: "ghp_..." }) : authMethod === "gh" ? readGhAuthToken() : undefined;
+  const projectConfig = await promptGitHubProjectConfig(context, prompts, repoSlug, githubToken, authMethod === "gh" ? refreshGhProjectScopesAndReadToken : undefined);
+  const effectiveGithubToken = projectConfig.githubToken ?? githubToken;
+  const result = await runControlPlaneInit(context, {
+    repoSlug,
+    githubToken: effectiveGithubToken,
+    githubAuthMethod: authMethod,
+    githubProject: projectConfig.githubProject,
+    githubProjectStatusField: projectConfig.githubProjectStatusField,
+    githubProjectStatuses: projectConfig.githubProjectStatuses,
+    repair,
+    privateStateOnly,
+    server: placement,
+    ...remoteAlias ? { remoteAlias } : {},
+    ...remoteHost ? { remoteHost } : {},
+    ...remotePort !== undefined ? { remotePort } : {},
+    ...remoteCheckout ? { remoteCheckout } : {}
+  });
+  const details = result.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : {};
+  const deviceAuth = details.deviceAuth && typeof details.deviceAuth === "object" && !Array.isArray(details.deviceAuth) ? details.deviceAuth : null;
+  const deviceMessage = deviceAuth ? ` GitHub device flow: open ${String(deviceAuth.verificationUri ?? deviceAuth.verification_uri ?? deviceAuth.verification_uri_complete ?? "the verification URL returned by the server")} and enter ${String(deviceAuth.userCode ?? deviceAuth.user_code ?? "the returned user code")}.` : "";
+  prompts.outro?.(`Rig project initialized (${placement} placement).${deviceMessage} Next: rig doctor && rig task list`);
+  return result;
+}
+async function executeInit(context, args) {
+  const parsed = parseInitOptions(args);
+  if (parsed.options.demo) {
+    if (parsed.rest.length > 0) {
+      throw new CliError(`Unexpected arguments: ${parsed.rest.join(" ")}
+Usage: rig init --demo [--yes] [--repair]`, 1, { hint: "Run `rig init --demo` (optionally with --repair to rewrite an existing rig.config)." });
+    }
+    return runDemoInit(context, parsed.options);
+  }
+  if (parsed.options.yes || parsed.options.repoSlug || parsed.options.githubToken || parsed.options.privateStateOnly || parsed.options.repair || parsed.options.githubAuthMethod || parsed.options.server || parsed.options.remoteHost) {
+    if (parsed.rest.length > 0)
+      throw new CliError(`Unexpected arguments: ${parsed.rest.join(" ")}
+Usage: rig init [--demo] [--repo owner/repo] [--server local|remote] [--remote-host <host>] [--remote-alias <a>] [--remote-port <n>] [--remote-checkout <path>] [--github-auth gh|token|device|skip] [--github-token <token>] [--github-project off|<project-id>] [--yes]`, 1);
+    return runControlPlaneInit(context, parsed.options);
+  }
+  if (parsed.rest.length > 0)
+    throw new CliError(`Unexpected arguments: ${parsed.rest.join(" ")}
+Usage: rig init`, 1);
+  if (!process.stdin.isTTY) {
+    throw new CliError("rig init needs an interactive terminal. For scripts, pass flags: rig init --yes --repo owner/repo [--server local|remote --remote-host <host>] [--github-auth gh|token|device|skip].", 1);
+  }
+  return runInteractiveControlPlaneInit(context, await loadClackPrompts());
+}
+export {
+  runInteractiveControlPlaneInit,
+  runDemoInit,
+  executeInit,
+  buildRigInitConfigSource,
+  DEMO_TASKS_RELATIVE_DIR,
+  DEMO_TASKS
+};