@h-rig/init-plugin 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/setup.d.ts

@@ -1,121 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { type GitHubAuthStatus, type GitHubUserFetcher } from "@rig/github-provider-plugin";
-import { type PlacementKind } from "@rig/runtime/control-plane/placement";
-export type RigConfigStatus = {
-    readonly exists: boolean;
-    readonly valid: boolean;
-    readonly path: string;
-    readonly slug: string | null;
-    readonly reason?: string;
-};
-export type RigStateStatus = {
-    readonly valid: boolean;
-    readonly selected: string | null;
-    readonly project: string | null;
-    readonly reason?: string;
-};
-export type RigAuthValidation = {
-    readonly ok: boolean;
-    readonly source: "stored-token" | "gh" | "missing";
-    readonly login?: string | null;
-    readonly detail: string;
-    readonly status?: GitHubAuthStatus;
-};
-export type RigSetupStatus = {
-    readonly configured: boolean;
-    readonly projectRoot: string;
-    readonly slug: string | null;
-    readonly config: RigConfigStatus;
-    readonly state: RigStateStatus;
-    readonly auth: RigAuthValidation;
-    readonly reasons: readonly string[];
-};
-export type RigSetupPlacement = {
-    readonly alias: string;
-    readonly kind: PlacementKind;
-    readonly host?: string;
-    readonly port?: number;
-    readonly token?: string | null;
-};
-export type RigSetupDeps = {
-    readonly spawn?: typeof spawnSync;
-    readonly fetch?: typeof fetch;
-    readonly fetchUser?: GitHubUserFetcher;
-};
-export type RunSetupInput = {
-    readonly projectRoot: string;
-    readonly slug: string;
-    readonly placement: RigSetupPlacement;
-    readonly rewriteConfig?: boolean;
-    readonly ensurePi?: boolean;
-    readonly githubToken?: string | null;
-    readonly importGhToken?: boolean;
-    readonly ensureLabels?: boolean;
-    readonly deps?: RigSetupDeps;
-};
-export declare function parseRepoSlugFromRemote(remoteUrl: string): string | null;
-export declare function parseRepoSlug(value: string): {
-    owner: string;
-    repo: string;
-    slug: string;
-};
-export declare function detectOriginRepoSlug(projectRoot: string, deps?: RigSetupDeps): string | null;
-export declare function ensureRigPrivateDirs(projectRoot: string): void;
-export declare function ensureGitignoreEntries(projectRoot: string): void;
-export declare function writeRigConnectionState(projectRoot: string, slug: string, placement: RigSetupPlacement): void;
-export declare function writeRigConfig(projectRoot: string, slug: string): void;
-export declare function readRigConfigStatus(projectRoot: string): RigConfigStatus;
-export declare function readRigConnectionStatus(projectRoot: string): RigStateStatus;
-export declare function detectGhAuth(projectRoot: string, slug: string, deps?: RigSetupDeps): RigAuthValidation | null;
-export declare function validateGitHubAuth(projectRoot: string, slug: string | null, deps?: RigSetupDeps): Promise<RigAuthValidation>;
-export declare function saveGitHubTokenLocally(projectRoot: string, token: string, slug: string, deps?: RigSetupDeps): Promise<void>;
-export declare function readGhAuthToken(projectRoot: string, deps?: RigSetupDeps): string;
-export declare function ensureGitHubAuth(input: {
-    projectRoot: string;
-    slug: string;
-    token?: string | null;
-    importGhToken?: boolean;
-    deps?: RigSetupDeps;
-}): Promise<RigAuthValidation>;
-export declare function ensureGitHubLabels(input: {
-    projectRoot: string;
-    slug: string;
-    token?: string | null;
-    deps?: RigSetupDeps;
-}): Promise<{
-    ok: true;
-    method: "api" | "gh";
-    labels: readonly string[];
-}>;
-export declare function ensurePiRigInstalledForSetup(projectRoot: string, deps?: RigSetupDeps): {
-    ok: true;
-    detail: string;
-};
-export declare function detectRigStartupStatus(input: {
-    projectRoot: string;
-    deps?: RigSetupDeps;
-}): Promise<RigSetupStatus>;
-export declare const detectStartupStatus: typeof detectRigStartupStatus;
-export declare function applyRigSetupProject(input: {
-    projectRoot: string;
-    slug: string;
-    placement: RigSetupPlacement;
-    rewriteConfig: boolean;
-    ensurePi?: boolean;
-    ensureLabels?: boolean;
-    deps?: RigSetupDeps;
-}): Promise<{
-    repoSlug: string;
-    placement: string;
-    configWritten: boolean;
-    labels: unknown;
-    pi: unknown;
-}>;
-export declare function runSetup(input: RunSetupInput): Promise<{
-    repoSlug: string;
-    placement: string;
-    configWritten: boolean;
-    labels: unknown;
-    pi: unknown;
-    status: RigSetupStatus;
-}>;

