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

package/dist/src/commands/_inprocess-services.d.ts

@@ -0,0 +1,33 @@
+import { saveGitHubTokenForProject, type GitHubAuthStatus } from "@rig/runtime/control-plane/github/index";
+export type GitHubAuthStatusResponse = {
+    readonly ok: true;
+} & GitHubAuthStatus;
+export type GitHubTokenPostResponse = Awaited<ReturnType<typeof saveGitHubTokenForProject>> & {
+    readonly authenticated: boolean;
+    readonly apiSessionToken: string;
+};
+export declare function setGitHubBearerTokenForCurrentProcess(token: string | null, projectRoot?: string): void;
+export declare function getGitHubAuthStatusInProcess(context: {
+    projectRoot: string;
+}): Promise<GitHubAuthStatusResponse>;
+export declare function postGitHubTokenInProcess(context: {
+    projectRoot: string;
+}, token: string, options?: {
+    readonly selectedRepo?: string;
+    readonly projectRoot?: string;
+}): Promise<GitHubTokenPostResponse>;
+export declare function listGitHubProjectsInProcess(context: {
+    projectRoot: string;
+}, owner: string, options?: {
+    readonly authToken?: string | null;
+    readonly baseUrl?: string | null;
+}): Promise<Record<string, unknown>>;
+export declare function getGitHubProjectStatusFieldInProcess(context: {
+    projectRoot: string;
+}, projectId: string, options?: {
+    readonly authToken?: string | null;
+    readonly baseUrl?: string | null;
+}): Promise<Record<string, unknown>>;
+export declare function requestGitHubAuthJsonInProcess(context: {
+    projectRoot: string;
+}, pathname: string, init?: RequestInit): Promise<unknown>;

package/dist/src/commands/_inprocess-services.js

