@gh-symphony/cli 0.4.6 → 0.4.9

package/dist/{chunk-FBJRJWE5.js → chunk-RMXW2QQF.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   workflow_init_default
-} from "./chunk-DENDF6S6.js";
+} from "./chunk-77INSSMM.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber,
   inspectManagedProjectSelection,
   resolveTrackerAdapter
-} from "./chunk-RMNLHTIK.js";
+} from "./chunk-D7HICFZ5.js";
 import {
   GitHubApiError,
   createClient,
@@ -14,12 +14,12 @@ import {
   getGhTokenWithSource,
   getProjectDetail,
   validateGitHubToken
-} from "./chunk-SMNIGNS3.js";
+} from "./chunk-FFY5VKNV.js";
 import {
   buildPromptVariables,
   parseWorkflowMarkdown,
   renderPrompt
-} from "./chunk-RGCSM2KZ.js";
+} from "./chunk-77H5ED5L.js";
 import {
   loadActiveProjectConfig
 } from "./chunk-YZP5N5XP.js";

package/dist/{doctor-YV5NV4HX.js → doctor-U57B6LVZ.js}

@@ -5,18 +5,23 @@ import {
   parseIssueReference,
   readGitHubProjectBinding,
   renderIssueWorkflowPreview
-} from "./chunk-FBJRJWE5.js";
-import "./chunk-DENDF6S6.js";
+} from "./chunk-RMXW2QQF.js";
+import {
+  commandExistsOnPath
+} from "./chunk-JNEP7OYK.js";
+import "./chunk-77INSSMM.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber,
   fetchGithubProjectIssues,
   inspectManagedProjectSelection
