create-deka-app 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-deka-app",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Scaffold a new deka app",
   "bin": {
     "create-deka-app": "./index.js"

package/src/cli.js

@@ -17,11 +17,17 @@ export function run({
   cwd = process.cwd(),
   log = console.log,
   error = console.error,
+  // create-deka-app's own version. Not currently used by createApp -- the
+  // runtime version it pins in the generated package.json is resolved
+  // separately, from the npm registry, since create-deka-app's own 0.0.x
+  // line and @dekaruntime/deka's release line are not in lockstep. Kept
+  // here as the CLI's own version for whatever legitimately needs it
+  // (e.g. a future `--version` flag).
   ownVersion = ownPackageJson.version,
 } = {}) {
   const targetArg = argv[0]
   try {
-    return createApp({ targetArg, cwd, env, ownVersion, log })
+    return createApp({ targetArg, cwd, env, log })
   } catch (err) {
     if (err instanceof ScaffoldError) {
       error(err.message)

package/src/package-manager.js

@@ -8,11 +8,17 @@
 // arm64". `npm_execpath` is a fallback for the rarer case where that header
 // is absent but the package manager's own launcher script is still visible
 // on the path it invoked us with.
+// `runScript` renders the command we tell the user to run for a
+// package.json script (currently always "dev"). It must work with zero
+// global installs, using only what the install step above already put on
+// disk -- so it is each package manager's own idiom for running a local
+// script, never a bare `deka ...` invocation (deka itself only lives in
+// this project's node_modules/.bin).
 const MANAGERS = {
-  npm: { name: 'npm', install: ['npm', ['install']] },
-  pnpm: { name: 'pnpm', install: ['pnpm', ['install']] },
-  yarn: { name: 'yarn', install: ['yarn', ['install']] },
-  bun: { name: 'bun', install: ['bun', ['install']] },
+  npm: { name: 'npm', install: ['npm', ['install']], runScript: (script) => `npm run ${script}` },
+  pnpm: { name: 'pnpm', install: ['pnpm', ['install']], runScript: (script) => `pnpm ${script}` },
+  yarn: { name: 'yarn', install: ['yarn', ['install']], runScript: (script) => `yarn ${script}` },
+  bun: { name: 'bun', install: ['bun', ['install']], runScript: (script) => `bun run ${script}` },
 }
 
 export function detectPackageManager(env = process.env) {

package/src/scaffold.js

@@ -29,10 +29,49 @@ function dekaBinPath(targetDir, platform) {
   return path.join(targetDir, 'node_modules', '.bin', platform === 'win32' ? 'deka.cmd' : 'deka')
 }
 
+// `deka init`'s own "next steps" block always starts with a line beginning
+// "[init]" (verified against the real binary: `[init] DekaScript app
+// ready` followed by 1-2 indented command lines). Everything from that
+// line onward is deka's suggestion for what to run next, and we always
+// replace it with our own -- see printNextSteps below for why. Everything
+// before it (the banner, the per-file `[create] ...` lines) is left
+// intact so the user still sees the scaffold happen.
+function stripDekaNextSteps(output) {
+  if (!output) return ''
+  const lines = String(output).split(/\r?\n/)
+  const cutIndex = lines.findIndex((line) => line.startsWith('[init]'))
+  return cutIndex === -1 ? String(output) : lines.slice(0, cutIndex).join('\n')
+}
+
+// deka init's own next-steps text always tells the user to run a bare
+// `deka ...` command, because that's correct advice for someone who ran
+// `deka init` by hand with deka already on their PATH. It is wrong advice
+// here: create-deka-app only ever installs deka into this project's own
+// node_modules/.bin, so a bare `deka` command fails for a user who has no
+// global install. We suppress deka's block (stripDekaNextSteps) and print
+// our own -- the `cd` line plus the detected package manager's own idiom
+// for running the "dev" script already sitting in package.json, which
+// works with nothing beyond what the install step just put on disk.
+function printNextSteps(log, dirName, pm) {
+  log('')
+  log('  Next steps:')
+  log(`    cd ${dirName}`)
+  log(`    ${pm.runScript('dev')}`)
+}
+
+export const RUNTIME_PACKAGE = '@dekaruntime/deka'
+
 // Builds the package.json this package writes into every scaffolded
 // project. Exported so the test suite can assert on it directly without
 // re-deriving the shape.
-export function buildPackageJson(dirName, ownVersion) {
+//
+// `runtimeVersion` must be the @dekaruntime/deka version resolved at
+// scaffold time (see resolveRuntimeVersion below) -- never this package's
+// own version. create-deka-app has its own 0.0.x release line and
+// @dekaruntime/deka tracks deka's releases; the two are not in lockstep
+// and never will be, so passing this package's own version here pins a
+// version of the runtime that may not exist (see deka#1076-era bug).
+export function buildPackageJson(dirName, runtimeVersion) {
   return {
     name: sanitizePackageName(dirName),
     private: true,
@@ -43,11 +82,41 @@ export function buildPackageJson(dirName, ownVersion) {
       start: 'deka start',
     },
     devDependencies: {
-      '@dekaruntime/deka': ownVersion,
+      [RUNTIME_PACKAGE]: runtimeVersion,
     },
   }
 }
 
+// Looks up the latest published @dekaruntime/deka version from the npm
+// registry so the generated package.json pins something that actually
+// exists, rather than assuming it matches create-deka-app's own version.
+//
+// Always shells out to `npm` for this lookup (not the detected package
+// manager) -- npm ships with every Node.js install, so it is available
+// regardless of whether the user ran this via npx, pnpm create, yarn
+// create or bun create, and `npm view` is a read-only registry query with
+// no project-local side effects.
+//
+// Falls back to the "latest" dist-tag -- never to a version we already
+// know is wrong -- if the registry can't be reached (offline, registry
+// outage, etc), and says so via `log` so the fallback is visible.
+export function resolveRuntimeVersion({ spawn = spawnSync, cwd = process.cwd(), log = console.log } = {}) {
+  const result = spawn('npm', ['view', RUNTIME_PACKAGE, 'version'], { cwd, encoding: 'utf8' })
+
+  const version =
+    result && !result.error && result.status === 0 ? String(result.stdout || '').trim() : ''
+
+  if (!version) {
+    log(
+      `> Could not resolve the latest ${RUNTIME_PACKAGE} version from the npm registry ` +
+        '(offline, or the registry is unreachable); pinning "latest" instead.'
+    )
+    return 'latest'
+  }
+
+  return version
+}
+
 /**
  * Orchestrates the scaffold. Everything the real `deka init` binary is
  * responsible for (writing app/, public/, deka.json, deka.lock, printing
@@ -61,7 +130,6 @@ export function createApp({
   targetArg,
   cwd = process.cwd(),
   env = process.env,
-  ownVersion,
   platform = process.platform,
   arch = process.arch,
   spawn = spawnSync,
@@ -96,7 +164,9 @@ export function createApp({
     mkdirSync(targetDir, { recursive: true })
   }
 
-  const pkg = buildPackageJson(path.basename(targetDir), ownVersion)
+  const runtimeVersion = resolveRuntimeVersion({ spawn, cwd: targetDir, log })
+
+  const pkg = buildPackageJson(path.basename(targetDir), runtimeVersion)
   writeFileSync(path.join(targetDir, 'package.json'), `${JSON.stringify(pkg, null, 2)}\n`)
 
   const pm = detectPackageManager(env)
@@ -128,17 +198,38 @@ export function createApp({
     )
   }
 
-  const init = spawn(dekaBin, ['init'], { cwd: targetDir, stdio: 'inherit' })
+  // Invoked as `deka init <dirName>` from the *parent* directory -- the
+  // same shape as someone typing `deka init myapp` by hand -- rather than
+  // `deka init` with cwd already set to targetDir. deka init never
+  // overwrites a file that already exists (package.json, written above,
+  // survives untouched), and this shape is what makes deka's own output
+  // reference the right directory name if any of it leaks through.
+  const dirName = path.basename(targetDir)
+  const parentDir = path.dirname(targetDir)
+  const init = spawn(dekaBin, ['init', dirName], {
+    cwd: parentDir,
+    stdio: ['inherit', 'pipe', 'pipe'],
+    encoding: 'utf8',
+  })
 
   if (init.error) {
     throw new ScaffoldError(`Could not run "deka init" in ${targetDir}: ${init.error.message}`)
   }
   if (init.status !== 0) {
+    // Something went wrong -- show everything deka printed, unfiltered,
+    // so the real error is visible. Filtering only ever happens below, on
+    // the success path, where we know exactly what we're throwing away.
+    if (init.stdout) log(String(init.stdout))
+    if (init.stderr) log(String(init.stderr))
     throw new ScaffoldError(
       `"deka init" failed in ${targetDir} (exit code ${init.status}).`,
       init.status ?? 1
     )
   }
 
+  if (init.stdout) log(stripDekaNextSteps(init.stdout))
+  if (init.stderr) log(stripDekaNextSteps(init.stderr))
+  printNextSteps(log, dirName, pm)
+
   return 0
 }