create-three-blocks-starter 0.0.1

package/README.md

@@ -0,0 +1,43 @@
+# @three-blocks/create-starter
+
+Private CLI to scaffold a new project from the Three Blocks starter.
+
+## Usage
+
+Authenticate to the private registry first (one time per project):
+
+```bash
+npx -y three-blocks-login --mode project --scope @three-blocks
+```
+
+Then scaffold a new app:
+
+```bash
+npm create @three-blocks/starter@latest my-app
+# or
+pnpm dlx @three-blocks/create-starter my-app
+```
+
+Next steps:
+
+```bash
+cd my-app
+pnpm i
+pnpm dev
+```
+
+## Development (monorepo)
+
+- The CLI pulls the template from `packages/three-blocks-starter/` during `prepack`.
+- To sync locally without publishing:
+
+```bash
+pnpm --filter @three-blocks/create-starter run dev:sync
+```
+
+## Publish
+
+```bash
+npx -y three-blocks-login --mode project --scope @three-blocks
+pnpm --filter @three-blocks/create-starter publish --access restricted
+```

package/bin/index.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+// Node 18+
+// Usage:
+//   THREE_BLOCKS_LICENSE_KEY=sk_live_... npx three-blocks-create-app my-app
+//   npx three-blocks-create-app my-app  (will prompt for key)
+
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import readline from 'node:readline';
+
+const STARTER_PKG = '@three-blocks/starter';   // private starter (lives in CodeArtifact)
+const LOGIN_CLI = 'three-blocks-login';        // public login CLI
+const SCOPE = '@three-blocks';
+
+const die = (m) => { console.error(m); process.exit(1); };
+const run = (cmd, args, opts = {}) => {
+  const r = spawnSync(cmd, args, { stdio: 'inherit', ...opts });
+  if (r.status !== 0) process.exit(r.status ?? 1);
+};
+
+async function ensureEmptyDir(dir) {
+  try { await fsp.mkdir(dir, { recursive: true }); } catch {}
+  const files = await fsp.readdir(dir).catch(() => []);
+  if (files.length) die(`Target directory '${path.basename(dir)}' is not empty.`);
+}
+
+async function promptHidden(label) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return await new Promise((resolve) => {
+    process.stdout.write(label);
+    const onData = (char) => {
+      char = String(char);
+      if (char === '\n' || char === '\r' || char === '\u0004') process.stdout.write('\n');
+      else process.stdout.write('*');
+    };
+    process.stdin.on('data', onData);
+    rl.question('', (v) => {
+      process.stdin.removeListener('data', onData);
+      rl.close();
+      resolve(v.trim());
+    });
+  });
+}
+
+function mkTmpDir(prefix = 'three-blocks-') {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let appName = '';
+  let channel = String(process.env.THREE_BLOCKS_CHANNEL || 'stable').toLowerCase();
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a.startsWith('-') && !appName) { appName = a; continue; }
+    if (a === '--channel' || a === '-c') { const v = args[i + 1]; if (v) { channel = String(v).toLowerCase(); i++; } continue; }
+    const m = a.match(/^--channel=(.+)$/);
+    if (m) { channel = String(m[1]).toLowerCase(); continue; }
+  }
+  if (!['stable', 'beta', 'alpha'].includes(channel)) channel = 'stable';
+  if (!appName) {
+    die(
+      `Usage:\n` +
+      `  THREE_BLOCKS_LICENSE_KEY=sk_live_... npx three-blocks-create-app <directory>\n` +
+      `  (or: npx three-blocks-create-app <directory> and enter the key when prompted)`
+    );
+  }
+
+  const targetDir = path.resolve(process.cwd(), appName);
+  await ensureEmptyDir(targetDir);
+
+  // 1) License key (env or prompt)
+  let license = process.env.THREE_BLOCKS_LICENSE_KEY;
+  if (!license) {
+    license = await promptHidden('Enter your THREE_BLOCKS_LICENSE_KEY: ');
+    if (!license) die('License key is required to install private packages.');
+  }
+
+  // 2) Pre-login in a TEMP dir to generate a temp .npmrc (no always-auth)
+  const tmp = mkTmpDir();
+  const tmpNpmrc = path.join(tmp, '.npmrc');
+  console.log(`> Fetching short-lived token (temp .npmrc) [channel: ${channel}] ...`);
+  run('npx', ['-y', LOGIN_CLI, '--mode', 'project', '--scope', SCOPE, '--channel', channel], {
+    cwd: tmp,
+    env: { ...process.env, THREE_BLOCKS_LICENSE_KEY: license, THREE_BLOCKS_CHANNEL: channel },
+  });
+  if (!fs.existsSync(tmpNpmrc)) die('Login failed: temp .npmrc not created.');
+
+  // 3) Scaffold the private starter using the temp .npmrc
+  const starterSpec = `${STARTER_PKG}@${channel === 'stable' ? 'latest' : channel}`;
+  console.log(`> Creating ${appName} from ${starterSpec} ...`);
+  const createEnv = {
+    ...process.env,
+    THREE_BLOCKS_LICENSE_KEY: license,
+    NPM_CONFIG_USERCONFIG: tmpNpmrc,
+    npm_config_userconfig: tmpNpmrc,
+  };
+  run('npm', ['create', starterSpec, appName], { env: createEnv });
+
+  // 4) Write .env.local and .gitignore entries
+  await fsp.writeFile(path.join(targetDir, '.env.local'),
+    `THREE_BLOCKS_LICENSE_KEY=${license}\nTHREE_BLOCKS_CHANNEL=${channel}\n`, { mode: 0o600 }).catch(() => {});
+  const giPath = path.join(targetDir, '.gitignore');
+  let gi = '';
+  try { gi = await fsp.readFile(giPath, 'utf8'); } catch {}
+  for (const line of ['.env.local', '.npmrc']) {
+    if (!gi.includes(line)) gi += (gi.endsWith('\n') || gi === '' ? '' : '\n') + line + '\n';
+  }
+  await fsp.writeFile(giPath, gi);
+
+  // 5) First install — the starter already has:
+  //    "preinstall": "npx -y three-blocks-login --mode project --scope @three-blocks"
+  //    so it will mint a fresh token and write a project .npmrc.
+  try {
+    const pkgPath = path.join(targetDir, 'package.json');
+    const pkgRaw = await fsp.readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(pkgRaw);
+    pkg.scripts = pkg.scripts || {};
+    if (!pkg.scripts.preinstall) {
+      pkg.scripts.preinstall = `npx -y ${LOGIN_CLI} --mode project --scope ${SCOPE} --channel ${channel}`;
+    }
+    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+    console.log('> Added preinstall to generated package.json to refresh token on installs.');
+  } catch (e) {
+    console.log('> Warning: could not add preinstall to package.json:', e?.message || String(e));
+  }
+
+  console.log('> Installing dependencies (preinstall will refresh token) ...');
+  const hasPnpm = spawnSync('pnpm', ['-v'], { stdio: 'ignore' }).status === 0;
+  run(hasPnpm ? 'pnpm' : 'npm', [hasPnpm ? 'install' : 'ci'], {
+    cwd: targetDir,
+    env: { ...process.env, THREE_BLOCKS_LICENSE_KEY: license, THREE_BLOCKS_CHANNEL: channel },
+  });
+
+  // 6) Cleanup temp dir
+  try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {}
+
+  console.log(`\nSuccess! ${appName} is ready.`);
+  console.log(`\nNext:`);
+  console.log(`  cd ${appName}`);
+  console.log(`  ${hasPnpm ? 'pnpm dev' : 'npm run dev'}`);
+  console.log(`\nNotes:`);
+  console.log(`  • Your license key is stored in .env.local (gitignored).`);
+  console.log(`  • ${SCOPE} packages are private; each install refreshes a short-lived token via preinstall.`);
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "create-three-blocks-starter",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "description": "Create a new Three Blocks starter app",
+  "bin": {
+    "create-three-blocks-starter": "bin/index.js"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "three",
+    "threejs",
+    "webgpu",
+    "starter",
+    "scaffold"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "kolorist": "^1.8.0"
+  }
+}