-} from "./chunk-RMNLHTIK.js";
-import "./chunk-XLDJTMW5.js";
+} from "./chunk-D7HICFZ5.js";
+import "./chunk-MAJOIZ5Q.js";
+import "./chunk-LSH5HRQT.js";
 import {
   resolveRuntimeRoot
 } from "./chunk-3IRPSPAF.js";
 import {
+  DEFAULT_GITHUB_GRAPHQL_API_URL,
   GitHubApiError,
   REQUIRED_GH_SCOPES,
   checkGhAuthenticated,
@@ -31,16 +36,18 @@ import {
   runGhAuthLogin,
   runGhAuthRefresh,
   validateGitHubToken
-} from "./chunk-SMNIGNS3.js";
+} from "./chunk-FFY5VKNV.js";
 import {
   isClaudeRuntimeCommand,
-  parseWorkflowMarkdown,
-  redactObservabilityDiagnosticsWithStats,
-  redactObservabilityTextWithStats,
   resolveClaudeCommandBinary,
   resolveRuntimeCommandBinary,
   runClaudePreflight
-} from "./chunk-RGCSM2KZ.js";
+} from "./chunk-PKUD2SVX.js";
+import {
+  parseWorkflowMarkdown,
+  redactObservabilityDiagnosticsWithStats,
+  redactObservabilityTextWithStats
+} from "./chunk-77H5ED5L.js";
 import {
   configFilePath,
   orchestratorLogPath,
@@ -51,7 +58,7 @@ import {
 import { constants as constants2 } from "fs";
 import { execFileSync, spawnSync } from "child_process";
 import { access as access2, mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
-import { delimiter, isAbsolute, join as join2, resolve as resolve2 } from "path";
+import { isAbsolute, join as join2, resolve as resolve2 } from "path";
 
 // src/support/bundle.ts
 import { constants } from "fs";
@@ -537,6 +544,67 @@ function warnCheck(id, title, summary, remediation, details) {
 function formatAuthSource(source) {
   return source === "env" ? "GITHUB_GRAPHQL_TOKEN" : "gh CLI";
 }
+function normalizeGitHubGraphqlEndpoint(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const url = new URL(trimmed);
+    url.hostname = url.hostname.toLowerCase();
+    url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return trimmed.replace(/\/+$/, "");
+  }
+}
+function deriveGhHostnameFromGraphqlEndpoint(endpoint) {
+  try {
+    const hostname = new URL(endpoint).hostname.toLowerCase();
+    return hostname === "api.github.com" ? "github.com" : hostname;
+  } catch {
+    return void 0;
+  }
+}
+function resolveGitHubGraphqlEndpoint(input) {
+  const trackerApiUrl = normalizeGitHubGraphqlEndpoint(input.trackerApiUrl);
+  const envApiUrl = normalizeGitHubGraphqlEndpoint(input.envApiUrl);
+  const resolvedEndpoint = trackerApiUrl ?? envApiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL;
+  return {
+    resolvedEndpoint,
+    source: trackerApiUrl ? "tracker" : envApiUrl ? "env" : "default",
+    trackerApiUrl,
+    envApiUrl,
+    mismatch: trackerApiUrl !== null && envApiUrl !== null && trackerApiUrl !== envApiUrl,
+    ghHostname: deriveGhHostnameFromGraphqlEndpoint(resolvedEndpoint)
+  };
+}
+function buildGitHubGraphqlEndpointCheck(input) {
+  const details = {
+    resolvedEndpoint: input.resolvedEndpoint,
+    source: input.source,
+    trackerApiUrl: input.trackerApiUrl,
+    envApiUrl: input.envApiUrl,
+    ghHostname: input.ghHostname
+  };
+  if (input.mismatch) {
+    return warnCheck(
+      "github_graphql_endpoint",
+      "GitHub GraphQL endpoint",
+      `Resolved GitHub GraphQL endpoint is ${input.resolvedEndpoint}, but GITHUB_GRAPHQL_API_URL is ${input.envApiUrl}.`,
+      "Keep WORKFLOW.md tracker.endpoint/tracker.apiUrl and GITHUB_GRAPHQL_API_URL aligned, or unset GITHUB_GRAPHQL_API_URL so the workflow endpoint is authoritative.",
+      details
+    );
+  }
+  return passCheck(
+    "github_graphql_endpoint",
+    "GitHub GraphQL endpoint",
+    `Resolved GitHub GraphQL endpoint: ${input.resolvedEndpoint}.`,
+    details
+  );
+}
 function remediationStep(id, checkId, title, status, summary, command, details) {
   return { id, checkId, title, status, summary, command, details };
 }
@@ -626,49 +694,6 @@ function formatGhSymphonyCommand(args, deps, options) {
   );
   return `gh-symphony ${commandArgs.join(" ")}`;
 }
-function getCommandCandidates(binary, deps) {
-  if (deps.platform !== "win32") {
-    return [binary];
-  }
-  const pathExts = (deps.pathExtEnv ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => ext.trim()).filter(Boolean);
-  const normalizedBinary = binary.toLowerCase();
-  if (pathExts.some((ext) => normalizedBinary.endsWith(ext.toLowerCase()))) {
-    return [binary];
-  }
-  return [binary, ...pathExts.map((ext) => `${binary}${ext}`)];
-}
-async function commandExistsOnPath(binary, deps) {
-  if (!binary) {
-    return false;
-  }
-  const candidates = getCommandCandidates(binary, deps);
-  if (isAbsolute(binary) || binary.includes("/") || binary.includes("\\")) {
-    for (const candidate of candidates) {
-      try {
-        await deps.access(resolve2(candidate), constants2.X_OK);
-        return true;
-      } catch {
-        continue;
-      }
-    }
-    return false;
-  }
-  for (const segment of (deps.pathEnv ?? "").split(delimiter)) {
-    if (!segment) {
-      continue;
-    }
-    for (const command of candidates) {
-      const candidate = join2(segment, command);
-      try {
-        await deps.access(candidate, constants2.X_OK);
-        return true;
-      } catch {
-        continue;
-      }
-    }
-  }
-  return false;
-}
 function toDoctorClaudeCheck(check) {
   const id = check.id;
   if (check.status === "pass") {
@@ -768,7 +793,10 @@ function buildGithubTrackerConfig(input) {
 }
 async function checkLinearTrackerResolution(input) {
   const tracker = input.projectConfig.projectConfig.tracker;
-  const projectSlug = readStringSetting(tracker.settings, "projectSlug")?.trim();
+  const projectSlug = readStringSetting(
+    tracker.settings,
+    "projectSlug"
+  )?.trim();
   const activeStates = readLinearActiveStates(tracker.settings);
   const pickupLabels = readLinearPickupLabels(tracker.settings);
   if (!projectSlug) {
@@ -915,7 +943,9 @@ async function fetchLinearProjectBySlug(input) {
     })
   });
   if (!response.ok) {
-    throw new Error(`Linear GraphQL request failed with HTTP ${response.status}.`);
+    throw new Error(
+      `Linear GraphQL request failed with HTTP ${response.status}.`
+    );
   }
   const payload = await response.json();
   if (payload.errors?.length) {
@@ -1453,6 +1483,7 @@ ${DOCTOR_USAGE}`);
   let resolvedProjectConfig = null;
   let resolvedGithubProjectDetail = null;
   let resolvedGithubProjectBindingId = null;
+  let githubGraphqlEndpoint = null;
   const envToken = deps.getEnvGitHubToken();
   const currentNodeVersion = deps.processVersion;
   const currentNodeMajor = parseMajorNodeVersion(currentNodeVersion);
@@ -1531,19 +1562,68 @@ ${DOCTOR_USAGE}`);
       )
     );
   }
