@h-rig/cli 0.0.6-alpha.89 → 0.0.6-alpha.90

package/dist/src/commands/init.js

@@ -121,7 +121,7 @@ function createTtySpinner(input) {
       output.write("\r\x1B[2K");
   };
   render();
-  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 120) : null;
   return {
     setLabel(next) {
       label = next;
@@ -320,7 +320,7 @@ var init_drone_ui = __esm(() => {
 });
 
 // packages/cli/src/commands/init.ts
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
 import { spawnSync } from "child_process";
 import { basename, resolve as resolve6 } from "path";
 
@@ -459,28 +459,12 @@ function readRepoConnection(projectRoot) {
     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
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
   };
 }
 function writeRepoConnection(projectRoot, state) {
   writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
 }
-function rootAllowedForSelection(repo, connection) {
-  const root = repo.serverProjectRoot?.trim();
-  if (!root)
-    return;
-  if (connection.kind === "remote") {
-    if (repo.serverProjectRootAlias !== repo.selected)
-      return;
-    if (repo.serverProjectRootBaseUrl !== connection.baseUrl)
-      return;
-  } else if (repo.serverProjectRootAlias && repo.serverProjectRootAlias !== repo.selected) {
-    return;
-  }
-  return root;
-}
 function resolveSelectedConnection(projectRoot, options = {}) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
@@ -492,46 +476,18 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   if (!connection) {
     throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
   }
-  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
+  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
 }
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
     return;
-  let inferred = metadata;
-  if (!inferred.alias || !inferred.baseUrl) {
-    try {
-      const selected = resolveSelectedConnection(projectRoot);
-      if (selected?.connection.kind === "remote") {
-        inferred = {
-          alias: inferred.alias ?? selected.alias,
-          baseUrl: inferred.baseUrl ?? selected.connection.baseUrl
-        };
-      }
-    } catch {}
-  }
-  writeRepoConnection(projectRoot, {
-    ...repo,
-    ...metadata.project ? { project: metadata.project } : {},
-    serverProjectRoot,
-    ...inferred.alias ? { serverProjectRootAlias: inferred.alias } : {},
-    ...inferred.baseUrl ? { serverProjectRootBaseUrl: inferred.baseUrl.replace(/\/+$/, "") } : {}
-  });
-}
-function clearRepoServerProjectRoot(projectRoot) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  writeRepoConnection(projectRoot, {
-    selected: repo.selected,
-    ...repo.project ? { project: repo.project } : {},
-    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
-  });
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
 }
 
 // packages/cli/src/commands/_server-client.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, isAbsolute, resolve as resolve2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
 var scopedGitHubBearerTokens = new Map;
 var serverPhaseListener = null;
@@ -546,21 +502,17 @@ function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
   const scopedKey = resolve2(projectRoot ?? process.cwd());
   scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
-function readRemoteAuthState(projectRoot) {
+function readPrivateRemoteSessionToken(projectRoot) {
   const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
   if (!existsSync2(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
   } catch {
     return null;
   }
 }
-function readPrivateRemoteSessionToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined) : null;
-}
 function readGitHubBearerTokenForRemote(projectRoot) {
   const scopedKey = resolve2(projectRoot);
   if (scopedGitHubBearerTokens.has(scopedKey))
@@ -571,415 +523,18 @@ function readGitHubBearerTokenForRemote(projectRoot) {
   return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
 }
 function readStoredGitHubAuthToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
-}
-function inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug) {
-  if (!/^[^/]+\/[^/]+$/.test(repoSlug))
-    return null;
-  const repo = readRepoConnection(projectRoot);
-  const auth = readRemoteAuthState(projectRoot);
-  const authUpdatedAt = typeof auth?.updatedAt === "string" ? Date.parse(auth.updatedAt) : Number.NaN;
-  const repoLinkedAt = typeof repo?.linkedAt === "string" ? Date.parse(repo.linkedAt) : Number.NaN;
-  if (Number.isFinite(authUpdatedAt) && Number.isFinite(repoLinkedAt) && authUpdatedAt + 1000 < repoLinkedAt)
-    return null;
-  const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
-  if (!checkoutBaseDir)
-    return null;
-  return `${checkoutBaseDir.replace(/\/+$/, "")}/${repoSlug}`;
-}
-function readLocalConnectionFallbackToken(projectRoot) {
-  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
-}
-function normalizeRepoSlug(value) {
-  const slug = value?.trim();
-  return slug && /^[^/\s]+\/[^/\s]+$/.test(slug) ? slug : null;
-}
-function readProjectLinkSlug(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
+  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
   if (!existsSync2(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    return normalizeRepoSlug(typeof parsed.repoSlug === "string" ? String(parsed.repoSlug) : null);
-  } catch {
-    return null;
-  }
-}
-function writeProjectLinkConnection(projectRoot, repoSlug, alias) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, `${JSON.stringify({ repoSlug, connection: alias, linkedAt: new Date().toISOString() }, null, 2)}
-`, "utf8");
-}
-function remoteLinkRepairCommand(repoSlug) {
-  return repoSlug ? `rig server repair-link --repo ${repoSlug}` : "rig server repair-link --repo owner/repo";
-}
-function formatRemoteProjectLinkHint(resolution) {
-  const repair = remoteLinkRepairCommand(resolution.repoSlug);
-  if (resolution.status === "auth_required") {
-    return `Authenticate the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}, then run \`${repair}\`. Use \`rig github auth import-gh\` or \`rig init --repair --server remote --github-auth device${resolution.repoSlug ? ` --repo ${resolution.repoSlug}` : ""}\`.`;
-  }
-  if (resolution.status === "missing_project") {
-    return `Record the repo slug, then run \`${repair}\` (or \`rig init --repo owner/repo --server remote --github-auth device\`).`;
-  }
-  if (resolution.status === "not_remote")
-    return "Select a remote server with `rig server use <alias>` before repairing a remote project link.";
-  return `Run \`${repair}\` to backfill or prepare a server-host checkout for the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}.`;
-}
-function remoteProjectLinkFailure(input) {
-  const partial = {
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug
-  };
-  return {
-    ok: false,
-    ...input,
-    hint: formatRemoteProjectLinkHint(partial),
-    next: remoteLinkRepairCommand(input.repoSlug)
-  };
-}
-function remoteProjectLinkSuccess(input) {
-  return {
-    ok: true,
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug,
-    serverProjectRoot: input.serverProjectRoot,
-    source: input.source,
-    prepared: input.prepared ?? input.status === "prepared",
-    validated: input.validated ?? false,
-    message: input.message ?? `Remote project link ready for ${input.repoSlug}.`,
-    hint: "Remote-scoped task/run/status requests will send x-rig-project-root for this server-host checkout.",
-    next: "rig task list"
-  };
-}
-function localCheckoutPathCandidate(projectRoot, candidate) {
-  try {
-    const local = resolve2(projectRoot);
-    const resolved = resolve2(candidate);
-    return resolved === local || resolved.startsWith(`${local}/`);
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
   } catch {
-    return false;
-  }
-}
-async function requestRemoteProjectLinkJson(baseUrl, pathname, authToken, init = {}) {
-  const requestUrl = new URL(`${baseUrl}${pathname}`);
-  if (authToken && queryAuthFallbackEnabled())
-    requestUrl.searchParams.set("rt", authToken);
-  const response = await fetch(requestUrl, {
-    ...init,
-    headers: mergeHeaders(init.headers, authToken)
-  });
-  const text = await response.text();
-  const payload = text.trim().length > 0 ? (() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })() : null;
-  return { ok: response.ok, status: response.status, payload, text };
-}
-function payloadError(payload, fallback) {
-  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
-    const record = payload;
-    const value = record.error ?? record.message ?? record.reason;
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-  }
-  return fallback;
-}
-function checkoutPathsFromProjectPayload(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return [];
-  const project = payload.project;
-  if (!project || typeof project !== "object" || Array.isArray(project))
-    return [];
-  const checkouts = project.checkouts;
-  if (!Array.isArray(checkouts))
-    return [];
-  return [...checkouts].reverse().flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-      return [];
-    const path = entry.path;
-    return typeof path === "string" && path.trim() ? [path.trim()] : [];
-  });
-}
-function checkoutPathFromPreparePayload(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
     return null;
-  const checkout = payload.checkout;
-  if (!checkout || typeof checkout !== "object" || Array.isArray(checkout))
-    return null;
-  const path = checkout.path;
-  return typeof path === "string" && path.trim() ? path.trim() : null;
-}
-async function validateAndPersistRemoteRoot(input) {
-  const candidate = input.candidate.trim();
-  if (!candidate || !isAbsolute(candidate)) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Remote project root candidate is not an absolute server-host path: ${candidate || "(empty)"}.`
-    });
-  }
-  if (localCheckoutPathCandidate(input.projectRoot, candidate)) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Refusing to use local checkout path ${candidate} as a remote server project root.`
-    });
-  }
-  let response;
-  try {
-    response = await requestRemoteProjectLinkJson(input.baseUrl, "/api/server/project-root", input.authToken, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ projectRoot: candidate })
-    });
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Could not validate remote project root ${candidate}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (response.status === 401 || response.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      statusCode: response.status,
-      message: `Remote server ${input.alias} requires authentication before validating project root ${candidate}.`
-    });
   }
