trustci 0.2.1 → 0.3.0

package/README.md

@@ -32,7 +32,7 @@ npx trustci list
 | ---------- | ---------------------------------------------------------------------------------------------- | --------------- |
 | `github`   | `--repo <owner/repo>` `--file <workflow>`                                                       | `--env <name>`  |
 | `gitlab`   | `--project <group/project>` (or `--repo`) `--file <workflow>`                                   | `--env <name>`  |
-| `circleci` | `--org-id` `--project-id` `--pipeline-definition-id` `--vcs-origin <url>`                        | `--context-id` (repeatable) |
+| `circleci` | Either all of `--org-id` `--project-id` `--pipeline-definition-id`, or a CircleCI token | `--vcs-origin <host/owner/repo>`, `--circle-token`, `--file`, `--context-id` (repeatable) |
 
 At least one of `--allow-publish` / `--allow-stage-publish` is required.
 
@@ -40,14 +40,39 @@ At least one of `--allow-publish` / `--allow-stage-publish` is required.
 # GitLab
 npx trustci --provider gitlab --project me/repo --file .gitlab-ci.yml --allow-publish -y
 
-# CircleCI (vcs-origin must include the protocol)
+# CircleCI (vcs-origin is host/owner/repo; a leading https:// is stripped automatically)
 npx trustci --provider circleci \
   --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> \
-  --vcs-origin https://github.com/me/repo \
+  --vcs-origin github.com/me/repo \
   --context-id <uuid> \
   --allow-publish
 ```
 
+#### CircleCI `--vcs-origin`
+
+When `--vcs-origin` is omitted, trustci takes it from the root `package.json`
+`repository` field (URL, `git+https://…`, `git@host:owner/repo`, or the
+`github:` / `gitlab:` / `bitbucket:` / `owner/repo` shorthands), then from
+`git remote get-url origin`. It prints which one it used, and warns when the two
+disagree (`package.json` wins, since it is committed rather than clone-specific).
+
+#### CircleCI token lookup
+
+When any of the three UUIDs is missing, trustci resolves it through the CircleCI
+API v2. The token is taken from the first of these that is set, and trustci
+prints which one it used (never the token itself):
+
+1. `--circle-token`
+2. `CIRCLE_TOKEN` (circleci CLI v1, chunk)
+3. `CIRCLECI_TOKEN` (chunk)
+4. `CIRCLE_CLI_TOKEN` (circleci CLI v1, legacy alias)
+5. `CIRCLECI_CLI_TOKEN` (circleci CLI v0.1)
+6. `token` in `~/.circleci/cli.yml`, written by `circleci setup` in circleci CLI v0.1.
+   It is ignored when its `host` is not `https://circleci.com`.
+
+The OS keychain, where circleci CLI v1 and chunk store tokens by default, is not read.
+When all three UUIDs are given, no token is looked up.
+
 ### Common options
 
 | Flag                     | Description                                          |

package/dist/cli.js

@@ -7,6 +7,83 @@ import { createInterface } from "node:readline/promises";
 // src/args.ts
 import { parseArgs } from "node:util";
 
