@dbx-tools/core 0.9.69 → 0.9.71

package/lib/src/project-utils.d.ts

@@ -13,7 +13,9 @@ import { net } from "@dbx-tools/shared-core";
 export declare function resolveWorkingDirectory(cwd?: string | null): string;
 /** A command's stdout, classified as a filesystem path and/or a URL. */
 export interface ProjectContext {
-    readonly output: string;
+    readonly output?: string;
+    /** Whether the command exited successfully. */
+    readonly success: boolean;
     /** `output` when it names something on disk. */
     readonly path?: string;
     /** `file.statSync` of {@link path}, when it exists. */
@@ -45,6 +47,44 @@ export declare function resolveProjectRoots(cwd?: string): Generator<string>;
  * directory's basename.
  */
 export declare function name(cwd?: string): string;
+/** Parsed GitHub-style remote coordinates. */
+export interface ProjectGhRemote {
+    /** Account hinted by an SSH alias such as `git@github-work:`. */
+    readonly accountHint?: string;
+    /** Host written in the remote before SSH alias resolution. */
+    readonly host: string;
+    /** `owner/repository` path. */
+    readonly repository: string;
+}
+/** Authenticated GitHub CLI account selected for one project remote. */
+export interface ProjectGhAccount {
+    /** Environment to pass to every `gh` command for this project. */
+    readonly env: NodeJS.ProcessEnv;
+    /** Actual GitHub host selected from `gh auth status`. */
+    readonly host: string;
+    /** Authenticated GitHub login. */
+    readonly login: string;
+    /** Parsed project remote. */
+    readonly remote: ProjectGhRemote;
+    /** Resolved project directory used for command execution. */
+    readonly root: string;
+}
+/** Options for cached project GitHub-account resolution. */
+export interface ResolveProjectGhAccountOptions {
+    /** Git remote name. Defaults to `origin`. */
+    readonly remote?: string;
+    /** Re-read git, SSH, and GitHub CLI state instead of using the process cache. */
+    readonly refresh?: boolean;
+}
+/** Parse HTTPS, SSH URL, or scp-like GitHub remote coordinates. */
+export declare function parseProjectGhRemote(remoteUrl: string): ProjectGhRemote | undefined;
+/**
+ * Resolve and cache the authenticated `gh` account that can access a project's
+ * remote. SSH alias account hints win, followed by the active account on the
+ * effective SSH/HTTPS host, then other authenticated accounts. Every candidate
+ * is verified against the repository before it is returned.
+ */
+export declare function resolveProjectGhAccount(cwd?: string, options?: ResolveProjectGhAccountOptions): ProjectGhAccount | undefined;
 /**
  * The repo's canonical remote URL, or `undefined` when there is no git remote.
  * Tries `gh repo view` first (host-accurate, no parsing), then normalizes

package/lib/src/project-utils.js

@@ -25,16 +25,12 @@ const ROOT_MARKERS = [
 export function resolveWorkingDirectory(cwd) {
     return resolve(stringUtils.trimToNull(cwd) ?? process.cwd());
 }
-/**
- * because this is crucial do not use exec.spawnSync
- *
- * Run `command args` in `cwd` and classify its stdout: `path` + `pathStats` when
- * the output names something on disk, `url` (a {@link net.UrlBuilder}) when it
- * parses as a real network URL. Empty {@link ProjectContext} on a non-zero exit
- * or empty output.
- */
-function projectContextCommandOutput(command, args, cwd) {
-    const result = spawnSync(command, args, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+function projectContextCommandOutput(command, args, cwd, env) {
+    const result = spawnSync(command, args, {
+        cwd,
+        env: env ?? process.env,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
     const output = result?.stdout?.toString()?.trim();
     if (result.status === 0 && output) {
         const pathStats = fileStatSync(output);
@@ -43,27 +39,47 @@ function projectContextCommandOutput(command, args, cwd) {
         // `http://localhost/…`), which would mislabel directory outputs and bare
         // tokens - so gate on the raw output already carrying a scheme + authority.
         const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(output) ? net.urlBuilder(output) : undefined;
-        return { output, path: pathStats ? output : undefined, pathStats, url };
+        return { output, path: pathStats ? output : undefined, pathStats, success: true, url };
     }
-    return { output };
+    return { output, success: result.status === 0 };
 }
 const projectCommandCache = new Map();
-function projectContextCommand(command, args, cwd) {
+function projectContextCommand(command, args, cwd, options = {}) {
     const resolved = resolveWorkingDirectory(cwd);
-    const key = resolved === resolveWorkingDirectory() ? JSON.stringify([command, ...args]) : undefined;
+    const cache = options.cache ?? (!options.env && resolved === resolveWorkingDirectory());
+    const key = cache ? JSON.stringify([resolved, command, ...args]) : undefined;
     if (key !== undefined) {
         const cached = projectCommandCache.get(key);
         if (cached !== undefined)
             return cached;
     }
-    const value = projectContextCommandOutput(command, args, resolved);
+    const value = projectContextCommandOutput(command, args, resolved, options.env);
     if (key !== undefined)
         projectCommandCache.set(key, value);
     return value;
 }
-function commandRoot(command, args, cwd) {
-    const parsed = projectContextCommand(command, args, cwd);
-    return parsed.pathStats?.isDirectory() ? parsed.path : undefined;
+function projectCommand(command) {
+    const context = (args, cwd, options) => projectContextCommand(command, args, cwd, options);
+    return {
+        context,
+        output(args, cwd, options) {
+            return stringUtils.trimToNull(context(args, cwd, options).output) ?? undefined;
+        },
+        root(args, cwd) {
+            const parsed = context(args, cwd);
+            return parsed.pathStats?.isDirectory() ? parsed.path : undefined;
+        },
+        succeeds(args, cwd, options) {
+            return context(args, cwd, options).success;
+        },
+    };
+}
+const gitCommand = projectCommand("git");
+const ghCommand = projectCommand("gh");
+const npmCommand = projectCommand("npm");
+const sshCommand = projectCommand("ssh");
+function gitRemoteUrl(cwd, remote = "origin", refresh = false) {
+    return gitCommand.output(["remote", "get-url", remote], cwd, { cache: !refresh });
 }
 /**
  * Closest directory with a `package.json` or `node_modules`, matching `npm prefix`.
@@ -83,7 +99,7 @@ function npmRoot(cwd) {
         if (fromEnv)
             return fromEnv;
     }
-    return commandRoot("npm", ["prefix"], resolved);
+    return npmCommand.root(["prefix"], resolved);
 }
 function envDirectory(value) {
     const path = stringUtils.trimToNull(value);
@@ -94,7 +110,7 @@ function envDirectory(value) {
 }
 function gitRoot(cwd) {
     const resolved = resolveWorkingDirectory(cwd);
-    return commandRoot("git", ["rev-parse", "--show-toplevel"], resolved);
+    return gitCommand.root(["rev-parse", "--show-toplevel"], resolved);
 }
 /** Resolve the nearest project root without walking above its npm or Git boundary. */
 export function root(cwd) {
@@ -211,7 +227,7 @@ export function name(cwd) {
     const fromPackage = readPackageName(resolve(rootDir, "package.json"));
     if (fromPackage)
         return fromPackage;
-    const remote = projectContextCommand("git", ["-C", rootDir, "remote", "get-url", "origin"], rootDir).output;
+    const remote = gitRemoteUrl(rootDir);
     const fromGit = remote ? parseGitRemote(remote) : undefined;
     if (fromGit)
         return fromGit;
@@ -223,17 +239,114 @@ export function name(cwd) {
  * `undefined` when `gh` is absent, unauthenticated, or the dir isn't a GH repo.
  */
 function repositoryUrlFromGh(cwd) {
-    const out = projectContextCommand("gh", ["repo", "view", "--json", "url"], cwd).output;
+    const account = resolveProjectGhAccount(cwd);
+    if (!account)
+        return undefined;
+    const out = ghCommand.output(["repo", "view", account.remote.repository, "--json", "url"], account.root, { cache: false, env: account.env });
     return stringUtils.trimToNull(json.parseRecord(out)?.url) ?? undefined;
 }
 /** Resolve an ssh host alias (`~/.ssh/config`) to its effective `hostname` via `ssh -G`. */
-function resolveSshHostName(host, cwd) {
-    const line = projectContextCommand("ssh", ["-G", host], cwd)
+function resolveSshHostName(host, cwd, refresh = false) {
+    const line = sshCommand
+        .context(["-G", host], cwd, { cache: !refresh })
         .output?.split("\n")
         .find((l) => /^hostname\s/i.test(l.trim()));
     const name = line?.trim().split(/\s+/)[1];
     return name && name !== host ? name : undefined;
 }
+/** Parse HTTPS, SSH URL, or scp-like GitHub remote coordinates. */
+export function parseProjectGhRemote(remoteUrl) {
+    const value = remoteUrl.trim().replace(/\.git$/i, "");
+    const https = /^https?:\/\/([^/]+)\/([^/]+)\/([^/]+)$/i.exec(value);
+    if (https)
+        return { host: https[1], repository: `${https[2]}/${https[3]}` };
+    const ssh = /^(?:ssh:\/\/)?git@([^/:]+)[:/]([^/]+)\/([^/]+)$/i.exec(value);
+    if (!ssh)
+        return undefined;
+    const accountHint = /^github-(.+)$/i.exec(ssh[1])?.[1];
+    return {
+        ...(accountHint ? { accountHint } : {}),
+        host: ssh[1],
+        repository: `${ssh[2]}/${ssh[3]}`,
+    };
+}
+const projectGhAccountCache = new Map();
+/**
+ * Resolve and cache the authenticated `gh` account that can access a project's
+ * remote. SSH alias account hints win, followed by the active account on the
+ * effective SSH/HTTPS host, then other authenticated accounts. Every candidate
+ * is verified against the repository before it is returned.
+ */
+export function resolveProjectGhAccount(cwd, options = {}) {
+    const root = resolveWorkingDirectory(cwd);
+    const remoteName = stringUtils.trimToNull(options.remote) ?? "origin";
+    const key = JSON.stringify([
+        root,
+        remoteName,
+        homedir(),
+        process.env.GH_CONFIG_DIR ?? "",
+    ]);
+    if (!options.refresh && projectGhAccountCache.has(key)) {
+        return projectGhAccountCache.get(key) ?? undefined;
+    }
+    const remoteUrl = gitRemoteUrl(root, remoteName, options.refresh);
+    if (!remoteUrl)
+        return undefined;
+    const remote = parseProjectGhRemote(remoteUrl);
+    if (!remote)
+        return undefined;
+    const effectiveHost = resolveSshHostName(remote.host, root, options.refresh) ?? remote.host;
+    const status = ghCommand.output(["auth", "status", "--json", "hosts"], root, {
+        cache: false,
+    });
+    if (!status) {
+        projectGhAccountCache.set(key, null);
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(status);
+    }
+    catch {
+        projectGhAccountCache.set(key, null);
+        return undefined;
+    }
+    const accounts = Object.entries(parsed.hosts ?? {}).flatMap(([host, entries]) => entries
+        .filter((entry) => entry.state === "success" && entry.login)
+        .map((entry) => ({
+        active: entry.active === true,
+        host: entry.host ?? host,
+        login: entry.login,
+    })));
+    accounts.sort((left, right) => {
+        const rank = (account) => {
+            if (remote.accountHint && account.login === remote.accountHint)
+                return 0;
+            if (account.host === effectiveHost && account.active)
+                return 1;
+            if (account.host === effectiveHost)
+                return 2;
+            if (account.active)
+                return 3;
+            return 4;
+        };
+        return rank(left) - rank(right);
+    });
+    for (const account of accounts) {
+        const token = ghCommand.output(["auth", "token", "--hostname", account.host, "--user", account.login], root, { cache: false });
+        if (!token)
+            continue;
+        const env = { ...process.env, GH_HOST: account.host, GH_TOKEN: token };
+        if (!ghCommand.succeeds(["api", "--hostname", account.host, `repos/${remote.repository}`, "--silent"], root, { cache: false, env })) {
+            continue;
+        }
+        const selected = { env, host: account.host, login: account.login, remote, root };
+        projectGhAccountCache.set(key, selected);
+        return selected;
+    }
+    projectGhAccountCache.set(key, null);
+    return undefined;
+}
 /**
  * Fallback: normalize `git remote get-url origin` to a plain
  * `https://host/owner/repo` URL. scp-like / `ssh://` / `git://` /
@@ -241,7 +354,7 @@ function resolveSshHostName(host, cwd) {
  * followed to its real hostname.
  */
 function repositoryUrlFromGit(cwd) {
-    const raw = projectContextCommand("git", ["remote", "get-url", "origin"], cwd).output;
+    const raw = gitRemoteUrl(cwd);
     if (!raw)
         return undefined;
     // Normalize the scheme to https at the string level first: the WHATWG `URL`
@@ -261,7 +374,7 @@ function repositoryUrlFromGit(cwd) {
     if (builder.username || builder.password) {
         builder = builder.with("username", "").with("password", "");
     }
-    // Follow an ssh host alias to the true host (so `github-reggie-db` -> `github.com`).
+    // Follow an ssh host alias to the true host.
     const realHost = resolveSshHostName(builder.hostname, cwd);
     if (realHost)
         builder = builder.with("hostname", realHost);
@@ -497,5 +610,14 @@ if (import.meta.main) {
     console.log("project name:", name());
     console.log("repository url:", repositoryUrl());
     console.log("repository url (npm):", repositoryUrl(undefined, "npm"));
+    const ghAccount = resolveProjectGhAccount();
+    if (ghAccount) {
+        console.log("project gh host:", ghAccount.host);
+        console.log("project gh login:", ghAccount.login);
+        console.log("project gh remote:", ghAccount.remote.repository);
+    }
+    else {
+        console.log("project gh account: not found");
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-utils.js","sourceRoot":"","sources":["../../src/project-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repository, package, bundle, and project discovery for Node and Bun tools.\n *\n * This module is the shared owner for working-directory normalization, project\n * roots, repository URLs, package names, and Databricks bundle context. Reuse it\n * instead of adding package-local root-marker walks or Git remote parsing.\n *\n * @module\n */\n\nimport { spawnSync } from \"node:child_process\";\nimport { Stats, readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { basename, dirname, join, resolve } from \"node:path\";\nimport { json, net, object, stringUtils } from \"@dbx-tools/shared-core\";\nimport { parse as parseYaml } from \"yaml\";\nimport { cachedRecord, statSync as fileStatSync } from \"./file.ts\";\n\nconst ROOT_MARKERS = [\n  \".projenrc.ts\",\n  \".projenrc.js\",\n  \".projenrc.mjs\",\n  \".projenrc.cjs\",\n  \"package.json\",\n] as const;\n\n/** Resolve a blank, null, omitted, relative, or absolute cwd to an absolute path. */\nexport function resolveWorkingDirectory(cwd?: string | null): string {\n  return resolve(stringUtils.trimToNull(cwd) ?? process.cwd());\n}\n\n/** A command's stdout, classified as a filesystem path and/or a URL. */\nexport interface ProjectContext {\n  readonly output: string;\n  /** `output` when it names something on disk. */\n  readonly path?: string;\n  /** `file.statSync` of {@link path}, when it exists. */\n  readonly pathStats?: Stats;\n  /**\n   * `output` parsed into a chainable {@link net.UrlBuilder}, when it is a real\n   * network URL - a non-blank scheme (not `file:`) AND a non-blank hostname.\n   * Bare paths, scp-like `git@host:...` remotes, and `file:` URLs stay unset.\n   */\n  readonly url?: net.UrlBuilder;\n}\n\n/**\n * because this is crucial do not use exec.spawnSync\n *\n * Run `command args` in `cwd` and classify its stdout: `path` + `pathStats` when\n * the output names something on disk, `url` (a {@link net.UrlBuilder}) when it\n * parses as a real network URL. Empty {@link ProjectContext} on a non-zero exit\n * or empty output.\n */\nfunction projectContextCommandOutput(command: string, args: string[], cwd: string): ProjectContext {\n  const result = spawnSync(command, args, { cwd, stdio: [\"ignore\", \"pipe\", \"ignore\"] });\n  const output = result?.stdout?.toString()?.trim();\n  if (result.status === 0 && output) {\n    const pathStats = fileStatSync(output);\n    // Only an EXPLICIT `scheme://...` counts as a URL. `urlBuilder` otherwise\n    // synthesizes one (a bare `example.com` -> `https://…`, an absolute path ->\n    // `http://localhost/…`), which would mislabel directory outputs and bare\n    // tokens - so gate on the raw output already carrying a scheme + authority.\n    const url = /^[a-z][a-z0-9+.-]*:\\/\\//i.test(output) ? net.urlBuilder(output) : undefined;\n    return { output, path: pathStats ? output : undefined, pathStats, url };\n  }\n  return { output };\n}\n\nconst projectCommandCache = new Map<string, ProjectContext>();\n\nfunction projectContextCommand(command: string, args: string[], cwd?: string): ProjectContext {\n  const resolved = resolveWorkingDirectory(cwd);\n  const key =\n    resolved === resolveWorkingDirectory() ? JSON.stringify([command, ...args]) : undefined;\n  if (key !== undefined) {\n    const cached = projectCommandCache.get(key);\n    if (cached !== undefined) return cached;\n  }\n  const value = projectContextCommandOutput(command, args, resolved);\n  if (key !== undefined) projectCommandCache.set(key, value);\n  return value;\n}\n\nfunction commandRoot(command: string, args: string[], cwd: string): string | undefined {\n  const parsed = projectContextCommand(command, args, cwd);\n  return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n}\n\n/**\n * Closest directory with a `package.json` or `node_modules`, matching `npm prefix`.\n *\n * Lifecycle scripts from npm and Bun set `npm_config_local_prefix` to that\n * directory. Read it first when resolving this process's cwd so a missing npm\n * CLI is not required. `npm_config_prefix` / `PREFIX` are the global install\n * prefix and must not be used here.\n *\n * Bun has no prefix command (`bun pm bin` is the `.bin` directory). pnpm's\n * `prefix` command is unimplemented; `pnpm root` prints `node_modules`.\n */\nfunction npmRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  if (resolved === resolveWorkingDirectory()) {\n    const fromEnv = envDirectory(process.env.npm_config_local_prefix);\n    if (fromEnv) return fromEnv;\n  }\n  return commandRoot(\"npm\", [\"prefix\"], resolved);\n}\n\nfunction envDirectory(value: string | undefined): string | undefined {\n  const path = stringUtils.trimToNull(value);\n  if (!path) return undefined;\n  const resolved = resolve(path);\n  return fileStatSync(resolved)?.isDirectory() ? resolved : undefined;\n}\n\nfunction gitRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return commandRoot(\"git\", [\"rev-parse\", \"--show-toplevel\"], resolved);\n}\n\n/** Resolve the nearest project root without walking above its npm or Git boundary. */\nexport function root(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  let current = resolved;\n\n  if (!fileStatSync(current)?.isDirectory()) {\n    current = dirname(current);\n  }\n  const boundaries = new Set(\n    [npmBoundary(resolved), gitRoot(resolved)]\n      .filter((path): path is string => path !== undefined)\n      .map((path) => resolve(path)),\n  );\n  const hasBoundary = boundaries.size > 0;\n  let best: { dir: string; priority: number } | undefined;\n  while (true) {\n    for (const [priority, marker] of ROOT_MARKERS.entries()) {\n      if (fileStatSync(join(current, marker))?.isFile()) {\n        if (\n          best === undefined ||\n          priority < best.priority ||\n          (priority === best.priority && current.length < best.dir.length)\n        ) {\n          best = { dir: current, priority };\n        }\n        break;\n      }\n    }\n    if (!hasBoundary && best) {\n      return best.dir;\n    }\n    if (boundaries.has(current)) {\n      return best?.dir;\n    }\n    const parent = dirname(current);\n    if (parent === current) {\n      return best?.dir;\n    }\n    current = parent;\n  }\n}\n\nfunction npmBoundary(cwd: string): string | undefined {\n  const candidate = npmRoot(cwd);\n  if (!candidate) return undefined;\n  const resolved = resolve(candidate);\n  if (fileStatSync(join(resolved, \"package.json\"))?.isFile()) return resolved;\n  if (fileStatSync(join(resolved, \"node_modules\"))?.isDirectory()) return resolved;\n  return undefined;\n}\n\n/**\n * Parse a git remote URL (`https://...`, `git@host:owner/repo.git`, etc.) and\n * return the repo segment, stripping any `.git` suffix. Returns `undefined` for\n * empty or unparsable input.\n */\nexport function parseGitRemote(url: string): string | undefined {\n  const trimmed = url.trim();\n  if (!trimmed) return undefined;\n\n  const scp = /^[^@]+@[^:]+:(.+)$/i.exec(trimmed);\n  if (scp) return lastPathSegment(scp[1] ?? \"\");\n\n  try {\n    const normalized = trimmed.replace(/\\.git$/i, \"\");\n    const pathname = new URL(normalized).pathname;\n    const segment = pathname.split(\"/\").filter(Boolean).at(-1);\n    return segment ? lastPathSegment(segment) : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction lastPathSegment(path: string): string {\n  const segment = path.split(\"/\").filter(Boolean).at(-1) ?? path;\n  return segment.replace(/\\.git$/i, \"\");\n}\n\n/**\n * Yield candidate project-root directories for `cwd`, in priority order: the\n * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;\n * only existing directories are yielded (except the final `cwd` fallback).\n */\nexport function* resolveProjectRoots(cwd?: string): Generator<string> {\n  const base = resolveWorkingDirectory(cwd);\n  const seen = new Set<string>();\n  for (const candidate of [npmRoot(base), gitRoot(base)]) {\n    if (!candidate) continue;\n    const dir = resolve(candidate);\n    if (seen.has(dir)) continue;\n    seen.add(dir);\n    if (fileStatSync(dir)?.isDirectory()) yield dir;\n  }\n  if (!seen.has(base)) yield base;\n}\n\n/** The nearest ancestor of `cwd` (from {@link resolveProjectRoots}) with a `package.json`. */\nfunction workspaceRoot(cwd?: string): string {\n  let last: string | undefined;\n  for (const dir of resolveProjectRoots(cwd)) {\n    if (fileStatSync(resolve(dir, \"package.json\"))?.isFile()) return dir;\n    last = dir;\n  }\n  return last ?? resolveWorkingDirectory(cwd);\n}\n\n/**\n * Resolve a human-friendly project name for the repo rooted at `cwd`:\n * `package.json` `name`, then the git remote's repo name, then the root\n * directory's basename.\n */\nexport function name(cwd?: string): string {\n  const resolved = resolveWorkingDirectory(cwd);\n  const rootDir = workspaceRoot(resolved);\n\n  const fromPackage = readPackageName(resolve(rootDir, \"package.json\"));\n  if (fromPackage) return fromPackage;\n\n  const remote = projectContextCommand(\n    \"git\",\n    [\"-C\", rootDir, \"remote\", \"get-url\", \"origin\"],\n    rootDir,\n  ).output;\n  const fromGit = remote ? parseGitRemote(remote) : undefined;\n  if (fromGit) return fromGit;\n\n  return basename(rootDir);\n}\n\n/**\n * The GitHub CLI's canonical repo URL - the easy path. `gh` already resolves the\n * true host (no ssh-alias parsing) and prints a clean `https://host/owner/repo`.\n * `undefined` when `gh` is absent, unauthenticated, or the dir isn't a GH repo.\n */\nfunction repositoryUrlFromGh(cwd?: string): string | undefined {\n  const out = projectContextCommand(\"gh\", [\"repo\", \"view\", \"--json\", \"url\"], cwd).output;\n  return stringUtils.trimToNull(json.parseRecord(out)?.url) ?? undefined;\n}\n\n/** Resolve an ssh host alias (`~/.ssh/config`) to its effective `hostname` via `ssh -G`. */\nfunction resolveSshHostName(host: string, cwd?: string): string | undefined {\n  const line = projectContextCommand(\"ssh\", [\"-G\", host], cwd)\n    .output?.split(\"\\n\")\n    .find((l) => /^hostname\\s/i.test(l.trim()));\n  const name = line?.trim().split(/\\s+/)[1];\n  return name && name !== host ? name : undefined;\n}\n\n/**\n * Fallback: normalize `git remote get-url origin` to a plain\n * `https://host/owner/repo` URL. scp-like / `ssh://` / `git://` /\n * embedded-credential forms are rewritten to https, and an ssh host alias is\n * followed to its real hostname.\n */\nfunction repositoryUrlFromGit(cwd?: string): string | undefined {\n  const raw = projectContextCommand(\"git\", [\"remote\", \"get-url\", \"origin\"], cwd).output;\n  if (!raw) return undefined;\n\n  // Normalize the scheme to https at the string level first: the WHATWG `URL`\n  // parser can't convert a non-special scheme (`ssh`/`git`) to `https` (the\n  // `protocol` setter no-ops), and scp-like `git@host:owner/repo` isn't a URL at\n  // all. Rewrite both into an `https://` string, then let {@link net.urlBuilder}\n  // own the structured edits (strip credentials, swap the host).\n  let https = raw.replace(/^git\\+/, \"\");\n  const scp = /^[^@]+@([^:]+):(.+)$/.exec(https);\n  if (scp) https = `https://${scp[1]}/${scp[2]}`;\n  https = https.replace(/^(ssh|git):\\/\\//, \"https://\");\n\n  let builder = net.urlBuilder(https);\n  if (!builder) return undefined;\n  // Drop any embedded `user[:pass]@` credentials.\n  if (builder.username || builder.password) {\n    builder = builder.with(\"username\", \"\").with(\"password\", \"\");\n  }\n  // Follow an ssh host alias to the true host (so `github-reggie-db` -> `github.com`).\n  const realHost = resolveSshHostName(builder.hostname, cwd);\n  if (realHost) builder = builder.with(\"hostname\", realHost);\n\n  return `${builder.origin}${builder.pathname.replace(/\\.git$/, \"\")}`;\n}\n\n/**\n * The repo's canonical remote URL, or `undefined` when there is no git remote.\n * Tries `gh repo view` first (host-accurate, no parsing), then normalizes\n * `git remote get-url origin`. A blank, omitted, or explicitly current `cwd`\n * reuses cached command probes; another resolved directory executes directly.\n *\n * @param cwd - directory to resolve from (defaults to `process.cwd()`).\n * @param format - `\"https\"` (default) yields `https://host/owner/repo`;\n *   `\"npm\"` yields npm's `git+https://host/owner/repo.git` form (for a\n *   `package.json` `repository.url` that passes npm provenance).\n */\nexport function repositoryUrl(cwd?: string, format: \"https\" | \"npm\" = \"https\"): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  const https = repositoryUrlFromGh(resolved) ?? repositoryUrlFromGit(resolved);\n  if (!https) return undefined;\n  return format === \"npm\" ? `git+${https.replace(/\\.git$/, \"\")}.git` : https;\n}\n\n/** Public npm, used only after env, npmrc, bunfig, and pnpm yaml miss. */\nconst DEFAULT_NPM_REGISTRY = \"https://registry.npmjs.org/\";\n\n/** Inputs that control active npm registry discovery. */\nexport type NpmRegistryOptions = {\n  /** Skip public npmjs.org so callers can detect a configured override. */\n  overrideOnly?: boolean;\n  /**\n   * Read `npm_config_registry`, `NPM_CONFIG_REGISTRY`, and `BUN_CONFIG_REGISTRY`\n   * first. Defaults to true so the same cascade a package manager uses is the\n   * default.\n   */\n  envVars?: boolean;\n};\n\nconst npmRegistryCache = new Map<string, net.UrlBuilder | undefined>();\n\n/**\n * The active npm registry as a chainable {@link net.UrlBuilder}.\n *\n * Resolution is manager-agnostic and memoized per cwd plus options: environment\n * variables, then `.npmrc` (project ancestors, user, global), then Bun\n * `bunfig.toml` `install.registry`, then pnpm workspace/global YAML, then\n * `https://registry.npmjs.org/`. `overrideOnly` skips that public default.\n */\nexport function npmRegistry(\n  cwd?: string | null,\n  options?: NpmRegistryOptions,\n): net.UrlBuilder | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  const envVars = options?.envVars !== false;\n  const overrideOnly = Boolean(options?.overrideOnly);\n  const key = JSON.stringify([\n    resolved,\n    overrideOnly,\n    envVars,\n    homedir(),\n    process.env.NPM_CONFIG_USERCONFIG ?? \"\",\n    process.env.NPM_CONFIG_GLOBALCONFIG ?? \"\",\n    process.env.PREFIX ?? \"\",\n    envVars ? (process.env.npm_config_registry ?? \"\") : \"\",\n    envVars ? (process.env.NPM_CONFIG_REGISTRY ?? \"\") : \"\",\n    envVars ? (process.env.BUN_CONFIG_REGISTRY ?? \"\") : \"\",\n  ]);\n  if (npmRegistryCache.has(key)) return npmRegistryCache.get(key);\n  const value = resolveNpmRegistry(resolved, { overrideOnly, envVars });\n  npmRegistryCache.set(key, value);\n  return value;\n}\n\nfunction resolveNpmRegistry(\n  cwd: string,\n  options: { overrideOnly: boolean; envVars: boolean },\n): net.UrlBuilder | undefined {\n  for (const candidate of npmRegistryCandidates(cwd, options.envVars)) {\n    const url = toRegistryUrl(candidate, options.overrideOnly);\n    if (url) return url;\n  }\n  return toRegistryUrl(DEFAULT_NPM_REGISTRY, options.overrideOnly);\n}\n\nfunction* npmRegistryCandidates(cwd: string, envVars: boolean): Generator<string | undefined> {\n  if (envVars) {\n    yield process.env.npm_config_registry;\n    yield process.env.NPM_CONFIG_REGISTRY;\n    yield process.env.BUN_CONFIG_REGISTRY;\n  }\n  for (const dir of ancestorDirs(cwd)) {\n    yield readNpmrcRegistry(join(dir, \".npmrc\"));\n  }\n  yield readNpmrcRegistry(process.env.NPM_CONFIG_USERCONFIG ?? join(homedir(), \".npmrc\"));\n  yield readNpmrcRegistry(process.env.NPM_CONFIG_GLOBALCONFIG ?? defaultGlobalNpmrc());\n  for (const dir of ancestorDirs(cwd)) {\n    yield readBunfigRegistry(join(dir, \"bunfig.toml\"));\n  }\n  yield readBunfigRegistry(join(homedir(), \"bunfig.toml\"));\n  for (const dir of ancestorDirs(cwd)) {\n    yield readYamlRegistry(join(dir, \"pnpm-workspace.yaml\"));\n  }\n  for (const path of pnpmGlobalConfigPaths()) {\n    yield readYamlRegistry(path);\n  }\n}\n\nfunction toRegistryUrl(\n  candidate: string | undefined,\n  overrideOnly: boolean,\n): net.UrlBuilder | undefined {\n  const trimmed = stringUtils.trimToNull(candidate);\n  if (!trimmed) return undefined;\n  const url = net.urlBuilder(trimmed);\n  if (!url) return undefined;\n  if (overrideOnly && isPublicNpmRegistry(url)) return undefined;\n  return url;\n}\n\nfunction isPublicNpmRegistry(url: net.UrlBuilder): boolean {\n  return url.hostname === \"registry.npmjs.org\";\n}\n\nfunction* ancestorDirs(cwd: string): Generator<string> {\n  let current = cwd;\n  while (true) {\n    yield current;\n    const parent = dirname(current);\n    if (parent === current) return;\n    current = parent;\n  }\n}\n\nfunction defaultGlobalNpmrc(): string {\n  if (process.platform === \"win32\") {\n    return join(process.env.PROGRAMDATA ?? \"C:\\\\ProgramData\", \"npm\", \"etc\", \"npmrc\");\n  }\n  return join(process.env.PREFIX ?? \"/usr/local\", \"etc\", \"npmrc\");\n}\n\nfunction pnpmGlobalConfigPaths(): string[] {\n  const home = homedir();\n  if (process.platform === \"darwin\") {\n    return [join(home, \"Library/Preferences/pnpm/config.yaml\")];\n  }\n  if (process.platform === \"win32\") {\n    return [join(process.env.LOCALAPPDATA ?? join(home, \"AppData/Local\"), \"pnpm/config.yaml\")];\n  }\n  return [join(home, \".config/pnpm/config.yaml\")];\n}\n\nfunction readNpmrcRegistry(path: string): string | undefined {\n  return cachedRecord(`npmrc-registry:${path}`, () => {\n    const text = readTextFile(path);\n    const registry = text ? parseIniRegistry(text) : undefined;\n    return registry ? { registry } : undefined;\n  })?.registry;\n}\n\nfunction readBunfigRegistry(path: string): string | undefined {\n  return cachedRecord(`bunfig-registry:${path}`, () => {\n    const text = readTextFile(path);\n    const registry = text ? parseBunfigRegistry(text) : undefined;\n    return registry ? { registry } : undefined;\n  })?.registry;\n}\n\nfunction readYamlRegistry(path: string): string | undefined {\n  return cachedRecord(`yaml-registry:${path}`, () => {\n    const text = readTextFile(path);\n    if (!text) return undefined;\n    const parsed = parseYaml(text);\n    if (!object.isRecord(parsed)) return undefined;\n    const registry = yamlRegistry(parsed);\n    return registry ? { registry } : undefined;\n  })?.registry;\n}\n\nfunction readTextFile(path: string): string | undefined {\n  if (!fileStatSync(path)?.isFile()) return undefined;\n  return readFileSync(path, \"utf8\");\n}\n\n/** Parse a `registry=` assignment from npmrc / ini text. */\nfunction parseIniRegistry(text: string): string | undefined {\n  for (const raw of text.split(/\\r?\\n/)) {\n    const line = raw.trim();\n    if (!line || line.startsWith(\"#\") || line.startsWith(\";\")) continue;\n    const eq = line.indexOf(\"=\");\n    if (eq === -1) continue;\n    if (line.slice(0, eq).trim() !== \"registry\") continue;\n    return unquoteIniValue(line.slice(eq + 1));\n  }\n  return undefined;\n}\n\n/**\n * Read Bun `install.registry` from a bunfig.toml. Table form\n * `[install.registry]` with `url = \"...\"` is accepted; scoped maps are ignored.\n */\nfunction parseBunfigRegistry(text: string): string | undefined {\n  let section = \"\";\n  for (const raw of text.split(/\\r?\\n/)) {\n    const line = stripTomlComment(raw).trim();\n    if (!line) continue;\n    const header = /^\\[([^\\]]+)\\]$/.exec(line);\n    if (header) {\n      section = header[1]!.trim();\n      continue;\n    }\n    const eq = line.indexOf(\"=\");\n    if (eq === -1) continue;\n    const key = line.slice(0, eq).trim();\n    const value = unquoteIniValue(line.slice(eq + 1));\n    if (section === \"install\" && key === \"registry\" && !value.startsWith(\"{\")) return value;\n    if (section === \"install.registry\" && key === \"url\") return value;\n    if (!section && key === \"install.registry\") return value;\n  }\n  return undefined;\n}\n\nfunction yamlRegistry(data: Record<string, unknown>): string | undefined {\n  if (typeof data.registry === \"string\") return data.registry;\n  const registries = data.registries;\n  if (object.isRecord(registries) && typeof registries.default === \"string\") {\n    return registries.default;\n  }\n  return undefined;\n}\n\nfunction unquoteIniValue(value: string): string {\n  const trimmed = value.trim();\n  const comment = trimmed.search(/\\s+#/);\n  const raw = comment === -1 ? trimmed : trimmed.slice(0, comment).trim();\n  if ((raw.startsWith('\"') && raw.endsWith('\"')) || (raw.startsWith(\"'\") && raw.endsWith(\"'\"))) {\n    return raw.slice(1, -1);\n  }\n  return raw;\n}\n\nfunction stripTomlComment(line: string): string {\n  const hash = line.indexOf(\"#\");\n  return hash === -1 ? line : line.slice(0, hash);\n}\n\nfunction readPackageName(pkgPath: string): string | undefined {\n  if (!fileStatSync(pkgPath)?.isFile()) return undefined;\n  return stringUtils.trimToNull(json.parseRecord(readFileSync(pkgPath, \"utf8\"))?.name) ?? undefined;\n}\n\nif (import.meta.main) {\n  console.log(\"npm root:\", npmRoot());\n  console.log(\"repo root:\", gitRoot());\n  console.log(\"package root:\", root());\n  console.log(\"project name:\", name());\n  console.log(\"repository url:\", repositoryUrl());\n  console.log(\"repository url (npm):\", repositoryUrl(undefined, \"npm\"));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-utils.js","sourceRoot":"","sources":["../../src/project-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repository, package, bundle, and project discovery for Node and Bun tools.\n *\n * This module is the shared owner for working-directory normalization, project\n * roots, repository URLs, package names, and Databricks bundle context. Reuse it\n * instead of adding package-local root-marker walks or Git remote parsing.\n *\n * @module\n */\n\nimport { spawnSync } from \"node:child_process\";\nimport { Stats, readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { basename, dirname, join, resolve } from \"node:path\";\nimport { json, net, object, stringUtils } from \"@dbx-tools/shared-core\";\nimport { parse as parseYaml } from \"yaml\";\nimport { cachedRecord, statSync as fileStatSync } from \"./file.ts\";\n\nconst ROOT_MARKERS = [\n  \".projenrc.ts\",\n  \".projenrc.js\",\n  \".projenrc.mjs\",\n  \".projenrc.cjs\",\n  \"package.json\",\n] as const;\n\n/** Resolve a blank, null, omitted, relative, or absolute cwd to an absolute path. */\nexport function resolveWorkingDirectory(cwd?: string | null): string {\n  return resolve(stringUtils.trimToNull(cwd) ?? process.cwd());\n}\n\n/** A command's stdout, classified as a filesystem path and/or a URL. */\nexport interface ProjectContext {\n  readonly output?: string;\n  /** Whether the command exited successfully. */\n  readonly success: boolean;\n  /** `output` when it names something on disk. */\n  readonly path?: string;\n  /** `file.statSync` of {@link path}, when it exists. */\n  readonly pathStats?: Stats;\n  /**\n   * `output` parsed into a chainable {@link net.UrlBuilder}, when it is a real\n   * network URL - a non-blank scheme (not `file:`) AND a non-blank hostname.\n   * Bare paths, scp-like `git@host:...` remotes, and `file:` URLs stay unset.\n   */\n  readonly url?: net.UrlBuilder;\n}\n\n/**\n * because this is crucial do not use exec.spawnSync\n *\n * Run `command args` in `cwd` and classify its stdout: `path` + `pathStats` when\n * the output names something on disk, `url` (a {@link net.UrlBuilder}) when it\n * parses as a real network URL. Empty {@link ProjectContext} on a non-zero exit\n * or empty output.\n */\ninterface ProjectCommandOptions {\n  readonly cache?: boolean;\n  readonly env?: NodeJS.ProcessEnv;\n}\n\nfunction projectContextCommandOutput(\n  command: string,\n  args: string[],\n  cwd: string,\n  env?: NodeJS.ProcessEnv,\n): ProjectContext {\n  const result = spawnSync(command, args, {\n    cwd,\n    env: env ?? process.env,\n    stdio: [\"ignore\", \"pipe\", \"ignore\"],\n  });\n  const output = result?.stdout?.toString()?.trim();\n  if (result.status === 0 && output) {\n    const pathStats = fileStatSync(output);\n    // Only an EXPLICIT `scheme://...` counts as a URL. `urlBuilder` otherwise\n    // synthesizes one (a bare `example.com` -> `https://…`, an absolute path ->\n    // `http://localhost/…`), which would mislabel directory outputs and bare\n    // tokens - so gate on the raw output already carrying a scheme + authority.\n    const url = /^[a-z][a-z0-9+.-]*:\\/\\//i.test(output) ? net.urlBuilder(output) : undefined;\n    return { output, path: pathStats ? output : undefined, pathStats, success: true, url };\n  }\n  return { output, success: result.status === 0 };\n}\n\nconst projectCommandCache = new Map<string, ProjectContext>();\n\nfunction projectContextCommand(\n  command: string,\n  args: string[],\n  cwd?: string,\n  options: ProjectCommandOptions = {},\n): ProjectContext {\n  const resolved = resolveWorkingDirectory(cwd);\n  const cache = options.cache ?? (!options.env && resolved === resolveWorkingDirectory());\n  const key = cache ? JSON.stringify([resolved, command, ...args]) : undefined;\n  if (key !== undefined) {\n    const cached = projectCommandCache.get(key);\n    if (cached !== undefined) return cached;\n  }\n  const value = projectContextCommandOutput(command, args, resolved, options.env);\n  if (key !== undefined) projectCommandCache.set(key, value);\n  return value;\n}\n\nfunction projectCommand(command: string) {\n  const context = (\n    args: string[],\n    cwd?: string,\n    options?: ProjectCommandOptions,\n  ): ProjectContext => projectContextCommand(command, args, cwd, options);\n  return {\n    context,\n    output(\n      args: string[],\n      cwd?: string,\n      options?: ProjectCommandOptions,\n    ): string | undefined {\n      return stringUtils.trimToNull(context(args, cwd, options).output) ?? undefined;\n    },\n    root(args: string[], cwd: string): string | undefined {\n      const parsed = context(args, cwd);\n      return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n    },\n    succeeds(args: string[], cwd?: string, options?: ProjectCommandOptions): boolean {\n      return context(args, cwd, options).success;\n    },\n  };\n}\n\nconst gitCommand = projectCommand(\"git\");\nconst ghCommand = projectCommand(\"gh\");\nconst npmCommand = projectCommand(\"npm\");\nconst sshCommand = projectCommand(\"ssh\");\n\nfunction gitRemoteUrl(cwd?: string, remote = \"origin\", refresh = false): string | undefined {\n  return gitCommand.output([\"remote\", \"get-url\", remote], cwd, { cache: !refresh });\n}\n\n/**\n * Closest directory with a `package.json` or `node_modules`, matching `npm prefix`.\n *\n * Lifecycle scripts from npm and Bun set `npm_config_local_prefix` to that\n * directory. Read it first when resolving this process's cwd so a missing npm\n * CLI is not required. `npm_config_prefix` / `PREFIX` are the global install\n * prefix and must not be used here.\n *\n * Bun has no prefix command (`bun pm bin` is the `.bin` directory). pnpm's\n * `prefix` command is unimplemented; `pnpm root` prints `node_modules`.\n */\nfunction npmRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  if (resolved === resolveWorkingDirectory()) {\n    const fromEnv = envDirectory(process.env.npm_config_local_prefix);\n    if (fromEnv) return fromEnv;\n  }\n  return npmCommand.root([\"prefix\"], resolved);\n}\n\nfunction envDirectory(value: string | undefined): string | undefined {\n  const path = stringUtils.trimToNull(value);\n  if (!path) return undefined;\n  const resolved = resolve(path);\n  return fileStatSync(resolved)?.isDirectory() ? resolved : undefined;\n}\n\nfunction gitRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return gitCommand.root([\"rev-parse\", \"--show-toplevel\"], resolved);\n}\n\n/** Resolve the nearest project root without walking above its npm or Git boundary. */\nexport function root(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  let current = resolved;\n\n  if (!fileStatSync(current)?.isDirectory()) {\n    current = dirname(current);\n  }\n  const boundaries = new Set(\n    [npmBoundary(resolved), gitRoot(resolved)]\n      .filter((path): path is string => path !== undefined)\n      .map((path) => resolve(path)),\n  );\n  const hasBoundary = boundaries.size > 0;\n  let best: { dir: string; priority: number } | undefined;\n  while (true) {\n    for (const [priority, marker] of ROOT_MARKERS.entries()) {\n      if (fileStatSync(join(current, marker))?.isFile()) {\n        if (\n          best === undefined ||\n          priority < best.priority ||\n          (priority === best.priority && current.length < best.dir.length)\n        ) {\n          best = { dir: current, priority };\n        }\n        break;\n      }\n    }\n    if (!hasBoundary && best) {\n      return best.dir;\n    }\n    if (boundaries.has(current)) {\n      return best?.dir;\n    }\n    const parent = dirname(current);\n    if (parent === current) {\n      return best?.dir;\n    }\n    current = parent;\n  }\n}\n\nfunction npmBoundary(cwd: string): string | undefined {\n  const candidate = npmRoot(cwd);\n  if (!candidate) return undefined;\n  const resolved = resolve(candidate);\n  if (fileStatSync(join(resolved, \"package.json\"))?.isFile()) return resolved;\n  if (fileStatSync(join(resolved, \"node_modules\"))?.isDirectory()) return resolved;\n  return undefined;\n}\n\n/**\n * Parse a git remote URL (`https://...`, `git@host:owner/repo.git`, etc.) and\n * return the repo segment, stripping any `.git` suffix. Returns `undefined` for\n * empty or unparsable input.\n */\nexport function parseGitRemote(url: string): string | undefined {\n  const trimmed = url.trim();\n  if (!trimmed) return undefined;\n\n  const scp = /^[^@]+@[^:]+:(.+)$/i.exec(trimmed);\n  if (scp) return lastPathSegment(scp[1] ?? \"\");\n\n  try {\n    const normalized = trimmed.replace(/\\.git$/i, \"\");\n    const pathname = new URL(normalized).pathname;\n    const segment = pathname.split(\"/\").filter(Boolean).at(-1);\n    return segment ? lastPathSegment(segment) : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction lastPathSegment(path: string): string {\n  const segment = path.split(\"/\").filter(Boolean).at(-1) ?? path;\n  return segment.replace(/\\.git$/i, \"\");\n}\n\n/**\n * Yield candidate project-root directories for `cwd`, in priority order: the\n * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;\n * only existing directories are yielded (except the final `cwd` fallback).\n */\nexport function* resolveProjectRoots(cwd?: string): Generator<string> {\n  const base = resolveWorkingDirectory(cwd);\n  const seen = new Set<string>();\n  for (const candidate of [npmRoot(base), gitRoot(base)]) {\n    if (!candidate) continue;\n    const dir = resolve(candidate);\n    if (seen.has(dir)) continue;\n    seen.add(dir);\n    if (fileStatSync(dir)?.isDirectory()) yield dir;\n  }\n  if (!seen.has(base)) yield base;\n}\n\n/** The nearest ancestor of `cwd` (from {@link resolveProjectRoots}) with a `package.json`. */\nfunction workspaceRoot(cwd?: string): string {\n  let last: string | undefined;\n  for (const dir of resolveProjectRoots(cwd)) {\n    if (fileStatSync(resolve(dir, \"package.json\"))?.isFile()) return dir;\n    last = dir;\n  }\n  return last ?? resolveWorkingDirectory(cwd);\n}\n\n/**\n * Resolve a human-friendly project name for the repo rooted at `cwd`:\n * `package.json` `name`, then the git remote's repo name, then the root\n * directory's basename.\n */\nexport function name(cwd?: string): string {\n  const resolved = resolveWorkingDirectory(cwd);\n  const rootDir = workspaceRoot(resolved);\n\n  const fromPackage = readPackageName(resolve(rootDir, \"package.json\"));\n  if (fromPackage) return fromPackage;\n\n  const remote = gitRemoteUrl(rootDir);\n  const fromGit = remote ? parseGitRemote(remote) : undefined;\n  if (fromGit) return fromGit;\n\n  return basename(rootDir);\n}\n\n/**\n * The GitHub CLI's canonical repo URL - the easy path. `gh` already resolves the\n * true host (no ssh-alias parsing) and prints a clean `https://host/owner/repo`.\n * `undefined` when `gh` is absent, unauthenticated, or the dir isn't a GH repo.\n */\nfunction repositoryUrlFromGh(cwd?: string): string | undefined {\n  const account = resolveProjectGhAccount(cwd);\n  if (!account) return undefined;\n  const out = ghCommand.output(\n    [\"repo\", \"view\", account.remote.repository, \"--json\", \"url\"],\n    account.root,\n    { cache: false, env: account.env },\n  );\n  return stringUtils.trimToNull(json.parseRecord(out)?.url) ?? undefined;\n}\n\n/** Resolve an ssh host alias (`~/.ssh/config`) to its effective `hostname` via `ssh -G`. */\nfunction resolveSshHostName(host: string, cwd?: string, refresh = false): string | undefined {\n  const line = sshCommand\n    .context([\"-G\", host], cwd, { cache: !refresh })\n    .output?.split(\"\\n\")\n    .find((l) => /^hostname\\s/i.test(l.trim()));\n  const name = line?.trim().split(/\\s+/)[1];\n  return name && name !== host ? name : undefined;\n}\n\n/** Parsed GitHub-style remote coordinates. */\nexport interface ProjectGhRemote {\n  /** Account hinted by an SSH alias such as `git@github-work:`. */\n  readonly accountHint?: string;\n  /** Host written in the remote before SSH alias resolution. */\n  readonly host: string;\n  /** `owner/repository` path. */\n  readonly repository: string;\n}\n\n/** Authenticated GitHub CLI account selected for one project remote. */\nexport interface ProjectGhAccount {\n  /** Environment to pass to every `gh` command for this project. */\n  readonly env: NodeJS.ProcessEnv;\n  /** Actual GitHub host selected from `gh auth status`. */\n  readonly host: string;\n  /** Authenticated GitHub login. */\n  readonly login: string;\n  /** Parsed project remote. */\n  readonly remote: ProjectGhRemote;\n  /** Resolved project directory used for command execution. */\n  readonly root: string;\n}\n\n/** Options for cached project GitHub-account resolution. */\nexport interface ResolveProjectGhAccountOptions {\n  /** Git remote name. Defaults to `origin`. */\n  readonly remote?: string;\n  /** Re-read git, SSH, and GitHub CLI state instead of using the process cache. */\n  readonly refresh?: boolean;\n}\n\n/** Parse HTTPS, SSH URL, or scp-like GitHub remote coordinates. */\nexport function parseProjectGhRemote(remoteUrl: string): ProjectGhRemote | undefined {\n  const value = remoteUrl.trim().replace(/\\.git$/i, \"\");\n  const https = /^https?:\\/\\/([^/]+)\\/([^/]+)\\/([^/]+)$/i.exec(value);\n  if (https) return { host: https[1]!, repository: `${https[2]}/${https[3]}` };\n  const ssh = /^(?:ssh:\\/\\/)?git@([^/:]+)[:/]([^/]+)\\/([^/]+)$/i.exec(value);\n  if (!ssh) return undefined;\n  const accountHint = /^github-(.+)$/i.exec(ssh[1]!)?.[1];\n  return {\n    ...(accountHint ? { accountHint } : {}),\n    host: ssh[1]!,\n    repository: `${ssh[2]}/${ssh[3]}`,\n  };\n}\n\nconst projectGhAccountCache = new Map<string, ProjectGhAccount | null>();\n\n/**\n * Resolve and cache the authenticated `gh` account that can access a project's\n * remote. SSH alias account hints win, followed by the active account on the\n * effective SSH/HTTPS host, then other authenticated accounts. Every candidate\n * is verified against the repository before it is returned.\n */\nexport function resolveProjectGhAccount(\n  cwd?: string,\n  options: ResolveProjectGhAccountOptions = {},\n): ProjectGhAccount | undefined {\n  const root = resolveWorkingDirectory(cwd);\n  const remoteName = stringUtils.trimToNull(options.remote) ?? \"origin\";\n  const key = JSON.stringify([\n    root,\n    remoteName,\n    homedir(),\n    process.env.GH_CONFIG_DIR ?? \"\",\n  ]);\n  if (!options.refresh && projectGhAccountCache.has(key)) {\n    return projectGhAccountCache.get(key) ?? undefined;\n  }\n  const remoteUrl = gitRemoteUrl(root, remoteName, options.refresh);\n  if (!remoteUrl) return undefined;\n  const remote = parseProjectGhRemote(remoteUrl);\n  if (!remote) return undefined;\n  const effectiveHost = resolveSshHostName(remote.host, root, options.refresh) ?? remote.host;\n\n  const status = ghCommand.output([\"auth\", \"status\", \"--json\", \"hosts\"], root, {\n    cache: false,\n  });\n  if (!status) {\n    projectGhAccountCache.set(key, null);\n    return undefined;\n  }\n  let parsed: {\n    hosts?: Record<\n      string,\n      Array<{ active?: boolean; host?: string; login?: string; state?: string }>\n    >;\n  };\n  try {\n    parsed = JSON.parse(status) as typeof parsed;\n  } catch {\n    projectGhAccountCache.set(key, null);\n    return undefined;\n  }\n  const accounts = Object.entries(parsed.hosts ?? {}).flatMap(([host, entries]) =>\n    entries\n      .filter((entry) => entry.state === \"success\" && entry.login)\n      .map((entry) => ({\n        active: entry.active === true,\n        host: entry.host ?? host,\n        login: entry.login!,\n      })),\n  );\n  accounts.sort((left, right) => {\n    const rank = (account: (typeof accounts)[number]): number => {\n      if (remote.accountHint && account.login === remote.accountHint) return 0;\n      if (account.host === effectiveHost && account.active) return 1;\n      if (account.host === effectiveHost) return 2;\n      if (account.active) return 3;\n      return 4;\n    };\n    return rank(left) - rank(right);\n  });\n\n  for (const account of accounts) {\n    const token = ghCommand.output(\n      [\"auth\", \"token\", \"--hostname\", account.host, \"--user\", account.login],\n      root,\n      { cache: false },\n    );\n    if (!token) continue;\n    const env = { ...process.env, GH_HOST: account.host, GH_TOKEN: token };\n    if (\n      !ghCommand.succeeds(\n        [\"api\", \"--hostname\", account.host, `repos/${remote.repository}`, \"--silent\"],\n        root,\n        { cache: false, env },\n      )\n    ) {\n      continue;\n    }\n    const selected = { env, host: account.host, login: account.login, remote, root };\n    projectGhAccountCache.set(key, selected);\n    return selected;\n  }\n  projectGhAccountCache.set(key, null);\n  return undefined;\n}\n\n/**\n * Fallback: normalize `git remote get-url origin` to a plain\n * `https://host/owner/repo` URL. scp-like / `ssh://` / `git://` /\n * embedded-credential forms are rewritten to https, and an ssh host alias is\n * followed to its real hostname.\n */\nfunction repositoryUrlFromGit(cwd?: string): string | undefined {\n  const raw = gitRemoteUrl(cwd);\n  if (!raw) return undefined;\n\n  // Normalize the scheme to https at the string level first: the WHATWG `URL`\n  // parser can't convert a non-special scheme (`ssh`/`git`) to `https` (the\n  // `protocol` setter no-ops), and scp-like `git@host:owner/repo` isn't a URL at\n  // all. Rewrite both into an `https://` string, then let {@link net.urlBuilder}\n  // own the structured edits (strip credentials, swap the host).\n  let https = raw.replace(/^git\\+/, \"\");\n  const scp = /^[^@]+@([^:]+):(.+)$/.exec(https);\n  if (scp) https = `https://${scp[1]}/${scp[2]}`;\n  https = https.replace(/^(ssh|git):\\/\\//, \"https://\");\n\n  let builder = net.urlBuilder(https);\n  if (!builder) return undefined;\n  // Drop any embedded `user[:pass]@` credentials.\n  if (builder.username || builder.password) {\n    builder = builder.with(\"username\", \"\").with(\"password\", \"\");\n  }\n  // Follow an ssh host alias to the true host.\n  const realHost = resolveSshHostName(builder.hostname, cwd);\n  if (realHost) builder = builder.with(\"hostname\", realHost);\n\n  return `${builder.origin}${builder.pathname.replace(/\\.git$/, \"\")}`;\n}\n\n/**\n * The repo's canonical remote URL, or `undefined` when there is no git remote.\n * Tries `gh repo view` first (host-accurate, no parsing), then normalizes\n * `git remote get-url origin`. A blank, omitted, or explicitly current `cwd`\n * reuses cached command probes; another resolved directory executes directly.\n *\n * @param cwd - directory to resolve from (defaults to `process.cwd()`).\n * @param format - `\"https\"` (default) yields `https://host/owner/repo`;\n *   `\"npm\"` yields npm's `git+https://host/owner/repo.git` form (for a\n *   `package.json` `repository.url` that passes npm provenance).\n */\nexport function repositoryUrl(cwd?: string, format: \"https\" | \"npm\" = \"https\"): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  const https = repositoryUrlFromGh(resolved) ?? repositoryUrlFromGit(resolved);\n  if (!https) return undefined;\n  return format === \"npm\" ? `git+${https.replace(/\\.git$/, \"\")}.git` : https;\n}\n\n/** Public npm, used only after env, npmrc, bunfig, and pnpm yaml miss. */\nconst DEFAULT_NPM_REGISTRY = \"https://registry.npmjs.org/\";\n\n/** Inputs that control active npm registry discovery. */\nexport type NpmRegistryOptions = {\n  /** Skip public npmjs.org so callers can detect a configured override. */\n  overrideOnly?: boolean;\n  /**\n   * Read `npm_config_registry`, `NPM_CONFIG_REGISTRY`, and `BUN_CONFIG_REGISTRY`\n   * first. Defaults to true so the same cascade a package manager uses is the\n   * default.\n   */\n  envVars?: boolean;\n};\n\nconst npmRegistryCache = new Map<string, net.UrlBuilder | undefined>();\n\n/**\n * The active npm registry as a chainable {@link net.UrlBuilder}.\n *\n * Resolution is manager-agnostic and memoized per cwd plus options: environment\n * variables, then `.npmrc` (project ancestors, user, global), then Bun\n * `bunfig.toml` `install.registry`, then pnpm workspace/global YAML, then\n * `https://registry.npmjs.org/`. `overrideOnly` skips that public default.\n */\nexport function npmRegistry(\n  cwd?: string | null,\n  options?: NpmRegistryOptions,\n): net.UrlBuilder | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  const envVars = options?.envVars !== false;\n  const overrideOnly = Boolean(options?.overrideOnly);\n  const key = JSON.stringify([\n    resolved,\n    overrideOnly,\n    envVars,\n    homedir(),\n    process.env.NPM_CONFIG_USERCONFIG ?? \"\",\n    process.env.NPM_CONFIG_GLOBALCONFIG ?? \"\",\n    process.env.PREFIX ?? \"\",\n    envVars ? (process.env.npm_config_registry ?? \"\") : \"\",\n    envVars ? (process.env.NPM_CONFIG_REGISTRY ?? \"\") : \"\",\n    envVars ? (process.env.BUN_CONFIG_REGISTRY ?? \"\") : \"\",\n  ]);\n  if (npmRegistryCache.has(key)) return npmRegistryCache.get(key);\n  const value = resolveNpmRegistry(resolved, { overrideOnly, envVars });\n  npmRegistryCache.set(key, value);\n  return value;\n}\n\nfunction resolveNpmRegistry(\n  cwd: string,\n  options: { overrideOnly: boolean; envVars: boolean },\n): net.UrlBuilder | undefined {\n  for (const candidate of npmRegistryCandidates(cwd, options.envVars)) {\n    const url = toRegistryUrl(candidate, options.overrideOnly);\n    if (url) return url;\n  }\n  return toRegistryUrl(DEFAULT_NPM_REGISTRY, options.overrideOnly);\n}\n\nfunction* npmRegistryCandidates(cwd: string, envVars: boolean): Generator<string | undefined> {\n  if (envVars) {\n    yield process.env.npm_config_registry;\n    yield process.env.NPM_CONFIG_REGISTRY;\n    yield process.env.BUN_CONFIG_REGISTRY;\n  }\n  for (const dir of ancestorDirs(cwd)) {\n    yield readNpmrcRegistry(join(dir, \".npmrc\"));\n  }\n  yield readNpmrcRegistry(process.env.NPM_CONFIG_USERCONFIG ?? join(homedir(), \".npmrc\"));\n  yield readNpmrcRegistry(process.env.NPM_CONFIG_GLOBALCONFIG ?? defaultGlobalNpmrc());\n  for (const dir of ancestorDirs(cwd)) {\n    yield readBunfigRegistry(join(dir, \"bunfig.toml\"));\n  }\n  yield readBunfigRegistry(join(homedir(), \"bunfig.toml\"));\n  for (const dir of ancestorDirs(cwd)) {\n    yield readYamlRegistry(join(dir, \"pnpm-workspace.yaml\"));\n  }\n  for (const path of pnpmGlobalConfigPaths()) {\n    yield readYamlRegistry(path);\n  }\n}\n\nfunction toRegistryUrl(\n  candidate: string | undefined,\n  overrideOnly: boolean,\n): net.UrlBuilder | undefined {\n  const trimmed = stringUtils.trimToNull(candidate);\n  if (!trimmed) return undefined;\n  const url = net.urlBuilder(trimmed);\n  if (!url) return undefined;\n  if (overrideOnly && isPublicNpmRegistry(url)) return undefined;\n  return url;\n}\n\nfunction isPublicNpmRegistry(url: net.UrlBuilder): boolean {\n  return url.hostname === \"registry.npmjs.org\";\n}\n\nfunction* ancestorDirs(cwd: string): Generator<string> {\n  let current = cwd;\n  while (true) {\n    yield current;\n    const parent = dirname(current);\n    if (parent === current) return;\n    current = parent;\n  }\n}\n\nfunction defaultGlobalNpmrc(): string {\n  if (process.platform === \"win32\") {\n    return join(process.env.PROGRAMDATA ?? \"C:\\\\ProgramData\", \"npm\", \"etc\", \"npmrc\");\n  }\n  return join(process.env.PREFIX ?? \"/usr/local\", \"etc\", \"npmrc\");\n}\n\nfunction pnpmGlobalConfigPaths(): string[] {\n  const home = homedir();\n  if (process.platform === \"darwin\") {\n    return [join(home, \"Library/Preferences/pnpm/config.yaml\")];\n  }\n  if (process.platform === \"win32\") {\n    return [join(process.env.LOCALAPPDATA ?? join(home, \"AppData/Local\"), \"pnpm/config.yaml\")];\n  }\n  return [join(home, \".config/pnpm/config.yaml\")];\n}\n\nfunction readNpmrcRegistry(path: string): string | undefined {\n  return cachedRecord(`npmrc-registry:${path}`, () => {\n    const text = readTextFile(path);\n    const registry = text ? parseIniRegistry(text) : undefined;\n    return registry ? { registry } : undefined;\n  })?.registry;\n}\n\nfunction readBunfigRegistry(path: string): string | undefined {\n  return cachedRecord(`bunfig-registry:${path}`, () => {\n    const text = readTextFile(path);\n    const registry = text ? parseBunfigRegistry(text) : undefined;\n    return registry ? { registry } : undefined;\n  })?.registry;\n}\n\nfunction readYamlRegistry(path: string): string | undefined {\n  return cachedRecord(`yaml-registry:${path}`, () => {\n    const text = readTextFile(path);\n    if (!text) return undefined;\n    const parsed = parseYaml(text);\n    if (!object.isRecord(parsed)) return undefined;\n    const registry = yamlRegistry(parsed);\n    return registry ? { registry } : undefined;\n  })?.registry;\n}\n\nfunction readTextFile(path: string): string | undefined {\n  if (!fileStatSync(path)?.isFile()) return undefined;\n  return readFileSync(path, \"utf8\");\n}\n\n/** Parse a `registry=` assignment from npmrc / ini text. */\nfunction parseIniRegistry(text: string): string | undefined {\n  for (const raw of text.split(/\\r?\\n/)) {\n    const line = raw.trim();\n    if (!line || line.startsWith(\"#\") || line.startsWith(\";\")) continue;\n    const eq = line.indexOf(\"=\");\n    if (eq === -1) continue;\n    if (line.slice(0, eq).trim() !== \"registry\") continue;\n    return unquoteIniValue(line.slice(eq + 1));\n  }\n  return undefined;\n}\n\n/**\n * Read Bun `install.registry` from a bunfig.toml. Table form\n * `[install.registry]` with `url = \"...\"` is accepted; scoped maps are ignored.\n */\nfunction parseBunfigRegistry(text: string): string | undefined {\n  let section = \"\";\n  for (const raw of text.split(/\\r?\\n/)) {\n    const line = stripTomlComment(raw).trim();\n    if (!line) continue;\n    const header = /^\\[([^\\]]+)\\]$/.exec(line);\n    if (header) {\n      section = header[1]!.trim();\n      continue;\n    }\n    const eq = line.indexOf(\"=\");\n    if (eq === -1) continue;\n    const key = line.slice(0, eq).trim();\n    const value = unquoteIniValue(line.slice(eq + 1));\n    if (section === \"install\" && key === \"registry\" && !value.startsWith(\"{\")) return value;\n    if (section === \"install.registry\" && key === \"url\") return value;\n    if (!section && key === \"install.registry\") return value;\n  }\n  return undefined;\n}\n\nfunction yamlRegistry(data: Record<string, unknown>): string | undefined {\n  if (typeof data.registry === \"string\") return data.registry;\n  const registries = data.registries;\n  if (object.isRecord(registries) && typeof registries.default === \"string\") {\n    return registries.default;\n  }\n  return undefined;\n}\n\nfunction unquoteIniValue(value: string): string {\n  const trimmed = value.trim();\n  const comment = trimmed.search(/\\s+#/);\n  const raw = comment === -1 ? trimmed : trimmed.slice(0, comment).trim();\n  if ((raw.startsWith('\"') && raw.endsWith('\"')) || (raw.startsWith(\"'\") && raw.endsWith(\"'\"))) {\n    return raw.slice(1, -1);\n  }\n  return raw;\n}\n\nfunction stripTomlComment(line: string): string {\n  const hash = line.indexOf(\"#\");\n  return hash === -1 ? line : line.slice(0, hash);\n}\n\nfunction readPackageName(pkgPath: string): string | undefined {\n  if (!fileStatSync(pkgPath)?.isFile()) return undefined;\n  return stringUtils.trimToNull(json.parseRecord(readFileSync(pkgPath, \"utf8\"))?.name) ?? undefined;\n}\n\nif (import.meta.main) {\n  console.log(\"npm root:\", npmRoot());\n  console.log(\"repo root:\", gitRoot());\n  console.log(\"package root:\", root());\n  console.log(\"project name:\", name());\n  console.log(\"repository url:\", repositoryUrl());\n  console.log(\"repository url (npm):\", repositoryUrl(undefined, \"npm\"));\n  const ghAccount = resolveProjectGhAccount();\n  if (ghAccount) {\n    console.log(\"project gh host:\", ghAccount.host);\n    console.log(\"project gh login:\", ghAccount.login);\n    console.log(\"project gh remote:\", ghAccount.remote.repository);\n  } else {\n    console.log(\"project gh account: not found\");\n  }\n}\n"]}

package/package.json

@@ -25,7 +25,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "^0.9.69",
+    "@dbx-tools/shared-core": "^0.9.71",
     "extract-zip": "^2.0.1",
     "proper-lockfile": "^4.1.2",
     "semver": "^7.7.3",
@@ -87,7 +87,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.69",
+  "version": "0.9.71",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [