@h-rig/cli 0.0.6-alpha.82 → 0.0.6-alpha.84

package/dist/src/app-opentui/adapters/server.js

@@ -14,6 +14,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
@@ -34,6 +35,19 @@ var init_runner = __esm(() => {
 });
 
 // packages/cli/src/commands/_connection-state.ts
+var exports__connection_state = {};
+__export(exports__connection_state, {
+  writeRepoServerProjectRoot: () => writeRepoServerProjectRoot,
+  writeRepoConnection: () => writeRepoConnection,
+  writeGlobalConnections: () => writeGlobalConnections,
+  upsertGlobalConnection: () => upsertGlobalConnection,
+  resolveSelectedConnection: () => resolveSelectedConnection,
+  resolveRepoConnectionPath: () => resolveRepoConnectionPath,
+  resolveGlobalConnectionsPath: () => resolveGlobalConnectionsPath,
+  readRepoConnection: () => readRepoConnection,
+  readGlobalConnections: () => readGlobalConnections,
+  isRemoteConnectionSelected: () => isRemoteConnectionSelected
+});
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, resolve } from "path";
@@ -92,6 +106,18 @@ function readGlobalConnections(options = {}) {
   }
   return { connections };
 }
+function writeGlobalConnections(state, options = {}) {
+  writeJsonFile(resolveGlobalConnectionsPath(options.env ?? process.env), state);
+}
+function upsertGlobalConnection(alias, connection, options = {}) {
+  const cleanAlias = alias.trim();
+  if (!cleanAlias)
+    throw new CliError("Connection alias is required.", 1, { hint: "Save a server with `rig server add <alias> <url>`." });
+  const state = readGlobalConnections(options);
+  state.connections[cleanAlias] = connection;
+  writeGlobalConnections(state, options);
+  return state;
+}
 function readRepoConnection(projectRoot) {
   const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
   if (!payload || typeof payload !== "object" || Array.isArray(payload))
@@ -129,6 +155,9 @@ function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
     return;
   writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
 }
+function isRemoteConnectionSelected(projectRoot) {
+  return resolveSelectedConnection(projectRoot)?.connection.kind === "remote";
+}
 var init__connection_state = __esm(() => {
   init_runner();
 });
@@ -192,17 +221,21 @@ function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
   const scopedKey = resolve2(projectRoot ?? process.cwd());
   scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