package/dist/src/setup.js

@@ -1,458 +0,0 @@
-// @bun
-// packages/init-plugin/src/setup.ts
-import { spawnSync } from "child_process";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
-import {
-  createGitHubAuthStore,
-  probeGitHubRepository,
-  resolveGitHubAuthStatus,
-  saveGitHubTokenForProject
-} from "@rig/github-provider-plugin";
-import { addPlacement, selectPlacement } from "@rig/runtime/control-plane/placement";
-
-// packages/init-plugin/src/rig-init-builder.ts
-function buildRigInitConfigSource(input) {
-  const lines = [`import { defineConfig } from "@rig/core/config";`];
-  if (input.useStandardPlugin) {
-    lines.push(`import { standardPlugins } from "@rig/standard-plugin/bundle";`);
-    if (input.taskSource.kind === "github-issues") {
-      lines.push(`import { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
-    }
-  }
-  lines.push(``, `export default defineConfig({`);
-  const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
-  lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
-  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`  plugins: [...standardPlugins({`);
-    lines.push(`    taskSources: {`);
-    lines.push(`      githubCredentialProvider: createStateGitHubCredentialProvider(),`);
-    lines.push(`      githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
-    lines.push(`      githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
-    lines.push(`    },`);
-    lines.push(`  })],`);
-  } else {
-    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardPlugins()" : ""}],`);
-  }
-  if (input.taskSource.kind === "github-issues") {
-    lines.push(`  taskSource: {`);
-    lines.push(`    kind: "github-issues",`);
-    lines.push(`    owner: ${JSON.stringify(input.taskSource.owner)},`);
-    lines.push(`    repo: ${JSON.stringify(input.taskSource.repo)},`);
-    lines.push(`    // labels: ["task"],  // uncomment to filter by labels`);
-    lines.push(`    state: "open",`);
-    if (input.taskSource.assignee?.trim()) {
-      lines.push(`    options: { assignee: ${JSON.stringify(input.taskSource.assignee.trim())} },`);
-    }
-    lines.push(`  },`);
-  } else {
-    lines.push(`  taskSource: {`);
-    lines.push(`    kind: "files",`);
-    lines.push(`    path: ${JSON.stringify(input.taskSource.path)},`);
-    lines.push(`  },`);
-  }
-  lines.push(`  workspace: { mainRepo: ".", isolation: "worktree" },`);
-  const sshTarget = input.sshTarget?.trim();
-  lines.push(sshTarget ? `  runtime: { harness: "pi", mode: "yolo", server: { sshTarget: ${JSON.stringify(sshTarget)} } },` : `  runtime: { harness: "pi", mode: "yolo" },  // server.sshTarget unset = local placement`);
-  lines.push(`  planning: { mode: "auto" },`);
-  lines.push(`  github: {`);
-  lines.push(`    issueUpdates: "lifecycle",`);
-  lines.push(`    projects: { enabled: false },`);
-  lines.push(`  },`);
-  lines.push(`  automation: { maxValidationAttempts: 30, maxPrFixIterations: 100500 },`);
-  lines.push(`  pr: { mode: "auto", watchChecks: true, autoFixChecks: true, autoFixReview: true },`);
-  lines.push(`  merge: { mode: "auto", method: "repo-default", deleteBranch: "repo-default", bypass: false },`);
-  lines.push(`  issueAnalysis: { enabled: true, harness: "pi", mode: "continuous" },`);
-  lines.push(`});`);
-  lines.push(``);
-  return lines.join(`
-`);
-}
-
-// packages/init-plugin/src/setup.ts
-var RIG_LABELS_TO_ENSURE = [
-  "rig:running",
-  "rig:pr-open",
-  "rig:ci-fixing",
-  "rig:merging",
-  "rig:done",
-  "rig:needs-attention",
-  "rig:ready",
-  "rig:blocked",
-  "rig:generated"
-];
-var RIG_LABEL_METADATA = {
-  "rig:running": { color: "1d76db", description: "Rig is actively working on this issue." },
-  "rig:pr-open": { color: "5319e7", description: "Rig opened a pull request for this issue." },
-  "rig:ci-fixing": { color: "fbca04", description: "Rig is fixing CI or review feedback for this issue." },
-  "rig:merging": { color: "0052cc", description: "Rig is merging the completed change for this issue." },
-  "rig:done": { color: "0e8a16", description: "Rig completed this issue." },
-  "rig:needs-attention": { color: "d93f0b", description: "Rig needs operator attention for this issue." },
-  "rig:ready": { color: "0e8a16", description: "Rig issue analysis marked this issue ready." },
-  "rig:blocked": { color: "d93f0b", description: "Rig issue analysis found blockers for this issue." },
-  "rig:generated": { color: "c5def5", description: "Rig generated this follow-up issue." }
-};
-function cleanString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function parseRepoSlugFromRemote(remoteUrl) {
-  const trimmed = remoteUrl.trim();
-  const match = trimmed.match(/github\.com[:/]([^/\s]+)\/([^/\s.]+)(?:\.git)?$/i);
-  return match ? `${match[1]}/${match[2]}` : null;
-}
-function parseRepoSlug(value) {
-  const match = value.trim().match(/^([^/\s]+)\/([^/\s]+)$/);
-  if (!match)
-    throw new Error(`Invalid GitHub repo slug "${value}". Expected owner/repo.`);
-  return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
-}
-function runSyncCommand(command, input = {}) {
-  const executable = command[0];
-  if (!executable)
-    throw new Error("command is required");
-  return (input.spawn ?? spawnSync)(executable, [...command.slice(1)], {
-    cwd: input.cwd,
-    encoding: "utf8",
-    timeout: input.timeoutMs ?? 1e4,
-    env: input.env ?? process.env
-  });
-}
-function detectOriginRepoSlug(projectRoot, deps = {}) {
-  const result = runSyncCommand(["git", "-C", projectRoot, "remote", "get-url", "origin"], { timeoutMs: 5000, spawn: deps.spawn });
-  if (result.status !== 0 || result.error)
-    return null;
-  return parseRepoSlugFromRemote(result.stdout.trim());
-}
-function connectionStatePath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "connection.json");
-}
-function projectLinkStatePath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "project-link.json");
-}
-function readJsonRecord(path) {
-  if (!existsSync(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function writeJsonFile(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf-8");
-}
-function ensureRigPrivateDirs(projectRoot) {
-  mkdirSync(resolve(projectRoot, ".rig", "state"), { recursive: true });
-  mkdirSync(resolve(projectRoot, ".rig", "logs"), { recursive: true });
-  mkdirSync(resolve(projectRoot, ".rig", "runs"), { recursive: true });
-  mkdirSync(resolve(projectRoot, ".rig", "tmp"), { recursive: true });
-  mkdirSync(resolve(projectRoot, "artifacts"), { recursive: true });
-  const taskConfigPath = resolve(projectRoot, ".rig", "task-config.json");
-  if (!existsSync(taskConfigPath))
-    writeFileSync(taskConfigPath, `{}
-`, "utf-8");
-}
-function ensureGitignoreEntries(projectRoot) {
-  const path = resolve(projectRoot, ".gitignore");
-  const existing = existsSync(path) ? readFileSync(path, "utf-8") : "";
-  const lines = new Set(existing.split(/\r?\n/));
-  const missing = [".rig/state/", ".rig/logs/", ".rig/runs/", ".rig/tmp/"].filter((entry) => !lines.has(entry));
-  if (missing.length === 0)
-    return;
-  const prefix = existing.length > 0 && !existing.endsWith(`
-`) ? `
-` : "";
-  appendFileSync(path, `${prefix}${missing.join(`
-`)}
-`, "utf-8");
-}
-function writeRigConnectionState(projectRoot, slug, placement) {
-  const previous = readJsonRecord(connectionStatePath(projectRoot)) ?? {};
-  writeJsonFile(connectionStatePath(projectRoot), {
-    ...previous,
-    selected: placement.alias,
-    project: slug,
-    linkedAt: new Date().toISOString()
-  });
-  writeJsonFile(projectLinkStatePath(projectRoot), {
-    repoSlug: slug,
-    connection: placement.alias,
-    linkedAt: new Date().toISOString()
-  });
-  if (placement.alias === "local")
-    delete process.env.RIG_REMOTE_ALIAS;
-  else
-    process.env.RIG_REMOTE_ALIAS = placement.alias;
-}
-function writeRigConfig(projectRoot, slug) {
-  const repo = parseRepoSlug(slug);
-  writeFileSync(resolve(projectRoot, "rig.config.ts"), buildRigInitConfigSource({
-    projectName: repo.slug,
-    projectRepo: repo.slug,
-    taskSource: { kind: "github-issues", owner: repo.owner, repo: repo.repo },
-    useStandardPlugin: true
-  }), "utf-8");
-}
-function readRigConfigStatus(projectRoot) {
-  const path = resolve(projectRoot, "rig.config.ts");
-  if (!existsSync(path))
-    return { exists: false, valid: false, path, slug: null, reason: "missing rig.config.ts" };
-  try {
-    const source = readFileSync(path, "utf-8");
-    const owner = source.match(/\bowner:\s*["']([^"']+)["']/)?.[1] ?? null;
-    const repoValues = [...source.matchAll(/\brepo:\s*["']([^"']+)["']/g)].map((match) => match[1]).filter(Boolean);
-    const taskRepo = repoValues.find((value) => !value.includes("/")) ?? null;
-    const projectRepo = repoValues.find((value) => value.includes("/")) ?? null;
-    const githubIssues = /\bkind:\s*["']github-issues["']/.test(source);
-    const slug = owner && taskRepo ? `${owner}/${taskRepo}` : projectRepo;
-    if (!githubIssues || !slug)
-      return { exists: true, valid: false, path, slug: slug ?? null, reason: "rig.config.ts is not a GitHub Issues Rig config" };
-    parseRepoSlug(slug);
-    return { exists: true, valid: true, path, slug };
-  } catch (error) {
-    return { exists: true, valid: false, path, slug: null, reason: error instanceof Error ? error.message : String(error) };
-  }
-}
-function readRigConnectionStatus(projectRoot) {
-  const stateDir = resolve(projectRoot, ".rig", "state");
-  if (!existsSync(stateDir))
-    return { valid: false, selected: null, project: null, reason: "missing .rig/state" };
-  const connection = readJsonRecord(connectionStatePath(projectRoot));
-  if (!connection)
-    return { valid: false, selected: null, project: null, reason: "missing or invalid .rig/state/connection.json" };
-  const selected = cleanString(connection.selected);
-  const project = cleanString(connection.project);
-  if (!selected)
-    return { valid: false, selected: null, project, reason: "connection.json is missing selected placement" };
-  if (!project)
-    return { valid: false, selected, project: null, reason: "connection.json is missing project slug" };
-  try {
-    parseRepoSlug(project);
-  } catch (error) {
-    return { valid: false, selected, project, reason: error instanceof Error ? error.message : String(error) };
-  }
-  return { valid: true, selected, project };
-}
-function detectGhAuth(projectRoot, slug, deps = {}) {
-  const user = runSyncCommand(["gh", "api", "user", "--jq", ".login"], { cwd: projectRoot, timeoutMs: 5000, spawn: deps.spawn });
-  if (user.status !== 0 || user.error || !user.stdout.trim())
-    return null;
-  const repo = runSyncCommand(["gh", "repo", "view", slug, "--json", "nameWithOwner", "--jq", ".nameWithOwner"], { cwd: projectRoot, timeoutMs: 5000, spawn: deps.spawn });
-  if (repo.status !== 0 || repo.error)
-    return { ok: false, source: "gh", login: user.stdout.trim(), detail: (repo.stderr || repo.stdout || "gh cannot access the selected repository").trim() };
-  return { ok: true, source: "gh", login: user.stdout.trim(), detail: "gh CLI authentication can access the selected repository" };
-}
-async function validateGitHubAuth(projectRoot, slug, deps = {}) {
-  if (!slug)
-    return { ok: false, source: "missing", detail: "GitHub repo slug is unknown" };
-  const status = resolveGitHubAuthStatus({ projectRoot, oauthConfigured: Boolean(process.env.RIG_GITHUB_OAUTH_CLIENT_ID?.trim()) });
-  if (status.signedIn) {
-    const store = createGitHubAuthStore(projectRoot);
-    if (!status.selectedRepo) {
-      store.saveSelectedRepo(slug);
-      return { ok: true, source: "stored-token", login: status.login, detail: "stored Rig GitHub token selected for this repo", status: store.status({ oauthConfigured: status.oauthConfigured }) };
-    }
-    if (status.selectedRepo !== slug)
-      return { ok: false, source: "stored-token", login: status.login, detail: `stored GitHub token is scoped to ${status.selectedRepo}, not ${slug}`, status };
-    return { ok: true, source: "stored-token", login: status.login, detail: "stored Rig GitHub token is present", status };
-  }
-  const gh = detectGhAuth(projectRoot, slug, deps);
-  if (gh)
-    return gh;
-  return { ok: false, source: "missing", detail: "Sign in with `gh auth login`, choose Setup \u2192 GitHub auth, or paste a token." };
-}
-async function saveGitHubTokenLocally(projectRoot, token, slug, deps = {}) {
-  ensureRigPrivateDirs(projectRoot);
-  await saveGitHubTokenForProject({
-    projectRoot,
-    token,
-    tokenSource: "manual-token",
-    selectedRepo: slug,
-    ...deps.fetchUser ? { fetchUser: deps.fetchUser } : {}
-  });
-  createGitHubAuthStore(projectRoot).copyToLocalProjectRoot(projectRoot);
-}
-function readGhAuthToken(projectRoot, deps = {}) {
-  const result = runSyncCommand(["gh", "auth", "token"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
-  if (result.status !== 0 || result.error || !result.stdout.trim())
-    throw new Error((result.stderr || result.stdout || "Could not read GitHub token from `gh auth token`.").trim());
-  return result.stdout.trim();
-}
-async function ensureGitHubAuth(input) {
-  const current = await validateGitHubAuth(input.projectRoot, input.slug, input.deps);
-  if (current.ok && !input.token && !input.importGhToken)
-    return current;
-  if (input.token?.trim())
-    await saveGitHubTokenLocally(input.projectRoot, input.token.trim(), input.slug, input.deps);
-  else if (input.importGhToken)
-    await saveGitHubTokenLocally(input.projectRoot, readGhAuthToken(input.projectRoot, input.deps), input.slug, input.deps);
-  return validateGitHubAuth(input.projectRoot, input.slug, input.deps);
-}
-async function ensureGitHubLabels(input) {
-  const repo = parseRepoSlug(input.slug);
-  const token = input.token?.trim() || createGitHubAuthStore(input.projectRoot).readToken();
-  if (token) {
-    const fetchLabels = input.deps?.fetch ?? fetch;
-    for (const name of RIG_LABELS_TO_ENSURE) {
-      const metadata = RIG_LABEL_METADATA[name];
-      const response = await fetchLabels(`https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/labels`, {
-        method: "POST",
-        headers: {
-          accept: "application/vnd.github+json",
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json",
-          "user-agent": "rig"
-        },
-        body: JSON.stringify({ name, color: metadata.color, description: metadata.description })
-      });
-      if (response.ok)
-        continue;
-      const text = await response.text().catch(() => "");
-      if (response.status === 422 && /already_exists|already exists|exists/i.test(text))
-        continue;
-      throw new Error(`Could not create GitHub label ${name}: ${response.status} ${text || response.statusText}`);
-    }
-    return { ok: true, method: "api", labels: RIG_LABELS_TO_ENSURE };
-  }
-  const gh = detectGhAuth(input.projectRoot, input.slug, input.deps);
-  if (!gh?.ok)
-    throw new Error("GitHub labels require a stored Rig token or gh auth.");
-  for (const name of RIG_LABELS_TO_ENSURE) {
-    const metadata = RIG_LABEL_METADATA[name];
-    const result = runSyncCommand(["gh", "label", "create", name, "--repo", input.slug, "--color", metadata.color, "--description", metadata.description, "--force"], { cwd: input.projectRoot, timeoutMs: 1e4, spawn: input.deps?.spawn });
-    if (result.status !== 0 || result.error)
-      throw new Error(`gh label create ${name} failed: ${(result.stderr || result.stdout || result.error?.message || "unknown error").trim()}`);
-  }
-  return { ok: true, method: "gh", labels: RIG_LABELS_TO_ENSURE };
-}
-function piListContainsRigExtension(output) {
-  return output.split(/\r?\n/).some((line) => line.includes("@h-rig/pi-rig") || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(line));
-}
-function splitInstallCommand(value) {
-  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^["']|["']$/g, "")) ?? [];
-}
-function ensurePiRigInstalledForSetup(projectRoot, deps = {}) {
-  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1")
-    return { ok: true, detail: "fake-pi" };
-  let version = runSyncCommand(["pi", "--version"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
-  if (version.status !== 0 || version.error) {
-    const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim();
-    if (!installCommand)
-      throw new Error(`Pi/OMP is not available: ${(version.stderr || version.stdout || version.error?.message || "pi --version failed").trim()}. Install Pi/OMP or set RIG_PI_INSTALL_COMMAND.`);
-    const parts = splitInstallCommand(installCommand);
-    if (parts.length === 0)
-      throw new Error("RIG_PI_INSTALL_COMMAND is empty.");
-    const install = runSyncCommand(parts, { cwd: projectRoot, timeoutMs: 120000, spawn: deps.spawn });
-    if (install.status !== 0 || install.error)
-      throw new Error(`Pi/OMP install command failed: ${(install.stderr || install.stdout || install.error?.message || "unknown error").trim()}`);
-    version = runSyncCommand(["pi", "--version"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
-    if (version.status !== 0 || version.error)
-      throw new Error(`Pi/OMP is still unavailable after install: ${(version.stderr || version.stdout || version.error?.message || "pi --version failed").trim()}`);
-  }
-  let list = runSyncCommand(["pi", "list"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
-  if (!piListContainsRigExtension(`${list.stdout}
-${list.stderr}`)) {
-    const packageSource = existsSync(resolve(projectRoot, "packages", "pi-rig", "package.json")) ? resolve(projectRoot, "packages", "pi-rig") : "npm:@h-rig/pi-rig";
-    const install = runSyncCommand(["pi", "install", packageSource], { cwd: projectRoot, timeoutMs: 120000, spawn: deps.spawn });
-    if (install.status !== 0 || install.error)
-      throw new Error(`Could not install/register the Rig OMP extension: ${(install.stderr || install.stdout || install.error?.message || "pi install failed").trim()}`);
-    list = runSyncCommand(["pi", "list"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
-    if (!piListContainsRigExtension(`${list.stdout}
-${list.stderr}`))
-      throw new Error("Pi/OMP is installed, but `pi list` does not show the Rig extension.");
-  }
-  return { ok: true, detail: (version.stdout || version.stderr).trim() || "pi available; rig extension registered" };
-}
-async function detectRigStartupStatus(input) {
-  const projectRoot = input.projectRoot;
-  const config = readRigConfigStatus(projectRoot);
-  const state = readRigConnectionStatus(projectRoot);
-  const detectedSlug = detectOriginRepoSlug(projectRoot, input.deps);
-  const slug = config.slug ?? state.project ?? detectedSlug;
-  const reasons = [];
-  if (!detectedSlug)
-    reasons.push("git origin does not point at a GitHub owner/repo remote");
-  if (!config.exists || !config.valid)
-    reasons.push(config.reason ?? "rig.config.ts is invalid");
-  if (!state.valid)
-    reasons.push(state.reason ?? ".rig/state/connection.json is invalid");
-  if (config.slug && state.project && config.slug !== state.project)
-    reasons.push(`rig.config.ts repo ${config.slug} does not match connection project ${state.project}`);
-  if (slug && detectedSlug && slug !== detectedSlug)
-    reasons.push(`configured repo ${slug} does not match git origin ${detectedSlug}`);
-  const auth = await validateGitHubAuth(projectRoot, slug, input.deps);
-  if (!auth.ok)
-    reasons.push(auth.detail);
-  return { configured: reasons.length === 0, projectRoot, slug, config, state, auth, reasons };
-}
-var detectStartupStatus = detectRigStartupStatus;
-async function applyRigSetupProject(input) {
-  const repo = parseRepoSlug(input.slug);
-  ensureRigPrivateDirs(input.projectRoot);
-  ensureGitignoreEntries(input.projectRoot);
-  if (input.placement.alias !== "local" && input.placement.host) {
-    addPlacement(input.projectRoot, { alias: input.placement.alias, host: input.placement.host, port: input.placement.port, token: input.placement.token, select: true });
-  } else {
-    selectPlacement(input.projectRoot, input.placement.alias);
-  }
-  writeRigConnectionState(input.projectRoot, repo.slug, input.placement);
-  if (input.rewriteConfig)
-    writeRigConfig(input.projectRoot, repo.slug);
-  const labels = input.ensureLabels === false ? { skipped: true } : await ensureGitHubLabels({ projectRoot: input.projectRoot, slug: repo.slug, deps: input.deps });
-  const pi = input.ensurePi === false ? { skipped: true } : ensurePiRigInstalledForSetup(input.projectRoot, input.deps);
-  return { repoSlug: repo.slug, placement: input.placement.alias, configWritten: input.rewriteConfig, labels, pi };
-}
-async function runSetup(input) {
-  const repo = parseRepoSlug(input.slug);
-  const auth = await ensureGitHubAuth({ projectRoot: input.projectRoot, slug: repo.slug, token: input.githubToken, importGhToken: input.importGhToken, deps: input.deps });
-  if (!auth.ok)
-    throw new Error(auth.detail);
-  const token = createGitHubAuthStore(input.projectRoot).readToken();
-  const probe = await probeGitHubRepository({
-    owner: repo.owner,
-    repo: repo.repo,
-    token,
-    scopes: auth.status?.scopes ?? [],
-    ...input.deps?.fetch ? { fetchRepository: input.deps.fetch } : {}
-  });
-  if (!probe.ok)
-    throw new Error(probe.message);
-  const result = await applyRigSetupProject({
-    projectRoot: input.projectRoot,
-    slug: repo.slug,
-    placement: input.placement,
-    rewriteConfig: input.rewriteConfig ?? true,
-    ensurePi: input.ensurePi,
-    ensureLabels: input.ensureLabels,
-    deps: input.deps
-  });
-  const status = await detectRigStartupStatus({ projectRoot: input.projectRoot, deps: input.deps });
-  if (!status.configured)
-    throw new Error(`Setup wrote state but doctor still reports: ${status.reasons.join("; ")}`);
-  return { ...result, status };
-}
-export {
-  writeRigConnectionState,
-  writeRigConfig,
-  validateGitHubAuth,
-  saveGitHubTokenLocally,
-  runSetup,
-  readRigConnectionStatus,
-  readRigConfigStatus,
-  readGhAuthToken,
-  parseRepoSlugFromRemote,
-  parseRepoSlug,
-  ensureRigPrivateDirs,
-  ensurePiRigInstalledForSetup,
-  ensureGitignoreEntries,
-  ensureGitHubLabels,
-  ensureGitHubAuth,
-  detectStartupStatus,
-  detectRigStartupStatus,
-  detectOriginRepoSlug,
-  detectGhAuth,
-  applyRigSetupProject
-};