+// src/circleci.ts
+var BASE_URL = "https://circleci.com/api/v2";
+function vcsTypeFromUrl(url) {
+  const { hostname } = new URL(url);
+  if (hostname === "github.com" || hostname.endsWith(".github.com"))
+    return "github";
+  if (hostname === "gitlab.com" || hostname.endsWith(".gitlab.com"))
+    return "gitlab";
+  if (hostname === "bitbucket.org" || hostname.endsWith(".bitbucket.org"))
+    return "bitbucket";
+  throw new Error(`Cannot determine VCS type from URL: ${url}`);
+}
+function normalizeVcsOrigin(value) {
+  const v = value.trim().replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/\/+$/, "");
+  const parts = v.split("/");
+  if (parts.length < 3 || parts.some((p) => !p)) {
+    throw new Error(`vcs-origin must be in the form host/owner/repo, e.g. github.com/org/repo (got "${value}").`);
+  }
+  return v;
+}
+function projectSlugFromVcsOrigin(origin) {
+  const url = origin.includes("://") ? origin : `https://${origin}`;
+  const vcsType = vcsTypeFromUrl(url);
+  const { pathname } = new URL(url);
+  const parts = pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
+  if (parts.length < 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Cannot extract org/repo from URL: ${url}`);
+  }
+  return `${vcsType}/${parts[0]}/${parts[1]}`;
+}
+
+class CircleApiError extends Error {
+  status;
+  path;
+  body;
+  constructor(status, path, body) {
+    super(`CircleCI API error (${status}) for ${path}: ${body}`);
+    this.status = status;
+    this.path = path;
+    this.body = body;
+  }
+}
+async function circleGet(token, path) {
+  const response = await fetch(`${BASE_URL}${path}`, {
+    headers: { "Circle-Token": token, Accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new CircleApiError(response.status, path, await response.text());
+  }
+  return response.json();
+}
+async function resolveOrgAndProjectId(token, vcsOrigin) {
+  const slug = projectSlugFromVcsOrigin(vcsOrigin);
+  const project = await circleGet(token, `/project/${slug}`);
+  return { orgId: project.organization_id, projectId: project.id };
+}
+async function resolvePipelineDefinitionId(token, projectId, file) {
+  const data = await circleGet(token, `/projects/${encodeURIComponent(projectId)}/pipeline-definitions`);
+  if (data.items.length === 0) {
+    throw new Error(`No pipeline definitions found for project "${projectId}".`);
+  }
+  if (file) {
+    const match = data.items.find((d) => d.config_source?.file_path === file || d.name === file);
+    if (!match) {
+      const available2 = data.items.map((d) => d.config_source?.file_path ?? d.name ?? d.id).join(", ");
+      throw new Error(`No pipeline definition found matching "${file}". Available: ${available2}`);
+    }
+    return match.id;
+  }
+  const [only] = data.items;
+  if (data.items.length === 1 && only) {
+    return only.id;
+  }
+  const available = data.items.map((d) => d.config_source?.file_path ?? d.name ?? d.id).join(", ");
+  throw new Error(`Multiple pipeline definitions found for project "${projectId}". Specify --file to select one: ${available}`);
+}
+
 // src/types.ts
 var PROVIDERS = ["github", "gitlab", "circleci"];
 
@@ -102,22 +179,17 @@ function parseCliArgs(argv) {
       break;
     }
     case "circleci": {
-      const vcsOrigin = require_(values["vcs-origin"], "vcs-origin", "circleci");
-      if (!vcsOrigin.includes("://")) {
-        throw new ArgError(`--vcs-origin must include a protocol, e.g. https://github.com/org/repo (got "${vcsOrigin}").`);
+      const rawVcsOrigin = values["vcs-origin"];
+      let vcsOrigin;
+      try {
+        vcsOrigin = rawVcsOrigin === undefined ? undefined : normalizeVcsOrigin(rawVcsOrigin);
+      } catch (e) {
+        throw new ArgError(`--${e.message}`);
       }
       const circleToken = values["circle-token"];
       const orgId = values["org-id"];
       const projectId = values["project-id"];
       const pipelineDefinitionId = values["pipeline-definition-id"];
-      if (!circleToken) {
-        if (!orgId)
-          throw new ArgError("--org-id is required for --provider circleci (or provide --circle-token for auto-resolution).");
-        if (!projectId)
-          throw new ArgError("--project-id is required for --provider circleci (or provide --circle-token for auto-resolution).");
-        if (!pipelineDefinitionId)
-          throw new ArgError("--pipeline-definition-id is required for --provider circleci (or provide --circle-token for auto-resolution).");
-      }
       providerOptions = {
         provider: "circleci",
         circleToken,
@@ -141,63 +213,6 @@ function parseCliArgs(argv) {
   };
 }
 
-// src/circleci.ts
-var BASE_URL = "https://circleci.com/api/v2";
-function vcsTypeFromUrl(url) {
-  const { hostname } = new URL(url);
-  if (hostname === "github.com" || hostname.endsWith(".github.com"))
-    return "github";
-  if (hostname === "gitlab.com" || hostname.endsWith(".gitlab.com"))
-    return "gitlab";
-  if (hostname === "bitbucket.org" || hostname.endsWith(".bitbucket.org"))
-    return "bitbucket";
-  throw new Error(`Cannot determine VCS type from URL: ${url}`);
-}
-function projectSlugFromVcsOrigin(url) {
-  const vcsType = vcsTypeFromUrl(url);
-  const { pathname } = new URL(url);
-  const parts = pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
-  if (parts.length < 2 || !parts[0] || !parts[1]) {
-    throw new Error(`Cannot extract org/repo from URL: ${url}`);
-  }
-  return `${vcsType}/${parts[0]}/${parts[1]}`;
-}
-async function circleGet(token, path) {
-  const response = await fetch(`${BASE_URL}${path}`, {
-    headers: { "Circle-Token": token, Accept: "application/json" }
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`CircleCI API error (${response.status}) for ${path}: ${body}`);
-  }
-  return response.json();
-}
-async function resolveOrgAndProjectId(token, vcsOrigin) {
-  const slug = projectSlugFromVcsOrigin(vcsOrigin);
-  const project = await circleGet(token, `/project/${slug}`);
-  return { orgId: project.organization_id, projectId: project.id };
-}
-async function resolvePipelineDefinitionId(token, projectId, file) {
-  const data = await circleGet(token, `/pipeline-definitions?project_id=${encodeURIComponent(projectId)}`);
-  if (data.items.length === 0) {
-    throw new Error(`No pipeline definitions found for project "${projectId}".`);
-  }
-  if (file) {
-    const match = data.items.find((d) => d.config_file_path === file || d.name === file);
-    if (!match) {
-      const available2 = data.items.map((d) => d.config_file_path ?? d.name ?? d.id).join(", ");
-      throw new Error(`No pipeline definition found matching "${file}". Available: ${available2}`);
-    }
-    return match.id;
-  }
-  const [only] = data.items;
-  if (data.items.length === 1 && only) {
-    return only.id;
-  }
-  const available = data.items.map((d) => d.config_file_path ?? d.name ?? d.id).join(", ");
-  throw new Error(`Multiple pipeline definitions found for project "${projectId}". Specify --file to select one: ${available}`);
-}
-
 // src/exec.ts
 import { spawnSync } from "node:child_process";
 function run(cmd, args) {
@@ -213,6 +228,214 @@ function runInherit(cmd, args) {
   return res.status ?? (res.error || res.signal ? 1 : 0);
 }
 
+// src/resolve.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/token.ts
+import { join } from "node:path";
+var DEFAULT_HOST = "https://circleci.com";
+var LEGACY_CLI_YML = "~/.circleci/cli.yml";
+var TOKEN_ENV_VARS = ["CIRCLE_TOKEN", "CIRCLECI_TOKEN", "CIRCLE_CLI_TOKEN", "CIRCLECI_CLI_TOKEN"];
+var TOKEN_SOURCES = ["--circle-token", ...TOKEN_ENV_VARS, LEGACY_CLI_YML];
+function parseLegacyCliYml(content) {
+  const out = {};
+  for (const raw of content.split(/\r?\n/)) {
+    const m = /^(token|host):(.*)$/.exec(raw);
+    if (!m)
+      continue;
+    const value = parseScalar(m[2].trim());
+    if (value)
+      out[m[1]] = value;
+  }
+  return out;
+}
+function parseScalar(v) {
+  const quoted = /^(["'])(.*)\1(\s+#.*)?$/.exec(v);
+  if (quoted)
+    return quoted[2];
+  return v.replace(/\s+#.*$/, "").trim();
+}
+function resolveCircleToken(input) {
+  if (input.flag)
+    return { token: input.flag, source: "--circle-token", notes: [] };
+  for (const name of TOKEN_ENV_VARS) {
+    const value = input.env[name];
+    if (value)
+      return { token: value, source: name, notes: [] };
+  }
+  const content = input.readFile(join(input.homedir, ".circleci", "cli.yml"));
+  if (content === null)
+    return { token: undefined, notes: [] };
+  const { token, host } = parseLegacyCliYml(content);
+  if (!token)
+    return { token: undefined, notes: [] };
+  if (token === "|" || token === ">" || /^[|>][-+0-9]*$/.test(token)) {
+    return { token: undefined, notes: [`skipped ${LEGACY_CLI_YML}: its token is not a single-line value trustci can read`] };
+  }
+  if (host && host.replace(/\/+$/, "") !== DEFAULT_HOST) {
+    return { token: undefined, notes: [`skipped ${LEGACY_CLI_YML}: its token is for ${host}, not ${DEFAULT_HOST}`] };
+  }
+  return { token, source: LEGACY_CLI_YML, notes: [] };
+}
+
+// src/vcs.ts
+var SHORTHAND_HOSTS = {
+  github: "github.com",
+  gitlab: "gitlab.com",
+  bitbucket: "bitbucket.org"
+};
+var PACKAGE_JSON = "package.json repository";
+var GIT_REMOTE = "git remote origin";
+function parseRepositoryUrl(input) {
+  const s = input.trim();
+  let host;
+  let path;
+  const shorthand = /^(github|gitlab|bitbucket):(.+)$/.exec(s);
+  const scp = /^[^@/\s]+@([^:/\s]+):(.+)$/.exec(s);
+  if (shorthand) {
+    host = SHORTHAND_HOSTS[shorthand[1]];
+    path = shorthand[2];
+  } else if (/^[^/:\s]+\/[^/:\s]+$/.test(s)) {
+    host = "github.com";
+    path = s;
+  } else if (scp) {
+    host = scp[1];
+    path = scp[2];
+  } else {
+    let url;
+    try {
+      url = new URL(s.replace(/^git\+/, ""));
+    } catch {
+      return null;
+    }
+    if (!["https:", "http:", "ssh:", "git:"].includes(url.protocol) || !url.hostname)
+      return null;
+    host = url.hostname;
+    path = url.pathname;
+  }
+  const parts = path.replace(/#.*$/, "").replace(/^\/+|\/+$/g, "").replace(/\.git$/, "").split("/");
+  if (parts.length < 2 || parts.some((p) => !p))
+    return null;
+  return `${host}/${parts.join("/")}`;
+}
+function repositoryFromPackageJson(repository) {
+  if (typeof repository === "string")
+    return repository;
+  if (repository && typeof repository === "object" && "url" in repository) {
+    const url = repository.url;
+    if (typeof url === "string")
+      return url;
+  }
+  return;
+}
+function resolveVcsOrigin(input) {
+  if (input.flag)
+    return { value: input.flag, source: "--vcs-origin", warnings: [] };
+  const warnings = [];
+  const fromGit = input.gitRemote ? parseRepositoryUrl(input.gitRemote) : null;
+  if (input.pkgRepository !== undefined) {
+    const fromPkg = parseRepositoryUrl(input.pkgRepository);
+    if (fromPkg) {
+      if (fromGit && fromGit !== fromPkg) {
+        warnings.push(`${PACKAGE_JSON} (${fromPkg}) differs from ${GIT_REMOTE} (${fromGit}); using ${fromPkg}`);
+      }
+      return { value: fromPkg, source: PACKAGE_JSON, warnings };
+    }
+    warnings.push(`could not read a repository from ${PACKAGE_JSON} ("${input.pkgRepository}")`);
+  }
+  if (fromGit)
+    return { value: fromGit, source: GIT_REMOTE, warnings };
+  return { value: undefined, warnings };
+}
+
+// src/resolve.ts
+var defaultResolveDeps = {
+  resolveOrgAndProjectId,
+  resolvePipelineDefinitionId,
+  log: (message) => console.error(message),
+  env: process.env,
+  homedir: homedir(),
+  readFile: (path) => {
+    try {
+      return readFileSync(path, "utf8");
+    } catch {
+      return null;
+    }
+  },
+  cwd: process.cwd(),
+  gitRemoteUrl: () => {
+    const r = run("git", ["remote", "get-url", "origin"]);
+    return r.status === 0 && r.stdout.trim() ? r.stdout.trim() : null;
+  }
+};
+function resolveMissingVcsOrigin(opts, deps) {
+  if (opts.vcsOrigin)
+    return opts.vcsOrigin;
+  let pkgRepository;
+  const pkgText = deps.readFile(join2(deps.cwd, "package.json"));
+  if (pkgText !== null) {
+    try {
+      pkgRepository = repositoryFromPackageJson(JSON.parse(pkgText).repository);
+    } catch {
+      deps.log("warning: could not parse package.json while looking for a repository");
+    }
+  }
+  const found = resolveVcsOrigin({ pkgRepository, gitRemote: deps.gitRemoteUrl() });
+  for (const w of found.warnings)
+    deps.log(`warning: ${w}`);
+  if (found.value === undefined) {
+    throw new Error("--vcs-origin is required for --provider circleci and could not be inferred " + "(looked in: package.json repository, git remote origin). Pass e.g. --vcs-origin github.com/org/repo.");
+  }
+  deps.log(`vcs-origin: ${found.value} (from ${found.source})`);
+  opts.vcsOrigin = found.value;
+  return found.value;
+}
+async function resolveCircleciOptions(parsed, deps = defaultResolveDeps) {
+  const opts = parsed.options;
+  if (opts.provider !== "circleci")
+    return;
+  const vcsOrigin = resolveMissingVcsOrigin(opts, deps);
+  const missing = [
+    !opts.orgId && "--org-id",
+    !opts.projectId && "--project-id",
+    !opts.pipelineDefinitionId && "--pipeline-definition-id"
+  ].filter((m) => Boolean(m));
+  if (missing.length === 0)
+    return;
+  const found = resolveCircleToken({
+    flag: opts.circleToken,
+    env: deps.env,
+    homedir: deps.homedir,
+    readFile: deps.readFile
+  });
+  for (const note of found.notes)
+    deps.log(`note: ${note}`);
+  if (found.token === undefined) {
+    throw new Error(`missing ${missing.join(", ")} for --provider circleci. Pass them explicitly, ` + `or provide a CircleCI API token so they can be resolved (looked in: ${TOKEN_SOURCES.join(", ")}).`);
+  }
+  const { token, source } = found;
+  deps.log(`Using CircleCI token from ${source}`);
+  try {
+    if (!opts.orgId || !opts.projectId) {
+      deps.log("Resolving org-id and project-id via CircleCI API...");
+      const resolved = await deps.resolveOrgAndProjectId(token, vcsOrigin);
+      opts.orgId ??= resolved.orgId;
+      opts.projectId ??= resolved.projectId;
+    }
+    if (!opts.pipelineDefinitionId) {
+      deps.log("Resolving pipeline-definition-id via CircleCI API...");
+      opts.pipelineDefinitionId = await deps.resolvePipelineDefinitionId(token, opts.projectId, opts.file);
+    }
+  } catch (err) {
+    if (err instanceof CircleApiError && (err.status === 401 || err.status === 403)) {
+      throw new Error(`CircleCI rejected the token from ${source} (${err.status}). ` + `Pass a valid token with --circle-token or the CIRCLE_TOKEN environment variable.`);
+    }
+    throw err;
+  }
+}
+
 // src/npm.ts
 var MIN_NODE = "22.14.0";
 var MIN_NPM = "11.5.1";
@@ -300,7 +523,7 @@ function displayCommand(args) {
 }
 
 // src/workspace.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
 import path2 from "node:path";
 
 // src/glob.ts
@@ -443,7 +666,7 @@ function parsePnpmPackages(content) {
   return result;
 }
 function readJson(file) {
-  return JSON.parse(readFileSync(file, "utf8"));
+  return JSON.parse(readFileSync2(file, "utf8"));
 }
 function readJsonSafe(file) {
   try {
@@ -456,7 +679,7 @@ function readJsonSafe(file) {
 function detectPatterns(root) {
   const pnpmFile = path2.join(root, "pnpm-workspace.yaml");
   if (existsSync(pnpmFile)) {
-    const patterns = parsePnpmPackages(readFileSync(pnpmFile, "utf8"));
+    const patterns = parsePnpmPackages(readFileSync2(pnpmFile, "utf8"));
     if (patterns.length > 0)
       return { source: "pnpm-workspace.yaml", patterns };
   }
@@ -526,9 +749,11 @@ function filterPackages(all, only, exclude) {
     return true;
   });
 }
+// package.json
+var version = "0.3.0";
 
 // src/cli.ts
-var VERSION = "0.1.0";
+var VERSION = version;
 var HELP = `trustci — bulk-register npm Trusted Publishers across a monorepo
 
 Usage:
@@ -539,11 +764,15 @@ Providers:
   github     --repo <owner/repo> --file <workflow> [--env <name>]
   gitlab     --project <group/project> --file <workflow> [--env <name>]
              (--repo is accepted as an alias for --project)
-  circleci   --vcs-origin <url> --circle-token <token> [--file <config>]
+  circleci   [--vcs-origin <host/owner/repo>] [--circle-token <token>] [--file <config>]
              [--org-id <uuid>] [--project-id <uuid>] [--pipeline-definition-id <uuid>]
              [--context-id <uuid> ...]
-             UUIDs are auto-resolved via CircleCI API v2 when --circle-token is provided.
-             Explicit UUIDs override auto-resolution and work without a token.
+             --vcs-origin defaults to the root package.json "repository", then
+             \`git remote get-url origin\`.
+             Missing UUIDs are resolved via CircleCI API v2 using a token from
+             --circle-token, $CIRCLE_TOKEN, $CIRCLECI_TOKEN, $CIRCLE_CLI_TOKEN,
+             $CIRCLECI_CLI_TOKEN, or ~/.circleci/cli.yml (in that order).
+             Explicit UUIDs override auto-resolution; with all three, no token is needed.
 
 Permissions (at least one required):
   --allow-publish           allow npm publish
@@ -564,10 +793,9 @@ as a single-package fallback. Private packages ("private": true) are always excl
 Examples:
   trustci --dry-run --provider github --repo me/repo --file release.yml --allow-publish
   trustci --provider gitlab --project me/repo --file .gitlab-ci.yml --allow-publish -y
-  trustci --provider circleci --vcs-origin https://github.com/me/repo \\
-    --circle-token $CIRCLECI_TOKEN --allow-publish
+  CIRCLE_TOKEN=... trustci --provider circleci --allow-publish
   trustci --provider circleci --org-id <uuid> --project-id <uuid> \\
-    --pipeline-definition-id <uuid> --vcs-origin https://github.com/me/repo --allow-publish
+    --pipeline-definition-id <uuid> --vcs-origin github.com/me/repo --allow-publish
   trustci list
 `;
 async function confirm(question) {
@@ -712,25 +940,11 @@ async function main() {
   }
   if (parsed.kind === "list")
     return runList(parsed.pkg, parsed.dryRun);
-  if (parsed.options.provider === "circleci" && !parsed.dryRun) {
-    const opts = parsed.options;
-    if (opts.circleToken) {
-      try {
-        if (!opts.orgId || !opts.projectId) {
-          console.error("Resolving org-id and project-id via CircleCI API...");
-          const resolved = await resolveOrgAndProjectId(opts.circleToken, opts.vcsOrigin);
-          opts.orgId ??= resolved.orgId;
-          opts.projectId ??= resolved.projectId;
-        }
-        if (!opts.pipelineDefinitionId) {
-          console.error("Resolving pipeline-definition-id via CircleCI API...");
-          opts.pipelineDefinitionId = await resolvePipelineDefinitionId(opts.circleToken, opts.projectId, opts.file);
-        }
-      } catch (err) {
-        console.error(`error: ${err.message}`);
-        return 1;
-      }
-    }
+  try {
+    await resolveCircleciOptions(parsed);
+  } catch (err) {
+    console.error(`error: ${err.message}`);
+    return 1;
   }
   return runTrust(parsed);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trustci",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Bulk-register npm Trusted Publishers (npm trust) across all public packages in a monorepo. Supports GitHub, GitLab and CircleCI.",
   "type": "module",
   "bin": {