@10stars/config 16.2.0 → 17.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@10stars/config",
-  "version": "16.2.0",
+  "version": "17.0.1",
   "private": false,
   "bin": {
     "config": "./src/index.ts"

package/src/index.ts

@@ -5,6 +5,7 @@ import path from "node:path"
 
 import { resetColorIndex } from "./colors"
 import { checkIsMonorepo, dedupeSingletons, linkPackages } from "./link-packages"
+import { dedupeRemote, linkRemote } from "./link-remote"
 import { setupOverrides } from "./manage-overrides"
 import { runConcurrently, type CommandConfig } from "./runner"
 import { setupSideEffects } from "./vanilla-extract/manage-side-effects"
@@ -61,15 +62,25 @@ const actions = {
       const config = await getConfig()
       if (config?.linkPackages) {
         const linkedPaths = await linkPackages(cwd, config.linkPackages)
-        if (config.dedupeSingletons !== false) {
-          const singletons = Array.isArray(config.dedupeSingletons)
-            ? config.dedupeSingletons
-            : undefined
-          await dedupeSingletons(cwd, config.linkPackages, linkedPaths, singletons)
-        }
+        await dedupeSingletons(cwd, config.linkPackages, linkedPaths, config.dedupeSingletons)
+      }
+    },
+  },
+  linkRemote: {
+    info: `CI: clone the transitive file: sibling graph before "bun install" (branch-first; --from <manifest> to pin/revert, --emit-manifest <path> to record)`,
+    action: () => {
+      const args = process.argv.slice(3)
+      const flag = (name: string) => {
+        const i = args.indexOf(name)
+        return i >= 0 ? args[i + 1] : undefined
       }
+      return linkRemote(cwd, { manifestOut: flag(`--emit-manifest`), fromManifest: flag(`--from`) })
     },
   },
+  dedupe: {
+    info: `CI: dedupe type singletons across linked siblings onto the consumer, after "bun install"`,
+    action: () => dedupeRemote(cwd),
+  },
   ts: {
     info: `Typecheck code (in watch mode)`,
     action: () => exec(`tsc --project ./tsconfig.json --noEmit --watch`),

package/src/link-packages.ts

@@ -32,9 +32,8 @@ export const linkPackages = async (cwd: string, packagesToLink: string[]) => {
     )
     if (!pkgJson) return
 
-    const [orgName, pkgName] = pkgJson.name!.split(`/`)
-
-    const pathSymlink = path.join(cwd, `node_modules`, orgName, pkgName)
+    // path.join normalizes the `/` in a scoped name (`@common/env`) and handles bare names (`frontend-toolkit`)
+    const pathSymlink = path.join(cwd, `node_modules`, pkgJson.name!)
     await symlink(pathPkg, pathSymlink)
     linkedPaths.push(pathPkg)
   }
