@gh-symphony/cli 0.0.17 → 0.0.19

package/dist/chunk-TILHWBP6.js

@@ -0,0 +1,638 @@
+#!/usr/bin/env node
+
+// src/github/client.ts
+var DEFAULT_API_URL = "https://api.github.com/graphql";
+var REST_API_URL = "https://api.github.com";
+var GitHubApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "GitHubApiError";
+  }
+};
+var GitHubScopeError = class extends GitHubApiError {
+  constructor(message, requiredScopes, currentScopes) {
+    super(message);
+    this.requiredScopes = requiredScopes;
+    this.currentScopes = currentScopes;
+    this.name = "GitHubScopeError";
+  }
+};
+function createClient(token, options) {
+  return {
+    token,
+    apiUrl: options?.apiUrl ?? DEFAULT_API_URL,
+    fetchImpl: options?.fetchImpl ?? fetch
+  };
+}
+async function validateToken(client) {
+  const restUrl = client.apiUrl.replace("/graphql", "");
+  const baseUrl = restUrl === client.apiUrl ? REST_API_URL : restUrl;
+  const response = await client.fetchImpl(`${baseUrl}/user`, {
+    headers: {
+      authorization: `Bearer ${client.token}`,
+      accept: "application/vnd.github+json"
+    }
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new GitHubApiError("Invalid token: authentication failed.", 401);
+    }
+    throw new GitHubApiError(
+      `GitHub API error: ${response.status} ${response.statusText}`,
+      response.status
+    );
+  }
+  const scopes = response.headers.get("x-oauth-scopes")?.split(",").map((s) => s.trim()).filter(Boolean) ?? [];
+  const user = await response.json();
+  return {
+    login: user.login,
+    name: user.name,
+    scopes
+  };
+}
+function checkRequiredScopes(scopes) {
+  const required = ["repo", "read:org", "project"];
+  const normalizedScopes = scopes.map((s) => s.toLowerCase());
+  const missing = required.filter((r) => !normalizedScopes.includes(r));
+  return { valid: missing.length === 0, missing };
+}
+async function listUserProjects(client) {
+  const data = await graphql(
+    client,
+    VIEWER_PROJECTS_QUERY
+  );
+  const projects = [];
+  for (const node of data.viewer.projectsV2?.nodes ?? []) {
+    if (!node) continue;
+    projects.push(
+      normalizeProjectSummary(node, {
+        login: data.viewer.login,
+        type: "User"
+      })
+    );
+  }
+  for (const orgNode of data.viewer.organizations?.nodes ?? []) {
+    if (!orgNode) continue;
+    for (const projNode of orgNode.projectsV2?.nodes ?? []) {
+      if (!projNode) continue;
+      projects.push(
+        normalizeProjectSummary(projNode, {
+          login: orgNode.login,
+          type: "Organization"
+        })
+      );
+    }
+  }
+  return projects;
+}
+function normalizeProjectSummary(node, owner) {
+  return {
+    id: node.id,
+    title: node.title,
+    shortDescription: node.shortDescription ?? "",
+    url: node.url,
+    openItemCount: node.items?.totalCount ?? 0,
+    owner
+  };
+}
+async function getProjectDetail(client, projectId) {
+  const data = await graphql(
+    client,
+    PROJECT_DETAIL_QUERY,
+    { projectId }
+  );
+  const project = data.node;
+  if (!project || project.__typename !== "ProjectV2") {
+    throw new GitHubApiError(`Project not found: ${projectId}`);
+  }
+  const statusFields = [];
+  const textFields = [];
+  for (const field of project.fields?.nodes ?? []) {
+    if (!field) continue;
+    if (field.__typename === "ProjectV2SingleSelectField") {
+      statusFields.push({
+        id: field.id,
+        name: field.name,
+        options: (field.options ?? []).map((opt) => ({
+          id: opt.id,
+          name: opt.name,
+          description: opt.description ?? null,
+          color: opt.color ?? null
+        }))
+      });
+    } else if (field.__typename === "ProjectV2Field" && field.dataType) {
+      textFields.push({
+        id: field.id,
+        name: field.name,
+        dataType: field.dataType
+      });
+    }
+  }
+  const repoMap = /* @__PURE__ */ new Map();
+  let cursor = null;
+  let hasMore = true;
+  for (const item of project.items?.nodes ?? []) {
+    const repo = item?.content?.repository;
+    if (!repo) continue;
+    const key = `${repo.owner.login}/${repo.name}`;
+    if (!repoMap.has(key)) {
+      repoMap.set(key, {
+        owner: repo.owner.login,
+        name: repo.name,
+        url: repo.url,
+        cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`
+      });
+    }
+  }
+  hasMore = project.items?.pageInfo?.hasNextPage ?? false;
+  cursor = project.items?.pageInfo?.endCursor ?? null;
+  while (hasMore && cursor) {
+    const pageData = await graphql(
+      client,
+      PROJECT_ITEMS_PAGE_QUERY,
+      { projectId, cursor }
+    );
+    const items = pageData.node?.items;
+    if (!items) break;
+    for (const item of items.nodes ?? []) {
+      const repo = item?.content?.repository;
+      if (!repo) continue;
+      const key = `${repo.owner.login}/${repo.name}`;
+      if (!repoMap.has(key)) {
+        repoMap.set(key, {
+          owner: repo.owner.login,
+          name: repo.name,
+          url: repo.url,
+          cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`
+        });
+      }
+    }
+    hasMore = items.pageInfo?.hasNextPage ?? false;
+    cursor = items.pageInfo?.endCursor ?? null;
+  }
+  return {
+    id: project.id,
+    title: project.title,
+    url: project.url,
+    statusFields,
+    textFields,
+    linkedRepositories: [...repoMap.values()]
+  };
+}
+async function graphql(client, query, variables) {
+  const response = await client.fetchImpl(client.apiUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${client.token}`
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new GitHubApiError(
+      `GitHub GraphQL request failed: ${response.status} ${response.statusText}. ${text}`,
+      response.status
+    );
+  }
+  const payload = await response.json();
+  if (payload.errors?.length) {
+    const scopeMessages = payload.errors.map((e) => e.message).filter((m) => m.includes("has not been granted the required scopes"));
+    if (scopeMessages.length > 0) {
+      const requiredScopes = /* @__PURE__ */ new Set();
+      let currentScopes = [];
+      for (const msg of scopeMessages) {
+        for (const match of msg.matchAll(
+          /requires one of the following scopes: \['([^']+)'\]/g
+        )) {
+          requiredScopes.add(match[1]);
+        }
+        if (currentScopes.length === 0) {
+          const currMatch = /has only been granted the: \[([^\]]+)\]/.exec(msg);
+          if (currMatch) {
+            currentScopes = currMatch[1].split(",").map((s) => s.trim().replace(/'/g, "")).filter(Boolean);
+          }
+        }
+      }
+      throw new GitHubScopeError(
+        "Token is missing required GitHub scopes.",
+        [...requiredScopes],
+        currentScopes
+      );
+    }
+    throw new GitHubApiError(
+      `GraphQL errors: ${payload.errors.map((e) => e.message).join("; ")}`
+    );
+  }
+  if (!payload.data) {
+    throw new GitHubApiError("GraphQL response missing data.");
+  }
+  return payload.data;
+}
+var VIEWER_PROJECTS_QUERY = `
+  query ViewerProjects {
+    viewer {
+      login
+      projectsV2(first: 50) {
+        nodes {
+          id
+          title
+          shortDescription
+          url
+          items { totalCount }
+        }
+      }
+      organizations(first: 20) {
+        nodes {
+          login
+          projectsV2(first: 50) {
+            nodes {
+              id
+              title
+              shortDescription
+              url
+              items { totalCount }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var PROJECT_DETAIL_QUERY = `
+  query ProjectDetail($projectId: ID!) {
+    node(id: $projectId) {
+      __typename
+      ... on ProjectV2 {
+        id
+        title
+        url
+        fields(first: 50) {
+          nodes {
+            __typename
+            ... on ProjectV2SingleSelectField {
+              id
+              name
+              options {
+                id
+                name
+                description
+                color
+              }
+            }
+            ... on ProjectV2Field {
+              id
+              name
+              dataType
+            }
+          }
+        }
+        items(first: 100) {
+          nodes {
+            content {
+              __typename
+              ... on Issue {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+              ... on PullRequest {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var PROJECT_ITEMS_PAGE_QUERY = `
+  query ProjectItemsPage($projectId: ID!, $cursor: String) {
+    node(id: $projectId) {
+      ... on ProjectV2 {
+        items(first: 100, after: $cursor) {
+          nodes {
+            content {
+              __typename
+              ... on Issue {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+              ... on PullRequest {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/github/gh-auth.ts
+import { execFileSync, spawnSync } from "child_process";
+var REQUIRED_GH_SCOPES = ["repo", "read:org", "project"];
+var GhAuthError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "GhAuthError";
+  }
+};
+function ghTokenReadErrorMessage() {
+  return "Failed to read a GitHub token from gh CLI. Run 'gh auth status' and try again.";
+}
+function missingGhScopesMessage(missing) {
+  return `Run 'gh auth refresh --scopes repo,read:org,project'. Missing scopes: ${missing.join(", ")}`;
+}
+function classifyTokenValidationError(error, source) {
+  if (error instanceof GhAuthError) {
+    return error;
+  }
+  if (error instanceof GitHubApiError) {
+    if (error.status === 401) {
+      return new GhAuthError(
+        source === "env" ? "invalid_token" : "token_failed",
+        source === "env" ? "GITHUB_GRAPHQL_TOKEN is invalid or expired." : ghTokenReadErrorMessage()
+      );
+    }
+    const prefix = source === "env" ? "GITHUB_GRAPHQL_TOKEN could not be validated" : "gh CLI token could not be validated";
+    return new GhAuthError("token_failed", `${prefix}: ${error.message}`);
+  }
+  if (error instanceof Error) {
+    const prefix = source === "env" ? "GITHUB_GRAPHQL_TOKEN could not be validated" : "gh CLI token could not be validated";
+    return new GhAuthError("token_failed", `${prefix}: ${error.message}`);
+  }
+  return new GhAuthError(
+    "token_failed",
+    source === "env" ? "GITHUB_GRAPHQL_TOKEN could not be validated." : "gh CLI token could not be validated."
+  );
+}
+function getEnvGitHubToken() {
+  const token = process.env.GITHUB_GRAPHQL_TOKEN?.trim();
+  return token ? token : null;
+}
+function checkGhInstalled(opts) {
+  const execImpl = opts?.execImpl ?? execFileSync;
+  try {
+    execImpl("gh", ["--version"], { stdio: "pipe" });
+    return true;
+  } catch (error) {
+    const execError = error;
+    if (execError.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function checkGhAuthenticated(opts) {
+  const spawnImpl = opts?.spawnImpl ?? spawnSync;
+  const result = spawnImpl("gh", ["auth", "status"], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if ((result.status ?? 1) !== 0) {
+    return { authenticated: false };
+  }
+  const login = parseLogin((result.stdout ?? "").toString());
+  return { authenticated: true, login };
+}
+function checkGhScopes(opts) {
+  const spawnImpl = opts?.spawnImpl ?? spawnSync;
+  const result = spawnImpl("gh", ["auth", "status"], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const output = (result.stdout ?? "").toString();
+  const scopes = parseScopes(output);
+  if (scopes.length === 0) {
+    return { valid: true, missing: [], scopes: [] };
+  }
+  const normalized = scopes.map((scope) => scope.toLowerCase());
+  const missing = REQUIRED_GH_SCOPES.filter(
+    (scope) => !normalized.includes(scope)
+  );
+  return {
+    valid: missing.length === 0,
+    missing: [...missing],
+    scopes
+  };
+}
+function getGhToken(opts) {
+  const envToken = opts?.allowEnv === false ? null : getEnvGitHubToken();
+  if (envToken) {
+    return envToken;
+  }
+  return getGhTokenWithSource({
+    execImpl: opts?.execImpl,
+    envToken: void 0
+  }).token;
+}
+function getGhTokenWithSource(opts) {
+  const hasExplicitEnvToken = opts !== void 0 && Object.prototype.hasOwnProperty.call(opts, "envToken");
+  const envToken = hasExplicitEnvToken ? opts.envToken?.trim() ?? null : getEnvGitHubToken();
+  if (envToken) {
+    return { token: envToken, source: "env" };
+  }
+  const execImpl = opts?.execImpl ?? execFileSync;
+  try {
+    const token = execImpl("gh", ["auth", "token"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).toString().trim();
+    if (!token) {
+      throw new GhAuthError("token_failed", ghTokenReadErrorMessage());
+    }
+    return { token, source: "gh" };
+  } catch (error) {
+    if (error instanceof GhAuthError) {
+      throw error;
+    }
+    throw new GhAuthError("token_failed", ghTokenReadErrorMessage());
+  }
+}
+async function validateGitHubToken(token, source, opts) {
+  const createClientImpl = opts?.createClientImpl ?? createClient;
+  const validateTokenImpl = opts?.validateTokenImpl ?? validateToken;
+  const checkRequiredScopesImpl = opts?.checkRequiredScopesImpl ?? checkRequiredScopes;
+  let viewer;
+  try {
+    const client = createClientImpl(token);
+    viewer = await validateTokenImpl(client);
+  } catch (error) {
+    throw classifyTokenValidationError(error, source);
+  }
+  const scopeCheck = checkRequiredScopesImpl(viewer.scopes);
+  if (!scopeCheck.valid) {
+    if (source === "env") {
+      throw new GhAuthError(
+        "missing_scopes",
+        `GITHUB_GRAPHQL_TOKEN is missing required scopes: ${scopeCheck.missing.join(", ")}`
+      );
+    }
+    throw new GhAuthError(
+      "missing_scopes",
+      missingGhScopesMessage(scopeCheck.missing)
+    );
+  }
+  return {
+    source,
+    token,
+    login: viewer.login,
+    scopes: viewer.scopes
+  };
+}
+async function resolveGitHubAuth(opts) {
+  const envToken = getEnvGitHubToken();
+  let envError = null;
+  if (envToken) {
+    try {
+      return await validateGitHubToken(envToken, "env", opts);
+    } catch (error) {
+      if (error instanceof GhAuthError) {
+        envError = error;
+      } else {
+        throw error;
+      }
+    }
+  }
+  try {
+    const auth = ensureGhAuth(opts);
+    return await validateGitHubToken(auth.token, "gh", opts);
+  } catch (error) {
+    if (envError && error instanceof GhAuthError) {
+      throw envError;
+    }
+    throw error;
+  }
+}
+function ensureGhAuth(opts) {
+  const execImpl = opts?.execImpl ?? execFileSync;
+  const spawnImpl = opts?.spawnImpl ?? spawnSync;
+  if (!checkGhInstalled({ execImpl })) {
+    throw new GhAuthError(
+      "not_installed",
+      "gh CLI is not installed. Install it from https://cli.github.com or set GITHUB_GRAPHQL_TOKEN."
+    );
+  }
+  const auth = checkGhAuthenticated({ spawnImpl });
+  if (!auth.authenticated) {
+    throw new GhAuthError(
+      "not_authenticated",
+      "Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN."
+    );
+  }
+  const scopeCheck = checkGhScopes({ spawnImpl });
+  if (!scopeCheck.valid) {
+    throw new GhAuthError(
+      "missing_scopes",
+      missingGhScopesMessage(scopeCheck.missing)
+    );
+  }
+  const { token } = getGhTokenWithSource({
+    execImpl,
+    envToken: void 0
+  });
+  return { login: auth.login ?? "unknown", token, source: "gh" };
+}
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function runGhAuthCommand(mode, opts) {
+  const spawnImpl = opts?.spawnImpl ?? spawnSync;
+  const command = `gh auth ${mode} --scopes ${REQUIRED_GH_SCOPES.join(",")}`;
+  const interactive = opts?.interactive ?? isInteractiveTerminal();
+  if (!interactive) {
+    return {
+      mode,
+      status: "manual",
+      command,
+      summary: `Interactive terminal not available. Run '${command}' manually.`
+    };
+  }
+  const result = spawnImpl(
+    "gh",
+    ["auth", mode, "--scopes", REQUIRED_GH_SCOPES.join(",")],
+    {
+      stdio: "inherit"
+    }
+  );
+  if ((result.status ?? 1) === 0) {
+    return {
+      mode,
+      status: "applied",
+      command,
+      summary: `Executed '${command}'.`
+    };
+  }
+  return {
+    mode,
+    status: "manual",
+    command,
+    summary: `Failed to complete '${command}' automatically. Re-run it manually.`
+  };
+}
+function runGhAuthLogin(opts) {
+  return runGhAuthCommand("login", opts);
+}
+function runGhAuthRefresh(opts) {
+  return runGhAuthCommand("refresh", opts);
+}
+function parseLogin(output) {
+  const matched = output.match(
+    /Logged in to github\.com account\s+\*?\*?([A-Za-z0-9_-]+)\*?\*?/i
+  );
+  return matched?.[1];
+}
+function parseScopes(output) {
+  const matched = output.match(/Token scopes:\s*(.+)/i);
+  if (!matched) {
+    return [];
+  }
+  return matched[1].split(",").map((scope) => scope.trim().replace(/^'+|'+$/g, "")).filter((scope) => scope.length > 0);
+}
+
+export {
+  GitHubApiError,
+  GitHubScopeError,
+  createClient,
+  validateToken,
+  checkRequiredScopes,
+  listUserProjects,
+  getProjectDetail,
+  REQUIRED_GH_SCOPES,
+  GhAuthError,
+  getEnvGitHubToken,
+  checkGhInstalled,
+  checkGhAuthenticated,
+  checkGhScopes,
+  getGhToken,
+  getGhTokenWithSource,
+  validateGitHubToken,
+  resolveGitHubAuth,
+  ensureGhAuth,
+  runGhAuthLogin,
+  runGhAuthRefresh
+};

package/dist/{chunk-6HBZC3BE.js → chunk-XN5ABWZ6.js}

@@ -19,7 +19,7 @@ import {
 import {
   handleMissingManagedProjectConfig,
   resolveManagedProjectConfig
-} from "./chunk-TH5QPO3Y.js";
+} from "./chunk-C7G7RJ4G.js";
 
 // src/commands/status.ts
 import { readFile } from "fs/promises";
@@ -30,7 +30,7 @@ var COL_ID = 24;
 var COL_STATUS = 14;
 var COL_PID = 8;
 var COL_AGE_TURN = 12;
-var COL_TOKENS = 10;
+var COL_TOKENS = 17;
 var COL_SESSION = 14;
 var COL_ID_HEADER = COL_ID + 2;
 var identity = (s) => s;
@@ -63,6 +63,11 @@ function compactSessionId(id) {
 function fmtTokens(n) {
   return n.toLocaleString("en-US");
 }
+function fmtTokenPair(delta, cumulative) {
+  const left = fmtTokens(delta ?? 0);
+  const right = fmtTokens(cumulative ?? delta ?? 0);
+  return `${left} / ${right}`;
+}
 function fmtAge(startedAt, now) {
   if (!startedAt) return "0m";
   const diffMs = now - new Date(startedAt).getTime();
@@ -173,7 +178,10 @@ function activeRunRow(run, now, evtWidth, c) {
   const turn = run.turnCount ?? 0;
   const ageTurn = pad(`${age}/${turn}`, COL_AGE_TURN);
   const tokens = pad(
-    fmtTokens(run.tokenUsage?.totalTokens ?? 0),
+    fmtTokenPair(
+      run.tokenUsage?.totalTokens,
+      run.tokenUsage?.cumulativeTotalTokens
+    ),
     COL_TOKENS,
     "right"
   );
@@ -260,6 +268,15 @@ function truncate(s, len) {
   if (s.length <= len) return s;
   return s.slice(0, len - 3) + "...";
 }
+function formatTokenPair(delta, cumulative) {
+  return `${delta.toLocaleString("en-US")} / ${cumulative.toLocaleString("en-US")}`;
+}
+function resolveProjectTokenDelta(snapshot) {
+  return snapshot.activeRuns.reduce(
+    (sum, run) => sum + (run.tokenUsage?.totalTokens ?? 0),
+    0
+  );
+}
 function renderLegacyStatus(snapshot, noColor) {
   const apply = noColor ? (s) => stripAnsi(s) : (s) => s;
   const lines = [];
@@ -326,12 +343,13 @@ function renderLegacyStatus(snapshot, noColor) {
     lines.push("");
   }
   if (snapshot.codexTotals) {
+    const tokenDelta = resolveProjectTokenDelta(snapshot);
     const tokenStr = apply(
-      `Tokens: ${snapshot.codexTotals.inputTokens} in / ${snapshot.codexTotals.outputTokens} out / ${snapshot.codexTotals.totalTokens} total`
+      `Tokens: ${formatTokenPair(tokenDelta, snapshot.codexTotals.totalTokens)} total`
     );
     lines.push(`  ${tokenStr}`);
   } else {
-    lines.push("  Tokens: 0 in / 0 out / 0 total");
+    lines.push("  Tokens: 0 / 0 total");
   }
   return lines.join("\n");
 }

package/dist/{chunk-76QPITKI.js → chunk-Y6TYJMNT.js}

@@ -2,7 +2,7 @@
 import {
   handleMissingManagedProjectConfig,
   resolveManagedProjectConfig
-} from "./chunk-TH5QPO3Y.js";
+} from "./chunk-C7G7RJ4G.js";
 import {
   daemonPidPath
 } from "./chunk-ROGRTUFI.js";