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

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

@@ -0,0 +1,186 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli/src/app-opentui/adapters/common.ts
+function projectRootOf(ctx) {
+  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
+  if (typeof root === "string" && root.trim())
+    return root;
+  throw new Error("App adapter requires a projectRoot.");
+}
+function normalizeAppError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message,
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+  };
+}
+function emitStarted(ctx, label, optimistic) {
+  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
+}
+function emitProgress(ctx, label, detail, data) {
+  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+}
+function emitCompleted(ctx, label, data) {
+  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+}
+function emitFailed(ctx, label, error, data) {
+  if (data)
+    patchData(ctx, data);
+  const normalized = normalizeAppError(error);
+  ctx.emit({
+    type: "action.failed",
+    label,
+    message: normalized.message,
+    ...normalized.hint ? { hint: normalized.hint } : {},
+    cause: error
+  });
+}
+function patchData(ctx, data) {
+  ctx.emit({ type: "data.patch", data });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+async function captureConsole(fn) {
+  const output = [];
+  const original = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  const capture = (...parts) => {
+    output.push(parts.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" "));
+  };
+  console.log = capture;
+  console.info = capture;
+  console.warn = capture;
+  console.error = capture;
+  try {
+    const result = await fn();
+    return { result, output };
+  } finally {
+    console.log = original.log;
+    console.info = original.info;
+    console.warn = original.warn;
+    console.error = original.error;
+  }
+}
+
+// packages/cli/src/app-opentui/adapters/repo.ts
+function repoActionRequest(ctx) {
+  const intent = ctx.getState().intent;
+  const payload = intent?.action?.payload;
+  if (!payload)
+    return { kind: "none" };
+  if (payload.repoReset === true)
+    return { kind: "reset" };
+  const alias = payload.repoSync;
+  if (typeof alias === "string" && alias.trim())
+    return { kind: "sync", alias: alias.trim() };
+  return { kind: "none" };
+}
+function readRepoGitStatus(projectRoot, checkoutRoot, pinnedCommit, runCapture, existsSync, joinPath) {
+  const unavailable = { available: false, clean: false, dirtyCount: 0, head: "", branch: "", ahead: 0, behind: 0 };
+  if (!checkoutRoot || !existsSync(joinPath(checkoutRoot, ".git")))
+    return unavailable;
+  const porcelain = runCapture(["git", "-C", checkoutRoot, "status", "--porcelain"], projectRoot);
+  if (porcelain.exitCode !== 0)
+    return unavailable;
+  const dirtyLines = porcelain.stdout.split(/\r?\n/).filter((row) => row.trim().length > 0);
+  const head = runCapture(["git", "-C", checkoutRoot, "rev-parse", "--short", "HEAD"], projectRoot).stdout.trim();
+  const branchRaw = runCapture(["git", "-C", checkoutRoot, "rev-parse", "--abbrev-ref", "HEAD"], projectRoot).stdout.trim();
+  let ahead = 0;
+  let behind = 0;
+  if (pinnedCommit) {
+    const counts = runCapture(["git", "-C", checkoutRoot, "rev-list", "--left-right", "--count", `${pinnedCommit}...HEAD`], projectRoot);
+    if (counts.exitCode === 0) {
+      const [behindStr = "0", aheadStr = "0"] = counts.stdout.trim().split(/\s+/);
+      behind = Number.parseInt(behindStr, 10) || 0;
+      ahead = Number.parseInt(aheadStr, 10) || 0;
+    }
+  }
+  return {
+    available: true,
+    clean: dirtyLines.length === 0,
+    dirtyCount: dirtyLines.length,
+    head,
+    branch: branchRaw && branchRaw !== "HEAD" ? branchRaw : "(detached)",
+    ahead,
+    behind
+  };
+}
+async function refreshRepo(ctx) {
+  const request = repoActionRequest(ctx);
+  const label = request.kind === "sync" ? `Syncing ${request.alias}` : request.kind === "reset" ? "Resetting repo baseline" : "Loading repo state";
+  emitStarted(ctx, label);
+  try {
+    const projectRoot = projectRootOf(ctx);
+    const [
+      { repoBaseline, resetBaseline },
+      { currentTaskId },
+      { listManagedRepoEntries, resolveManagedRepoIdByAlias },
+      { syncManagedRepo, resolveManagedRepoLayoutByAlias },
+      { runCapture },
+      { existsSync },
+      pathMod
+    ] = await Promise.all([
+      import("@rig/runtime/control-plane/native/repo-ops"),
+      import("@rig/runtime/control-plane/native/task-state"),
+      import("@rig/runtime/control-plane/repos/registry"),
+      import("@rig/runtime/control-plane/repos"),
+      import("@rig/runtime/control-plane/native/utils"),
+      import("fs"),
+      import("path")
+    ]);
+    const joinPath = (...parts) => pathMod.resolve(...parts);
+    if (request.kind === "sync") {
+      const repoId = resolveManagedRepoIdByAlias(request.alias);
+      if (!repoId)
+        throw new Error(`No managed repo registered for alias ${request.alias}.`);
+      emitProgress(ctx, label, `re-syncing ${request.alias} from its remote default branch`);
+      await captureConsole(() => syncManagedRepo(projectRoot, repoId));
+    } else if (request.kind === "reset") {
+      emitProgress(ctx, label, "resetting baseline to origin/main and refreshing pins");
+      await captureConsole(() => resetBaseline(projectRoot, false));
+    }
+    emitProgress(ctx, label, "reading baseline pins and managed repos");
+    const { result } = await captureConsole(() => ({
+      pins: repoBaseline(projectRoot, false),
+      taskId: currentTaskId(projectRoot),
+      managed: listManagedRepoEntries()
+    }));
+    const baselinePins = Object.entries(result.pins).map(([alias, commit]) => ({ alias, commit: String(commit) }));
+    const pinByAlias = new Map(baselinePins.map((pin) => [pin.alias, pin.commit]));
+    const managedRepos = result.managed.map((entry) => {
+      const layout = resolveManagedRepoLayoutByAlias(projectRoot, entry.alias);
+      const git = layout ? readRepoGitStatus(projectRoot, layout.checkoutRoot, pinByAlias.get(entry.alias), runCapture, existsSync, joinPath) : undefined;
+      return {
+        id: entry.id,
+        alias: entry.alias,
+        defaultBranch: entry.defaultBranch,
+        defaultRemoteUrl: entry.defaultRemoteUrl,
+        ...git ? { git } : {}
+      };
+    });
+    const snapshot = {
+      activeTaskId: result.taskId.trim() ? result.taskId.trim() : null,
+      baselinePins,
+      managedRepos,
+      flatLayout: managedRepos.length === 0,
+      refreshedAt: Date.now()
+    };
+    patchData(ctx, { repo: snapshot, lastRefreshError: undefined });
+    patchFooter(ctx, { message: snapshot.flatLayout ? "flat layout \xB7 no managed repos" : `${managedRepos.length} managed repos \xB7 ${baselinePins.length} pins` });
+    emitCompleted(ctx, label, { managed: managedRepos.length, pins: baselinePins.length, task: snapshot.activeTaskId });
+    return snapshot;
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+}
+export {
+  refreshRepo
+};

package/dist/src/app-opentui/adapters/run-detail.d.ts

@@ -1,6 +1,4 @@
-import type { AppAdapter } from "../types";
 import { type AppAdapterContext } from "./common";
-export declare function createRunDetailAdapter(): AppAdapter;
 export type AppRunSnapshot = {
     readonly runId: string;
     readonly status: string;
@@ -9,10 +7,19 @@ export type AppRunSnapshot = {
     readonly logs: Record<string, unknown>[];
     readonly timeline: Record<string, unknown>[];
     readonly timelineCursor: string | null;
+    /** Server-reported totals (when available) so the scene can show "N of M" and
+     * decide whether a "load more" affordance is warranted (#2). */
+    readonly logsTotal?: number;
+    readonly timelineTotal?: number;
 };
 export declare function loadRunDetail(ctx: AppAdapterContext, runId: string, options?: {
     readonly timelineCursor?: string | null;
 }): Promise<AppRunSnapshot>;
+/** "Load more" for the timeline (#2): fetch the NEXT page using the stored
+ * `timelineCursor` and APPEND it to the existing snapshot, advancing the cursor.
+ * The previously-loaded rows stay; nothing is re-fetched. No cursor ⇒ nothing
+ * more to load (the scene only offers the affordance while a cursor exists). */
+export declare function loadMoreRunTimeline(ctx: AppAdapterContext, runId: string): Promise<AppRunSnapshot | null>;
 export declare function steerRunFromApp(ctx: AppAdapterContext, input: {
     readonly runId: string;
     readonly message: string;

package/dist/src/app-opentui/adapters/run-detail.js

@@ -767,15 +767,6 @@ 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())
@@ -838,33 +829,17 @@ function stringField(record, keys, fallback = "") {
   }
   return fallback;
 }
-function payloadString(intent, key) {
-  const value = intent.action.payload?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 
 // packages/cli/src/app-opentui/adapters/run-detail.ts
-function createRunDetailAdapter() {
-  return {
-    id: "run-detail",
-    async handleIntent(runtime, intent) {
-      if (intent.scene !== "run-detail" && intent.action.kind !== "run-steer")
-        return false;
-      const ctx = adapterContextFromRuntime(runtime);
-      const runId = payloadString(intent, "runId") ?? runtime.getState().data.selectedRunId;
-      if (intent.action.kind === "run-steer") {
-        const message = payloadString(intent, "message") ?? intent.raw;
-        if (runId && message)
-          await steerRunFromApp(ctx, { runId, message });
-        return true;
-      }
-      if (runId) {
-        await loadRunDetail(ctx, runId);
-        return true;
-      }
-      return false;
-    }
-  };
+var LOG_PAGE = 100;
+var TIMELINE_PAGE = 200;
+function payloadTotal(payload) {
+  for (const key of ["total", "totalCount", "count"]) {
+    const value = payload[key];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+  }
+  return;
 }
 function unwrapRun(payload) {
   return payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
@@ -873,8 +848,24 @@ function nextCursor(payload) {
   const cursor = payload.nextCursor ?? payload.cursor;
   return typeof cursor === "string" && cursor.trim() ? cursor : null;
 }
+function loadMoreRequest(ctx, runId) {
+  const value = ctx.getState().data?.runDetailLoadMore;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.runId !== runId || typeof record.cursor !== "string" || !record.cursor.trim())
+    return null;
+  return { runId, cursor: record.cursor };
+}
 async function loadRunDetail(ctx, runId, options = {}) {
   const cleanRunId = runId.trim();
+  const more = loadMoreRequest(ctx, cleanRunId);
+  if (more) {
+    patchData(ctx, { runDetailLoadMore: undefined });
+    const appended = await loadMoreRunTimeline(ctx, cleanRunId).catch(() => null);
+    if (appended)
+      return appended;
+  }
   const label = `Loading run ${cleanRunId.slice(0, 8)}`;
   if (!cleanRunId) {
     const error = new Error("Run detail requires a run id.");
@@ -888,10 +879,12 @@ async function loadRunDetail(ctx, runId, options = {}) {
     emitProgress(ctx, label, "loading run, logs, and timeline");
     const [runPayload, logsPayload, timelinePayload] = await Promise.all([
       getRunDetailsViaServer2(context, cleanRunId),
-      getRunLogsViaServer2(context, cleanRunId, { limit: 100 }),
-      getRunTimelineViaServer2(context, cleanRunId, { limit: 200, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} })
+      getRunLogsViaServer2(context, cleanRunId, { limit: LOG_PAGE }),
+      getRunTimelineViaServer2(context, cleanRunId, { limit: TIMELINE_PAGE, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} })
     ]);
     const run = unwrapRun(runPayload);
+    const logsTotal = payloadTotal(logsPayload);
+    const timelineTotal = payloadTotal(timelinePayload);
     const snapshot = {
       runId: cleanRunId,
       status: stringField(run, ["status", "state"], "unknown"),
@@ -899,9 +892,12 @@ async function loadRunDetail(ctx, runId, options = {}) {
       run,
       logs: arrayFromPayload(logsPayload),
       timeline: arrayFromPayload(timelinePayload),
-      timelineCursor: nextCursor(timelinePayload)
+      timelineCursor: nextCursor(timelinePayload),
+      ...logsTotal !== undefined ? { logsTotal } : {},
+      ...timelineTotal !== undefined ? { timelineTotal } : {}
     };
-    patchData(ctx, { selectedRunId: cleanRunId, runDetail: snapshot });
+    const clearSettledSteer = settledSteerForRun(ctx, cleanRunId) ? { pendingRunMessage: undefined } : {};
+    patchData(ctx, { selectedRunId: cleanRunId, runDetail: snapshot, lastRefreshError: undefined, ...clearSettledSteer });
     patchFooter(ctx, { run: `${cleanRunId.slice(0, 8)} ${snapshot.status}` });
     emitCompleted(ctx, label, { runId: cleanRunId, status: snapshot.status, logs: snapshot.logs.length, timeline: snapshot.timeline.length });
     return snapshot;
@@ -910,6 +906,56 @@ async function loadRunDetail(ctx, runId, options = {}) {
     throw error;
   }
 }
+function settledSteerForRun(ctx, runId) {
+  const value = ctx.getState().data?.pendingRunMessage;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const record = value;
+  if (record.runId !== runId)
+    return false;
+  return record.status === "sent" || record.status === "delivered" || record.status === "failed";
+}
+function currentSnapshot(ctx) {
+  const value = ctx.getState().data?.runDetail;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+async function loadMoreRunTimeline(ctx, runId) {
+  const cleanRunId = runId.trim();
+  const snapshot = currentSnapshot(ctx);
+  if (!snapshot || snapshot.runId !== cleanRunId || !snapshot.timelineCursor)
+    return snapshot;
+  const label = `More timeline ${cleanRunId.slice(0, 8)}`;
+  emitStarted(ctx, label);
+  try {
+    const { getRunTimelineViaServer: getRunTimelineViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const context = { projectRoot: projectRootOf(ctx) };
+    const page = await getRunTimelineViaServer2(context, cleanRunId, { limit: TIMELINE_PAGE, cursor: snapshot.timelineCursor });
+    const more = arrayFromPayload(page);
+    const timelineTotal = payloadTotal(page) ?? snapshot.timelineTotal;
+    const next = {
+      ...snapshot,
+      timeline: [...snapshot.timeline, ...more],
+      timelineCursor: nextCursor(page),
+      ...timelineTotal !== undefined ? { timelineTotal } : {}
+    };
+    patchData(ctx, { runDetail: next, lastRefreshError: undefined });
+    emitCompleted(ctx, label, { runId: cleanRunId, added: more.length, timeline: next.timeline.length });
+    return next;
+  } catch (error) {
+    emitFailed(ctx, label, error, { runId: cleanRunId });
+    throw error;
+  }
+}
+function steerResultSummary(result) {
+  for (const key of ["status", "state", "message", "detail"]) {
+    const value = result[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  if (result.ok === true || result.queued === true || result.delivered === true)
+    return "accepted by run";
+  return "delivered";
+}
 async function steerRunFromApp(ctx, input) {
   const label = `Steering ${input.runId.slice(0, 8)}`;
   const message = input.message.trim();
@@ -918,17 +964,21 @@ async function steerRunFromApp(ctx, input) {
     emitFailed(ctx, label, error, { runId: input.runId });
     throw error;
   }
-  emitStarted(ctx, label, { runMessage: { runId: input.runId, text: message, status: "queued" } });
-  patchData(ctx, { pendingRunMessage: { runId: input.runId, text: message, status: "queued" } });
+  const pending = { runId: input.runId, text: message, status: "queued" };
+  emitStarted(ctx, label, { pendingRunMessage: pending });
+  patchData(ctx, { pendingRunMessage: pending });
   try {
     const { sendRunPiPromptViaServer: sendRunPiPromptViaServer2, steerRunViaServer: steerRunViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const context = { projectRoot: projectRootOf(ctx) };
     const result = await sendRunPiPromptViaServer2(context, input.runId, message, "steer").catch(() => steerRunViaServer2(context, input.runId, message));
+    const summary = steerResultSummary(result);
+    patchData(ctx, { pendingRunMessage: { runId: input.runId, text: message, status: "sent", result: summary } });
     emitCompleted(ctx, label, { runId: input.runId, result });
-    patchData(ctx, { pendingRunMessage: null });
     return result;
   } catch (error) {
-    emitFailed(ctx, label, error, { runId: input.runId, revert: { pendingRunMessage: null } });
+    const message2 = normalizeAppError(error).message;
+    emitFailed(ctx, label, error, { runId: input.runId });
+    patchData(ctx, { pendingRunMessage: { runId: input.runId, text: message, status: "failed", result: message2 } });
     throw error;
   }
 }
@@ -942,7 +992,10 @@ async function stopRunFromDetail(ctx, runId) {
     const { stopRunViaServer: stopRunViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const result = await stopRunViaServer2({ projectRoot: projectRootOf(ctx) }, cleanRunId);
     emitCompleted(ctx, label, { runId: cleanRunId, result });
-    await loadRunDetail(ctx, cleanRunId).catch(() => null);
+    await loadRunDetail(ctx, cleanRunId).catch((error) => {
+      patchData(ctx, { lastRefreshError: normalizeAppError(error).message });
+      return null;
+    });
     return result;
   } catch (error) {
     emitFailed(ctx, label, error, { runId: cleanRunId, revert: { status: "unknown" } });
@@ -953,5 +1006,5 @@ export {
   stopRunFromDetail,
   steerRunFromApp,
   loadRunDetail,
-  createRunDetailAdapter
+  loadMoreRunTimeline
 };

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

@@ -1,6 +1,4 @@
-import type { AppAdapter } from "../types";
 import { type AppAdapterContext } from "./common";
-export declare function createServerAdapter(): AppAdapter;
 export type AppServerState = {
     readonly label: string;
     readonly baseUrl?: string;
@@ -11,4 +9,14 @@ export type AppServerState = {
     readonly auth?: Record<string, unknown>;
     readonly error?: string;
 };
+/** Start the local Rig server DETACHED and return to the server scene (bug #3).
+ *
+ * `rig server start` is a blocking long-running process; running it through the
+ * foreground command PTY traps the operator (kitty-mode even swallows ctrl-c).
+ * Instead we: (a) switch this repo's connection to local, (b) spawn the server
+ * detached + wait for ready via ensureLocalRigServerConnection (it writes the
+ * published server state and unrefs the child), then (c) re-probe. The operator
+ * is never blocked: this returns once the detached server answers.
+ */
+export declare function startLocalServerFromApp(ctx: AppAdapterContext): Promise<AppServerState>;
 export declare function refreshServerStatus(ctx: AppAdapterContext): Promise<AppServerState>;

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();
 });
@@ -767,15 +796,6 @@ 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())
@@ -799,20 +819,7 @@ 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;
-      }
-      return false;
-    }
-  };
-}
+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);
@@ -825,7 +832,69 @@ function withTimeout(promise, ms, label) {
     });
   });
 }
+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));
+      }
+    }
+  }
+  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" } });
@@ -840,8 +909,8 @@ async function refreshServerStatus(ctx) {
     ]);
     emitProgress(ctx, label, "requesting server status", { baseUrl: server.baseUrl, kind: server.connectionKind });
     const [status, auth] = await Promise.all([
-      withTimeout(requestServerJson2({ projectRoot }, "/api/server/status"), 5000, "server status").catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) })),
-      withTimeout(requestServerJson2({ projectRoot }, "/api/github/auth/status"), 5000, "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,
@@ -870,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";