pi-fancy-footer 1.3.0 → 1.3.2

package/README.md

@@ -276,9 +276,10 @@ Notes:
   from `~/.pi/agent/auth.json`, falling back to Codex CLI credentials in
   `~/.codex/auth.json`. Claude uses pi Anthropic OAuth credentials from
   `~/.pi/agent/auth.json` and reads Claude.ai usage for the 5-hour and weekly
-  windows. Status is cached under `~/.cache/pi-fancy-footer/provider-status/`.
-  The widget is hidden when the active model selection is not backed by the
-  status provider.
+  windows. Status is cached under `~/.cache/pi-fancy-footer/provider-status/`;
+  when a refresh fails, cached quota windows keep showing until their reset times
+  pass instead of hiding the widget. The widget is hidden when the active model
+  selection is not backed by the status provider.
 - `provider-status` also refreshes from `x-codex-*` provider response headers
   when pi exposes them, avoiding a separate Codex status request after provider
   calls. Claude status refreshes from the Claude.ai usage endpoint, not
@@ -289,13 +290,15 @@ Notes:
   work better in terminals that don't use a Nerd Font.
 - Per-widget icon overrides only let you hide the icon. The selected
   `iconFamily` controls which icon each widget uses.
-- The PR widgets appear only for open GitHub pull requests and rely on the
-  GitHub CLI (`gh`) being available and authenticated.
+- The PR widgets appear only for open GitHub and GitHub Enterprise pull
+  requests on GitHub-style hosts such as `github.example.com`; they rely on the
+  GitHub CLI (`gh`) being available and authenticated for the remote host.
 - `pull-request-review-threads` counts unresolved GitHub review threads
   on the current PR.
 - `pull-request-ci-status` shows GitHub Actions workflow runs for the current
   PR head commit. It links to the relevant run and switches to failed as soon as
   one workflow fails, even when other workflows are still running.
