@mndrk/agx 2.4.4 → 2.4.6

package/cloud-runtime/standalone/apps/local/lib/device-flow.ts

@@ -1,5 +1,6 @@
 
 import { createAdminDbClient } from "@/lib/db-adapter";
+import { logger } from "@/lib/logger";
 
 export type DeviceCode = {
     device_code: string;
@@ -51,7 +52,7 @@ export async function createDeviceCode() {
         });
 
     if (error) {
-        console.error("[device-code] insert failed", {
+        logger.error("[device-code] insert failed", {
             message: error.message,
             code: error.code,
             details: error.details,
@@ -78,7 +79,7 @@ export async function getDeviceCode(deviceCode: string) {
         .single();
 
     if (error) {
-        console.error("[device-code] fetch failed", {
+        logger.error("[device-code] fetch failed", {
             message: error.message,
             code: error.code,
             details: error.details,
@@ -103,7 +104,7 @@ export async function approveDeviceCode(userCode: string, userId: string, tokens
 
     if (fetchError || !data) {
         if (fetchError) {
-            console.error("[device-code] approve fetch failed", {
+            logger.error("[device-code] approve fetch failed", {
                 message: fetchError.message,
                 code: fetchError.code,
                 details: fetchError.details,
@@ -125,7 +126,7 @@ export async function approveDeviceCode(userCode: string, userId: string, tokens
         .eq("device_code", data.device_code);
 
     if (error) {
-        console.error("[device-code] approve update failed", {
+        logger.error("[device-code] approve update failed", {
             message: error.message,
             code: error.code,
             details: error.details,

package/cloud-runtime/standalone/apps/local/lib/github-client.ts

@@ -0,0 +1,382 @@
+import type {
+  GithubPr,
+  GithubPrComment,
+  GithubPrFile,
+  GithubIssue,
+  GithubTokens,
+  GithubReviewer,
+  GithubCiStatus,
+  GithubReviewDecision,
+} from "./github-types";
+
+export class GithubAuthError extends Error {
+  constructor(message = "github auth failed") {
+    super(message);
+    this.name = "GithubAuthError";
+  }
+}
+
+export class GithubRateLimitError extends Error {
+  constructor(public resetAt: number) {
+    super("github rate limited");
+    this.name = "GithubRateLimitError";
+  }
+}
+
+type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+
+export interface GithubClientInit {
+  tokens: GithubTokens;
+  fetchImpl?: FetchLike;
+  baseUrl?: string;
+  userAgent?: string;
+}
+
+interface RawPull {
+  number: number;
+  title: string | null;
+  body: string | null;
+  state: string;
+  draft?: boolean;
+  merged_at?: string | null;
+  closed_at?: string | null;
+  created_at: string;
+  updated_at: string;
+  user: { login: string } | null;
+  head: { ref: string; sha: string };
+  base: { ref: string };
+  html_url: string;
+  assignees?: Array<{ login: string }>;
+  requested_reviewers?: Array<{ login: string }>;
+  labels?: Array<{ name: string }>;
+}
+
+interface RawIssueComment {
+  id: number;
+  user: { login: string } | null;
+  body: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface RawReviewComment extends RawIssueComment {
+  path: string;
+  line: number | null;
+}
+
+function toEpoch(iso: string | null | undefined): number {
+  return iso ? Date.parse(iso) : 0;
+}
+
+function mapReviewers(list: RawPull["requested_reviewers"]): GithubReviewer[] {
+  return (list ?? []).map((r) => ({ login: r.login, state: "pending" as const }));
+}
+
+function mapPr(owner: string, name: string, raw: RawPull, syncedAt: number): GithubPr {
+  const merged = raw.merged_at != null;
+  const closed = raw.closed_at != null;
+  const state: GithubPr["state"] = merged ? "merged" : closed ? "closed" : "open";
+  return {
+    id: `${owner}/${name}#${raw.number}`,
+    repoId: `${owner}/${name}`,
+    number: raw.number,
+    title: raw.title ?? "",
+    body: raw.body ?? "",
+    state,
+    draft: Boolean(raw.draft),
+    authorLogin: raw.user?.login ?? "",
+    headRef: raw.head.ref,
+    headSha: raw.head.sha,
+    baseRef: raw.base.ref,
+    url: raw.html_url,
+    ciStatus: null,
+    reviewDecision: null,
+    assignees: (raw.assignees ?? []).map((a) => a.login),
+    reviewers: mapReviewers(raw.requested_reviewers),
+    labels: (raw.labels ?? []).map((l) => l.name),
+    createdAt: toEpoch(raw.created_at),
+    updatedAt: toEpoch(raw.updated_at),
+    mergedAt: merged ? toEpoch(raw.merged_at) : null,
+    closedAt: closed ? toEpoch(raw.closed_at) : null,
+    lastSyncedAt: syncedAt,
+  };
+}
+
+export class GithubClient {
+  private readonly fetchImpl: FetchLike;
+  private readonly baseUrl: string;
+  private readonly tokens: GithubTokens;
+  private readonly userAgent: string;
+
+  constructor(init: GithubClientInit) {
+    this.tokens = init.tokens;
+    this.fetchImpl = init.fetchImpl ?? ((url, opts) => fetch(url, opts));
+    this.baseUrl = init.baseUrl ?? "https://api.github.com";
+    this.userAgent = init.userAgent ?? "agx-github-client";
+  }
+
+  private async request<T>(pathname: string): Promise<T> {
+    const res = await this.fetchImpl(`${this.baseUrl}${pathname}`, {
+      headers: {
+        Authorization: `Bearer ${this.tokens.accessToken}`,
+        "User-Agent": this.userAgent,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+    });
+    if (res.status === 401) throw new GithubAuthError();
+    if (res.status === 403) {
+      const remaining = res.headers.get("x-ratelimit-remaining");
+      if (remaining === "0") {
+        const reset = Number(res.headers.get("x-ratelimit-reset") ?? "0") * 1000;
+        throw new GithubRateLimitError(reset);
+      }
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`github ${res.status}: ${body.slice(0, 200)}`);
+    }
+    return (await res.json()) as T;
+  }
+
+  async listPullRequests(input: {
+    owner: string;
+    name: string;
+    state?: "all" | "open" | "closed";
+    perPage?: number;
+  }): Promise<GithubPr[]> {
+    const params = new URLSearchParams({
+      state: input.state ?? "all",
+      sort: "updated",
+      direction: "desc",
+      per_page: String(input.perPage ?? 50),
+    });
+    const raw = await this.request<RawPull[]>(
+      `/repos/${input.owner}/${input.name}/pulls?${params}`,
+    );
+    const now = Date.now();
+    return raw.map((r) => mapPr(input.owner, input.name, r, now));
+  }
+
+  async getCombinedStatus(input: {
+    owner: string;
+    name: string;
+    sha: string;
+  }): Promise<GithubCiStatus> {
+    const data = await this.request<{
+      check_runs?: Array<{
+        status: string;
+        conclusion: string | null;
+      }>;
+    }>(`/repos/${input.owner}/${input.name}/commits/${input.sha}/check-runs`);
+    const runs = data.check_runs ?? [];
+    if (runs.length === 0) return null;
+    if (runs.some((r) => r.status !== "completed")) return "pending";
+    const failConclusions = new Set([
+      "failure",
+      "timed_out",
+      "cancelled",
+      "action_required",
+    ]);
+    if (runs.some((r) => r.conclusion && failConclusions.has(r.conclusion))) {
+      return "failure";
+    }
+    if (runs.some((r) => r.conclusion === "success")) return "success";
+    return null;
+  }
+
+  async getReviewDecision(input: {
+    owner: string;
+    name: string;
+    number: number;
+  }): Promise<GithubReviewDecision> {
+    const reviews = await this.request<
+      Array<{
+        state: string;
+        user: { login: string } | null;
+        submitted_at: string | null;
+      }>
+    >(`/repos/${input.owner}/${input.name}/pulls/${input.number}/reviews`);
+    const latestByUser = new Map<string, { state: string; at: number }>();
+    for (const r of reviews) {
+      const login = r.user?.login;
+      if (!login) continue;
+      if (
+        r.state === "DISMISSED" ||
+        r.state === "PENDING" ||
+        r.state === "COMMENTED"
+      ) {
+        continue;
+      }
+      const at = toEpoch(r.submitted_at);
+      const existing = latestByUser.get(login);
+      if (!existing || at >= existing.at) {
+        latestByUser.set(login, { state: r.state, at });
+      }
+    }
+    const states = [...latestByUser.values()].map((v) => v.state);
+    if (states.length === 0) return "review_required";
+    if (states.some((s) => s === "CHANGES_REQUESTED")) return "changes_requested";
+    if (states.some((s) => s === "APPROVED")) return "approved";
+    return "review_required";
+  }
+
+  async enrichPrStatus(pr: GithubPr): Promise<GithubPr> {
+    const [owner, name] = pr.repoId.split("/");
+    if (!owner || !name) return pr;
+    const [ciStatus, reviewDecision] = await Promise.all([
+      this.getCombinedStatus({ owner, name, sha: pr.headSha }),
+      this.getReviewDecision({ owner, name, number: pr.number }),
+    ]);
+    return { ...pr, ciStatus, reviewDecision };
+  }
+
+  async listIssues(input: {
+    owner: string;
+    name: string;
+    state?: "all" | "open" | "closed";
+    perPage?: number;
+  }): Promise<GithubIssue[]> {
+    const params = new URLSearchParams({
+      state: input.state ?? "all",
+      sort: "updated",
+      direction: "desc",
+      per_page: String(input.perPage ?? 50),
+    });
+    // Note: GitHub's issues endpoint returns both issues and PRs; filter PRs out
+    const raw = await this.request<
+      Array<{
+        number: number;
+        title: string | null;
+        body: string | null;
+        state: string;
+        closed_at: string | null;
+        created_at: string;
+        updated_at: string;
+        user: { login: string } | null;
+        html_url: string;
+        assignees?: Array<{ login: string }>;
+        labels?: Array<{ name: string } | string>;
+        pull_request?: unknown;
+      }>
+    >(`/repos/${input.owner}/${input.name}/issues?${params}`);
+    const now = Date.now();
+    return raw
+      .filter((r) => !r.pull_request)
+      .map((r) => ({
+        id: `${input.owner}/${input.name}!${r.number}`,
+        repoId: `${input.owner}/${input.name}`,
+        number: r.number,
+        title: r.title ?? "",
+        body: r.body ?? "",
+        state: (r.state === "closed" ? "closed" : "open") as GithubIssue["state"],
+        authorLogin: r.user?.login ?? "",
+        url: r.html_url,
+        assignees: (r.assignees ?? []).map((a) => a.login),
+        labels: (r.labels ?? []).map((l) =>
+          typeof l === "string" ? l : l.name,
+        ),
+        createdAt: toEpoch(r.created_at),
+        updatedAt: toEpoch(r.updated_at),
+        closedAt: r.closed_at ? toEpoch(r.closed_at) : null,
+        lastSyncedAt: now,
+      }));
+  }
+
+  async listPullRequestFiles(input: {
+    owner: string;
+    name: string;
+    number: number;
+    perPage?: number;
+  }): Promise<GithubPrFile[]> {
+    const prId = `${input.owner}/${input.name}#${input.number}`;
+    const params = new URLSearchParams({
+      per_page: String(input.perPage ?? 100),
+    });
+    const raw = await this.request<
+      Array<{
+        filename: string;
+        status: string;
+        additions: number;
+        deletions: number;
+        changes: number;
+        patch?: string;
+      }>
+    >(`/repos/${input.owner}/${input.name}/pulls/${input.number}/files?${params}`);
+    const now = Date.now();
+    return raw.map((r) => ({
+      prId,
+      path: r.filename,
+      status: r.status,
+      additions: r.additions ?? 0,
+      deletions: r.deletions ?? 0,
+      changes: r.changes ?? 0,
+      patch: r.patch ?? null,
+      lastSyncedAt: now,
+    }));
+  }
+
+  async listPullRequestComments(input: {
+    owner: string;
+    name: string;
+    number: number;
+  }): Promise<GithubPrComment[]> {
+    const prId = `${input.owner}/${input.name}#${input.number}`;
+    const [issueComments, reviewComments] = await Promise.all([
+      this.request<RawIssueComment[]>(
+        `/repos/${input.owner}/${input.name}/issues/${input.number}/comments`,
+      ),
+      this.request<RawReviewComment[]>(
+        `/repos/${input.owner}/${input.name}/pulls/${input.number}/comments`,
+      ),
+    ]);
+    const mapped: GithubPrComment[] = [];
+    for (const c of issueComments) {
+      mapped.push({
+        id: String(c.id),
+        prId,
+        kind: "issue_comment",
+        authorLogin: c.user?.login ?? "",
+        body: c.body ?? "",
+        path: null,
+        line: null,
+        createdAt: toEpoch(c.created_at),
+        updatedAt: toEpoch(c.updated_at),
+      });
+    }
+    for (const c of reviewComments) {
+      mapped.push({
+        id: String(c.id),
+        prId,
+        kind: "review_comment",
+        authorLogin: c.user?.login ?? "",
+        body: c.body ?? "",
+        path: c.path ?? null,
+        line: c.line ?? null,
+        createdAt: toEpoch(c.created_at),
+        updatedAt: toEpoch(c.updated_at),
+      });
+    }
+    return mapped;
+  }
+}
+
+export interface RefreshTokensInput {
+  refreshToken: string;
+  endpoint?: string;
+  fetchImpl?: FetchLike;
+}
+
+export async function refreshGithubTokens(
+  input: RefreshTokensInput,
+): Promise<GithubTokens> {
+  const fetchImpl = input.fetchImpl ?? ((url, opts) => fetch(url, opts));
+  const endpoint = input.endpoint ?? "https://www.runagx.com/api/github/refresh";
+  const res = await fetchImpl(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ refresh_token: input.refreshToken }),
+  });
+  if (!res.ok) throw new GithubAuthError(`refresh failed ${res.status}`);
+  return (await res.json()) as GithubTokens;
+}

package/cloud-runtime/standalone/apps/local/lib/github-db.ts

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { DatabaseSync } from "node:sqlite";
+
+const { DatabaseSync: DatabaseSyncCtor } = process.getBuiltinModule(
+  "node:sqlite",
+) as typeof import("node:sqlite");
+
+function resolveGithubDir(): string {
+  return (
+    process.env.AGX_GITHUB_DIR?.trim() ||
+    path.join(
+      process.env.AGX_DATA_DIR || path.join(os.homedir(), ".agx"),
+      "github",
+    )
+  );
+}
+
+export function getGithubDbPath(): string {
+  return path.join(resolveGithubDir(), "prs.sqlite");
+}
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS github_repos (
+  id TEXT PRIMARY KEY,
+  owner TEXT NOT NULL,
+  name TEXT NOT NULL,
+  default_branch TEXT,
+  private INTEGER NOT NULL DEFAULT 0,
+  access_revoked INTEGER NOT NULL DEFAULT 0,
+  added_at INTEGER NOT NULL,
+  last_synced_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS github_prs (
+  id TEXT PRIMARY KEY,
+  repo_id TEXT NOT NULL,
+  number INTEGER NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  body TEXT NOT NULL DEFAULT '',
+  state TEXT NOT NULL,
+  draft INTEGER NOT NULL DEFAULT 0,
+  author_login TEXT NOT NULL DEFAULT '',
+  head_ref TEXT NOT NULL DEFAULT '',
+  head_sha TEXT NOT NULL DEFAULT '',
+  base_ref TEXT NOT NULL DEFAULT '',
+  url TEXT NOT NULL DEFAULT '',
+  ci_status TEXT,
+  review_decision TEXT,
+  assignees_json TEXT NOT NULL DEFAULT '[]',
+  reviewers_json TEXT NOT NULL DEFAULT '[]',
+  labels_json TEXT NOT NULL DEFAULT '[]',
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  merged_at INTEGER,
+  closed_at INTEGER,
+  last_synced_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_github_prs_repo_updated
+  ON github_prs (repo_id, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_github_prs_state
+  ON github_prs (state, updated_at DESC);
+
+CREATE TABLE IF NOT EXISTS github_issues (
+  id TEXT PRIMARY KEY,
+  repo_id TEXT NOT NULL,
+  number INTEGER NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  body TEXT NOT NULL DEFAULT '',
+  state TEXT NOT NULL,
+  author_login TEXT NOT NULL DEFAULT '',
+  url TEXT NOT NULL DEFAULT '',
+  assignees_json TEXT NOT NULL DEFAULT '[]',
+  labels_json TEXT NOT NULL DEFAULT '[]',
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  closed_at INTEGER,
+  last_synced_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_github_issues_repo_updated
+  ON github_issues (repo_id, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_github_issues_state
+  ON github_issues (state, updated_at DESC);
+
+CREATE TABLE IF NOT EXISTS pr_links (
+  pr_id TEXT NOT NULL,
+  target_type TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  link_source TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (pr_id, target_type, target_id)
+);
+CREATE INDEX IF NOT EXISTS idx_pr_links_target
+  ON pr_links (target_type, target_id);
+
+CREATE TABLE IF NOT EXISTS github_pr_comments (
+  id TEXT PRIMARY KEY,
+  pr_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  author_login TEXT NOT NULL DEFAULT '',
+  body TEXT NOT NULL DEFAULT '',
+  path TEXT,
+  line INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_github_pr_comments_pr
+  ON github_pr_comments (pr_id);
+
+CREATE TABLE IF NOT EXISTS github_pr_files (
+  pr_id TEXT NOT NULL,
+  path TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT '',
+  additions INTEGER NOT NULL DEFAULT 0,
+  deletions INTEGER NOT NULL DEFAULT 0,
+  changes INTEGER NOT NULL DEFAULT 0,
+  patch TEXT,
+  last_synced_at INTEGER NOT NULL,
+  PRIMARY KEY (pr_id, path)
+);
+CREATE INDEX IF NOT EXISTS idx_github_pr_files_pr
+  ON github_pr_files (pr_id);
+
+CREATE TABLE IF NOT EXISTS github_sync_state (
+  repo_id TEXT PRIMARY KEY,
+  last_synced_at INTEGER NOT NULL,
+  cursor TEXT
+);
+`;
+
+export function withGithubDatabase<T>(run: (db: DatabaseSync) => T): T {
+  const dir = resolveGithubDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const db = new DatabaseSyncCtor(getGithubDbPath());
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec(SCHEMA_SQL);
+    return run(db);
+  } finally {
+    db.close();
+  }
+}

package/cloud-runtime/standalone/apps/local/lib/github-issue-store.ts

@@ -0,0 +1,101 @@
+import type { GithubIssue } from "./github-types";
+import { withGithubDatabase } from "./github-db";
+
+function parseJsonArray<T>(v: unknown, fallback: T[]): T[] {
+  if (typeof v !== "string" || v.length === 0) return fallback;
+  try {
+    const parsed = JSON.parse(v);
+    return Array.isArray(parsed) ? (parsed as T[]) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function rowToIssue(row: Record<string, unknown>): GithubIssue {
+  return {
+    id: String(row.id),
+    repoId: String(row.repo_id),
+    number: Number(row.number),
+    title: String(row.title),
+    body: String(row.body),
+    state: row.state as GithubIssue["state"],
+    authorLogin: String(row.author_login),
+    url: String(row.url),
+    assignees: parseJsonArray<string>(row.assignees_json, []),
+    labels: parseJsonArray<string>(row.labels_json, []),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    closedAt: row.closed_at == null ? null : Number(row.closed_at),
+    lastSyncedAt: Number(row.last_synced_at),
+  };
+}
+
+export function upsertGithubIssue(issue: GithubIssue): void {
+  withGithubDatabase((db) => {
+    db.prepare(
+      `INSERT INTO github_issues (id, repo_id, number, title, body, state, author_login, url, assignees_json, labels_json, created_at, updated_at, closed_at, last_synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         title = excluded.title,
+         body = excluded.body,
+         state = excluded.state,
+         author_login = excluded.author_login,
+         url = excluded.url,
+         assignees_json = excluded.assignees_json,
+         labels_json = excluded.labels_json,
+         updated_at = excluded.updated_at,
+         closed_at = excluded.closed_at,
+         last_synced_at = excluded.last_synced_at`,
+    ).run(
+      issue.id,
+      issue.repoId,
+      issue.number,
+      issue.title,
+      issue.body,
+      issue.state,
+      issue.authorLogin,
+      issue.url,
+      JSON.stringify(issue.assignees),
+      JSON.stringify(issue.labels),
+      issue.createdAt,
+      issue.updatedAt,
+      issue.closedAt,
+      issue.lastSyncedAt,
+    );
+  });
+}
+
+export function listGithubIssuesByRepo(repoId: string): GithubIssue[] {
+  return withGithubDatabase((db) => {
+    const rows = db
+      .prepare(
+        `SELECT * FROM github_issues WHERE repo_id = ? ORDER BY updated_at DESC`,
+      )
+      .all(repoId) as Record<string, unknown>[];
+    return rows.map(rowToIssue);
+  });
+}
+
+export function listAllGithubIssues(): GithubIssue[] {
+  return withGithubDatabase((db) => {
+    const rows = db
+      .prepare(`SELECT * FROM github_issues ORDER BY updated_at DESC`)
+      .all() as Record<string, unknown>[];
+    return rows.map(rowToIssue);
+  });
+}
+
+export function getGithubIssue(id: string): GithubIssue | null {
+  return withGithubDatabase((db) => {
+    const row = db
+      .prepare(`SELECT * FROM github_issues WHERE id = ?`)
+      .get(id) as Record<string, unknown> | undefined;
+    return row ? rowToIssue(row) : null;
+  });
+}
+
+export function deleteGithubIssuesByRepo(repoId: string): void {
+  withGithubDatabase((db) => {
+    db.prepare(`DELETE FROM github_issues WHERE repo_id = ?`).run(repoId);
+  });
+}