@@ -82,13 +81,18 @@ export const dedupeSingletons = async (
   cwd: string,
   packagesToLink: string[],
   linkedPaths: string[],
-  singletons: string[] = DEFAULT_SINGLETONS,
+  singletons: boolean | string[] = true,
+  canonicalRoot?: string,
 ) => {
-  // siblings share cwd's parent; the formula reduces to path.dirname(cwd) for `../pkg` entries
+  if (singletons === false) return
+  const packages = Array.isArray(singletons) ? singletons : DEFAULT_SINGLETONS
+
+  // siblings share cwd's parent; the formula reduces to path.dirname(cwd) for `../pkg` entries.
+  // canonicalRoot overrides this for standalone CI checkouts, where the consumer (cwd) holds the canonical copy.
   const roots = new Set(packagesToLink.map((rel) => path.resolve(cwd, rel, `..`)))
-  const workspaceRoot = roots.size === 1 ? [...roots][0]! : path.dirname(cwd)
+  const workspaceRoot = canonicalRoot ?? (roots.size === 1 ? [...roots][0]! : path.dirname(cwd))
 
-  for (const pkg of singletons) {
+  for (const pkg of packages) {
     const canonical = path.join(workspaceRoot, `node_modules`, pkg)
     const canonicalVersion = await readPkgVersion(canonical)
     if (!canonicalVersion) {

package/src/link-remote.ts

@@ -0,0 +1,312 @@
+import { execFileSync } from "node:child_process"
+import fs from "node:fs/promises"
+import path from "node:path"
+
+import type * as TF from "type-fest"
+
+import { dedupeSingletons } from "./link-packages"
+
+interface Config {
+  dedupeSingletons?: boolean | string[]
+}
+
+interface ManifestSibling {
+  repo: string
+  path: string // relative to the consumer, e.g. "../common"
+  ref: string | null
+  sha: string | null
+  version: string | null // nearest git tag, if any
+}
+
+interface Manifest {
+  schema: 1
+  consumer: { repo: string; ref: string | null; sha: string | null }
+  createdAt: string
+  siblings: ManifestSibling[]
+}
+
+interface LinkRemoteOptions {
+  /** Write the resolved transitive closure ({repo, ref, sha, version}) to this path. */
+  manifestOut?: string
+  /** Pin-clone each sibling at the SHA recorded in this manifest (revert), instead of branch-first. */
+  fromManifest?: string
+}
+
+/** A discovered sibling repo root and the ref it resolved to (branch name, or null if detached/pinned). */
+type Sibling = { abs: string; ref: string | null }
+
+// execFile (not a shell) so branch names / refs / SHAs can't inject shell syntax.
+const git = (args: string[], cwd?: string): string =>
+  execFileSync(`git`, args, { cwd, encoding: `utf8` }).trim()
+
+const gitInherit = (args: string[], cwd?: string): void => {
+  execFileSync(`git`, args, { cwd, stdio: `inherit` })
+}
+
+const tryGit = (args: string[], cwd?: string): string | null => {
+  try {
+    return git(args, cwd)
+  } catch {
+    return null
+  }
+}
+
+const bunInstall = (cwd: string): void =>
+  void execFileSync(`bun`, [`install`], { cwd, stdio: `inherit` })
+
+const exists = (p: string): Promise<boolean> =>
+  fs
+    .stat(p)
+    .then(() => true)
+    .catch(() => false)
+
+const readPkg = async (dir: string): Promise<TF.PackageJson | null> => {
+  try {
+    return JSON.parse(await fs.readFile(path.join(dir, `package.json`), `utf8`))
+  } catch {
+    return null
+  }
+}
+
+const getConfig = async (cwd: string): Promise<Config | null> =>
+  import(path.join(cwd, `10stars.config`)).catch(() => null)
+
+const getOrg = (): string => {
+  const org = process.env.GITHUB_ORG ?? process.env.GITHUB_REPOSITORY?.split(`/`)[0]
+  if (!org) {
+    throw new Error(
+      `Cannot determine org: set GITHUB_ORG, or run inside GitHub Actions (GITHUB_REPOSITORY)`,
+    )
+  }
+  return org
+}
+
+const repoUrl = (repo: string) => `https://github.com/${getOrg()}/${repo}.git`
+
+/**
+ * Absolute repo roots referenced by one dir's `file:` deps.
+ * `file:../common/env` → `<dir>/../common`; whole-repo `file:../frontend-toolkit` → itself.
+ * Self-refs (`file:.`) and non-parent paths are skipped, so registry deps (incl.
+ * `@anime.club/translations`) are never included.
+ */
+const fileSiblingRoots = async (dir: string): Promise<string[]> => {
+  const pkg = await readPkg(dir)
+  if (!pkg) return []
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies }
+  const roots = new Set<string>()
+  for (const spec of Object.values(allDeps)) {
+    if (typeof spec !== `string` || !spec.startsWith(`file:`)) continue
+    const rel = spec.slice(`file:`.length)
+    if (!rel.startsWith(`..`)) continue
+    const segments = rel.split(`/`)
+    const firstNamed = segments.findIndex((s) => s !== `..`)
+    if (firstNamed < 0) continue
+    roots.add(path.resolve(dir, segments.slice(0, firstNamed + 1).join(`/`)))
+  }
+  return [...roots]
+}
+
+/**
+ * BFS the transitive `file:` sibling graph from `cwd`, invoking `visit` once per newly discovered
+ * sibling root in dependents-first order. Cloning inside `visit` makes that sibling's own `file:`
+ * deps discoverable when it is later dequeued; a still-missing dir simply yields no children.
+ */
+const bfsSiblings = async (cwd: string, visit: (sib: string) => Promise<void>): Promise<void> => {
+  const visited = new Set<string>([path.resolve(cwd)])
+  const queue = [path.resolve(cwd)]
+  while (queue.length) {
+    const dir = queue.shift()!
+    for (const sib of await fileSiblingRoots(dir)) {
+      if (visited.has(sib)) continue
+      visited.add(sib)
+      await visit(sib)
+      queue.push(sib)
+    }
+  }
+}
+
+/**
+ * Branch-first: current PR branch, then push branch, then `develop`, then `production`. A single
+ * `ls-remote --heads` lists every head in one network round-trip; candidates are matched locally
+ * (avoids one request per ref). A non-zero exit means the repo is unreadable (private + missing/
+ * unauthorized clone token → "Repository not found") — surfaced immediately rather than masquerading
+ * as "No branch found".
+ */
+const resolveRef = (url: string, repo: string): string => {
+  const candidates = [
+    process.env.GITHUB_HEAD_REF, // pull_request events
+    process.env.GITHUB_REF_NAME, // push events
+    `develop`,
+    `production`,
+  ].filter((v): v is string => Boolean(v))
+
+  let heads: string
+  try {
+    heads = git([`ls-remote`, `--heads`, url])
+  } catch (err) {
+    const stderr = (err as { stderr?: string | Buffer })?.stderr
+    throw new Error(
+      `Cannot read ${url}: repo is unreachable — if private, the clone token is missing or ` +
+        `unauthorized. Pass app-key to setup-siblings and install the GitHub App on this repo ` +
+        `with contents:read.\n${(stderr ?? (err as Error)?.message ?? ``).toString().trim()}`,
+    )
+  }
+
+  // Each line is "<sha>\trefs/heads/<branch>"; a branch may itself contain slashes (e.g. alice/x).
+  const present = new Set(
+    heads
+      .split(`\n`)
+      .map((line) => line.split(`refs/heads/`)[1])
+      .filter(Boolean),
+  )
+  for (const ref of candidates) if (present.has(ref)) return ref
+  throw new Error(
+    `No branch found for ${repo}; tried: ${candidates.join(`, `)} (repo reachable, refs absent)`,
+  )
+}
+
+const headSha = (dir: string): string | null => tryGit([`rev-parse`, `HEAD`], dir)
+
+const nearestTag = (dir: string): string | null => tryGit([`describe`, `--tags`, `--abbrev=0`], dir)
+
+const currentRef = (dir: string): string | null => {
+  const branch = tryGit([`rev-parse`, `--abbrev-ref`, `HEAD`], dir)
+  return branch === `HEAD` ? null : branch
+}
+
+const clonePinned = (url: string, sha: string, dir: string): void => {
+  gitInherit([`init`, dir])
+  gitInherit([`remote`, `add`, `origin`, url], dir)
+  gitInherit([`fetch`, `--depth`, `1`, `origin`, sha], dir) // GitHub allows fetching a reachable SHA
+  gitInherit([`checkout`, `FETCH_HEAD`], dir)
+}
+
+/**
+ * Walk the transitive `file:` graph from `cwd`, cloning each missing sibling as a flat peer.
+ * Returns siblings in discovery (BFS) order — dependents before their dependencies.
+ */
+const cloneClosureBranchFirst = async (cwd: string): Promise<Sibling[]> => {
+  const order: Sibling[] = []
+  await bfsSiblings(cwd, async (sib) => {
+    let ref: string | null
+    if (await exists(sib)) {
+      console.info(`linkRemote: ${path.relative(cwd, sib)} already present; not cloning`)
+      ref = currentRef(sib)
+    } else {
+      const repo = path.basename(sib)
+      const url = repoUrl(repo)
+      ref = resolveRef(url, repo)
+      console.info(`linkRemote: cloning ${repo}@${ref} -> ${path.relative(cwd, sib)}`)
+      gitInherit([`clone`, `--depth`, `1`, `--single-branch`, `--branch`, ref, url, sib])
+    }
+    order.push({ abs: sib, ref })
+  })
+  return order
+}
+
+const writeManifest = async (cwd: string, siblings: Sibling[], out: string): Promise<void> => {
+  const manifest: Manifest = {
+    schema: 1,
+    consumer: {
+      repo: path.basename(path.resolve(cwd)),
+      ref: process.env.GITHUB_HEAD_REF ?? process.env.GITHUB_REF_NAME ?? currentRef(cwd),
+      sha: headSha(cwd),
+    },
+    createdAt: new Date().toISOString(),
+    siblings: siblings.map(({ abs, ref }) => ({
+      repo: path.basename(abs),
+      path: path.relative(cwd, abs),
+      ref,
+      sha: headSha(abs),
+      version: nearestTag(abs),
+    })),
+  }
+  await fs.writeFile(out, JSON.stringify(manifest, null, 2) + `\n`)
+  console.info(`linkRemote: wrote manifest -> ${out}`)
+}
+
+const linkRemoteFromManifest = async (cwd: string, manifestPath: string): Promise<void> => {
+  const manifest: Manifest = JSON.parse(await fs.readFile(manifestPath, `utf8`))
+  if (!manifest.siblings?.length) {
+    console.info(`linkRemote --from: manifest has no siblings; nothing to do`)
+    return
+  }
+
+  for (const sib of manifest.siblings) {
+    const abs = path.resolve(cwd, sib.path)
+    if (await exists(abs)) {
+      console.info(`linkRemote --from: ${sib.path} already present; leaving as-is`)
+      continue
+    }
+    if (!sib.sha) throw new Error(`Manifest entry "${sib.repo}" has no sha to pin`)
+    console.info(`linkRemote --from: pinning ${sib.repo}@${sib.sha} -> ${sib.path}`)
+    clonePinned(repoUrl(sib.repo), sib.sha, abs)
+  }
+
+  installLeavesFirst(
+    cwd,
+    manifest.siblings.map((s) => path.resolve(cwd, s.path)),
+  )
+}
+
+/**
+ * Install siblings leaves-first (reverse of dependents-first discovery order) so a hoisted
+ * sibling (e.g. `common`) is installed before a repo that links into it.
+ * Assumes an acyclic, mostly-linear `file:` graph; a diamond could need a real topological sort.
+ */
+const installLeavesFirst = (cwd: string, siblingsInDiscoveryOrder: string[]): void => {
+  for (const abs of [...siblingsInDiscoveryOrder].reverse()) {
+    console.info(`linkRemote: bun install in ${path.relative(cwd, abs)}`)
+    bunInstall(abs)
+  }
+}
+
+/**
+ * CI: materialize the transitive `file:` sibling graph that a standalone checkout lacks.
+ *
+ * Default (branch-first): BFS the graph, shallow single-branch clone each missing sibling at
+ * its resolved ref, then `bun install` leaves-first. `--emit-manifest` records the exact
+ * {repo, ref, sha, version} set (a cross-repo lockfile snapshot for revert). `--from` skips
+ * branch-first and pin-clones each sibling at the manifest's recorded SHA.
+ *
+ * Linking is done by the consumer's own `bun install` resolving the `file:` specs afterwards;
+ * run `dedupe` after that. No-op for repos with no `file:` siblings, and skips siblings already
+ * present (local dev).
+ */
+export const linkRemote = async (cwd: string, opts: LinkRemoteOptions = {}): Promise<void> => {
+  if (opts.fromManifest) return linkRemoteFromManifest(cwd, opts.fromManifest)
+
+  const siblings = await cloneClosureBranchFirst(cwd)
+  if (!siblings.length) {
+    console.info(`linkRemote: no file: siblings; nothing to do`)
+    return
+  }
+
+  installLeavesFirst(
+    cwd,
+    siblings.map((s) => s.abs),
+  )
+
+  if (opts.manifestOut) await writeManifest(cwd, siblings, opts.manifestOut)
+}
+
+/** Present transitive `file:` siblings (no cloning) — used for post-install dedupe. */
+const collectPresentSiblings = async (cwd: string): Promise<string[]> => {
+  const found: string[] = []
+  await bfsSiblings(cwd, async (sib) => {
+    if (await exists(sib)) found.push(sib)
+  })
+  return found
+}
+
+/**
+ * CI, run AFTER the consumer's `bun install`: collapse type singletons (`@types/react`, …)
+ * across the transitive linked graph onto the consumer's own copy. A standalone CI checkout
+ * has no hoisted workspace root, so the canonical is the consumer (`cwd`).
+ */
+export const dedupeRemote = async (cwd: string): Promise<void> => {
+  const config = await getConfig(cwd)
+  const siblings = await collectPresentSiblings(cwd)
+  if (!siblings.length) return
+  await dedupeSingletons(cwd, [], siblings, config?.dedupeSingletons, cwd)
+}