+
 ## 🧱 Gauge styles
 
 The `gaugeStyle` setting controls the characters used by the `context-bar`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fancy-footer",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "A fancy footer extension for pi",
   "type": "module",
   "peerDependencies": {

package/src/ci.test.ts

@@ -76,6 +76,13 @@ test("buildWorkflowRunsPath creates GitHub Actions runs endpoint", () => {
     buildWorkflowRunsPath("https://github.com/org/repo/pull/42", "abc123"),
     "repos/org/repo/actions/runs?head_sha=abc123&per_page=100",
   );
+  assert.equal(
+    buildWorkflowRunsPath(
+      "https://github.example.com/org/repo/pull/42",
+      "abc123",
+    ),
+    "repos/org/repo/actions/runs?head_sha=abc123&per_page=100",
+  );
   assert.equal(
     buildWorkflowRunsPath("https://example.com/x/y/pull/1", "abc"),
     undefined,

package/src/git.test.ts

@@ -129,6 +129,7 @@ test("collectPullRequestInfo ignores foreign branch-name matches and falls back
   assert.deepEqual(result.pullRequest, {
     number: 7,
     url: "https://github.com/org/repo/pull/7",
+    host: "github.com",
   });
   assert.equal(result.pullRequestLookupEnabled, true);
   assert.notEqual(result.pullRequestLookupAt, 0);
@@ -223,6 +224,7 @@ test("collectPullRequestInfo includes unresolved review thread count", async ()
   assert.deepEqual(result.pullRequest, {
     number: 12,
     url: "https://github.com/me/repo/pull/12",
+    host: "github.com",
     unresolvedReviewThreadCount: 2,
   });
 });
@@ -271,7 +273,9 @@ test("collectPullRequestInfo includes PR CI status when requested", async () =>
     if (
       command === "gh" &&
       args[0] === "api" &&
-      args[1] === "repos/me/repo/actions/runs?head_sha=abc123&per_page=100"
+      args[1] === "--hostname" &&
+      args[2] === "github.com" &&
+      args[3] === "repos/me/repo/actions/runs?head_sha=abc123&per_page=100"
     ) {
       return {
         code: 0,
@@ -306,6 +310,7 @@ test("collectPullRequestInfo includes PR CI status when requested", async () =>
   assert.deepEqual(result.pullRequest, {
     number: 12,
     url: "https://github.com/me/repo/pull/12",
+    host: "github.com",
     headRefOid: "abc123",
     ciStatus: {
       state: "failed",
@@ -314,6 +319,128 @@ test("collectPullRequestInfo includes PR CI status when requested", async () =>
   });
 });
 
+test("collectPullRequestInfo uses the GitHub Enterprise host for API calls", async () => {
+  const { pi, calls } = createPi(({ command, args }) => {
+    if (command === "git" && gitSubcommand(args) === "rev-parse") {
+      return { code: 0, stdout: "origin/feature\n", stderr: "" };
+    }
+
+    if (command === "git" && gitSubcommand(args) === "config") {
+      return {
+        code: 0,
+        stdout: "remote.origin.url git@github.example.com:me/repo.git",
+        stderr: "",
+      };
+    }
+
+    if (
+      command === "gh" &&
+      args[0] === "api" &&
+      args[1] === "graphql" &&
+      args[2] === "--hostname" &&
+      args[3] === "github.example.com" &&
+      args.includes("branch=feature")
+    ) {
+      return {
+        code: 0,
+        stdout: JSON.stringify({
+          data: {
+            repository: {
+              pullRequests: {
+                nodes: [
+                  {
+                    number: 12,
+                    url: "https://github.example.com/me/repo/pull/12",
+                    headRefOid: "abc123",
+                    headRepositoryOwner: { login: "me" },
+                  },
+                ],
+              },
+            },
+          },
+        }),
+        stderr: "",
+      };
+    }
+
+    if (
+      command === "gh" &&
+      args[0] === "api" &&
+      args[1] === "graphql" &&
+      args[2] === "--hostname" &&
+      args[3] === "github.example.com" &&
+      args.includes("number=12")
+    ) {
+      return {
+        code: 0,
+        stdout: JSON.stringify({
+          data: {
+            repository: {
+              pullRequest: {
+                reviewThreads: {
+                  pageInfo: {
+                    hasNextPage: false,
+                    endCursor: null,
+                  },
+                  nodes: [{ isResolved: false }],
+                },
+              },
+            },
+          },
+        }),
+        stderr: "",
+      };
+    }
+
+    if (
+      command === "gh" &&
+      args[0] === "api" &&
+      args[1] === "--hostname" &&
+      args[2] === "github.example.com" &&
+      args[3] === "repos/me/repo/actions/runs?head_sha=abc123&per_page=100"
+    ) {
+      return {
+        code: 0,
+        stdout: JSON.stringify({
+          workflow_runs: [
+            {
+              status: "completed",
+              conclusion: "success",
+              html_url: "https://github.example.com/me/repo/actions/runs/1",
+              updated_at: "2026-01-01T10:00:00Z",
+            },
+          ],
+        }),
+        stderr: "",
+      };
+    }
+
+    throw new Error(`Unexpected command: ${command} ${args.join(" ")}`);
+  });
+
+  const result = await collectPullRequestInfo(pi as never, "/repo", "feature", {
+    includeCiStatus: true,
+  });
+
+  assert.deepEqual(result.pullRequest, {
+    number: 12,
+    url: "https://github.example.com/me/repo/pull/12",
+    host: "github.example.com",
+    headRefOid: "abc123",
+    unresolvedReviewThreadCount: 1,
+    ciStatus: {
+      state: "okay",
+      url: "https://github.example.com/me/repo/actions/runs/1",
+    },
+  });
+  assert.equal(
+    calls
+      .filter((call) => call.command === "gh" && call.args[0] === "api")
+      .every((call) => call.args.includes("github.example.com")),
+    true,
+  );
+});
+
 test("collectPullRequestInfo skips GitHub CLI lookups when the repository has no GitHub remote", async () => {
   const { pi, calls } = createPi(({ command, args }) => {
     if (command === "git" && gitSubcommand(args) === "rev-parse") {

package/src/git.ts

@@ -6,10 +6,10 @@ import {
   parsePullRequest,
   parsePullRequestReviewThreadsPage,
   selectPullRequestFromGraphQL,
-  splitGitHubRepository,
 } from "./pull-request.ts";
 import {
   EMPTY_GIT_INFO,
+  type GitHubRepositoryRef,
   type GitInfo,
   parseNumstat,
   toNumber,
@@ -117,12 +117,11 @@ async function execGit(
 async function collectPullRequestFromBaseRepository(
   pi: ExtensionAPI,
   cwd: string,
-  baseRepository: string,
+  baseRepository: GitHubRepositoryRef,
   branch: string,
   headOwners: string[],
 ): Promise<GitInfo["pullRequest"]> {
-  const repository = splitGitHubRepository(baseRepository);
-  if (!repository || !branch) return undefined;
+  if (!branch) return undefined;
 
   const result = await execResult(
     pi,
@@ -130,12 +129,14 @@ async function collectPullRequestFromBaseRepository(
     [
       "api",
       "graphql",
+      "--hostname",
+      baseRepository.host,
       "-f",
       `query=${PULL_REQUEST_QUERY}`,
       "-F",
-      `owner=${repository.owner}`,
+      `owner=${baseRepository.owner}`,
       "-F",
-      `name=${repository.name}`,
+      `name=${baseRepository.name}`,
       "-F",
       `branch=${branch}`,
     ],
@@ -144,7 +145,9 @@ async function collectPullRequestFromBaseRepository(
   );
   if (result.code !== 0 || !result.stdout) return undefined;
 
-  return selectPullRequestFromGraphQL(result.stdout, headOwners);
+  const pullRequest = selectPullRequestFromGraphQL(result.stdout, headOwners);
+  if (!pullRequest) return undefined;
+  return { ...pullRequest, host: pullRequest.host ?? baseRepository.host };
 }
 
 async function collectCurrentBranchPullRequest(
@@ -178,6 +181,8 @@ async function collectPullRequestReviewThreadCount(
     const args = [
       "api",
       "graphql",
+      "--hostname",
+      location.host,
       "-f",
       `query=${PULL_REQUEST_REVIEW_THREADS_QUERY}`,
       "-F",
@@ -221,11 +226,14 @@ async function collectPullRequestCiStatus(
     pullRequest.headRefOid ?? "",
   );
   if (!path) return undefined;
+  const location = parseGitHubPullRequestUrl(pullRequest.url);
+  const host = pullRequest.host ?? location?.host;
+  if (!host) return undefined;
 
   const result = await execResult(
     pi,
     "gh",
-    ["api", path],
+    ["api", "--hostname", host, path],
     cwd,
     GITHUB_COMMAND_TIMEOUT_MS,
   );

package/src/provider-status.test.ts

@@ -14,10 +14,7 @@ import {
   providerStatusColor,
   updateProviderStatusFromHeaders,
 } from "./provider-status.ts";
-import {
-  getGaugeStyle,
-  type ProviderStatusConfigSnapshot,
-} from "./shared.ts";
+import { getGaugeStyle, type ProviderStatusConfigSnapshot } from "./shared.ts";
 
 const now = new Date("2026-05-06T10:00:00Z");
 const providerStatusConfig: ProviderStatusConfigSnapshot = {
@@ -338,6 +335,295 @@ test("collectProviderStatus does not present expired cache as live status after
   assert.match(snapshot?.error ?? "", /No usable Codex OAuth credentials/);
 });
 
+test("collectProviderStatus keeps cached quota in effect after a failed refresh", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  globalThis.fetch = async () =>
+    new Response(JSON.stringify({ error: { message: "rate limited" } }), {
+      status: 429,
+    });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({ anthropic: { access: "test-access-token" } }),
+    { mode: 0o600 },
+  );
+
+  const futureResetAt = Math.ceil(Date.now() / 1000) + 3_600;
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: {
+        label: "5h",
+        usedPercent: 5,
+        leftPercent: 95,
+        resetAt: futureResetAt,
+      },
+      secondary: {
+        label: "7d",
+        usedPercent: 12,
+        leftPercent: 88,
+        resetAt: futureResetAt,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "cache");
+  assert.equal(snapshot?.state, "ok");
+  assert.deepEqual(snapshot?.primary, {
+    label: "5h",
+    usedPercent: 5,
+    leftPercent: 95,
+    resetAt: futureResetAt,
+  });
+  assert.deepEqual(snapshot?.secondary, {
+    label: "7d",
+    usedPercent: 12,
+    leftPercent: 88,
+    resetAt: futureResetAt,
+  });
+  assert.match(snapshot?.error ?? "", /429/);
+});
+
+test("collectProviderStatus hides cached quota once its windows reset", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  globalThis.fetch = async () => new Response("rate limited", { status: 429 });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({ anthropic: { access: "test-access-token" } }),
+    { mode: 0o600 },
+  );
+
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: { label: "5h", usedPercent: 5, leftPercent: 95, resetAt: 1 },
+      secondary: {
+        label: "7d",
+        usedPercent: 12,
+        leftPercent: 88,
+        resetAt: 1,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "api");
+  assert.equal(snapshot?.state, "unavailable");
+  assert.equal(snapshot?.primary, undefined);
+  assert.equal(snapshot?.secondary, undefined);
+  assert.match(snapshot?.error ?? "", /429/);
+});
+
+test("collectProviderStatus keeps cached quota in effect after a failed auth refresh", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  globalThis.fetch = async () => new Response("rate limited", { status: 429 });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({
+      anthropic: {
+        access: "expired-access-token",
+        refresh: "test-refresh-token",
+        expires: Date.now() - 60_000,
+      },
+    }),
+    { mode: 0o600 },
+  );
+
+  const futureResetAt = Math.ceil(Date.now() / 1000) + 3_600;
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: {
+        label: "5h",
+        usedPercent: 5,
+        leftPercent: 95,
+        resetAt: futureResetAt,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "cache");
+  assert.equal(snapshot?.state, "ok");
+  assert.equal(snapshot?.primary?.resetAt, futureResetAt);
+  assert.match(snapshot?.error ?? "", /429/);
+});
+
+test("collectProviderStatus keeps cached quota in effect regardless of the failure cause", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  // A non-retryable failure (e.g. revoked credentials) must not invalidate a
+  // quota window that has not reset yet.
+  globalThis.fetch = async () => new Response("forbidden", { status: 403 });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({ anthropic: { access: "test-access-token" } }),
+    { mode: 0o600 },
+  );
+
+  const futureResetAt = Math.ceil(Date.now() / 1000) + 3_600;
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: {
+        label: "5h",
+        usedPercent: 5,
+        leftPercent: 95,
+        resetAt: futureResetAt,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "cache");
+  assert.equal(snapshot?.state, "ok");
+  assert.equal(snapshot?.primary?.resetAt, futureResetAt);
+  assert.match(snapshot?.error ?? "", /403/);
+});
+
 test("updateProviderStatusFromHeaders honors disabled providers", async () => {
   const updated = await updateProviderStatusFromHeaders(
     {

package/src/provider-status.ts

@@ -28,6 +28,10 @@ const CLAUDE_SECONDARY_WINDOW_LABEL = "7d";
 
 type HeaderLike = Record<string, string | number | boolean | undefined | null>;
 
+type TokenRefreshResult =
+  | { ok: true; stdout: string }
+  | { ok: false; error: Error };
+
 export interface ProviderStatusSource {
   id: string;
   label: string;
@@ -106,10 +110,7 @@ export function isProviderStatusRelevantToModel(
   providerId: string,
   model: ModelLike | string | undefined,
 ): boolean {
-  if (
-    providerId !== CODEX_SOURCE.id &&
-    providerId !== ANTHROPIC_SOURCE.id
-  ) {
+  if (providerId !== CODEX_SOURCE.id && providerId !== ANTHROPIC_SOURCE.id) {
     return true;
   }
 
@@ -238,20 +239,76 @@ async function collectProviderStatusFromSource(
     await writeProviderStatusCache(snapshot).catch(() => undefined);
     return snapshot;
   } catch (error) {
-    if (isProviderStatusFresh(cached, config.cacheTtlMs)) {
-      return { ...cached, source: "cache" };
-    }
-    return {
-      provider: source.id,
-      source: "api",
-      fetchedAt: new Date().toISOString(),
-      state: "unavailable",
-      url: source.usageUrl,
-      error: error instanceof Error ? error.message : String(error),
-    };
+    // A refresh failed. The cached quota windows remain valid until they
+    // reset, regardless of why the refresh failed, so keep showing whichever
+    // windows are still in effect.
+    return (
+      displayableCachedStatus(cached, error) ??
+      unavailableProviderStatus(source, error)
+    );
   }
 }
 
+// Projects a cached snapshot onto the windows that are still in effect, i.e.
+// have not reset yet. Returns undefined when nothing is left to display.
+function displayableCachedStatus(
+  cached: ProviderStatusSnapshot | undefined,
+  error: unknown,
+  now = new Date(),
+): ProviderStatusSnapshot | undefined {
+  if (!cached) return undefined;
+
+  const primary = windowInEffect(cached.primary, now);
+  const secondary = windowInEffect(cached.secondary, now);
+  if (!primary && !secondary) return undefined;
+
+  const {
+    primary: _expiredPrimary,
+    secondary: _expiredSecondary,
+    ...rest
+  } = cached;
+  return {
+    ...rest,
+    source: "cache",
+    state: computeProviderStatusState(primary, secondary),
+    ...(primary ? { primary } : {}),
+    ...(secondary ? { secondary } : {}),
+    error: providerStatusErrorMessage(error),
+  };
+}
+
+// A window is in effect while its reset time is still in the future. Windows
+// without a reset time have no intrinsic lifetime, so they are not shown once
+// the refresh that would confirm them has failed.
+function windowInEffect(
+  window: ProviderStatusWindow | undefined,
+  now: Date,
+): ProviderStatusWindow | undefined {
+  if (!window?.resetAt) return undefined;
+  const resetAtMs = window.resetAt * 1000;
+  return Number.isFinite(resetAtMs) && resetAtMs > now.getTime()
+    ? window
+    : undefined;
+}
+
+function unavailableProviderStatus(
+  source: ProviderStatusSource,
+  error: unknown,
+): ProviderStatusSnapshot {
+  return {
+    provider: source.id,
+    source: "api",
+    fetchedAt: new Date().toISOString(),
+    state: "unavailable",
+    url: source.usageUrl,
+    error: providerStatusErrorMessage(error),
+  };
+}
+
+function providerStatusErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export async function updateProviderStatusFromHeaders(
   headers: HeaderLike,
   config?: ProviderStatusConfigSnapshot,
@@ -495,7 +552,9 @@ async function resolveClaudeAuth(): Promise<AuthCredentials> {
   );
 }
 
-async function refreshIfNeeded(auth: AuthCredentials): Promise<AuthCredentials> {
+async function refreshIfNeeded(
+  auth: AuthCredentials,
+): Promise<AuthCredentials> {
   if (!auth.refreshToken || !auth.expiresAtMs) return auth;
   if (auth.expiresAtMs > Date.now() + 5 * 60 * 1000) return auth;
   return refreshAuth(auth);
@@ -522,12 +581,15 @@ async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
     client_id: refreshConfig.clientId,
   }).toString();
 
-  const result = await localRefresh(body, refreshConfig.tokenUrl);
+  const result = await requestTokenRefresh(
+    body,
+    refreshConfig.tokenUrl,
+    `${refreshConfig.label} auth refresh`,
+  );
 
-  if (result.code !== 0 || !result.stdout) {
-    throw new Error(
-      result.stderr || `Failed to refresh ${refreshConfig.label} auth`,
-    );
+  if (!result.ok) throw result.error;
+  if (!result.stdout) {
+    throw new Error(`Failed to refresh ${refreshConfig.label} auth`);
   }
 
   const refreshed = JSON.parse(result.stdout) as Record<string, unknown>;
@@ -538,7 +600,8 @@ async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
     );
   }
 
-  const refreshToken = stringValue(refreshed.refresh_token) ?? auth.refreshToken;
+  const refreshToken =
+    stringValue(refreshed.refresh_token) ?? auth.refreshToken;
   const expiresIn = numberValue(refreshed.expires_in);
   const next: AuthCredentials = {
     ...auth,
@@ -552,10 +615,11 @@ async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
   return next;
 }
 
-async function localRefresh(
+async function requestTokenRefresh(
   body: string,
   tokenUrl: string,
-): Promise<{ code: number; stdout: string; stderr: string }> {
+  label: string,
+): Promise<TokenRefreshResult> {
   try {
     const response = await fetch(tokenUrl, {
       method: "POST",
@@ -563,13 +627,19 @@ async function localRefresh(
       body,
     });
     const text = await response.text();
-    if (!response.ok) return { code: 1, stdout: "", stderr: text };
-    return { code: 0, stdout: text, stderr: "" };
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: new Error(
+          `${label} failed (${response.status}): ${text.slice(0, 500)}`,
+        ),
+      };
+    }
+    return { ok: true, stdout: text };
   } catch (error) {
     return {
-      code: -1,
-      stdout: "",
-      stderr: error instanceof Error ? error.message : String(error),
+      ok: false,
+      error: error instanceof Error ? error : new Error(String(error)),
     };
   }
 }
@@ -705,7 +775,7 @@ function mergeProviderStatus(
     ...update,
     ...(primary ? { primary } : {}),
     ...(secondary ? { secondary } : {}),
-    ...(update.credits ?? existing.credits
+    ...((update.credits ?? existing.credits)
       ? { credits: update.credits ?? existing.credits }
       : {}),
     state: computeProviderStatusState(primary, secondary),
@@ -762,7 +832,9 @@ function normalizeClaudeUsageWindow(
   );
 }
 
-function windowLabelFromSeconds(seconds: number | undefined): string | undefined {
+function windowLabelFromSeconds(
+  seconds: number | undefined,
+): string | undefined {
   if (seconds === undefined || seconds <= 0) return undefined;
   if (seconds % 86_400 === 0) return `${seconds / 86_400}d`;
   if (seconds % 3_600 === 0) return `${seconds / 3_600}h`;
@@ -854,7 +926,9 @@ function stringValue(value: unknown): string | undefined {
 }
 
 function numberValue(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
 }
 
 function numberString(value: string | undefined): number | undefined {

package/src/pull-request.test.ts

@@ -19,16 +19,84 @@ test("createGitHubRepositoryContext derives repository and PR lookup plan from r
   assert.equal(context.repository, "me/repo");
   assert.equal(context.pullRequestLookupEnabled, true);
   assert.deepEqual(context.pullRequestLookupPlan, {
-    baseRepositories: ["org/repo", "me/repo"],
+    baseRepositories: [
+      {
+        host: "github.com",
+        owner: "org",
+        name: "repo",
+        repository: "org/repo",
+      },
+      {
+        host: "github.com",
+        owner: "me",
+        name: "repo",
+        repository: "me/repo",
+      },
+    ],
     headOwners: ["me", "org"],
     allowCurrentBranchFallback: true,
   });
 });
 
+test("createGitHubRepositoryContext supports GitHub Enterprise hosts", () => {
+  const context = createGitHubRepositoryContext(
+    "remote.origin.url git@github.example.com:org/repo.git",
+    "origin/main",
+  );
+
+  assert.equal(context.repository, "org/repo");
+  assert.equal(context.pullRequestLookupEnabled, true);
+  assert.deepEqual(context.pullRequestLookupPlan, {
+    baseRepositories: [
+      {
+        host: "github.example.com",
+        owner: "org",
+        name: "repo",
+        repository: "org/repo",
+      },
+    ],
+    headOwners: ["org"],
+    allowCurrentBranchFallback: true,
+  });
+});
+
+test("createGitHubRepositoryContext supports GitHub Enterprise SSH URLs with ports", () => {
+  const context = createGitHubRepositoryContext(
+    "remote.origin.url ssh://git@github.example.com:2222/org/repo.git",
+    "origin/main",
+  );
+
+  assert.equal(context.repository, "org/repo");
+  assert.deepEqual(context.pullRequestLookupPlan?.baseRepositories, [
+    {
+      host: "github.example.com",
+      owner: "org",
+      name: "repo",
+      repository: "org/repo",
+    },
+  ]);
+});
+
+test("createGitHubRepositoryContext excludes non-GitHub hosts", () => {
+  const context = createGitHubRepositoryContext(
+    [
+      "remote.origin.url git@notgithub.com:org/repo.git",
+      "remote.upstream.url https://gitlab.githubmirror.com/org/repo.git",
+      "remote.fork.url https://gitlab.com/org/repo.git",
+    ].join("\n"),
+    "origin/main",
+  );
+
+  assert.equal(context.repository, "");
+  assert.equal(context.pullRequestLookupEnabled, false);
+  assert.equal(context.pullRequestLookupPlan, undefined);
+});
+
 test("parseGitHubPullRequestUrl extracts owner, repository, and PR number", () => {
   assert.deepEqual(
     parseGitHubPullRequestUrl("https://github.com/org/repo/pull/42"),
     {
+      host: "github.com",
       owner: "org",
       name: "repo",
       number: 42,
@@ -39,6 +107,16 @@ test("parseGitHubPullRequestUrl extracts owner, repository, and PR number", () =
       "https://github.com/org/repo/pull/42#discussion_r1",
     ),
     {
+      host: "github.com",
+      owner: "org",
+      name: "repo",
+      number: 42,
+    },
+  );
+  assert.deepEqual(
+    parseGitHubPullRequestUrl("https://github.example.com/org/repo/pull/42"),
+    {
+      host: "github.example.com",
       owner: "org",
       name: "repo",
       number: 42,
@@ -103,6 +181,7 @@ test("selectPullRequestFromGraphQL accepts only candidates from known head owner
   assert.deepEqual(selectPullRequestFromGraphQL(output, ["me", "org"]), {
     number: 7,
     url: "https://github.com/org/repo/pull/7",
+    host: "github.com",
   });
   assert.equal(selectPullRequestFromGraphQL(output, ["unknown"]), undefined);
 });

package/src/pull-request.ts

@@ -1,13 +1,13 @@
 import {
   type GitHubPullRequest,
+  type GitHubRepositoryRef,
   parseGitHubRemote,
   toNumber,
 } from "./shared.ts";
 
 interface GitHubRemote {
   name: string;
-  repository: string;
-  owner: string;
+  ref: GitHubRepositoryRef;
 }
 
 interface PullRequestCandidate {
@@ -18,6 +18,7 @@ interface PullRequestCandidate {
 }
 
 export interface GitHubPullRequestLocation {
+  host: string;
   owner: string;
   name: string;
   number: number;
@@ -30,7 +31,7 @@ export interface PullRequestReviewThreadsPage {
 }
 
 export interface PullRequestLookupPlan {
-  baseRepositories: string[];
+  baseRepositories: GitHubRepositoryRef[];
   headOwners: string[];
   allowCurrentBranchFallback: boolean;
 }
@@ -61,21 +62,13 @@ function parseRemoteName(ref: string): string {
   return ref.slice(0, slash);
 }
 
-function parseRepositoryOwner(repository: string): string {
-  const slash = repository.indexOf("/");
-  if (slash <= 0) return "";
-  return repository.slice(0, slash);
-}
-
 function parseGitHubRemotes(remoteUrls: string): GitHubRemote[] {
   const remotes: GitHubRemote[] = [];
 
   for (const [name, url] of parseRemoteUrls(remoteUrls)) {
-    const repository = parseGitHubRemote(url);
-    if (!repository) continue;
-    const owner = parseRepositoryOwner(repository);
-    if (!owner) continue;
-    remotes.push({ name, repository, owner });
+    const ref = parseGitHubRemote(url);
+    if (!ref) continue;
+    remotes.push({ name, ref });
   }
 
   return remotes;
@@ -85,6 +78,7 @@ function orderedRemoteValues<T>(
   remotes: GitHubRemote[],
   preferredNames: string[],
   pick: (remote: GitHubRemote) => T,
+  keyFor: (value: T) => string = String,
 ): T[] {
   const byName = new Map(remotes.map((remote) => [remote.name, remote]));
   const ordered: T[] = [];
@@ -98,7 +92,7 @@ function orderedRemoteValues<T>(
     const remote = byName.get(remoteName);
     if (!remote) continue;
     const value = pick(remote);
-    const key = String(value);
+    const key = keyFor(value);
     if (!key || seen.has(key)) continue;
     seen.add(key);
     ordered.push(value);
@@ -115,7 +109,7 @@ function selectGitHubRepository(
     orderedRemoteValues(
       remotes,
       [preferredRemote, "origin", "upstream"],
-      (remote) => remote.repository,
+      (remote) => remote.ref.repository,
     )[0] ?? ""
   );
 }
@@ -123,12 +117,13 @@ function selectGitHubRepository(
 function selectPullRequestBaseRepositories(
   remotes: GitHubRemote[],
   preferredRemote: string,
-): string[] {
+): GitHubRepositoryRef[] {
   // PRs often live in the upstream repo even when the branch tracks a fork remote.
   return orderedRemoteValues(
     remotes,
     ["upstream", preferredRemote, "origin"],
-    (remote) => remote.repository,
+    (remote) => remote.ref,
+    (ref) => `${ref.host}/${ref.repository}`,
   );
 }
 
@@ -139,7 +134,7 @@ function selectPullRequestHeadOwners(
   return orderedRemoteValues(
     remotes,
     [preferredRemote, "origin", "upstream"],
-    (remote) => remote.owner,
+    (remote) => remote.ref.owner,
   );
 }
 
@@ -178,9 +173,12 @@ function selectPullRequest(
 
   if (!bestCandidate) return undefined;
 
+  const location = parseGitHubPullRequestUrl(bestCandidate.url);
+
   return {
     number: bestCandidate.number,
     url: bestCandidate.url,
+    ...(location ? { host: location.host } : {}),
     ...(bestCandidate.headRefOid
       ? { headRefOid: bestCandidate.headRefOid }
       : {}),
@@ -244,17 +242,6 @@ export function createGitHubRepositoryContext(
   };
 }
 
-export function splitGitHubRepository(
-  repository: string,
-): { owner: string; name: string } | undefined {
-  const slash = repository.indexOf("/");
-  if (slash <= 0 || slash >= repository.length - 1) return undefined;
-  return {
-    owner: repository.slice(0, slash),
-    name: repository.slice(slash + 1),
-  };
-}
-
 export function parsePullRequest(
   output: string,
 ): GitHubPullRequest | undefined {
@@ -269,7 +256,13 @@ export function parsePullRequest(
     const headRefOid =
       typeof parsed?.headRefOid === "string" ? parsed.headRefOid : undefined;
     if (number <= 0 || !url) return undefined;
-    return { number, url, ...(headRefOid ? { headRefOid } : {}) };
+    const location = parseGitHubPullRequestUrl(url);
+    return {
+      number,
+      url,
+      ...(location ? { host: location.host } : {}),
+      ...(headRefOid ? { headRefOid } : {}),
+    };
   } catch {
     return undefined;
   }
@@ -279,14 +272,15 @@ export function parseGitHubPullRequestUrl(
   url: string,
 ): GitHubPullRequestLocation | undefined {
   const match = url.match(
-    /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:[/?#].*)?$/,
+    /^https:\/\/([^/]+)\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:[/?#].*)?$/,
   );
   if (!match) return undefined;
 
-  const [, owner, name, numberText] = match;
+  const [, rawHost, owner, name, numberText] = match;
+  const hostRef = parseGitHubRemote(`https://${rawHost}/${owner}/${name}.git`);
   const number = Math.max(0, Math.floor(toNumber(numberText)));
-  if (!owner || !name || number <= 0) return undefined;
-  return { owner, name, number };
+  if (!hostRef || number <= 0) return undefined;
+  return { host: hostRef.host, owner, name, number };
 }
 
 export function parsePullRequestReviewThreadsPage(

package/src/shared.ts

@@ -272,6 +272,7 @@ export interface ProviderStatusSnapshot {
 export interface GitHubPullRequest {
   number: number;
   url: string;
+  host?: string;
   headRefOid?: string;
   unresolvedReviewThreadCount?: number;
   ciStatus?: {
@@ -280,6 +281,13 @@ export interface GitHubPullRequest {
   };
 }
 
+export interface GitHubRepositoryRef {
+  host: string;
+  owner: string;
+  name: string;
+  repository: string;
+}
+
 export interface GitInfo {
   repository: string;
   branch: string;
@@ -761,9 +769,40 @@ export function formatThinkingLevel(level: string): string {
   return normalized;
 }
 
-export function parseGitHubRemote(url: string): string {
-  const match = url.match(/github\.com[:/](.+\/.+?)(?:\.git)?$/);
-  return match?.[1] ?? "";
+function parseGitHubHost(host: string): string {
+  const normalized = host.toLowerCase();
+  if (normalized === "github.com") return normalized;
+  if (/^github(?:[.-][a-z0-9][a-z0-9-]*)+\.[a-z]{2,}$/i.test(normalized)) {
+    return normalized;
+  }
+  return "";
+}
+
+export function parseGitHubRemote(url: string): GitHubRepositoryRef | undefined {
+  const trimmed = url.trim();
+  const scpLike = trimmed.includes("://")
+    ? undefined
+    : trimmed.match(/^.+@([^:/]+):([^/][^:]*\/[^:]+)$/);
+  const urlLike = trimmed.match(
+    /^(?:https?:\/\/|ssh:\/\/.+@)([^/:]+)(?::\d+)?\/(.+\/.+)$/,
+  );
+  const match = scpLike ?? urlLike;
+  if (!match) return undefined;
+
+  const [, rawHost, rawRepository] = match;
+  const host = parseGitHubHost(rawHost ?? "");
+  if (!host || !rawRepository) return undefined;
+
+  const repository = rawRepository.replace(/\.git$/i, "");
+  const slash = repository.indexOf("/");
+  if (slash <= 0 || slash >= repository.length - 1) return undefined;
+
+  return {
+    host,
+    owner: repository.slice(0, slash),
+    name: repository.slice(slash + 1),
+    repository,
+  };
 }
 
 export function formatTerminalHyperlink(url: string, text: string): string {