@hellcoder/companion 0.96.0

package/server/github-pr.ts

@@ -0,0 +1,379 @@
+import { execFileSync, execSync } from "node:child_process";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface GitHubCheckStatus {
+  name: string;
+  status: string;
+  conclusion: string | null;
+}
+
+export interface GitHubPRInfo {
+  number: number;
+  title: string;
+  url: string;
+  state: "OPEN" | "CLOSED" | "MERGED";
+  isDraft: boolean;
+  reviewDecision: "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED" | null;
+  additions: number;
+  deletions: number;
+  changedFiles: number;
+  checks: GitHubCheckStatus[];
+  checksSummary: {
+    total: number;
+    success: number;
+    failure: number;
+    pending: number;
+  };
+  reviewThreads: {
+    total: number;
+    resolved: number;
+    unresolved: number;
+  };
+}
+
+export interface PRStatusResponse {
+  available: boolean;
+  pr: GitHubPRInfo | null;
+}
+
+// ─── gh CLI Detection ────────────────────────────────────────────────────────
+
+let _ghAvailable: boolean | null = null;
+
+export function isGhAvailable(): boolean {
+  if (_ghAvailable !== null) return _ghAvailable;
+  try {
+    execSync("which gh", { stdio: "pipe", timeout: 5_000 });
+    _ghAvailable = true;
+  } catch {
+    _ghAvailable = false;
+  }
+  return _ghAvailable;
+}
+
+// Exported for testing
+export function _resetGhAvailable() {
+  _ghAvailable = null;
+}
+
+// ─── Repo Slug Resolution ────────────────────────────────────────────────────
+
+const repoSlugCache = new Map<string, { slug: string | null; timestamp: number }>();
+const REPO_SLUG_TTL = 5 * 60_000; // 5 minutes
+
+function getRepoSlug(cwd: string): string | null {
+  const cached = repoSlugCache.get(cwd);
+  if (cached && Date.now() - cached.timestamp < REPO_SLUG_TTL) {
+    return cached.slug;
+  }
+  try {
+    const slug = execSync("gh repo view --json nameWithOwner --jq .nameWithOwner", {
+      cwd,
+      stdio: "pipe",
+      timeout: 10_000,
+    })
+      .toString()
+      .trim();
+    const result = slug || null;
+    repoSlugCache.set(cwd, { slug: result, timestamp: Date.now() });
+    return result;
+  } catch {
+    repoSlugCache.set(cwd, { slug: null, timestamp: Date.now() });
+    return null;
+  }
+}
+
+async function getRepoSlugAsync(cwd: string): Promise<string | null> {
+  const cached = repoSlugCache.get(cwd);
+  if (cached && Date.now() - cached.timestamp < REPO_SLUG_TTL) {
+    return cached.slug;
+  }
+  try {
+    const proc = Bun.spawn(
+      ["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"],
+      { cwd, stdout: "pipe", stderr: "pipe" },
+    );
+    const timeout = setTimeout(() => proc.kill(), 10_000);
+    const exitCode = await proc.exited;
+    clearTimeout(timeout);
+    if (exitCode !== 0) {
+      repoSlugCache.set(cwd, { slug: null, timestamp: Date.now() });
+      return null;
+    }
+    const slug = (await new Response(proc.stdout).text()).trim();
+    const result = slug || null;
+    repoSlugCache.set(cwd, { slug: result, timestamp: Date.now() });
+    return result;
+  } catch {
+    repoSlugCache.set(cwd, { slug: null, timestamp: Date.now() });
+    return null;
+  }
+}
+
+// ─── PR Data Cache ───────────────────────────────────────────────────────────
+
+const prCache = new Map<string, { data: GitHubPRInfo | null; timestamp: number; ttl: number }>();
+const PR_CACHE_TTL = 30_000; // 30 seconds (default / legacy)
+
+// Exported for testing
+export function _clearCaches() {
+  prCache.clear();
+  repoSlugCache.clear();
+  _ghAvailable = null;
+}
+
+// ─── Adaptive TTL ───────────────────────────────────────────────────────────
+
+/** Compute polling interval based on PR state. */
+export function computeAdaptiveTTL(pr: GitHubPRInfo | null): number {
+  if (!pr) return 60_000; // No PR found — check again in 60s
+
+  // Merged or closed — terminal state, rarely changes
+  if (pr.state === "MERGED" || pr.state === "CLOSED") return 300_000; // 5 minutes
+
+  // CI actively running (pending checks) — user is watching
+  if (pr.checksSummary.pending > 0) return 10_000; // 10 seconds
+
+  // CI failed — user likely pushing fixes
+  if (pr.checksSummary.failure > 0) return 30_000; // 30 seconds
+
+  // Changes requested — moderate frequency
+  if (pr.reviewDecision === "CHANGES_REQUESTED") return 30_000; // 30 seconds
+
+  // Approved, all checks passed — stable
+  if (pr.reviewDecision === "APPROVED" && pr.checksSummary.pending === 0) return 120_000; // 2 minutes
+
+  // Review pending, checks passed — waiting on human reviewer
+  if (pr.reviewDecision === "REVIEW_REQUIRED" || pr.reviewDecision === null) return 45_000; // 45 seconds
+
+  // Default fallback
+  return 30_000;
+}
+
+// ─── GraphQL Query ───────────────────────────────────────────────────────────
+
+const PR_QUERY = `
+query($owner: String!, $name: String!, $branch: String!) {
+  repository(owner: $owner, name: $name) {
+    pullRequests(headRefName: $branch, first: 5, orderBy: {field: UPDATED_AT, direction: DESC}, states: [OPEN, MERGED]) {
+      nodes {
+        number
+        title
+        url
+        state
+        isDraft
+        isCrossRepository
+        reviewDecision
+        additions
+        deletions
+        changedFiles
+        reviewThreads(first: 100) {
+          totalCount
+          nodes {
+            isResolved
+          }
+        }
+        commits(last: 1) {
+          nodes {
+            commit {
+              statusCheckRollup {
+                contexts(first: 50) {
+                  nodes {
+                    __typename
+                    ... on CheckRun {
+                      name
+                      status
+                      conclusion
+                    }
+                    ... on StatusContext {
+                      context
+                      state
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+
+// ─── Response Parsing ────────────────────────────────────────────────────────
+
+interface GraphQLCheckRunNode {
+  __typename: "CheckRun";
+  name: string;
+  status: string;
+  conclusion: string | null;
+}
+
+interface GraphQLStatusContextNode {
+  __typename: "StatusContext";
+  context: string;
+  state: string;
+}
+
+type GraphQLContextNode = GraphQLCheckRunNode | GraphQLStatusContextNode;
+
+export function parseGraphQLResponse(data: unknown): GitHubPRInfo | null {
+  try {
+    const repo = (data as any)?.data?.repository;
+    const nodes = repo?.pullRequests?.nodes;
+    if (!nodes || nodes.length === 0) return null;
+
+    // Filter out cross-repository (fork) PRs — we only want same-repo PRs
+    const sameRepoPRs = nodes.filter((n: any) => !n.isCrossRepository);
+    if (sameRepoPRs.length === 0) return null;
+
+    const pr = sameRepoPRs[0];
+
+    // Normalize checks
+    const rawContexts: GraphQLContextNode[] =
+      pr.commits?.nodes?.[0]?.commit?.statusCheckRollup?.contexts?.nodes ?? [];
+
+    const checks: GitHubCheckStatus[] = rawContexts.map((node) => {
+      if (node.__typename === "CheckRun") {
+        return {
+          name: node.name,
+          status: node.status,
+          conclusion: node.conclusion,
+        };
+      }
+      // StatusContext
+      return {
+        name: node.context,
+        status: node.state === "PENDING" ? "IN_PROGRESS" : "COMPLETED",
+        conclusion: node.state === "SUCCESS" ? "SUCCESS" : (node.state === "FAILURE" || node.state === "ERROR") ? "FAILURE" : null,
+      };
+    });
+
+    // Compute summary
+    let success = 0;
+    let failure = 0;
+    let pending = 0;
+    for (const check of checks) {
+      if (check.conclusion === "SUCCESS" || check.conclusion === "NEUTRAL" || check.conclusion === "SKIPPED") {
+        success++;
+      } else if (check.conclusion === "FAILURE" || check.conclusion === "CANCELLED" || check.conclusion === "TIMED_OUT") {
+        failure++;
+      } else {
+        pending++;
+      }
+    }
+
+    // Compute review threads
+    const threadNodes: { isResolved: boolean }[] = pr.reviewThreads?.nodes ?? [];
+    const resolved = threadNodes.filter((t) => t.isResolved).length;
+    const unresolved = threadNodes.filter((t) => !t.isResolved).length;
+
+    return {
+      number: pr.number,
+      title: pr.title,
+      url: pr.url,
+      state: pr.state,
+      isDraft: pr.isDraft ?? false,
+      reviewDecision: pr.reviewDecision || null,
+      additions: pr.additions ?? 0,
+      deletions: pr.deletions ?? 0,
+      changedFiles: pr.changedFiles ?? 0,
+      checks,
+      checksSummary: { total: checks.length, success, failure, pending },
+      reviewThreads: {
+        total: pr.reviewThreads?.totalCount ?? 0,
+        resolved,
+        unresolved,
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ─── Main Fetch Function (sync — legacy, used by tests) ─────────────────────
+
+export async function fetchPRInfo(cwd: string, branch: string): Promise<GitHubPRInfo | null> {
+  if (!isGhAvailable()) return null;
+
+  const cacheKey = `${cwd}:${branch}`;
+  const cached = prCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < cached.ttl) {
+    return cached.data;
+  }
+
+  const slug = getRepoSlug(cwd);
+  if (!slug) {
+    prCache.set(cacheKey, { data: null, timestamp: Date.now(), ttl: PR_CACHE_TTL });
+    return null;
+  }
+
+  const [owner, name] = slug.split("/");
+  if (!owner || !name) return null;
+
+  try {
+    const result = execFileSync(
+      "gh",
+      ["api", "graphql", "-f", `query=${PR_QUERY}`, "-f", `owner=${owner}`, "-f", `name=${name}`, "-f", `branch=${branch}`],
+      { cwd, stdio: "pipe", timeout: 15_000 },
+    )
+      .toString()
+      .trim();
+
+    const parsed = JSON.parse(result);
+    const prInfo = parseGraphQLResponse(parsed);
+    const ttl = computeAdaptiveTTL(prInfo);
+    prCache.set(cacheKey, { data: prInfo, timestamp: Date.now(), ttl });
+    return prInfo;
+  } catch {
+    prCache.set(cacheKey, { data: null, timestamp: Date.now(), ttl: PR_CACHE_TTL });
+    return null;
+  }
+}
+
+// ─── Async Fetch Function (non-blocking, uses Bun.spawn) ────────────────────
+
+export async function fetchPRInfoAsync(cwd: string, branch: string): Promise<GitHubPRInfo | null> {
+  if (!isGhAvailable()) return null;
+
+  const cacheKey = `${cwd}:${branch}`;
+  const cached = prCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < cached.ttl) {
+    return cached.data;
+  }
+
+  const slug = await getRepoSlugAsync(cwd);
+  if (!slug) {
+    prCache.set(cacheKey, { data: null, timestamp: Date.now(), ttl: 60_000 });
+    return null;
+  }
+
+  const [owner, name] = slug.split("/");
+  if (!owner || !name) return null;
+
+  try {
+    const proc = Bun.spawn(
+      ["gh", "api", "graphql", "-f", `query=${PR_QUERY}`, "-f", `owner=${owner}`, "-f", `name=${name}`, "-f", `branch=${branch}`],
+      { cwd, stdout: "pipe", stderr: "pipe" },
+    );
+    const timeout = setTimeout(() => proc.kill(), 15_000);
+    const exitCode = await proc.exited;
+    clearTimeout(timeout);
+
+    if (exitCode !== 0) {
+      prCache.set(cacheKey, { data: null, timestamp: Date.now(), ttl: PR_CACHE_TTL });
+      return null;
+    }
+
+    const stdout = (await new Response(proc.stdout).text()).trim();
+    const parsed = JSON.parse(stdout);
+    const prInfo = parseGraphQLResponse(parsed);
+    const ttl = computeAdaptiveTTL(prInfo);
+    prCache.set(cacheKey, { data: prInfo, timestamp: Date.now(), ttl });
+    return prInfo;
+  } catch {
+    prCache.set(cacheKey, { data: null, timestamp: Date.now(), ttl: PR_CACHE_TTL });
+    return null;
+  }
+}

package/server/image-pull-manager.test.ts

@@ -0,0 +1,303 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock container-manager
+const mockImageExists = vi.hoisted(() => vi.fn((_image: string) => false));
+const mockPullImage = vi.hoisted(() => vi.fn(async (_remote: string, _local: string, _onProgress?: (line: string) => void) => true));
+const mockBuildImage = vi.hoisted(() => vi.fn((_path: string, _tag?: string) => "ok"));
+const mockGetRegistryImage = vi.hoisted(() => vi.fn((tag: string) => {
+  if (tag === "the-companion:latest") return "docker.io/stangirard/the-companion:latest";
+  return null as string | null;
+}));
+
+vi.mock("./container-manager.js", () => ({
+  containerManager: {
+    imageExists: mockImageExists,
+    pullImage: mockPullImage,
+    buildImage: mockBuildImage,
+  },
+  ContainerManager: {
+    getRegistryImage: mockGetRegistryImage,
+  },
+}));
+
+// Mock env-manager
+const mockListEnvs = vi.hoisted(() => vi.fn(() => [] as Array<{ name: string; slug: string; baseImage?: string; imageTag?: string; variables: Record<string, string>; createdAt: number; updatedAt: number }>));
+vi.mock("./env-manager.js", () => ({
+  listEnvs: mockListEnvs,
+}));
+
+// Mock existsSync for Dockerfile fallback
+const mockExistsSync = vi.hoisted(() => vi.fn(() => true));
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return { ...actual, existsSync: mockExistsSync };
+});
+
+// We need to re-import for each test to get a fresh singleton.
+// Instead we use a factory approach.
+async function createManager() {
+  // Clear module cache so we get a fresh singleton
+  vi.resetModules();
+  const mod = await import("./image-pull-manager.js");
+  return mod.imagePullManager;
+}
+
+describe("ImagePullManager", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockImageExists.mockReturnValue(false);
+    mockPullImage.mockResolvedValue(true);
+    mockBuildImage.mockReturnValue("ok");
+    mockExistsSync.mockReturnValue(true);
+    // Restore default registry mapping (clearAllMocks removes it)
+    mockGetRegistryImage.mockImplementation((tag: string) => {
+      if (tag === "the-companion:latest") return "docker.io/stangirard/the-companion:latest";
+      return null as string | null;
+    });
+  });
+
+  describe("getState", () => {
+    it("returns 'ready' when image exists locally", async () => {
+      mockImageExists.mockReturnValue(true);
+      const manager = await createManager();
+      const state = manager.getState("the-companion:latest");
+      expect(state.status).toBe("ready");
+      expect(state.image).toBe("the-companion:latest");
+    });
+
+    it("returns 'idle' when image does not exist locally", async () => {
+      mockImageExists.mockReturnValue(false);
+      const manager = await createManager();
+      const state = manager.getState("the-companion:latest");
+      expect(state.status).toBe("idle");
+    });
+  });
+
+  describe("isReady", () => {
+    it("returns true when image exists locally", async () => {
+      mockImageExists.mockReturnValue(true);
+      const manager = await createManager();
+      expect(manager.isReady("the-companion:latest")).toBe(true);
+    });
+
+    it("returns false when image does not exist locally", async () => {
+      mockImageExists.mockReturnValue(false);
+      const manager = await createManager();
+      expect(manager.isReady("the-companion:latest")).toBe(false);
+    });
+  });
+
+  describe("ensureImage", () => {
+    it("starts a background pull when image is missing", async () => {
+      mockImageExists.mockReturnValue(false);
+      const manager = await createManager();
+
+      manager.ensureImage("the-companion:latest");
+
+      const state = manager.getState("the-companion:latest");
+      expect(state.status).toBe("pulling");
+      expect(state.startedAt).toBeGreaterThan(0);
+
+      // Wait for the async pull to complete
+      await vi.waitFor(() => {
+        expect(manager.getState("the-companion:latest").status).toBe("ready");
+      });
+      expect(mockPullImage).toHaveBeenCalledOnce();
+    });
+
+    it("is a no-op when image is already ready", async () => {
+      mockImageExists.mockReturnValue(true);
+      const manager = await createManager();
+
+      manager.ensureImage("the-companion:latest");
+
+      expect(mockPullImage).not.toHaveBeenCalled();
+    });
+
+    it("is a no-op when image is already being pulled", async () => {
+      mockImageExists.mockReturnValue(false);
+      // Make pull hang
+      mockPullImage.mockImplementation(() => new Promise(() => {}));
+      const manager = await createManager();
+
+      manager.ensureImage("the-companion:latest");
+      manager.ensureImage("the-companion:latest"); // second call
+
+      expect(mockPullImage).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("waitForReady", () => {
+    it("resolves immediately when image already exists", async () => {
+      mockImageExists.mockReturnValue(true);
+      const manager = await createManager();
+
+      const result = await manager.waitForReady("the-companion:latest");
+      expect(result).toBe(true);
+    });
+
+    it("waits for an in-progress pull to complete", async () => {
+      mockImageExists.mockReturnValue(false);
+      const manager = await createManager();
+
+      manager.ensureImage("the-companion:latest");
+      const result = await manager.waitForReady("the-companion:latest", 5000);
+      expect(result).toBe(true);
+    });
+
+    it("returns false when pull fails", async () => {
+      mockImageExists.mockReturnValue(false);
+      mockPullImage.mockResolvedValue(false);
+      mockExistsSync.mockReturnValue(false); // no Dockerfile fallback
+      const manager = await createManager();
+
+      const result = await manager.waitForReady("the-companion:latest", 5000);
+      expect(result).toBe(false);
+    });
+
+    it("starts a pull if image is idle and not present", async () => {
+      mockImageExists.mockReturnValue(false);
+      const manager = await createManager();
+
+      // Calling waitForReady on an idle image should trigger a pull
+      const result = await manager.waitForReady("the-companion:latest", 5000);
+      expect(result).toBe(true);
+      expect(mockPullImage).toHaveBeenCalledOnce();
+    });
+
+    it("times out when pull takes too long", async () => {
+      mockImageExists.mockReturnValue(false);
+      mockPullImage.mockImplementation(() => new Promise(() => {})); // never resolves
+      const manager = await createManager();
+
+      const result = await manager.waitForReady("the-companion:latest", 50);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("pull (force re-pull)", () => {
+    it("triggers a pull even when image is already present", async () => {
+      mockImageExists.mockReturnValue(true);
+      const manager = await createManager();
+
+      manager.pull("the-companion:latest");
+
+      // Should have started pulling despite image being present
+      const state = manager.getState("the-companion:latest");
+      expect(state.status).toBe("pulling");
+      expect(mockPullImage).toHaveBeenCalledOnce();
+    });
+
+    it("is a no-op when a pull is already in progress", async () => {
+      mockImageExists.mockReturnValue(false);
+      mockPullImage.mockImplementation(() => new Promise(() => {}));
+      const manager = await createManager();
+
+      manager.pull("the-companion:latest");
+      manager.pull("the-companion:latest");
+
+      expect(mockPullImage).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("onProgress", () => {
+    it("fires callback for each progress line during pull", async () => {
+      mockImageExists.mockReturnValue(false);
+      const lines: string[] = [];
+      mockPullImage.mockImplementation(async (_remote: string, _local: string, onProgress?: (line: string) => void) => {
+        onProgress?.("Downloading layer 1/3");
+        onProgress?.("Downloading layer 2/3");
+        onProgress?.("Downloading layer 3/3");
+        return true;
+      });
+
+      const manager = await createManager();
+      const unsub = manager.onProgress("the-companion:latest", (line) => lines.push(line));
+
+      manager.ensureImage("the-companion:latest");
+
+      await vi.waitFor(() => {
+        expect(manager.getState("the-companion:latest").status).toBe("ready");
+      });
+
+      // Should have received the pull lines plus "Image ready"
+      expect(lines).toContain("Downloading layer 1/3");
+      expect(lines).toContain("Downloading layer 2/3");
+      expect(lines).toContain("Downloading layer 3/3");
+      expect(lines).toContain("Image ready");
+
+      unsub();
+    });
+  });
+
+  describe("fallback to local build", () => {
+    it("falls back to local build when pull fails for the-companion:latest", async () => {
+      mockImageExists.mockReturnValue(false);
+      mockPullImage.mockResolvedValue(false);
+      mockExistsSync.mockReturnValue(true);
+
+      const manager = await createManager();
+      const result = await manager.waitForReady("the-companion:latest", 5000);
+
+      expect(result).toBe(true);
+      expect(mockPullImage).toHaveBeenCalledOnce();
+      expect(mockBuildImage).toHaveBeenCalledOnce();
+    });
+
+    it("errors when pull fails for non-default image", async () => {
+      mockImageExists.mockReturnValue(false);
+      mockGetRegistryImage.mockReturnValue(null);
+
+      const manager = await createManager();
+      const result = await manager.waitForReady("custom-image:v1", 5000);
+
+      expect(result).toBe(false);
+      const state = manager.getState("custom-image:v1");
+      expect(state.status).toBe("error");
+    });
+
+    it("errors when pull fails and no Dockerfile exists", async () => {
+      mockImageExists.mockReturnValue(false);
+      mockPullImage.mockResolvedValue(false);
+      mockExistsSync.mockReturnValue(false); // no Dockerfile
+
+      const manager = await createManager();
+      const result = await manager.waitForReady("the-companion:latest", 5000);
+
+      expect(result).toBe(false);
+      const state = manager.getState("the-companion:latest");
+      expect(state.status).toBe("error");
+      expect(state.error).toContain("Dockerfile not found");
+    });
+  });
+
+  describe("initFromEnvironments", () => {
+    it("is a no-op since environments no longer carry Docker fields", async () => {
+      mockImageExists.mockReturnValue(false);
+      mockListEnvs.mockReturnValue([
+        { name: "env1", slug: "env1", baseImage: "the-companion:latest", variables: {}, createdAt: 0, updatedAt: 0 },
+        { name: "env2", slug: "env2", imageTag: "custom:v1", variables: {}, createdAt: 0, updatedAt: 0 },
+      ]);
+
+      const manager = await createManager();
+      manager.initFromEnvironments();
+
+      // initFromEnvironments is now a no-op — Docker fields moved to Sandboxes.
+      // No image pulls should be triggered regardless of environment config.
+      expect(mockPullImage).not.toHaveBeenCalled();
+      expect(mockListEnvs).not.toHaveBeenCalled();
+    });
+
+    it("skips images that are already available", async () => {
+      mockImageExists.mockReturnValue(true);
+      mockListEnvs.mockReturnValue([
+        { name: "env1", slug: "env1", baseImage: "the-companion:latest", variables: {}, createdAt: 0, updatedAt: 0 },
+      ]);
+
+      const manager = await createManager();
+      manager.initFromEnvironments();
+
+      expect(mockPullImage).not.toHaveBeenCalled();
+    });
+  });
+});