-  if (!response.ok) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      statusCode: response.status,
-      message: `Remote server rejected project root ${candidate} (${response.status}): ${payloadError(response.payload, response.text || "project-root validation failed")}`
-    });
-  }
-  const record = response.payload && typeof response.payload === "object" && !Array.isArray(response.payload) ? response.payload : {};
-  if (record.ok !== true) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Remote server did not accept project root ${candidate}: ${payloadError(response.payload, "project-root validation failed")}`
-    });
-  }
-  const accepted = typeof record.projectRoot === "string" && record.projectRoot.trim() ? record.projectRoot.trim() : typeof record.requestedProjectRoot === "string" && record.requestedProjectRoot.trim() ? record.requestedProjectRoot.trim() : candidate;
-  writeRepoServerProjectRoot(input.projectRoot, accepted, { alias: input.alias, baseUrl: input.baseUrl, project: input.repoSlug });
-  writeProjectLinkConnection(input.projectRoot, input.repoSlug, input.alias);
-  const status = input.status ?? (input.prepared ? "prepared" : "backfilled");
-  return remoteProjectLinkSuccess({
-    status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug,
-    serverProjectRoot: accepted,
-    source: input.source,
-    prepared: input.prepared,
-    validated: true,
-    message: status === "ready" ? `Remote project link already points to ${accepted} and was validated on ${input.alias}.` : input.prepared ? `Prepared and linked remote checkout ${accepted} for ${input.repoSlug}.` : `Backfilled remote checkout ${accepted} for ${input.repoSlug}.`
-  });
 }
-async function ensureRemoteProjectRootLink(projectRoot, options = {}) {
-  let selected;
-  try {
-    selected = resolveSelectedConnection(projectRoot);
-  } catch (error) {
-    return remoteProjectLinkFailure({ status: "error", message: error instanceof Error ? error.message : String(error) });
-  }
-  if (!selected || selected.connection.kind !== "remote") {
-    return remoteProjectLinkFailure({ status: "not_remote", message: "No remote Rig server is selected for this repo." });
-  }
-  const repo = readRepoConnection(projectRoot);
-  const explicitRepoRequested = options.repoSlug !== undefined;
-  const explicitRepoSlug = explicitRepoRequested ? normalizeRepoSlug(options.repoSlug) : null;
-  const repoProjectSlug = normalizeRepoSlug(repo?.project);
-  const repoSlug = explicitRepoSlug ?? repoProjectSlug ?? readProjectLinkSlug(projectRoot);
-  const alias = selected.alias;
-  const baseUrl = selected.connection.baseUrl;
-  const authToken = options.authToken === undefined ? readGitHubBearerTokenForRemote(projectRoot) : options.authToken;
-  const mode = options.mode ?? "backfill-only";
-  if (explicitRepoRequested && !explicitRepoSlug) {
-    return remoteProjectLinkFailure({
-      status: "missing_project",
-      alias,
-      baseUrl,
-      message: `Invalid --repo value ${JSON.stringify(options.repoSlug)}. Expected owner/repo.`
-    });
-  }
-  if (!repoSlug) {
-    return remoteProjectLinkFailure({
-      status: "missing_project",
-      alias,
-      baseUrl,
-      message: `Remote server ${alias} is selected, but this checkout has no GitHub repo slug recorded.`
-    });
-  }
-  const skippedCandidates = [];
-  const storedRoot = selected.serverProjectRoot?.trim() || null;
-  const storedRootMatchesResolvedRepo = repoProjectSlug === repoSlug;
-  if (storedRoot && storedRootMatchesResolvedRepo) {
-    if (localCheckoutPathCandidate(projectRoot, storedRoot)) {
-      clearRepoServerProjectRoot(projectRoot);
-      skippedCandidates.push(storedRoot);
-    } else {
-      const storedResult = await validateAndPersistRemoteRoot({
-        projectRoot,
-        alias,
-        baseUrl,
-        authToken,
-        repoSlug,
-        candidate: storedRoot,
-        source: "stored",
-        status: "ready"
-      });
-      if (storedResult.ok || storedResult.status === "auth_required" || storedResult.status === "error")
-        return storedResult;
-      clearRepoServerProjectRoot(projectRoot);
-      skippedCandidates.push(storedRoot);
-    }
-  } else if (storedRoot) {
-    skippedCandidates.push(storedRoot);
-  }
-  const authCandidate = inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug);
-  if (authCandidate) {
-    const authResult = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: authCandidate, source: "auth-state" });
-    if (authResult.ok || authResult.status === "auth_required")
-      return authResult;
-  }
-  let registryResponse;
-  try {
-    registryResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}`, authToken);
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Could not read remote project registry for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (registryResponse.status === 401 || registryResponse.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: registryResponse.status,
-      message: `Remote server ${alias} requires authentication before reading the ${repoSlug} project registry.`
-    });
-  }
-  if (registryResponse.ok) {
-    const candidates = checkoutPathsFromProjectPayload(registryResponse.payload);
-    for (const candidate of candidates) {
-      const result = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate, source: "registry" });
-      if (result.ok || result.status === "auth_required")
-        return result;
-      skippedCandidates.push(candidate);
-    }
-    if (mode === "backfill-only") {
-      return remoteProjectLinkFailure({
-        status: candidates.length > 0 ? "invalid_root" : "no_server_checkout",
-        alias,
-        baseUrl,
-        repoSlug,
-        message: candidates.length > 0 ? `Remote registry has checkout candidates for ${repoSlug}, but none validated for ${alias}.` : `Remote registry has ${repoSlug}, but no server checkout path is linked yet.`,
-        skippedCandidates
-      });
-    }
-  } else if (registryResponse.status === 404) {
-    if (mode === "backfill-only") {
-      return remoteProjectLinkFailure({
-        status: "project_not_registered",
-        alias,
-        baseUrl,
-        repoSlug,
-        statusCode: registryResponse.status,
-        message: `Remote server ${alias} has no registered project record for ${repoSlug}.`
-      });
-    }
-  } else {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: registryResponse.status,
-      message: `Could not backfill ${repoSlug} from remote registry (${registryResponse.status}): ${payloadError(registryResponse.payload, registryResponse.text || "registry lookup failed")}`,
-      skippedCandidates
-    });
-  }
-  let prepareResponse;
-  try {
-    prepareResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}/prepare-checkout`, authToken, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ checkout: { kind: "managed-clone" }, repoUrl: `https://github.com/${repoSlug}.git` })
-    });
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Could not prepare remote checkout for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (prepareResponse.status === 401 || prepareResponse.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: prepareResponse.status,
-      message: `Remote server ${alias} requires authentication before preparing ${repoSlug}.`
-    });
-  }
-  if (!prepareResponse.ok) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: prepareResponse.status,
-      message: `Remote checkout prepare failed for ${repoSlug} (${prepareResponse.status}): ${payloadError(prepareResponse.payload, prepareResponse.text || "prepare-checkout failed")}`,
-      skippedCandidates
-    });
-  }
-  const preparedPath = checkoutPathFromPreparePayload(prepareResponse.payload);
-  if (!preparedPath) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Remote checkout prepare for ${repoSlug} did not return a checkout.path.`,
-      skippedCandidates
-    });
-  }
-  return validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: preparedPath, source: "prepare", prepared: true });
+function readLocalConnectionFallbackToken(projectRoot) {
+  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
 }
 async function ensureServerForCli(projectRoot) {
   try {
@@ -987,12 +542,12 @@ async function ensureServerForCli(projectRoot) {
     if (selected?.connection.kind === "remote") {
       reportServerPhase(`Connecting to ${selected.alias}\u2026`);
       const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const link = await ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only", authToken });
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
       return {
         baseUrl: selected.connection.baseUrl,
         authToken,
         connectionKind: "remote",
-        serverProjectRoot: link.ok ? link.serverProjectRoot ?? null : null
+        serverProjectRoot
       };
     }
     reportServerPhase("Starting local Rig server\u2026");
@@ -1010,23 +565,33 @@ async function ensureServerForCli(projectRoot) {
     throw error;
   }
 }
-function mergeCookie(existing, name, value) {
-  const encoded = `${name}=${encodeURIComponent(value)}`;
-  if (!existing?.trim())
-    return encoded;
-  const parts = existing.split(";").map((part) => part.trim()).filter((part) => part && !part.startsWith(`${name}=`));
-  return [...parts, encoded].join("; ");
-}
-function queryAuthFallbackEnabled(env = process.env) {
-  return env.RIG_ENABLE_QUERY_AUTH_FALLBACK === "1" || env.RIG_QUERY_AUTH_FALLBACK === "1";
+async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug)
+    return null;
+  try {
+    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+      headers: mergeHeaders(undefined, authToken)
+    });
+    if (!response.ok)
+      return null;
+    const payload = await response.json();
+    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
+    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
+    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
+    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
+    if (path)
+      writeRepoServerProjectRoot(projectRoot, path);
+    return path;
+  } catch {
+    return null;
+  }
 }
 function mergeHeaders(headers, authToken) {
   const merged = new Headers(headers);
   if (authToken) {
-    const bearer = `Bearer ${authToken}`;
-    merged.set("authorization", bearer);
-    merged.set("x-auth", bearer);
-    merged.set("cookie", mergeCookie(merged.get("cookie"), "rig_auth", authToken));
+    merged.set("authorization", `Bearer ${authToken}`);
   }
   return merged;
 }
@@ -1087,41 +652,15 @@ async function buildServerFailureContext(projectRoot, server) {
     hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
   };
 }
-function isLoopbackRemoteBaseUrl(baseUrl) {
-  try {
-    const host = new URL(baseUrl).hostname.toLowerCase();
-    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
-  } catch {
-    return false;
-  }
-}
-function canUseRemoteWithoutProjectRoot(pathname) {
-  return pathname === "/health" || pathname === "/api/health" || pathname === "/api/server/status" || pathname === "/api/server/project-root" || pathname.startsWith("/api/github/auth/") || pathname === "/api/projects" || pathname.startsWith("/api/projects/");
-}
 async function requestServerJson(context, pathname, init = {}) {
   const server = await ensureServerForCli(context.projectRoot);
-  const requestUrl = new URL(`${server.baseUrl}${pathname}`);
-  let scopedServerProjectRoot = server.serverProjectRoot;
-  if (server.connectionKind === "remote" && !scopedServerProjectRoot && !canUseRemoteWithoutProjectRoot(requestUrl.pathname) && (server.authToken || !isLoopbackRemoteBaseUrl(server.baseUrl))) {
-    const link = await ensureRemoteProjectRootLink(context.projectRoot, { mode: "backfill-only", authToken: server.authToken });
-    if (link.ok && link.serverProjectRoot) {
-      scopedServerProjectRoot = link.serverProjectRoot;
-    } else {
-      const repo = readRepoConnection(context.projectRoot);
-      const target = link.alias && link.baseUrl ? `${link.alias} (${link.baseUrl})` : server.baseUrl;
-      throw new CliError(`Remote server ${target} is selected for ${link.repoSlug ?? repo?.project ?? "this repo"}, but this checkout has no server-host project root link. ${link.message}`, 1, { hint: link.hint });
-    }
-  }
   const headers = mergeHeaders(init.headers, server.authToken);
-  if (scopedServerProjectRoot)
-    headers.set("x-rig-project-root", scopedServerProjectRoot);
-  if (server.connectionKind === "remote" && server.authToken && queryAuthFallbackEnabled()) {
-    requestUrl.searchParams.set("rt", server.authToken);
-  }
+  if (server.serverProjectRoot)
+    headers.set("x-rig-project-root", server.serverProjectRoot);
   reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
   let response;
   try {
-    response = await fetch(requestUrl, {
+    response = await fetch(`${server.baseUrl}${pathname}`, {
       ...init,
       headers
     });
@@ -1150,26 +689,11 @@ ${failure.contextLine}`, 1, { hint: failure.hint });
   return payload;
 }
 async function postGitHubTokenViaServer(context, token, options = {}) {
-  const server = await ensureServerForCli(context.projectRoot);
-  const requestUrl = new URL(`${server.baseUrl}/api/github/auth/token`);
-  reportServerPhase("POST /api/github/auth/token\u2026");
-  let response;
-  try {
-    response = await fetch(requestUrl, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot ?? server.serverProjectRoot ?? undefined })
-    });
-  } catch (error) {
-    const failure = await buildServerFailureContext(context.projectRoot, server);
-    throw new CliError(`Rig server auth bootstrap failed: ${error instanceof Error ? error.message : String(error)}
-${failure.contextLine}`, 1, { hint: failure.hint });
-  }
-  const payload = await response.json().catch(() => null);
-  if (!response.ok) {
-    const detail = payload && typeof payload === "object" && !Array.isArray(payload) ? String(payload.error ?? JSON.stringify(payload)) : `HTTP ${response.status}`;
-    throw new CliError(`Rig server auth bootstrap failed (${response.status}): ${detail}`, 1, { hint: "Re-run `rig github auth import-gh`, or check the selected server with `rig server status`." });
-  }
+  const payload = await requestServerJson(context, "/api/github/auth/token", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot })
+  });
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 async function prepareRemoteCheckoutViaServer(context, input) {
@@ -1433,7 +957,7 @@ async function buildPiSetupChecks(input = {}) {
 
 // packages/cli/src/commands/_snapshot-upload.ts
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname3, resolve as resolve4, relative, sep } from "path";
+import { dirname as dirname2, resolve as resolve4, relative, sep } from "path";
 var SNAPSHOT_ARCHIVE_VERSION = 1;
 var SNAPSHOT_ARCHIVE_CONTENT_TYPE = "application/vnd.rig.snapshot+json";
 var DEFAULT_EXCLUDED_DIRECTORIES = new Set([
@@ -1781,14 +1305,14 @@ function parseRepoSlug(value) {
 }
 function ensureRigPrivateDirs(projectRoot) {
   const rigDir = resolve6(projectRoot, ".rig");
-  mkdirSync3(resolve6(rigDir, "state"), { recursive: true });
-  mkdirSync3(resolve6(rigDir, "logs"), { recursive: true });
-  mkdirSync3(resolve6(rigDir, "runs"), { recursive: true });
-  mkdirSync3(resolve6(rigDir, "tmp"), { recursive: true });
-  mkdirSync3(resolve6(projectRoot, "artifacts"), { recursive: true });
+  mkdirSync2(resolve6(rigDir, "state"), { recursive: true });
+  mkdirSync2(resolve6(rigDir, "logs"), { recursive: true });
+  mkdirSync2(resolve6(rigDir, "runs"), { recursive: true });
+  mkdirSync2(resolve6(rigDir, "tmp"), { recursive: true });
+  mkdirSync2(resolve6(projectRoot, "artifacts"), { recursive: true });
   const taskConfigPath = resolve6(rigDir, "task-config.json");
   if (!existsSync5(taskConfigPath))
-    writeFileSync3(taskConfigPath, `{}
+    writeFileSync2(taskConfigPath, `{}
 `, "utf-8");
 }
 function ensureGitignoreEntries(projectRoot) {
@@ -1816,7 +1340,7 @@ function ensureRigConfigPackageDependencies(projectRoot) {
     ...existsSync5(path) ? existing : { name: "rig-project", private: true },
     devDependencies
   };
-  writeFileSync3(path, `${JSON.stringify(next, null, 2)}
+  writeFileSync2(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
 }
 function applyGitHubProjectConfig(source, options) {
@@ -1842,9 +1366,9 @@ function checkoutForInit(projectRoot, serverKind, strategy) {
   const selected = strategy ?? { kind: "managed-clone" };
   switch (selected.kind) {
     case "managed-clone":
-      return { kind: "managed-clone" };
+      return { kind: "managed-clone", path: projectRoot };
     case "current-ref":
-      return { kind: "current-ref", ...selected.ref ? { ref: selected.ref } : {} };
+      return { kind: "current-ref", path: projectRoot, ...selected.ref ? { ref: selected.ref } : {} };
     case "uploaded-snapshot":
       return { kind: "uploaded-snapshot", path: projectRoot, source: "local-working-tree" };
     case "existing-path":
@@ -2114,7 +1638,7 @@ function remoteGitHubAuthMetadata(payload) {
   };
 }
 function writeRemoteGitHubAuthState(projectRoot, input) {
-  writeFileSync3(resolve6(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
+  writeFileSync2(resolve6(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
     authenticated: true,
     source: input.source,
     storedOnServer: true,
@@ -2162,7 +1686,7 @@ function runLocalFilesInit(context, options) {
       console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it.");
   } else {
     const projectName = basename(projectRoot) || "rig-project";
-    writeFileSync3(configTsPath, buildRigInitConfigSource({
+    writeFileSync2(configTsPath, buildRigInitConfigSource({
       projectName,
       taskSource: { kind: "files", path: "tasks" },
       useStandardPlugin: true
@@ -2171,8 +1695,8 @@ function runLocalFilesInit(context, options) {
   ensureRigConfigPackageDependencies(projectRoot);
   const tasksDir = resolve6(projectRoot, "tasks");
   if (!existsSync5(tasksDir)) {
-    mkdirSync3(tasksDir, { recursive: true });
-    writeFileSync3(resolve6(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)}
+    mkdirSync2(tasksDir, { recursive: true });
+    writeFileSync2(resolve6(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") {
@@ -2235,7 +1759,7 @@ function runDemoInit(context, options) {
       console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it for the demo.");
     }
   } else {
-    writeFileSync3(configTsPath, buildRigInitConfigSource({
+    writeFileSync2(configTsPath, buildRigInitConfigSource({
       projectName: basename(projectRoot) || "rig-demo",
       taskSource: { kind: "files", path: DEMO_TASKS_RELATIVE_DIR },
       useStandardPlugin: true
@@ -2244,14 +1768,14 @@ function runDemoInit(context, options) {
   }
   ensureRigConfigPackageDependencies(projectRoot);
   const demoTasksDir = resolve6(projectRoot, DEMO_TASKS_RELATIVE_DIR);
-  mkdirSync3(demoTasksDir, { recursive: true });
+  mkdirSync2(demoTasksDir, { recursive: true });
   const taskIds = [];
   for (const task of DEMO_TASKS) {
     const id = String(task.id);
     taskIds.push(id);
     const taskPath = resolve6(demoTasksDir, `${id}.json`);
     if (!existsSync5(taskPath)) {
-      writeFileSync3(taskPath, `${JSON.stringify(task, null, 2)}
+      writeFileSync2(taskPath, `${JSON.stringify(task, null, 2)}
 `, "utf-8");
     }
   }
@@ -2279,32 +1803,21 @@ function runDemoInit(context, options) {
 }
 async function runControlPlaneInit(context, options) {
   const projectRoot = context.projectRoot;
-  const existingRepoConnection = readRepoConnection(projectRoot);
-  const selectedConnection = (() => {
-    try {
-      return resolveSelectedConnection(projectRoot);
-    } catch {
-      return null;
-    }
-  })();
-  const selectedRemote = selectedConnection?.connection.kind === "remote" ? { alias: selectedConnection.alias, connection: selectedConnection.connection } : null;
-  const detectedSlug = options.repoSlug ?? existingRepoConnection?.project ?? detectOriginRepoSlug(projectRoot);
-  const serverKind = options.server ?? (selectedRemote ? "remote" : "local");
+  const detectedSlug = options.repoSlug ?? detectOriginRepoSlug(projectRoot);
   if (!detectedSlug) {
     const authMethod2 = options.githubAuthMethod ?? (options.githubToken ? "token" : "skip");
-    if (serverKind === "local" && authMethod2 === "skip") {
+    if ((options.server ?? "local") === "local" && authMethod2 === "skip") {
       return runLocalFilesInit(context, options);
     }
     throw new CliError("Could not detect GitHub repo slug from origin. Pass --repo owner/repo \u2014 or run `rig init --yes --server local --github-auth skip` for a local files-source project without GitHub.", 1);
   }
   const repo = parseRepoSlug(detectedSlug);
-  const connectionAlias = options.connectionAlias ?? (serverKind === "local" ? "local" : selectedRemote?.alias ?? "remote");
-  const selectedRemoteUrl = selectedRemote && (!options.connectionAlias || options.connectionAlias === selectedRemote.alias) ? selectedRemote.connection.baseUrl : undefined;
-  const remoteUrl = serverKind === "remote" ? (options.remoteUrl ?? selectedRemoteUrl)?.replace(/\/+$/, "") : undefined;
+  const serverKind = options.server ?? "local";
+  const connectionAlias = options.connectionAlias ?? (serverKind === "local" ? "local" : "remote");
   if (serverKind === "remote") {
-    if (!remoteUrl)
-      throw new CliError("Missing --remote-url for --server remote.", 1, { hint: "Re-run as `rig init --server remote --remote-url https://your-rig-server`, or first select a saved remote with `rig server use <alias>`." });
-    upsertGlobalConnection(connectionAlias, { kind: "remote", baseUrl: remoteUrl });
+    if (!options.remoteUrl)
+      throw new CliError("Missing --remote-url for --server remote.", 1, { hint: "Re-run as `rig init --server remote --remote-url https://your-rig-server`." });
+    upsertGlobalConnection(connectionAlias, { kind: "remote", baseUrl: options.remoteUrl });
   }
   writeRepoConnection(projectRoot, {
     selected: connectionAlias,
@@ -2327,11 +1840,11 @@ async function runControlPlaneInit(context, options) {
         taskSource: { kind: "github-issues", owner: repo.owner, repo: repo.repo },
         useStandardPlugin: true
       }), options);
-      writeFileSync3(configTsPath, source, "utf-8");
+      writeFileSync2(configTsPath, source, "utf-8");
     }
     ensureRigConfigPackageDependencies(projectRoot);
   }
-  writeFileSync3(resolve6(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
+  writeFileSync2(resolve6(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
   const checkout = checkoutForInit(projectRoot, serverKind, options.remoteCheckout);
   let uploadedSnapshot = null;
@@ -2346,7 +1859,7 @@ async function runControlPlaneInit(context, options) {
   let githubAuth = null;
   let deviceAuth = null;
   const authMethod = options.githubAuthMethod ?? (options.githubToken ? "token" : "skip");
-  const remoteGhTokenWarning = serverKind === "remote" && authMethod === "gh" ? `This sends a GitHub token from this machine to ${remoteUrl ?? "the remote Rig server"}.` : null;
+  const remoteGhTokenWarning = serverKind === "remote" && authMethod === "gh" ? `This sends a GitHub token from this machine to ${options.remoteUrl ?? "the remote Rig server"}.` : null;
   if (remoteGhTokenWarning && !options.yes) {
     throw new CliError(`${remoteGhTokenWarning} Re-run with --yes to confirm this explicit token transfer.`, 1);
   }