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

package/dist/src/commands/github.js

@@ -0,0 +1,342 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/github.ts
+import { spawnSync } from "child_process";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve3 } 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 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/_inprocess-services.ts
+import { resolve } 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 oauthClientId() {
+  return cleanToken(process.env.RIG_GITHUB_OAUTH_CLIENT_ID);
+}
+function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
+  scopedGitHubBearerTokens.set(resolve(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 };
+}
+
+// packages/cli-surface-plugin/src/commands/_connection-state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve2(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 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
+  };
+}
+
+// packages/cli-surface-plugin/src/commands/_async-ui.ts
+import pc from "picocolors";
+
+// packages/cli-surface-plugin/src/commands/_spinner.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+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}
+`);
+    }
+  };
+}
+
+// packages/cli-surface-plugin/src/commands/_async-ui.ts
+var FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
+var DONE_SYMBOL = pc.green("\u25C7");
+var FAIL_SYMBOL = pc.red("\u25A0");
+var activeUpdate = null;
+async function withSpinner(label, work, options = {}) {
+  if (options.outputMode === "json") {
+    return work(() => {
+      return;
+    });
+  }
+  if (activeUpdate) {
+    activeUpdate(label);
+    return work(activeUpdate);
+  }
+  const output = options.output ?? process.stderr;
+  const isTty = output.isTTY === true;
+  let lastLabel = label;
+  if (!isTty) {
+    output.write(`${label}
+`);
+    const update2 = (next) => {
+      lastLabel = next;
+    };
+    activeUpdate = update2;
+    try {
+      return await work(update2);
+    } finally {
+      activeUpdate = null;
+    }
+  }
+  const spinner = createTtySpinner({
+    label,
+    output,
+    frames: FRAMES,
+    styleFrame: (frame) => pc.cyan(frame)
+  });
+  const update = (next) => {
+    lastLabel = next;
+    spinner.setLabel(next);
+  };
+  activeUpdate = update;
+  try {
+    const result = await work(update);
+    spinner.stop(options.doneLabel ? `${DONE_SYMBOL} ${options.doneLabel}` : undefined);
+    return result;
+  } catch (error) {
+    spinner.stop(`${FAIL_SYMBOL} ${lastLabel}`);
+    throw error;
+  } finally {
+    activeUpdate = null;
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/github.ts
+function printPayload(context, _payload, fallback) {
+  if (context.outputMode === "text")
+    console.log(fallback);
+}
+function apiSessionTokenFrom(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  return payloadString(payload, "apiSessionToken");
+}
+function payloadString(payload, key) {
+  const value = Reflect.get(payload, key);
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function payloadRecord(payload, key) {
+  const value = Reflect.get(payload, key);
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function remoteNamespaceMetadata(result) {
+  const namespace = payloadRecord(result, "userNamespace");
+  const userId = payloadString(result, "userId");
+  const namespaceKey = (namespace ? payloadString(namespace, "key") : null) ?? (userId ? `gh:${userId}` : null);
+  return {
+    ...payloadString(result, "login") ? { login: payloadString(result, "login") } : {},
+    ...userId ? { userId } : {},
+    ...namespaceKey ? { userNamespaceKey: namespaceKey } : {},
+    ...namespace && payloadString(namespace, "root") ? { userNamespaceRoot: payloadString(namespace, "root") } : {},
+    ...namespace && payloadString(namespace, "checkoutBaseDir") ? { checkoutBaseDir: payloadString(namespace, "checkoutBaseDir") } : {},
+    ...namespace && payloadString(namespace, "snapshotBaseDir") ? { snapshotBaseDir: payloadString(namespace, "snapshotBaseDir") } : {}
+  };
+}
+function persistRemoteAuthSession(context, source, result, fallbackToken) {
+  const apiSessionToken = result.apiSessionToken || apiSessionTokenFrom(result);
+  setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? fallbackToken, context.projectRoot);
+  if (!apiSessionToken)
+    return;
+  const repo = readRepoConnection(context.projectRoot);
+  const path = resolve3(context.projectRoot, ".rig", "state", "github-auth.json");
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify({
+    authenticated: true,
+    source,
+    storedOnServer: true,
+    ...repo?.project ? { selectedRepo: repo.project } : {},
+    ...remoteNamespaceMetadata(result),
+    apiSessionToken,
+    updatedAt: new Date().toISOString()
+  }, null, 2)}
+`, "utf8");
+}
+function isSignedIn(status) {
+  return status.signedIn === true;
+}
+function readGhToken() {
+  const result = spawnSync("gh", ["auth", "token"], { encoding: "utf8" });
+  if (result.status !== 0) {
+    const detail = result.stderr?.trim() || result.stdout?.trim() || "gh auth token failed";
+    throw new CliError(`Could not import GitHub token from gh: ${detail}`, 1, { hint: "Sign in first with `gh auth login`, or store a token directly: `rig github auth token --token <token>`." });
+  }
+  const token = result.stdout.trim();
+  if (!token)
+    throw new CliError("gh auth token returned an empty token.", 1, { hint: "Sign in with `gh auth login`, then re-run `rig github auth import-gh`." });
+  return token;
+}
+async function executeGithub(context, args) {
+  const [group, command, ...rest] = args;
+  if (group !== "auth") {
+    throw new CliError("Usage: rig github auth <status|import-gh|token>", 1);
+  }
+  switch (command) {
+    case "status": {
+      if (rest.length > 0)
+        throw new CliError("Usage: rig github auth status", 1);
+      const status = await withSpinner("Checking GitHub auth on the server\u2026", () => getGitHubAuthStatusInProcess(context), { outputMode: context.outputMode });
+      printPayload(context, status, `GitHub auth: ${isSignedIn(status) ? "authenticated" : "unauthenticated"}`);
+      return { ok: true, group: "github", command: "auth status", details: status };
+    }
+    case "token": {
+      const parsed = takeOption(rest, "--token");
+      if (parsed.rest.length > 0)
+        throw new CliError("Usage: rig github auth token --token <token>", 1);
+      const token = parsed.value?.trim();
+      if (!token)
+        throw new CliError("Missing --token value.", 1, { hint: "Re-run as `rig github auth token --token <token>`." });
+      const repo = readRepoConnection(context.projectRoot);
+      const result = await withSpinner("Storing GitHub token on the server\u2026", () => postGitHubTokenInProcess(context, token, repo?.project ? { selectedRepo: repo.project } : {}), { outputMode: context.outputMode });
+      persistRemoteAuthSession(context, "token", result, token);
+      printPayload(context, result, "GitHub token stored on the selected server.");
+      return { ok: true, group: "github", command: "auth token", details: result };
+    }
+    case "import-gh": {
+      if (rest.length > 0)
+        throw new CliError("Usage: rig github auth import-gh", 1);
+      const importedToken = readGhToken();
+      const repo = readRepoConnection(context.projectRoot);
+      const result = await withSpinner("Storing GitHub token on the server\u2026", () => postGitHubTokenInProcess(context, importedToken, repo?.project ? { selectedRepo: repo.project } : {}), { outputMode: context.outputMode });
+      persistRemoteAuthSession(context, "gh", result, importedToken);
+      printPayload(context, result, "GitHub token imported from gh and stored on the selected server.");
+      return { ok: true, group: "github", command: "auth import-gh", details: result };
+    }
+    default:
+      throw new CliError("Usage: rig github auth <status|import-gh|token>", 1);
+  }
+}
+export {
+  executeGithub
+};