@@ -0,0 +1,102 @@
+// @bun
+// packages/cli/src/commands/_inprocess-services.ts
+import { resolve } from "path";
+import {
+  beginGitHubDeviceFlow,
+  checkGitHubRepoPermissions,
+  createGitHubAuthStore,
+  listGitHubProjects,
+  pollGitHubDeviceFlow,
+  resolveGitHubAuthStatus,
+  resolveProjectStatusField,
+  saveGitHubTokenForProject
+} from "@rig/runtime/control-plane/github/index";
+var scopedGitHubBearerTokens = new Map;
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function cleanString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function oauthClientId() {
+  return cleanToken(process.env.RIG_GITHUB_OAUTH_CLIENT_ID);
+}
+function tokenForProject(projectRoot, override) {
+  const scoped = scopedGitHubBearerTokens.get(resolve(projectRoot));
+  return cleanToken(override) ?? scoped ?? createGitHubAuthStore(projectRoot).readToken() ?? cleanToken(process.env.RIG_GITHUB_TOKEN);
+}
+function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
+  scopedGitHubBearerTokens.set(resolve(projectRoot ?? process.cwd()), cleanToken(token));
+}
+async function getGitHubAuthStatusInProcess(context) {
+  return { ok: true, ...resolveGitHubAuthStatus({ projectRoot: context.projectRoot, oauthConfigured: Boolean(oauthClientId()) }) };
+}
+async function postGitHubTokenInProcess(context, token, options = {}) {
+  const targetRoot = options.projectRoot?.trim() || context.projectRoot;
+  const result = await saveGitHubTokenForProject({
+    projectRoot: targetRoot,
+    token,
+    tokenSource: "manual-token",
+    selectedRepo: options.selectedRepo ?? null
+  });
+  const store = createGitHubAuthStore(targetRoot);
+  const session = store.createApiSession();
+  if (targetRoot !== context.projectRoot) {
+    store.copyToLocalProjectRoot(context.projectRoot);
+  }
+  return { ...result, authenticated: result.signedIn, apiSessionToken: session.token };
+}
+async function listGitHubProjectsInProcess(context, owner, options = {}) {
+  const token = tokenForProject(context.projectRoot, options.authToken);
+  if (!token)
+    return { ok: false, error: "missing-token", projects: [] };
+  const projects = await listGitHubProjects({ owner, token });
+  return { ok: true, projects };
+}
+async function getGitHubProjectStatusFieldInProcess(context, projectId, options = {}) {
+  const token = tokenForProject(context.projectRoot, options.authToken);
+  if (!token)
+    return { ok: false, error: "missing-token" };
+  const field = await resolveProjectStatusField({ projectId, token });
+  return { ok: true, field };
+}
+async function requestGitHubAuthJsonInProcess(context, pathname, init = {}) {
+  const method = (init.method ?? "GET").toUpperCase();
+  if (pathname === "/api/github/auth/status")
+    return getGitHubAuthStatusInProcess(context);
+  if (pathname === "/api/github/repo/permissions") {
+    return checkGitHubRepoPermissions({ projectRoot: context.projectRoot, oauthConfigured: Boolean(oauthClientId()) });
+  }
+  if (pathname === "/api/github/auth/device/start" && method === "POST") {
+    const clientId = oauthClientId();
+    if (!clientId)
+      return { ok: false, oauthConfigured: false, error: "RIG_GITHUB_OAUTH_CLIENT_ID is not configured." };
+    const body = init.body ? JSON.parse(String(init.body)) : {};
+    return beginGitHubDeviceFlow({
+      projectRoot: context.projectRoot,
+      clientId,
+      scope: cleanString(body.scope) ?? undefined,
+      selectedRepo: cleanString(body.repoSlug)
+    });
+  }
+  if (pathname === "/api/github/auth/device/poll" && method === "POST") {
+    const clientId = oauthClientId();
+    if (!clientId)
+      return { ok: false, oauthConfigured: false, error: "RIG_GITHUB_OAUTH_CLIENT_ID is not configured." };
+    const body = init.body ? JSON.parse(String(init.body)) : {};
+    const pollId = cleanString(body.pollId);
+    if (!pollId)
+      return { ok: false, status: "error", error: "pollId is required" };
+    return pollGitHubDeviceFlow({ projectRoot: context.projectRoot, clientId, pollId, selectedRepo: cleanString(body.repoSlug) });
+  }
+  throw new Error(`No in-process GitHub auth API for ${method} ${pathname}`);
+}
+export {
+  setGitHubBearerTokenForCurrentProcess,
+  requestGitHubAuthJsonInProcess,
+  postGitHubTokenInProcess,
+  listGitHubProjectsInProcess,
+  getGitHubProjectStatusFieldInProcess,
+  getGitHubAuthStatusInProcess
+};

package/dist/src/commands/_json-output.js

