create-three-blocks-starter 0.0.1 → 0.0.3

package/README.md

@@ -1,4 +1,4 @@
-# @three-blocks/create-starter
+# create-three-blocks-starter
 
 Private CLI to scaffold a new project from the Three Blocks starter.
 
@@ -15,7 +15,7 @@ Then scaffold a new app:
 ```bash
 npm create @three-blocks/starter@latest my-app
 # or
-pnpm dlx @three-blocks/create-starter my-app
+pnpm dlx create-three-blocks-starter my-app
 ```
 
 Next steps:
@@ -32,12 +32,12 @@ pnpm dev
 - To sync locally without publishing:
 
 ```bash
-pnpm --filter @three-blocks/create-starter run dev:sync
+pnpm --filter create-three-blocks-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
+pnpm --filter create-three-blocks-starter publish --access restricted
 ```

package/bin/index.js

@@ -1,8 +1,8 @@
 #!/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)
+//   THREE_BLOCKS_SECRET_KEY=sk_live_... npx create-three-blocks-starter my-app
+//   npx create-three-blocks-starter my-app  (will prompt for key)
 
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
@@ -10,6 +10,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import readline from 'node:readline';
+import { bold, cyan, dim, gray, green, yellow } from 'kolorist';
 
 const STARTER_PKG = '@three-blocks/starter';   // private starter (lives in CodeArtifact)
 const LOGIN_CLI = 'three-blocks-login';        // public login CLI
@@ -21,6 +22,13 @@ const run = (cmd, args, opts = {}) => {
   if (r.status !== 0) process.exit(r.status ?? 1);
 };
 
+// capture stdout (used for npm pack)
+const exec = (cmd, args, opts = {}) => {
+  const r = spawnSync(cmd, args, { stdio: ['ignore', 'pipe', 'inherit'], ...opts });
+  if (r.status !== 0) process.exit(r.status ?? 1);
+  return (r.stdout || Buffer.alloc(0)).toString();
+};
+
 async function ensureEmptyDir(dir) {
   try { await fsp.mkdir(dir, { recursive: true }); } catch {}
   const files = await fsp.readdir(dir).catch(() => []);
@@ -28,20 +36,44 @@ async function ensureEmptyDir(dir) {
 }
 
 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('*');
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let value = '';
+    const cleanup = () => {
+      stdin.removeListener('data', onData);
+      if (stdin.isTTY) stdin.setRawMode(false);
+      stdin.pause();
     };
-    process.stdin.on('data', onData);
-    rl.question('', (v) => {
-      process.stdin.removeListener('data', onData);
-      rl.close();
-      resolve(v.trim());
-    });
+    const onData = (chunk) => {
+      const str = String(chunk);
+      for (const ch of str) {
+        if (ch === '\u0003') { cleanup(); process.exit(1); }
+        if (ch === '\r' || ch === '\n' || ch === '\u0004') {
+          stdout.write('\n');
+          cleanup();
+          return resolve(value.trim());
+        }
+        if (ch === '\u0008' || ch === '\u007f') {
+          if (value.length) {
+            value = value.slice(0, -1);
+            readline.moveCursor(stdout, -1, 0);
+            stdout.write(' ');
+            readline.moveCursor(stdout, -1, 0);
+          }
+          continue;
+        }
+        // Ignore ESC start of control sequences
+        if (ch === '\u001b') continue;
+        value += ch;
+        stdout.write('•');
+      }
+    };
+    stdout.write(label);
+    stdin.setEncoding('utf8');
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on('data', onData);
   });
 }
 
@@ -49,6 +81,13 @@ function mkTmpDir(prefix = 'three-blocks-') {
   return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
 }
 
