@looop-games/cli 0.1.10 → 0.1.11

package/CHANGELOG.md

@@ -14,6 +14,23 @@ Versions: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.11] - 2026-07-12
+
+### Fixed
+- `looop update` now updates the **`looop` command itself**, not just the engine.
+  It used to leave the command at whatever version your game had pinned — so an
+  update could hand you an engine whose skills tell you to run a command your
+  `looop` was too old to have (`Unknown command: changelog`). It now moves both,
+  and says which versions it moved you between.
+
+  If you are seeing `Unknown command` today, you are on a `looop` from before
+  this fix and it cannot update itself. Run this once, and it will keep itself
+  current from then on:
+
+  ```bash
+  npm update @looop-games/cli
+  ```
+
 ## [0.1.10] - 2026-07-12
 
 ### Added

package/lib/self-update.mjs

@@ -0,0 +1,120 @@
+// Keep the `looop` command itself up to date — the third lane.
+//
+// THE BUG THIS EXISTS FOR. A game's skills and its engine ride one artifact, so
+// they can't drift. The `looop` command does not: it's an npm devDependency
+// pinned in the game's own lockfile, and `npx looop` runs THAT copy, not npm's
+// latest. `looop update` used to move only the engine — so a real game (riven)
+// ended up on engine 0.1.14, whose skills tell the agent to run
+// `looop changelog`, while its CLI was still 0.1.6:
+//
+//     $ npx looop changelog
+//     Unknown command: changelog
+//
+// The agent surface is shipped BY the engine and can name any `looop` command it
+// likes. Nothing kept the CLI in step with it. So `looop update` must mean
+// "update Looop" — engine, skills, AND the command — or the next skill that
+// mentions a new command breaks the same way.
+//
+// FAIL SOFT, ALWAYS. The engine update is the important half and it has already
+// happened by the time we get here. A CLI bump that cannot be done (offline, npm
+// down, no write access) must warn and step aside — never take the command down
+// with it. Nothing in here throws.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { runNpm } from './npm.mjs';
+
+export const CLI_PKG = '@looop-games/cli';
+
+// What `npx looop` will run NEXT TIME — the copy on disk in this game, which is
+// not necessarily the copy running right now (`npx @looop-games/cli@x update` in
+// a repo pinned to something older runs the newer one but must still fix the
+// repo).
+export function projectCliVersion(projectDir) {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(projectDir, 'node_modules', ...CLI_PKG.split('/'), 'package.json'), 'utf8'),
+    );
+    return typeof pkg.version === 'string' ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
+function isOlder(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0);
+  }
+  return false;
+}
+
+export async function syncCli({ projectDir, npm = runNpm, log = console.log } = {}) {
+  const from = projectCliVersion(projectDir);
+
+  // Nothing installed: `create` and `dev` own that. There is nothing to bring up
+  // to date, and force-installing here would be a surprise.
+  if (!from) return { from: null, to: null, updated: false, skipped: 'not-installed' };
+
+  let latest;
+  try {
+    const out = npm(['view', CLI_PKG, 'version', '--json'], { cwd: projectDir });
+    latest = JSON.parse(out.stdout.toString());
+  } catch (err) {
+    log('');
+    log(`   Could not check for a newer looop command (npm did not answer). Your engine is`);
+    log(`   up to date; the command stayed at ${from}. Try again later, or run:`);
+    log(`      npm update ${CLI_PKG}`);
+    return { from, to: null, updated: false, error: err };
+  }
+
+  // Never downgrade. A local dev build (or a version newer than the registry
+  // knows about) is deliberate — leave it alone.
+  if (!isOlder(from, latest)) return { from, to: latest, updated: false };
+
+  try {
+    // --save-dev so the DECLARED range moves too. Without it the next plain
+    // `npm install` in that repo happily resolves back down to the old pin, and
+    // the update silently un-does itself.
+    npm(['install', '--save-dev', `${CLI_PKG}@${latest}`], { cwd: projectDir });
+  } catch (err) {
+    log('');
+    log(`   The looop command could not be updated to ${latest} (npm install failed).`);
+    log(`   Your engine is up to date; the command is still ${from}. Run this to retry:`);
+    log(`      npm install --save-dev ${CLI_PKG}@${latest}`);
+    return { from, to: latest, updated: false, error: err };
+  }
+
+  return { from, to: latest, updated: true };
+}
+
+// The version of the CLI EXECUTING right now — which is not always the one the
+// project has installed. `npx looop` runs the local install (so they match), but
+// `npx @looop-games/cli@latest update` runs a newer one against an older repo.
+export function runningCliVersion() {
+  try {
+    return JSON.parse(readFileSync(join(import.meta.dirname, '..', 'package.json'), 'utf8')).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// What `update` prints. Separate so the wording is testable.
+//
+// The caveat — "you're still running the old one" — is TRUE only when the process
+// executing is the copy we just replaced. An earlier version asserted it
+// unconditionally and told a `npx @looop-games/cli@latest update` run that it was
+// "still running 0.1.6", which it plainly was not. Caught by reading the output of
+// a real run against riven. Say it only when it's true.
+export function reportCli(log, cli, { running = runningCliVersion() } = {}) {
+  if (!cli?.updated) return;
+  log('');
+  log(`✅ The looop command updated: ${cli.from} → ${cli.to}`);
+  if (running === cli.from) {
+    log(`   You're still running ${cli.from} in this process — any new commands work from`);
+    log(`   your next \`npx looop\`.`);
+  } else {
+    log(`   New commands are available from your next \`npx looop\`.`);
+  }
+  log(`   Its own changes are in node_modules/${CLI_PKG}/CHANGELOG.md.`);
+}

package/lib/update.mjs

@@ -16,6 +16,7 @@ import { getToken, getApiBase } from './config.mjs';
 import { login } from './login.mjs';
 import { DEFAULT_API_BASE } from './llm-shim.mjs';
 import { compareVersions, renderReleases } from './changelog.mjs';
+import { syncCli, reportCli } from './self-update.mjs';
 
 // The report is the point. A creator reading this must be able to answer, with
 // no further digging: what changed, was any of it mine, and what do I do now.
@@ -57,6 +58,7 @@ export async function update({
   loginFn = login,
   ensure = ensureEngine,
   reconcile = reconcileAgentSurface,
+  syncCliFn = syncCli,
 } = {}) {
   const project = findProject(cwd);
   const from = readEnginePin(project.dir);
@@ -122,6 +124,24 @@ export async function update({
   const surface = engineDir ? reconcile(project.dir, engineDir, { log }) : { skipped: true };
   if (!surface.skipped) report(log, surface.engineVersion ?? latest, surface);
 
+  // The third lane: the `looop` command itself (see self-update.mjs). The skills
+  // we just reconciled ship WITH the engine and can name any command they like —
+  // riven ended up on an engine whose skills say `looop changelog` while its CLI
+  // was four versions too old to have it. So update moves this too.
+  //
+  // Wrapped: syncCli is already fail-soft, but a bug in it must not undo an
+  // engine update that has already landed on disk.
+  let cli;
+  try {
+    cli = await syncCliFn({ projectDir: project.dir, log });
+    reportCli(log, cli);
+  } catch (err) {
+    cli = { updated: false, error: err };
+    log('');
+    log(`   The looop command could not be updated (${err.message}).`);
+    log('   Your engine and skills are up to date. Retry with: npm update @looop-games/cli');
+  }
+
   if (updated) {
     log('');
     if (crossed === null) {
@@ -133,5 +153,5 @@ export async function update({
     log('');
     log('   Republish (`npx looop publish`) when you want the live game on it.');
   }
-  return { from, to: latest, updated, surface, crossed };
+  return { from, to: latest, updated, surface, crossed, cli };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looop-games/cli",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Looop game development CLI — dev server, login, and publishing for standalone Looop games.",
   "type": "module",
   "license": "Apache-2.0",