package/dist/src/commands/inbox.d.ts

@@ -0,0 +1,19 @@
+import type { CommandOutcome } from "@rig/runtime";
+import type { InboxDeps as ClientInboxDeps, InboxKind, InboxRecord } from "@rig/client";
+import { type RunnerContext } from "../runner";
+export type { InboxKind, InboxRecord } from "@rig/client";
+export interface InboxFilters {
+    readonly run?: string;
+    readonly task?: string;
+}
+export interface InboxDeps {
+    readonly listInbox?: (projectRoot: string, kind: InboxKind, filters: InboxFilters) => Promise<InboxRecord[]>;
+    readonly listRuns?: ClientInboxDeps["listRuns"];
+}
+export declare function listInboxRecords(context: Pick<RunnerContext, "projectRoot">, kind: InboxKind, filters?: InboxFilters, deps?: InboxDeps): Promise<InboxRecord[]>;
+export declare function listInbox(context: Pick<RunnerContext, "projectRoot">, kind: InboxKind, filters?: InboxFilters, deps?: InboxDeps): Promise<InboxRecord[]>;
+export declare function readPendingInboxCounts(context: Pick<RunnerContext, "projectRoot">): Promise<{
+    approvals: number;
+    inputs: number;
+} | null>;
+export declare function executeInbox(context: RunnerContext, args: string[], deps?: InboxDeps): Promise<CommandOutcome>;