-function readPrivateRemoteSessionToken(projectRoot) {
+function readRemoteAuthState(projectRoot) {
   const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
   if (!existsSync2(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } 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))
@@ -213,15 +246,25 @@ function readGitHubBearerTokenForRemote(projectRoot) {
   return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
 }
 function readStoredGitHubAuthToken(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
+  const parsed = readRemoteAuthState(projectRoot);
+  return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
+}
+function inferRemoteServerProjectRootFromAuthState(projectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug || !/^[^/]+\/[^/]+$/.test(slug))
     return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
-  } catch {
+  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;
+  const inferred = `${checkoutBaseDir.replace(/\/+$/, "")}/${slug}`;
+  writeRepoServerProjectRoot(projectRoot, inferred);
+  return inferred;
 }
 function readLocalConnectionFallbackToken(projectRoot) {
   return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
@@ -232,7 +275,7 @@ async function ensureServerForCli(projectRoot) {
     if (selected?.connection.kind === "remote") {
       reportServerPhase(`Connecting to ${selected.alias}\u2026`);
       const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      const serverProjectRoot = selected.serverProjectRoot ?? inferRemoteServerProjectRootFromAuthState(projectRoot) ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
       return {
         baseUrl: selected.connection.baseUrl,
         authToken,
@@ -261,7 +304,10 @@ async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken)
   if (!slug)
     return null;
   try {
-    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+    const url = new URL(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`);
+    if (authToken && queryAuthFallbackEnabled())
+      url.searchParams.set("rt", authToken);
+    const response = await fetch(url, {
       headers: mergeHeaders(undefined, authToken)
     });
     if (!response.ok)
@@ -288,10 +334,23 @@ function appendTaskFilterParams(url, filters) {
   if (filters.limit !== undefined)
     url.searchParams.set("limit", String(filters.limit));
 }
+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";
+}
 function mergeHeaders(headers, authToken) {
   const merged = new Headers(headers);
   if (authToken) {
-    merged.set("authorization", `Bearer ${authToken}`);
+    const bearer = `Bearer ${authToken}`;
+    merged.set("authorization", bearer);
+    merged.set("x-auth", bearer);
+    merged.set("cookie", mergeCookie(merged.get("cookie"), "rig_auth", authToken));
   }
   return merged;
 }
@@ -351,15 +410,34 @@ 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}`);
+  if (server.connectionKind === "remote" && !server.serverProjectRoot && !canUseRemoteWithoutProjectRoot(requestUrl.pathname) && (server.authToken || !isLoopbackRemoteBaseUrl(server.baseUrl))) {
+    const repo = readRepoConnection(context.projectRoot);
+    throw new CliError(`Remote server is selected for ${repo?.project ?? "this repo"}, but this checkout has no server-host project root link.`, 1, { hint: "Run `rig init --repair` or `rig init --yes --repo owner/repo --server remote` to repair the remote project link before task/run commands." });
+  }
   const headers = mergeHeaders(init.headers, server.authToken);
   if (server.serverProjectRoot)
     headers.set("x-rig-project-root", server.serverProjectRoot);
+  if (server.connectionKind === "remote" && server.authToken && queryAuthFallbackEnabled()) {
+    requestUrl.searchParams.set("rt", server.authToken);
+  }
   reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
   let response;
   try {
-    response = await fetch(`${server.baseUrl}${pathname}`, {
+    response = await fetch(requestUrl, {
       ...init,
       headers
     });
@@ -421,11 +499,26 @@ async function getGitHubAuthStatusViaServer(context) {
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 async function postGitHubTokenViaServer(context, token, options = {}) {
-  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 })
-  });
+  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`." });
+  }
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 async function prepareRemoteCheckoutViaServer(context, input) {
@@ -703,20 +796,11 @@ var init__server_client = __esm(() => {
 });
 
 // packages/cli/src/app-opentui/adapters/common.ts
-function adapterContextFromRuntime(runtime, renderer) {
-  return {
-    projectRoot: runtime.getState().projectRoot,
-    renderer,
-    ensureRuntime: () => runtime.getRunnerContext(),
-    emit: (event) => runtime.emit(event),
-    getState: () => runtime.getState()
-  };
-}
 function projectRootOf(ctx) {
   const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
   if (typeof root === "string" && root.trim())
     return root;
-  throw new Error("Rig app adapter requires a projectRoot.");
+  throw new Error("App adapter requires a projectRoot.");
 }
 function emitStarted(ctx, label, optimistic) {
   ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
@@ -735,36 +819,98 @@ function patchFooter(ctx, footer) {
 }
 
 // packages/cli/src/app-opentui/adapters/server.ts
-function createServerAdapter() {
-  return {
-    id: "server",
-    async handleIntent(runtime, intent) {
-      if (intent.scene !== "server")
-        return false;
-      if (intent.action.kind === "refresh" || intent.action.kind === "navigate") {
-        await refreshServerStatus(adapterContextFromRuntime(runtime));
-        return true;
+var SERVER_PROBE_TIMEOUT_MS = Number(process.env.RIG_SERVER_PROBE_TIMEOUT_MS) || 5000;
+function withTimeout(promise, ms, label) {
+  return new Promise((resolve3, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve3(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+async function withRetry(label, attempt, opts) {
+  const retries = opts?.retries ?? 1;
+  const baseDelayMs = opts?.baseDelayMs ?? 250;
+  let lastError;
+  for (let n = 0;n <= retries; n++) {
+    try {
+      return await attempt();
+    } catch (error) {
+      lastError = error;
+      if (n < retries) {
+        const delay = baseDelayMs * 2 ** n;
+        await new Promise((r) => setTimeout(r, delay));
       }
-      return false;
     }
-  };
+  }
+  throw lastError instanceof Error ? lastError : new Error(`${label} failed: ${String(lastError)}`);
+}
+function startLocalRequested(ctx) {
+  const intent = ctx.getState().data?.lastIntent;
+  if (!intent || typeof intent !== "object" || Array.isArray(intent))
+    return false;
+  const action = intent.action;
+  return action?.payload?.startLocal === true;
+}
+async function startLocalServerFromApp(ctx) {
+  const label = "Starting local server";
+  emitStarted(ctx, label);
+  patchData(ctx, {
+    lastIntent: undefined,
+    server: { label: "starting local server", reachable: false, error: "spawning local rig-server (detached)\u2026" }
+  });
+  try {
+    const projectRoot = projectRootOf(ctx);
+    emitProgress(ctx, label, "selecting local server for this repo");
+    const { writeRepoConnection: writeRepoConnection2, readRepoConnection: readRepoConnection2 } = await Promise.resolve().then(() => (init__connection_state(), exports__connection_state));
+    const previous = readRepoConnection2(projectRoot);
+    writeRepoConnection2(projectRoot, {
+      selected: "local",
+      ...previous?.project ? { project: previous.project } : {},
+      linkedAt: new Date().toISOString()
+    });
+    emitProgress(ctx, label, "spawning local rig-server (detached) and waiting for ready");
+    const { ensureLocalRigServerConnection: ensureLocalRigServerConnection2 } = await import("@rig/runtime/local-server");
+    const connection = await ensureLocalRigServerConnection2(projectRoot);
+    emitProgress(ctx, label, "local server ready", { baseUrl: connection.baseUrl });
+    emitCompleted(ctx, label, { baseUrl: connection.baseUrl });
+    return await refreshServerStatus(ctx);
+  } catch (error) {
+    const state = {
+      label: "local server failed to start",
+      reachable: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+    patchData(ctx, { server: state, lastRefreshError: state.error });
+    patchFooter(ctx, { server: "unavailable" });
+    emitCompleted(ctx, label, { server: state.label, reachable: false, error: state.error });
+    return state;
+  }
 }
 async function refreshServerStatus(ctx) {
+  if (startLocalRequested(ctx)) {
+    return startLocalServerFromApp(ctx);
+  }
   const label = "Checking server";
   emitStarted(ctx, label);
+  patchData(ctx, { server: { label: "checking selected server", reachable: false, error: "checking selected server\u2026" } });
   const started = Date.now();
   try {
     const { ensureServerForCli: ensureServerForCli2, requestServerJson: requestServerJson2, resolveServerConnectionLabel: resolveServerConnectionLabel2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const projectRoot = projectRootOf(ctx);
-    emitProgress(ctx, label, "resolving selected Rig server");
+    emitProgress(ctx, label, "resolving selected server");
     const [connectionLabel, server] = await Promise.all([
       resolveServerConnectionLabel2(projectRoot),
-      ensureServerForCli2(projectRoot)
+      withTimeout(ensureServerForCli2(projectRoot), 5000, "server connection")
     ]);
     emitProgress(ctx, label, "requesting server status", { baseUrl: server.baseUrl, kind: server.connectionKind });
     const [status, auth] = await Promise.all([
-      requestServerJson2({ projectRoot }, "/api/server/status").catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) })),
-      requestServerJson2({ projectRoot }, "/api/github/auth/status").catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) }))
+      withRetry("server status", () => withTimeout(requestServerJson2({ projectRoot }, "/api/server/status"), SERVER_PROBE_TIMEOUT_MS, "server status")).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) })),
+      withRetry("github auth status", () => withTimeout(requestServerJson2({ projectRoot }, "/api/github/auth/status"), SERVER_PROBE_TIMEOUT_MS, "github auth status")).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) }))
     ]);
     const state = {
       label: connectionLabel,
@@ -793,6 +939,6 @@ async function refreshServerStatus(ctx) {
   }
 }
 export {
-  refreshServerStatus,
-  createServerAdapter
+  startLocalServerFromApp,
+  refreshServerStatus
 };

package/dist/src/app-opentui/adapters/tasks.d.ts

@@ -1,6 +1,4 @@
-import type { AppAdapter } from "../types";
 import { type AppAdapterContext } from "./common";
-export declare function createTasksAdapter(): AppAdapter;
 export type AppTaskSort = "priority" | "recency" | "status" | "id";
 export type AppTaskFilters = {
     readonly preset?: "open" | "ready" | "blocked" | "closed" | "mine" | "all" | "custom";
@@ -11,6 +9,11 @@ export type AppTaskFilters = {
     readonly label?: string;
     readonly search?: string;
 };
+export type AppTaskActiveRun = {
+    readonly runId: string;
+    readonly status?: string;
+    readonly stage?: string;
+};
 export type AppTaskRecord = {
     readonly id: string;
     readonly status: string;
@@ -20,6 +23,7 @@ export type AppTaskRecord = {
     readonly createdAt?: string;
     readonly labels: readonly string[];
     readonly assignees: readonly string[];
+    readonly activeRun?: AppTaskActiveRun;
     readonly raw: Record<string, unknown>;
 };
 export type AppTaskViewState = {
@@ -31,6 +35,8 @@ export type AppTaskViewState = {
     readonly totalCount: number;
     readonly visibleCount: number;
 };
+export declare function activeRunIdFromTaskLike(task: Record<string, unknown>): string | undefined;
+export declare function activeRunIdFromTaskRunError(error: unknown): string | null;
 export declare function normalizeTaskRecord(record: Record<string, unknown>): AppTaskRecord | null;
 export declare function refreshTasks(ctx: AppAdapterContext, input?: AppTaskFilters & {
     readonly sort?: AppTaskSort | string;
@@ -40,6 +46,7 @@ export declare function submitTaskRun(ctx: AppAdapterContext, input?: {
     readonly title?: string;
     readonly initialPrompt?: string;
     readonly runId?: string;
+    readonly detach?: boolean;
 }): Promise<{
     runId: string;
 }>;
@@ -47,6 +54,8 @@ export declare function submitNextTaskRun(ctx: AppAdapterContext, filters?: {
     readonly assignee?: string;
     readonly state?: string;
     readonly status?: string;
+}, options?: {
+    readonly detach?: boolean;
 }): Promise<{
     runId: string;
     task: AppTaskRecord | null;