@evgeny.skarlat/cli 0.0.22-beta.7

package/README.md

@@ -0,0 +1,36 @@
+# @evgeny.skarlat/cli
+
+RenreKit CLI — lightweight plugin-driven development CLI.
+
+This is the **meta package**. It does not contain a binary by itself; instead
+it lists per-platform packages in `optionalDependencies` and npm filters those
+by `os` + `cpu` so only the matching one installs.
+
+The `renre-kit` command on your `PATH` is a small Node dispatcher that resolves
+the installed platform package and execs its native binary.
+
+## Install
+
+```bash
+npm install -g @evgeny.skarlat/cli
+```
+
+## Supported platforms
+
+| OS      | Arch  | Package                          |
+| ------- | ----- | -------------------------------- |
+| Linux   | x64   | `@evgeny.skarlat/cli-linux-x64`       |
+| Linux   | arm64 | `@evgeny.skarlat/cli-linux-arm64`     |
+| macOS   | x64   | `@evgeny.skarlat/cli-darwin-x64`      |
+| macOS   | arm64 | `@evgeny.skarlat/cli-darwin-arm64`    |
+| Windows | x64   | `@evgeny.skarlat/cli-win32-x64`       |
+
+## Architecture
+
+See `renre-kit-architecture/adr/distribution/`:
+
+- ADR-001 — JFrog npm registry as sole channel
+- ADR-002 — Bun `--compile` for cross-platform single-file binaries
+- ADR-003 — Platform-`optionalDependencies` package layout
+- ADR-004 — Embed the web dashboard inside the CLI binary
+- ADR-005 — `rnrk` Python lifecycle manager relegated to contributor path