-  const ghAuth = ghInstalled ? deps.checkGhAuthenticated() : { authenticated: false };
-  const ghScopes = ghInstalled && ghAuth.authenticated ? deps.checkGhScopes() : { valid: false, missing: [...REQUIRED_GH_SCOPES], scopes: [] };
+  resolvedProjectConfig = await deps.inspectManagedProjectSelection({
+    configDir: options.configDir,
+    requestedProjectId: parsedArgs.projectId
+  });
+  if (resolvedProjectConfig.kind === "resolved") {
+    resolvedProjectId = resolvedProjectConfig.projectId;
+    checks.push(
+      passCheck(
+        "managed_project",
+        "Managed project selection",
+        `Resolved managed project "${resolvedProjectConfig.projectId}".`,
+        {
+          projectId: resolvedProjectConfig.projectId,
+          workspaceDir: resolvedProjectConfig.projectConfig.workspaceDir
+        }
+      )
+    );
+    if (resolvedProjectConfig.projectConfig.tracker.adapter !== "linear") {
+      githubGraphqlEndpoint = resolveGitHubGraphqlEndpoint({
+        trackerApiUrl: resolvedProjectConfig.projectConfig.tracker.apiUrl,
+        envApiUrl: process.env.GITHUB_GRAPHQL_API_URL
+      });
+      checks.push(buildGitHubGraphqlEndpointCheck(githubGraphqlEndpoint));
+    }
+  } else {
+    checks.push(
+      failCheck(
+        "managed_project",
+        "Managed project selection",
+        resolvedProjectConfig.message,
+        "Run 'gh-symphony repo init' from the target repository.",
+        {
+          reason: resolvedProjectConfig.kind,
+          ...resolvedProjectConfig.projectId ? { projectId: resolvedProjectConfig.projectId } : {}
+        }
+      )
+    );
+  }
+  const ghHostname = githubGraphqlEndpoint?.ghHostname;
+  const ghAuth = ghInstalled ? deps.checkGhAuthenticated({ hostname: ghHostname }) : { authenticated: false };
+  const ghScopes = ghInstalled && ghAuth.authenticated ? deps.checkGhScopes({ hostname: ghHostname }) : { valid: false, missing: [...REQUIRED_GH_SCOPES], scopes: [] };
+  const ghHostnameArg = ghHostname ? ` --hostname ${ghHostname}` : "";
+  const ghLoginCommand = `gh auth login --scopes ${REQUIRED_GH_SCOPES.join(",")}${ghHostnameArg}`;
+  const ghRefreshCommand = `gh auth refresh --scopes ${REQUIRED_GH_SCOPES.join(",")}${ghHostnameArg}`;
   if (envToken) {
     try {
-      auth = await deps.validateGitHubToken(envToken, "env");
+      auth = await deps.validateGitHubToken(envToken, "env", {
+        apiUrl: githubGraphqlEndpoint?.resolvedEndpoint
+      });
     } catch (error) {
       envTokenError = error instanceof Error ? error.message : "Unknown token validation error.";
     }
   }
   if (!auth && ghInstalled && ghAuth.authenticated && ghScopes.valid) {
     try {
-      const ghToken = deps.getGhToken({ allowEnv: false });
-      auth = await deps.validateGitHubToken(ghToken, "gh");
+      const ghToken = deps.getGhToken({
+        allowEnv: false,
+        hostname: ghHostname
+      });
+      auth = await deps.validateGitHubToken(ghToken, "gh", {
+        apiUrl: githubGraphqlEndpoint?.resolvedEndpoint
+      });
     } catch (error) {
       tokenError = error instanceof Error ? error.message : "Unknown token retrieval error.";
     }
@@ -1575,7 +1655,7 @@ ${DOCTOR_USAGE}`);
         "gh_authentication",
         "GitHub authentication",
         "gh auth status failed or no GitHub login is configured.",
-        `Run 'gh auth login --scopes ${REQUIRED_GH_SCOPES.join(",")}' and re-run the doctor command.`
+        `Run '${ghLoginCommand}' and re-run the doctor command.`
       )
     );
   }
@@ -1605,42 +1685,11 @@ ${DOCTOR_USAGE}`);
         "gh_scopes",
         "GitHub token scopes",
         `Missing required scopes: ${missingScopes.join(", ")}.`,