package/dist/src/commands/inbox.js

@@ -0,0 +1,241 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/inbox.ts
+import { Duration, Effect, Stream } from "effect";
+import { localRunChanges } from "@rig/runtime/control-plane/run-discovery-stream";
+import { listInboxRecords as clientListInboxRecords, readInboxCounts, resolveInboxRequest } from "@rig/client";
+
+// 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 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 };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/_cli-format.ts
+import pc from "picocolors";
+import { runStatusColorRole, runStatusText, statusColorRole } from "@rig/client";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function colorForRole(role) {
+  switch (role) {
+    case "success":
+      return pc.green;
+    case "action-yellow":
+      return pc.yellow;
+    case "active-cyan":
+      return pc.cyan;
+    case "failure":
+      return pc.red;
+    case "muted":
+    case "neutral":
+      return pc.dim;
+  }
+}
+function statusColor(status) {
+  return colorForRole(statusColorRole(status));
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return fallback;
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function printFormattedOutput(message) {
+  console.log(message);
+}
+function formatStatusPill(status) {
+  const label = status || "unknown";
+  return statusColor(label)(`\u25CF ${label}`);
+}
+function formatSection(title, subtitle) {
+  return `${pc.bold(accent("\u25C6"))} ${pc.bold(title)}${subtitle ? dim(` \u2014 ${subtitle}`) : ""}`;
+}
+function formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${accent("\u203A")} ${step}`)];
+}
+function formatLegacyAutomationSurface() {
+  return [];
+}
+function formatInboxList(kind, entries) {
+  const title = kind === "approvals" ? "Pending approvals" : "Pending user input";
+  if (entries.length === 0) {
+    return [
+      formatSection(title, "empty"),
+      dim(kind === "approvals" ? "No pending approvals." : "No pending user-input requests."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const lines = [formatSection(title, `${entries.length}`)];
+  for (const record of entries) {
+    const runId = firstString(record, ["runId"], "(unknown-run)");
+    const taskId = firstString(record, ["taskId"], "");
+    const status = firstString(record, ["status"], "pending");
+    const prompt = firstString(record, ["prompt", "message", "reason", "title", "summary"], kind === "approvals" ? "Approval requested" : "Input requested");
+    lines.push(`${faintBar} ${pc.bold(requestIdOf(record))} ${formatStatusPill(status)} ${prompt}`);
+    lines.push(`${faintBar} ${dim("run".padEnd(12))} ${runId}${taskId ? dim(`  task ${taskId}`) : ""}`);
+  }
+  lines.push("", ...formatLegacyAutomationSurface(), ...formatNextSteps(kind === "approvals" ? ["Resolve: `rig inbox approve --run <run-id> --request <request-id> --decision approve|reject`"] : ["Reply: `rig inbox answer --run <run-id> --request <request-id> --text ...`"]));
+  return lines.join(`
+`);
+}
+
+// packages/cli-surface-plugin/src/commands/inbox.ts
+async function listInboxRecords(context, kind, filters = {}, deps = {}) {
+  const clientDeps = deps.listRuns ? { listRuns: deps.listRuns } : {};
+  return deps.listInbox ? deps.listInbox(context.projectRoot, kind, filters) : clientListInboxRecords(context.projectRoot, kind, filters, clientDeps);
+}
+async function listInbox(context, kind, filters = {}, deps = {}) {
+  return listInboxRecords(context, kind, filters, deps);
+}
+async function readPendingInboxCounts(context) {
+  return readInboxCounts(context.projectRoot);
+}
+function resolutionAttachError(runId, verb, error) {
+  const target = runId ?? "<run-id>";
+  const detail = error instanceof Error ? error.message : String(error);
+  throw new CliError(`rig inbox ${verb} could not deliver a resolution from this one-shot command.`, 2, {
+    hint: `${detail}
+Attach to resolve interactively: rig run attach ${target}`
+  });
+}
+async function readInboxSnapshot(context, filters, deps) {
+  const [approvals, inputs] = await Promise.all([
+    listInbox(context, "approvals", filters, deps),
+    listInbox(context, "inputs", filters, deps)
+  ]);
+  return { approvals, inputs };
+}
+function renderInboxSnapshot(snapshot) {
+  console.clear();
+  console.log(`rig inbox \u2014 watching (Ctrl-C to stop) \u2014 ${new Date().toLocaleTimeString()}`);
+  printFormattedOutput(formatInboxList("approvals", snapshot.approvals.map((entry) => ({ ...entry }))));
+  printFormattedOutput(formatInboxList("inputs", snapshot.inputs.map((entry) => ({ ...entry }))));
+  if (snapshot.approvals.length === 0 && snapshot.inputs.length === 0)
+    console.log("Nothing pending.");
+}
+async function watchInbox(context, filters, deps) {
+  const snapshot = await readInboxSnapshot(context, filters, deps);
+  if (context.outputMode !== "text")
+    return { ok: true, group: "inbox", command: "watch", details: snapshot };
+  renderInboxSnapshot(snapshot);
+  await Effect.runPromise(localRunChanges(context.projectRoot).pipe(Stream.debounce(Duration.millis(500)), Stream.runForEach(() => Effect.promise(async () => renderInboxSnapshot(await readInboxSnapshot(context, filters, deps))))));
+  return { ok: true, group: "inbox", command: "watch", details: snapshot };
+}
+async function executeInbox(context, args, deps = {}) {
+  const [command = "approvals", ...rest] = args;
+  const text = context.outputMode === "text";
+  switch (command) {
+    case "approvals":
+    case "inputs": {
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, `rig inbox ${command} [--run <id>] [--task <id>]`);
+      const kind = command === "approvals" ? "approvals" : "inputs";
+      const filters = { ...run.value ? { run: run.value } : {}, ...task.value ? { task: task.value } : {} };
+      const entries = await listInbox(context, kind, filters, deps);
+      if (text)
+        printFormattedOutput(formatInboxList(kind, entries.map((entry) => ({ ...entry }))));
+      return { ok: true, group: "inbox", command, details: { entries } };
+    }
+    case "approve": {
+      const run = takeOption(rest, "--run");
+      const request = takeOption(run.rest, "--request");
+      const decision = takeOption(request.rest, "--decision");
+      requireNoExtraArgs(decision.rest, "rig inbox approve --run <id> --request <id> --decision approve|reject");
+      if (!run.value || !request.value)
+        throw new CliError("rig inbox approve requires --run and --request.", 2);
+      const rawDecision = (decision.value ?? "approve").trim().toLowerCase();
+      if (rawDecision !== "approve" && rawDecision !== "approved" && rawDecision !== "reject" && rawDecision !== "rejected")
+        throw new CliError("--decision must be approve or reject.", 2);
+      try {
+        await resolveInboxRequest(context.projectRoot, run.value, request.value, { kind: "approval", decision: rawDecision });
+      } catch (error) {
+        resolutionAttachError(run.value, "approve", error);
+      }
+      if (text)
+        printFormattedOutput(`Resolved approval ${request.value} for run ${run.value}.`);
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, decision: rawDecision } };
+    }
+    case "respond":
+    case "answer": {
+      const run = takeOption(rest, "--run");
+      const request = takeOption(run.rest, "--request");
+      const textResult = takeOption(request.rest, "--text");
+      const answerResult = takeOption(textResult.rest, "--answer");
+      requireNoExtraArgs(answerResult.rest, `rig inbox ${command} --run <id> --request <id> (--text|--answer) <answer>`);
+      if (textResult.value && answerResult.value)
+        throw new CliError("Pass only one of --text or --answer.", 2);
+      const answer = textResult.value ?? answerResult.value;
+      if (!run.value || !request.value || !answer)
+        resolutionAttachError(run.value, "respond", new Error(`rig inbox ${command} requires --run, --request, and --text/--answer.`));
+      try {
+        await resolveInboxRequest(context.projectRoot, run.value, request.value, { kind: "input", answer });
+      } catch (error) {
+        resolutionAttachError(run.value, "respond", error);
+      }
+      if (text)
+        printFormattedOutput(`Sent response ${request.value} for run ${run.value}.`);
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, responded: true } };
+    }
+    case "watch": {
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, "rig inbox watch [--run <id>] [--task <id>]");
+      const filters = { ...run.value ? { run: run.value } : {}, ...task.value ? { task: task.value } : {} };
+      return watchInbox(context, filters, deps);
+    }
+    default:
+      throw new CliError(`Unknown inbox command: ${command}`, 1, { hint: "Run `rig inbox --help` to list inbox commands." });
+  }
+}
+export {
+  readPendingInboxCounts,
+  listInboxRecords,
+  listInbox,
+  executeInbox
+};

package/dist/src/commands/init.d.ts

@@ -0,0 +1,64 @@
+import { type RunnerContext } from "../runner";
+import { buildRigInitConfigSource, type RigInitConfigInput } from "@rig/core";
+import type { CommandOutcome } from "@rig/runtime";
+export { buildRigInitConfigSource };
+export type { RigInitConfigInput };
+type InitAuthMethod = "gh" | "token" | "device" | "skip";
+type InitControlPlaneOptions = {
+    demo?: boolean;
+    repoSlug?: string;
+    githubToken?: string;
+    githubAuthMethod?: InitAuthMethod;
+    githubProject?: "off" | string;
+    githubProjectStatusField?: string;
+    githubProjectStatuses?: Record<string, string>;
+    yes?: boolean;
+    repair?: boolean;
+    privateStateOnly?: boolean;
+    server?: "local" | "remote";
+    remoteAlias?: string;
+    remoteHost?: string;
+    remotePort?: number;
+    remoteCheckout?: string;
+};
+type InitPromptAdapter = {
+    intro?: (message: string) => void;
+    outro?: (message: string) => void;
+    cancel?: (message: string) => void;
+    isCancel: (value: unknown) => boolean;
+    text: (options: {
+        message: string;
+        placeholder?: string;
+        initialValue?: string;
+        defaultValue?: string;
+    }) => Promise<unknown>;
+    select: (options: {
+        message: string;
+        options: Array<{
+            value: string;
+            label: string;
+            hint?: string;
+        }>;
+        initialValue?: string;
+    }) => Promise<unknown>;
+    confirm?: (options: {
+        message: string;
+        initialValue?: boolean;
+    }) => Promise<unknown>;
+};
+export declare const DEMO_TASKS_RELATIVE_DIR = ".rig/demo-tasks";
+/**
+ * The three sample tasks `rig init --demo` seeds. Shapes match what the
+ * standard plugin's files task source reads: one JSON object per file with
+ * id/title/body/status/labels (see packages/standard-plugin/src/files-source.ts).
+ */
+export declare const DEMO_TASKS: ReadonlyArray<Record<string, unknown>>;
+/**
+ * `rig init --demo` — zero-GitHub, offline demo project: files task source
+ * pointing at .rig/demo-tasks/ with three seeded sample tasks, so an
+ * operator can see the full run lifecycle in minutes. Non-interactive and
+ * idempotent: an existing rig.config is left untouched unless --repair.
+ */
+export declare function runDemoInit(context: RunnerContext, options: InitControlPlaneOptions): CommandOutcome;
+export declare function runInteractiveControlPlaneInit(context: RunnerContext, prompts: InitPromptAdapter): Promise<CommandOutcome>;
+export declare function executeInit(context: RunnerContext, args: string[]): Promise<CommandOutcome>;