package/bin/renre-kit.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+// Cross-platform dispatcher for the @renre-kit/cli meta package (ADR-003).
+//
+// Resolves the per-OS / per-CPU / per-libc platform package that npm
+// filtered in via `optionalDependencies`, locates its native binary, and
+// execs it with the caller's argv + environment.
+//
+// Resolution order (first hit wins):
+//   1. $RENRE_KIT_BIN_PATH — explicit override, useful for local development
+//      against a freshly built binary without reinstalling.
+//   2. On linux: -musl variant if running on musl libc (Alpine etc.), then
+//      the glibc variant; on glibc the glibc variant first, then musl as a
+//      defensive fallback. (Older npm without `libc`-filtering may install
+//      both, so the dispatcher decides at runtime.)
+//   3. On macOS / Windows: the single `<os>-<arch>` variant.
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import { platform as osPlatform, arch as osArch } from 'node:os';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+
+function platformKey() {
+  const p = osPlatform();
+  const a = osArch();
+  if (p === 'win32') return ['win32', a];
+  if (p === 'darwin') return ['darwin', a];
+  if (p === 'linux') return ['linux', a];
+  return [p, a];
+}
+
+/**
+ * Detect whether the running Linux host uses musl libc (Alpine and similar
+ * minimal distros) rather than glibc. Two heuristics:
+ *   1. `/etc/alpine-release` exists  -> musl
+ *   2. `ldd --version` output contains "musl"
+ * Returns false on any other platform.
+ */
+function isMuslLinux() {
+  if (osPlatform() !== 'linux') return false;
+  try {
+    if (existsSync('/etc/alpine-release')) return true;
+  } catch {
+    /* permission denied or similar — fall through */
+  }
+  try {
+    const res = spawnSync('ldd', ['--version'], { encoding: 'utf8', timeout: 1500 });
+    const text = (res.stdout || '') + (res.stderr || '');
+    if (text.toLowerCase().includes('musl')) return true;
+  } catch {
+    /* ldd missing — assume glibc */
+  }
+  return false;
+}
+
+function candidatePackageNames(os, arch) {
+  if (os === 'linux') {
+    const glibc = `@evgeny.skarlat/cli-linux-${arch}`;
+    const musl = `@evgeny.skarlat/cli-linux-${arch}-musl`;
+    return isMuslLinux() ? [musl, glibc] : [glibc, musl];
+  }
+  return [`@evgeny.skarlat/cli-${os}-${arch}`];
+}
+
+function resolvePlatformPackageDir(pkgName) {
+  try {
+    const pkgJsonPath = require.resolve(`${pkgName}/package.json`);
+    return dirname(pkgJsonPath);
+  } catch {
+    return null;
+  }
+}
+
+function findBinary(os, arch) {
+  const binaryName = os === 'win32' ? 'renre-kit.exe' : 'renre-kit';
+  const candidates = candidatePackageNames(os, arch);
+  for (const pkg of candidates) {
+    const pkgDir = resolvePlatformPackageDir(pkg);
+    if (!pkgDir) continue;
+    const binaryPath = join(pkgDir, 'bin', binaryName);
+    if (existsSync(binaryPath)) {
+      return { binaryPath, pkg };
+    }
+  }
+  return { binaryPath: null, pkg: candidates[0] };
+}
+
+/**
+ * Resolve the on-disk path to `@github/copilot/index.js`, which the bundled
+ * `@github/copilot-sdk` inside the Bun binary needs to spawn the Copilot CLI.
+ *
+ * `import.meta.resolve` from inside a Bun-compiled binary (virtual fs at
+ * `/$bunfs/root/`) cannot see `node_modules/@github/copilot/`, so the SDK
+ * falls back to the `COPILOT_CLI_PATH` env var. We compute it here from the
+ * Node-side dispatcher, which has normal filesystem access.
+ *
+ * We use `require.resolve.paths()` to enumerate candidate node_modules dirs
+ * rather than `require.resolve('@github/copilot/package.json')` — the latter
+ * fails because `@github/copilot` ships an `exports` field that doesn't
+ * expose `./package.json`. This mirrors the SDK's own fallback (see
+ * `@github/copilot-sdk/dist/client.js:getBundledCliPath`).
+ *
+ * Returns `null` when the package is not installed — copilot is optional, so
+ * we don't fail the launch.
+ */
+export function resolveCopilotCliPath(req) {
+  try {
+    const paths = req.resolve.paths('@github/copilot') ?? [];
+    for (const base of paths) {
+      const candidate = join(base, '@github', 'copilot', 'index.js');
+      if (existsSync(candidate)) return candidate;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Locate the `node_modules` directory that contains `node-pty` and return
+ * the dir itself (not the package dir). The Bun-compiled binary marks
+ * `node-pty` as `--external`, so the native `conpty.node` (Windows) and
+ * `pty.node` (POSIX) bindings have to be resolved from disk at runtime.
+ * We surface the parent `node_modules` via `NODE_PATH` so Bun's runtime
+ * resolver picks up the prebuilt binding shipped by the npm package.
+ *
+ * Returns `null` when node-pty isn't installed — the terminal feature
+ * degrades to "unavailable" rather than crashing.
+ */
+export function resolveNodePtyNodeModules(req) {
+  try {
+    const paths = req.resolve.paths('node-pty') ?? [];
+    for (const base of paths) {
+      if (existsSync(join(base, 'node-pty', 'package.json'))) return base;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the child process environment. Injects `COPILOT_CLI_PATH` and
+ * prepends to `NODE_PATH` only when the caller hasn't set them explicitly —
+ * an explicit value from the user's shell or CI always wins.
+ */
+export function buildChildEnv(parentEnv, { copilotCliPath, nodePtyNodeModules } = {}) {
+  const env = { ...parentEnv };
+  if (copilotCliPath && !env.COPILOT_CLI_PATH) {
+    env.COPILOT_CLI_PATH = copilotCliPath;
+  }
+  if (nodePtyNodeModules) {
+    const sep = process.platform === 'win32' ? ';' : ':';
+    env.NODE_PATH = env.NODE_PATH
+      ? `${nodePtyNodeModules}${sep}${env.NODE_PATH}`
+      : nodePtyNodeModules;
+  }
+  return env;
+}
+
+function execAndExit(binaryPath) {
+  const childEnv = buildChildEnv(process.env, {
+    copilotCliPath: resolveCopilotCliPath(require),
+    nodePtyNodeModules: resolveNodePtyNodeModules(require),
+  });
+  const result = spawnSync(binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+    env: childEnv,
+    windowsHide: false,
+  });
+  if (result.error) {
+    process.stderr.write(`renre-kit: failed to launch native binary: ${result.error.message}\n`);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
+}
+
+function main() {
+  const [os, arch] = platformKey();
+
+  // 1. Explicit override — bypasses package resolution entirely. Useful when
+  //    pointing at a locally-built binary during development.
+  const envOverride = process.env.RENRE_KIT_BIN_PATH;
+  if (envOverride) {
+    if (!existsSync(envOverride)) {
+      process.stderr.write(
+        `\nrenre-kit: RENRE_KIT_BIN_PATH points to a file that does not exist:\n  ${envOverride}\n\n`,
+      );
+      process.exit(1);
+    }
+    execAndExit(envOverride);
+    return;
+  }
+
+  // 2. Resolve via optionalDependencies candidates.
+  const { binaryPath, pkg } = findBinary(os, arch);
+  if (!binaryPath) {
+    const candidates = candidatePackageNames(os, arch);
+    process.stderr.write(
+      `\nrenre-kit: no native binary installed for ${os}/${arch}` +
+        (os === 'linux' ? ` (${isMuslLinux() ? 'musl' : 'glibc'})` : '') +
+        `.\n` +
+        `Looked for: ${candidates.join(', ')}\n` +
+        `Reinstall with:    npm install -g @evgeny.skarlat/cli\n` +
+        `Or set RENRE_KIT_BIN_PATH to a local binary you trust.\n\n`,
+    );
+    process.exit(1);
+  }
+
+  if (process.env.RENRE_KIT_DEBUG_DISPATCH) {
+    process.stderr.write(`[renre-kit-dispatch] launching ${pkg} -> ${binaryPath}\n`);
+  }
+
+  execAndExit(binaryPath);
+}
+
+// Only auto-run when invoked as a script. Tests import this module to exercise
+// the helper functions without triggering the dispatch + process.exit chain.
+const invokedAsScript = process.argv[1] === fileURLToPath(import.meta.url);
+if (invokedAsScript) main();

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@evgeny.skarlat/cli",
+  "version": "0.0.22-beta.7",
+  "description": "RenreKit CLI — lightweight plugin-driven development CLI",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "renre-kit": "bin/renre-kit.js"
+  },
+  "files": [
+    "bin/renre-kit.js",
+    "scripts/postinstall.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@github/copilot": "^1.0.36"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0",
+    "@evgeny.skarlat/cli-darwin-arm64": "0.0.22-beta.7",
+    "@evgeny.skarlat/cli-darwin-x64": "0.0.22-beta.7",
+    "@evgeny.skarlat/cli-linux-arm64": "0.0.22-beta.7",
+    "@evgeny.skarlat/cli-linux-arm64-musl": "0.0.22-beta.7",
+    "@evgeny.skarlat/cli-linux-x64": "0.0.22-beta.7",
+    "@evgeny.skarlat/cli-linux-x64-musl": "0.0.22-beta.7",
+    "@evgeny.skarlat/cli-win32-x64": "0.0.22-beta.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * Postinstall verification for @renre-kit/cli.
+ *
+ * Confirms that npm picked up the right per-platform package from
+ * `optionalDependencies`. If it didn't, prints a clear actionable message
+ * and exits 0 anyway — failing the install would leave the user worse off
+ * (they couldn't even rerun `npm install` against a fixed registry without
+ * uninstalling the meta first).
+ *
+ * Detection logic mirrors bin/renre-kit.js so the same candidates are
+ * tried.
+ */
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import { platform as osPlatform, arch as osArch } from 'node:os';
+import { existsSync } from 'node:fs';
+
+const require = createRequire(import.meta.url);
+
+function isMuslLinux() {
+  if (osPlatform() !== 'linux') return false;
+  try {
+    if (existsSync('/etc/alpine-release')) return true;
+  } catch {
+    /* fall through */
+  }
+  try {
+    const res = spawnSync('ldd', ['--version'], { encoding: 'utf8', timeout: 1500 });
+    const text = (res.stdout || '') + (res.stderr || '');
+    if (text.toLowerCase().includes('musl')) return true;
+  } catch {
+    /* ldd missing */
+  }
+  return false;
+}
+
+function expectedCandidates() {
+  const p = osPlatform();
+  const a = osArch();
+  if (p === 'linux') {
+    const glibc = `@evgeny.skarlat/cli-linux-${a}`;
+    const musl = `@evgeny.skarlat/cli-linux-${a}-musl`;
+    return isMuslLinux() ? [musl, glibc] : [glibc, musl];
+  }
+  if (p === 'darwin') return [`@evgeny.skarlat/cli-darwin-${a}`];
+  if (p === 'win32') return [`@evgeny.skarlat/cli-win32-${a}`];
+  return [`@evgeny.skarlat/cli-${p}-${a}`];
+}
+
+function canResolve(pkg) {
+  try {
+    require.resolve(`${pkg}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  if (process.env.RENRE_KIT_SKIP_POSTINSTALL_CHECK) return;
+
+  const candidates = expectedCandidates();
+  const resolved = candidates.find(canResolve);
+  if (resolved) {
+    if (process.env.RENRE_KIT_DEBUG_DISPATCH) {
+      process.stderr.write(`[renre-kit-postinstall] resolved ${resolved}\n`);
+    }
+    return;
+  }
+
+  const p = osPlatform();
+  const a = osArch();
+  const libc = p === 'linux' ? (isMuslLinux() ? 'musl' : 'glibc') : null;
+  process.stderr.write(
+    [
+      '',
+      `renre-kit: WARNING — no platform binary package was installed.`,
+      `  Detected host: ${p}/${a}${libc ? ` (${libc})` : ''}`,
+      `  Looked for:    ${candidates.join(', ')}`,
+      '',
+      `  This usually means npm filtered out the optionalDependency for an`,
+      `  unsupported os/cpu/libc combination, or the registry mirror did not`,
+      `  carry the platform package.`,
+      '',
+      `  Fix by reinstalling once the right package is available:`,
+      `    npm install -g @evgeny.skarlat/cli`,
+      `  Or set RENRE_KIT_BIN_PATH to a binary you trust to bypass resolution.`,
+      '',
+    ].join('\n'),
+  );
+}
+
+try {
+  main();
+} catch (err) {
+  // Never fail the install on a verification hiccup.
+  process.stderr.write(
+    `renre-kit: postinstall verification error (non-fatal): ${err?.message ?? err}\n`,
+  );
+}