@@ -7,7 +7,9 @@ import {
   RigInboxInputsOutput,
   RigRunListOutput,
   RigRunShowOutput,
+  RigServerRepairLinkOutput,
   RigServerStatusOutput,
+  RigServerUseOutput,
   RigStatsOutput,
   RigTaskListOutput,
   RigTaskShowOutput
@@ -17,7 +19,9 @@ var CLI_OUTPUT_SCHEMAS = {
   "task show": RigTaskShowOutput,
   "run list": RigRunListOutput,
   "run show": RigRunShowOutput,
+  "server use": RigServerUseOutput,
   "server status": RigServerStatusOutput,
+  "server repair-link": RigServerRepairLinkOutput,
   "inbox approvals": RigInboxApprovalsOutput,
   "inbox inputs": RigInboxInputsOutput,
   "doctor check": RigDoctorCheckOutput,

package/dist/src/commands/_lazy-reconcile.d.ts

@@ -0,0 +1,34 @@
+import { SessionManager } from "@oh-my-pi/pi-coding-agent";
+import { type CollabRegistryFilter, type CollabSessionProjection } from "@oh-my-pi/pi-coding-agent/collab/api";
+import { type RunJournalProjection, type RunSessionCustomEntry } from "@rig/contracts";
+type SessionWriter = {
+    appendCustomEntry(customType: string, data: unknown): void;
+};
+export type CollabSessionProjectionLike = Pick<CollabSessionProjection, "collab" | "customEntries" | "source"> & {
+    readonly runId?: string;
+    readonly session: Pick<CollabSessionProjection["session"], "path" | "id">;
+};
+export type ProjectRunProjection = Pick<RunJournalProjection, "status">;
+export type ProjectRunFromSession = (source: Pick<SessionManager, "getEntries"> | ReadonlyArray<RunSessionCustomEntry> | readonly unknown[], runId: string) => ProjectRunProjection;
+export type LazyReconcileFlippedRun = {
+    readonly runId: string;
+    readonly sessionPath: string;
+    readonly reason: "lazy-reconcile:dead-pid";
+};
+export type LazyReconcileResult = {
+    readonly flipped: readonly LazyReconcileFlippedRun[];
+    readonly resumable: readonly LazyReconcileFlippedRun[];
+};
+type LazyReconcileDeps = {
+    readonly listCollabSessionProjections?: (filter: CollabRegistryFilter) => Promise<readonly CollabSessionProjectionLike[]>;
+    readonly projectRunFromSession?: ProjectRunFromSession;
+    readonly processExists?: (pid: number) => boolean;
+    readonly openSession?: (sessionPath: string) => Promise<SessionWriter>;
+    readonly nowIso?: () => string;
+};
+export type LazyReconcileInput = {
+    readonly workspaceRoot: string;
+    readonly identityFilter: CollabRegistryFilter;
+};
+export declare function runLazyReconcile(input: LazyReconcileInput, deps?: LazyReconcileDeps): Promise<LazyReconcileResult>;
+export {};

package/dist/src/commands/_lazy-reconcile.js

@@ -0,0 +1,102 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli/src/commands/_lazy-reconcile.ts
+import { SessionManager } from "@oh-my-pi/pi-coding-agent";
+import {
+  listCollabSessionProjections as ompListCollabSessionProjections
+} from "@oh-my-pi/pi-coding-agent/collab/api";
+import {
+  CUSTOM_TYPE_FOR,
+  isTerminalRunStatus
+} from "@rig/contracts";
+var ACTIVE_LOCAL_RUN_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "closing-out"
+]);
+function processExists(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultProjectRunFromSession(source, runId) {
+  const mod = await import("@rig/runtime/control-plane/run-session-projection");
+  const candidate = Reflect.get(mod, "projectRunFromSession");
+  if (typeof candidate !== "function") {
+    throw new Error("@rig/runtime/control-plane/run-session-projection does not export projectRunFromSession yet; inject projectRunFromSession until RunState lands it.");
+  }
+  return candidate(source, runId);
+}
+async function defaultOpenSession(sessionPath) {
+  return await SessionManager.open(sessionPath, undefined, undefined, { suppressBreadcrumb: true });
+}
+function projectionRunId(item) {
+  if (item.runId?.trim())
+    return item.runId.trim();
+  if (item.collab?.sessionId?.trim())
+    return item.collab.sessionId.trim();
+  if (item.session.id?.trim())
+    return item.session.id.trim();
+  return null;
+}
+function isLocallyDiscovered(item) {
+  return item.source === "session-list";
+}
+function isActiveStatus(status) {
+  if (status === null)
+    return false;
+  return !isTerminalRunStatus(status);
+}
+function shouldFlip(item, status, exists) {
+  if (!isActiveStatus(status))
+    return false;
+  if (item.collab?.stale === true)
+    return true;
+  const pid = item.collab?.pid;
+  return isLocallyDiscovered(item) && pid !== undefined && ACTIVE_LOCAL_RUN_STATUSES.has(status) && !exists(pid);
+}
+function failedStatusData(status, at) {
+  return {
+    type: "status-changed",
+    from: status,
+    to: "failed",
+    reason: "lazy-reconcile:dead-pid",
+    actor: { kind: "agent" },
+    at
+  };
+}
+async function runLazyReconcile(input, deps = {}) {
+  const listProjections = deps.listCollabSessionProjections ?? ompListCollabSessionProjections;
+  const projectRun = deps.projectRunFromSession ?? defaultProjectRunFromSession;
+  const exists = deps.processExists ?? processExists;
+  const openSession = deps.openSession ?? defaultOpenSession;
+  const nowIso = deps.nowIso ?? (() => new Date().toISOString());
+  const projections = await listProjections(input.identityFilter);
+  const flipped = [];
+  for (const item of projections) {
+    const runId = projectionRunId(item);
+    const sessionPath = item.session.path || item.collab?.sessionPath || "";
+    if (!runId || !sessionPath)
+      continue;
+    const projection = await projectRun(item.customEntries, runId);
+    const status = projection.status;
+    if (status === null || !shouldFlip(item, status, exists))
+      continue;
+    const session = await openSession(sessionPath);
+    session.appendCustomEntry(CUSTOM_TYPE_FOR["status-changed"], failedStatusData(status, nowIso()));
+    flipped.push({ runId, sessionPath, reason: "lazy-reconcile:dead-pid" });
+  }
+  return { flipped, resumable: flipped };
+}
+export {
+  runLazyReconcile
+};

package/dist/src/commands/_paths.js

@@ -1,7 +1,7 @@
 // @bun
 // packages/cli/src/commands/_paths.ts
 import { resolve } from "path";
-import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+import { resolveMonorepoRoot } from "@rig/runtime/layout";
 function resolveControlPlaneMonorepoRoot(projectRoot) {
   return resolveMonorepoRoot(projectRoot);
 }

package/dist/src/commands/_pi-frontend.d.ts

@@ -1,17 +1,17 @@
 import type { RunnerContext } from "../runner";
 type AttachResult = {
-    run: Record<string, unknown>;
-    logs: Record<string, unknown>[];
-    timeline: Record<string, unknown>[];
-    timelineCursor: string | null;
-    steered: boolean;
-    rendered: string;
-    detached?: boolean;
+    readonly run: Record<string, unknown>;
+    readonly logs: Record<string, unknown>[];
+    readonly timeline: Record<string, unknown>[];
+    readonly timelineCursor: string | null;
+    readonly steered: boolean;
+    readonly rendered: string;
+    readonly detached?: boolean;
 };
+export declare function resolveOperatorDroneCwd(runId: string, homeDir?: string): string;
 /**
- * Compose the operator-session environment for the attached Pi console.
- * Exported for tests: this is the contract between `rig run attach` and the
- * pi-rig extension's context discovery (see packages/pi-rig/src/client.ts).
+ * Compose the operator-session environment used by the legacy interactive
+ * attach shim. Exported for tests that pin the env contract.
  */
 export declare function buildOperatorPiEnv(input: {
     readonly runId: string;
@@ -20,8 +20,16 @@ export declare function buildOperatorPiEnv(input: {
     readonly serverProjectRoot?: string | null;
     readonly sessionDir: string;
 }): Record<string, string>;
+export declare function shouldRequireOperatorTranscript(status: unknown): boolean;
+export declare function missingOperatorTranscriptMessage(runId: string, status: unknown): string;
+/**
+ * Run `body` in-process while RETURNING (instead of terminating) when it calls
+ * `process.exit`. Exported for unit tests that pin the guard semantics.
+ */
+export declare function runWithProcessExitGuard(body: () => Promise<unknown>): Promise<number>;
 export declare function attachRunBundledPiFrontend(context: Pick<RunnerContext, "projectRoot" | "outputMode">, input: {
     readonly runId: string;
     readonly steered?: boolean;
+    readonly returnOnQuit?: boolean;
 }): Promise<AttachResult>;
 export {};