-        `Run 'gh auth refresh --scopes ${REQUIRED_GH_SCOPES.join(",")}' and confirm 'gh auth status' shows the updated scopes.`,
+        `Run '${ghRefreshCommand}' and confirm 'gh auth status${ghHostnameArg}' shows the updated scopes.`,
         { missing: missingScopes, scopes: ghScopes.scopes }
       )
     );
   }
-  resolvedProjectConfig = await deps.inspectManagedProjectSelection({
-    configDir: options.configDir,
-    requestedProjectId: parsedArgs.projectId
-  });
-  if (resolvedProjectConfig.kind === "resolved") {
-    resolvedProjectId = resolvedProjectConfig.projectId;
-    checks.push(
-      passCheck(
-        "managed_project",
-        "Managed project selection",
-        `Resolved managed project "${resolvedProjectConfig.projectId}".`,
-        {
-          projectId: resolvedProjectConfig.projectId,
-          workspaceDir: resolvedProjectConfig.projectConfig.workspaceDir
-        }
-      )
-    );
-  } else {
-    checks.push(
-      failCheck(
-        "managed_project",
-        "Managed project selection",
-        resolvedProjectConfig.message,
-        "Run 'gh-symphony repo init' from the target repository.",
-        {
-          reason: resolvedProjectConfig.kind,
-          ...resolvedProjectConfig.projectId ? { projectId: resolvedProjectConfig.projectId } : {}
-        }
-      )
-    );
-  }
   if (resolvedProjectConfig.kind === "resolved" && resolvedProjectConfig.projectConfig.tracker.adapter === "linear") {
     checks.push(
       await checkLinearTrackerResolution({
@@ -1683,7 +1732,9 @@ ${DOCTOR_USAGE}`);
         throw new Error("Managed project is not bound to a GitHub Project.");
       }
       resolvedGithubProjectBindingId = bindingId;
-      const client = deps.createClient(auth.token);
+      const client = deps.createClient(auth.token, {
+        apiUrl: githubGraphqlEndpoint?.resolvedEndpoint
+      });
       const detail = await deps.getProjectDetail(client, bindingId);
       resolvedGithubProjectDetail = detail;
       checks.push(

package/dist/index.d.ts

@@ -1,10 +1,49 @@
 type GlobalOptions = {
     configDir: string;
+    configDirOverride?: boolean;
+    configDirSource?: "cli" | "env" | "default";
     verbose: boolean;
     json: boolean;
     noColor: boolean;
 };
 type CommandHandler = (args: string[], options: GlobalOptions) => Promise<void>;
+type CliOptionValues = Partial<GlobalOptions & {
+    assignedOnly?: boolean;
+    config?: string;
+    daemon?: boolean;
+    dryRun?: boolean;
+    file?: string;
+    fix?: boolean;
+    follow?: boolean;
+    force?: boolean;
+    http?: string | boolean;
+    issue?: string;
+    level?: string;
+    logLevel?: string;
+    linearProjectSlug?: string;
+    nonInteractive?: boolean;
+    once?: boolean;
+    output?: string;
+    project?: string;
+    projectId?: string;
+    prune?: boolean;
+    run?: string;
+    runtime?: string;
+    skipContext?: boolean;
+    skipSkills?: boolean;
+    version?: boolean;
+    web?: string | boolean;
+    repoDir?: string;
+    workflowFile?: string;
+    workflow?: string;
+    watch?: boolean;
+    sample?: string;
+    smoke?: boolean;
+    bundle?: string | boolean;
+    attempt?: string;
+    tracker?: string;
+}>;
+declare function resolveGlobalOptions(values: CliOptionValues): GlobalOptions;
 declare function runCli(argv: string[]): Promise<void>;
 
-export { type CommandHandler, type GlobalOptions, runCli };
+export { type CommandHandler, type GlobalOptions, resolveGlobalOptions, runCli };