@10stars/config 17.0.1 → 17.0.2

package/package.json

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

package/src/link-remote.ts

@@ -126,23 +126,15 @@ const bfsSiblings = async (cwd: string, visit: (sib: string) => Promise<void>):
 }
 
 /**
- * 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".
+ * The first of `candidates` (priority order) that exists as a branch on the remote, else null.
+ * Queries only those specific refs in one `ls-remote` — no full head listing. A non-zero exit means
+ * the repo is unreadable (private + missing/unauthorized clone token → "Repository not found") —
+ * surfaced immediately rather than masquerading as a missing branch.
  */
-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
+const matchRemoteBranch = (url: string, candidates: string[]): string | null => {
+  let out: string
   try {
-    heads = git([`ls-remote`, `--heads`, url])
+    out = git([`ls-remote`, url, ...candidates.map((c) => `refs/heads/${c}`)])
   } catch (err) {
     const stderr = (err as { stderr?: string | Buffer })?.stderr
     throw new Error(
@@ -151,18 +143,41 @@ const resolveRef = (url: string, repo: string): string => {
         `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).
+  // Lines are "<sha>\trefs/heads/<branch>"; a branch may itself contain slashes (e.g. alice/x).
   const present = new Set(
-    heads
+    out
       .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)`,
-  )
+  return candidates.find((c) => present.has(c)) ?? null
+}
+
+/**
+ * Clone a missing sibling as a flat peer, returning the branch it landed on. Prefers a branch
+ * matching the consumer's coordinated branch (PR head, then push branch) when the sibling has one;
+ * otherwise clones the sibling's own default branch directly. A default-branch clone needs no
+ * `--branch`, so the `ls-remote` probe is skipped entirely when no coordinated branch is set — one
+ * fewer round-trip for local/manual runs (in GitHub Actions GITHUB_REF_NAME is always set).
+ */
+const cloneSibling = (url: string, repo: string, sib: string, dest: string): string | null => {
+  const coordinated = [
+    process.env.GITHUB_HEAD_REF, // pull_request events
+    process.env.GITHUB_REF_NAME, // push events
+  ].filter((v): v is string => Boolean(v))
+  const ref = coordinated.length ? matchRemoteBranch(url, coordinated) : null
+
+  console.info(`linkRemote: cloning ${repo}@${ref ?? `(default)`} -> ${dest}`)
+  gitInherit([
+    `clone`,
+    `--depth`,
+    `1`,
+    `--single-branch`,
+    ...(ref ? [`--branch`, ref] : []),
+    url,
+    sib,
+  ])
+  return ref ?? currentRef(sib)
 }
 
 const headSha = (dir: string): string | null => tryGit([`rev-parse`, `HEAD`], dir)
@@ -194,10 +209,7 @@ const cloneClosureBranchFirst = async (cwd: string): Promise<Sibling[]> => {
       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])
+      ref = cloneSibling(repoUrl(repo), repo, sib, path.relative(cwd, sib))
     }
     order.push({ abs: sib, ref })
   })

package/src/vanilla-extract/patch-vanilla-extract.ts

@@ -22,15 +22,29 @@ const PATCHED = String.raw`/(?:^|[/\\])css\.(js|cjs|mjs|jsx|ts|tsx)(\?used)?$/`
  */
 export const patchVanillaExtract = async (cwd: string): Promise<boolean> => {
   const nodeModules = path.join(cwd, `node_modules`)
-  const glob = new Bun.Glob(`**/@vanilla-extract/integration/dist/*.js`)
+
+  // Recursively collect `@vanilla-extract/integration/dist/*.js` WITHOUT following directory
+  // symlinks. A `file:` self-dep (e.g. frontend-toolkit's `frontend-toolkit: file:.` creates
+  // node_modules/frontend-toolkit -> .) makes symlink-following recurse forever — Bun.Glob does,
+  // even with `followSymlinks: false`. A linked sibling patches its own VE during its own install,
+  // and this repo's own copy is hoisted as a real dir, so real-dir-only recursion is sufficient.
+  const integrationDist = /[/\\]@vanilla-extract[/\\]integration[/\\]dist[/\\][^/\\]+\.js$/
+  const findFiles = async (dir: string, out: string[] = []): Promise<string[]> => {
+    for (const entry of await fs.readdir(dir, { withFileTypes: true }).catch(() => [])) {
+      if (entry.isSymbolicLink()) continue
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) await findFiles(full, out)
+      else if (entry.isFile() && integrationDist.test(full)) out.push(full)
+    }
+    return out
+  }
 
   let integrationFound = false
   let definitionFound = false
   const patched: string[] = []
 
-  for await (const rel of glob.scan({ cwd: nodeModules, onlyFiles: true })) {
+  for (const file of await findFiles(nodeModules)) {
     integrationFound = true
-    const file = path.join(nodeModules, rel)
     const content = await fs.readFile(file, `utf8`)
 
     if (content.includes(PATCHED)) {
@@ -41,7 +55,7 @@ export const patchVanillaExtract = async (cwd: string): Promise<boolean> => {
 
     definitionFound = true
     await fs.writeFile(file, content.replaceAll(ORIGINAL, PATCHED))
-    patched.push(rel)
+    patched.push(path.relative(nodeModules, file))
   }
 
   if (!integrationFound) return false // VE not installed here