+function mask(s) {
+  if (!s) return '';
+  const v = String(s);
+  if (v.length <= 6) return '••••';
+  return v.slice(0, 3) + '••••' + v.slice(-4);
+}
+
 async function main() {
   const args = process.argv.slice(2);
   let appName = '';
@@ -64,7 +103,7 @@ async function main() {
   if (!appName) {
     die(
       `Usage:\n` +
-      `  THREE_BLOCKS_LICENSE_KEY=sk_live_... npx three-blocks-create-app <directory>\n` +
+      `  THREE_BLOCKS_SECRET_KEY=sk_live_... npx three-blocks-create-app <directory>\n` +
       `  (or: npx three-blocks-create-app <directory> and enter the key when prompted)`
     );
   }
@@ -73,9 +112,15 @@ async function main() {
   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: ');
+  let license = process.env.THREE_BLOCKS_SECRET_KEY;
+  if (license) {
+    console.log(`${gray('›')} Using ${bold('THREE_BLOCKS_SECRET_KEY')} from environment ${dim(`(${mask(license)})`)}`);
+  } else {
+    console.log('');
+    console.log(bold(cyan('Three Blocks Starter')) + ' ' + dim(`[channel: ${channel}]`));
+    console.log(dim('Enter your license key to continue.'));
+    console.log(dim('Tip: paste it here; input is hidden. Press Enter to submit.'));
+    license = await promptHidden(`${gray('›')} ${bold('License key')} ${dim('(tb_…)')}: `);
     if (!license) die('License key is required to install private packages.');
   }
 
@@ -85,24 +130,44 @@ async function main() {
   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 },
+    env: { ...process.env, THREE_BLOCKS_SECRET_KEY: license, THREE_BLOCKS_CHANNEL: channel },
   });
   if (!fs.existsSync(tmpNpmrc)) die('Login failed: temp .npmrc not created.');
+  // Extract registry URL from temp .npmrc so we can pass it explicitly to npm create
+  let registryUrl = '';
+  try {
+    const txt = fs.readFileSync(tmpNpmrc, 'utf8');
+    const m = txt.match(/^@[^:]+:registry=(.+)$/m);
+    if (m && m[1]) registryUrl = m[1].trim();
+  } catch {}
 
-  // 3) Scaffold the private starter using the temp .npmrc
+  // 3) Scaffold the private starter by packing and extracting the tarball (avoids npm create naming transform)
   const starterSpec = `${STARTER_PKG}@${channel === 'stable' ? 'latest' : channel}`;
-  console.log(`> Creating ${appName} from ${starterSpec} ...`);
+  console.log(`> Fetching starter tarball ${starterSpec} ...`);
   const createEnv = {
     ...process.env,
-    THREE_BLOCKS_LICENSE_KEY: license,
+    THREE_BLOCKS_SECRET_KEY: license,
     NPM_CONFIG_USERCONFIG: tmpNpmrc,
     npm_config_userconfig: tmpNpmrc,
   };
-  run('npm', ['create', starterSpec, appName], { env: createEnv });
+  let packedOut = exec('npm', ['pack', starterSpec, '--json', '--silent'], { cwd: tmp, env: createEnv });
+  let tarName = '';
+  try {
+    const info = JSON.parse(packedOut);
+    if (Array.isArray(info)) tarName = info[0]?.filename || '';
+    else tarName = info.filename || '';
+  } catch {
+    const lines = String(packedOut || '').trim().split(/\r?\n/);
+    tarName = lines[lines.length - 1] || '';
+  }
+  const tarPath = path.join(tmp, tarName);
+  if (!tarName || !fs.existsSync(tarPath)) die('Failed to fetch starter tarball.');
+  console.log('> Extracting files ...');
+  run('tar', ['-xzf', tarPath, '-C', targetDir, '--strip-components=1']);
 
   // 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(() => {});
+    `THREE_BLOCKS_SECRET_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 {}
@@ -123,16 +188,20 @@ async function main() {
       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.');
+    console.log(`${green('✔')} 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(`${yellow('⚠')} 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 },
+    env: {
+      ...process.env,
+      THREE_BLOCKS_SECRET_KEY: license,
+      THREE_BLOCKS_CHANNEL: channel,
+    },
   });
 
   // 6) Cleanup temp dir

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-three-blocks-starter",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": false,
   "type": "module",
   "description": "Create a new Three Blocks starter app",