rigline 1.0.0-alpha.13 → 1.0.0-alpha.15

package/README.md

@@ -36,6 +36,12 @@ directory until *Developer: Reload Window*.
 
 **That is the whole of Rigline, and it needs nothing else.** Everything below is optional.
 
+**Where it works:** VS Code on Windows, Linux and macOS, in a local window, with Node 22.12 or
+newer. **Not supported yet:** remote windows, other editors built on VS Code, a portable VS Code, and
+a custom extensions directory. In any of them, Claude Code's panel stays as it ships.
+[Where Rigline works](https://github.com/Rigline/Rigline/blob/main/docs/support.md) lists each, and
+how to ask for one.
+
 ## Optional: let an extension do the remembering
 
     rigline vscode-setup
@@ -60,11 +66,13 @@ your injection alone, and `rigline restore` is what undoes the injection itself.
 
     rigline install    inject every version, bake plugins, report drift, record the baseline
     rigline check      the same report, writing nothing
+    rigline watch      install, and again whenever an extension update lands, until stopped
     rigline status     per version: vanilla or patched, by backup
     rigline restore    every version back to the extension's own bytes
+    rigline vscode-setup  install the companion into VS Code; --remove takes it out
 
     rigline add SPEC   install a plugin from a directory or npm, and re-inject
-    rigline remove N   delete a plugin rigline installed, and re-inject
+    rigline remove N   delete a plugin from ~/.rigline/plugins, and re-inject
     rigline disable N  switch a plugin off, and re-inject
     rigline enable N   switch it back on, and re-inject
     rigline update     move the engine and every npm plugin to what its tag resolves to
@@ -81,9 +89,8 @@ your injection alone, and `rigline restore` is what undoes the injection itself.
     rigline --help     the whole surface, from the engine
 
 `add` never runs a package manager for a plugin: a published plugin is one bundled ES module and a
-manifest, so there is nothing to resolve. A version must reach a minimum age (a day, by default)
-before `add` or `update` will take it, and a withheld version is named rather than skipped in
-silence. `update` applies the same rule to the engine, and says which version it moved from so
+manifest, so there is nothing to resolve. A version must be a day old before `add` or `update` will
+take it, unless you pass `--now`, and a withheld version is named rather than skipped in silence. `update` applies the same rule to the engine, and says which version it moved from so
 going back is one command.
 
 ## How it is put together
@@ -100,7 +107,7 @@ project that can declare dependencies does not need a delivery mechanism.
 
 ## Writing a plugin
 
-    npm create rigline-plugin
+    npm create rigline-plugin my-plugin
 
 [The authoring guide](https://github.com/Rigline/Rigline/blob/main/docs/authoring.md) is the long
 form. [Anchors](https://github.com/Rigline/Rigline/blob/main/docs/anchors.md) is what to read when

package/dist/commands.js

@@ -37,7 +37,8 @@ export async function updateCommand(args, options = {}) {
         throw new UserError(problem);
     notice(engine.version, wrapper);
     const code = await engine.run(["update", ...forward]);
-    return moved.outcome === "failed" ? 1 : code;
+    const needsYou = moved.outcome === "failed" || (moved.outcome === "withheld" && moved.by === "node");
+    return needsYou ? 1 : code;
 }
 export function notice(engine, wrapper = wrapperVersion()) {
     const line = newerWrapper(wrapper, engine);

package/dist/engine.js

@@ -4,8 +4,10 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { UserError } from "./errors.js";
+import { belowFloor } from "./floor.js";
 import { withHomeLock } from "./lock.js";
 import { releaseAgeProblem, resolveVersion } from "./registry.js";
+export { belowFloor } from "./floor.js";
 export const ENGINE_PACKAGE = "@rigline/core";
 export const ENGINE_BIN = "rigline-engine";
 export function riglineHome(env = process.env) {
@@ -59,7 +61,7 @@ export function majorProblem(wrapper, engine) {
     if (ours === null || theirs === null || ours === theirs)
         return null;
     return (`rigline ${ours}.x cannot run engine ${theirs}.x (${ENGINE_PACKAGE} ${engine}). ` +
-        "Run npm i -g rigline@latest.");
+        "Run npm i -g rigline@latest, then rigline vscode-setup if you use the companion.");
 }
 export function compareVersions(a, b) {
     const x = parseVersion(a);
@@ -118,14 +120,12 @@ export function handOffProblem(wrapper, engine) {
 }
 export function findNpmCli(execPath = process.execPath, exists = existsSync) {
     const here = dirname(execPath);
-    const candidates = [
-        join(here, "node_modules", "npm", "bin", "npm-cli.js"),
-        join(here, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
-    ];
+    const npmIn = (...dir) => join(here, ...dir, "node_modules", "npm", "bin", "npm-cli.js");
+    const candidates = [npmIn(), npmIn("..", "lib"), npmIn("..", "libexec", "lib")];
     const found = candidates.find(exists);
     if (found === undefined) {
         throw new UserError(`no npm was found beside ${execPath}, so the engine cannot be installed. ` +
-            `Run: npm install --prefix ${engineDir()} --save-exact --ignore-scripts ${ENGINE_PACKAGE}@latest`);
+            `Run: npm install --prefix "${engineDir()}" --save-exact --ignore-scripts ${ENGINE_PACKAGE}@latest`);
     }
     return found;
 }
@@ -246,9 +246,19 @@ export async function updateEngine(options = {}) {
         };
     }
     if (installed !== null) {
-        const withheld = releaseAgeProblem(resolved, options.registry);
-        if (withheld !== null) {
-            return { outcome: "withheld", from: installed, to: resolved.version, reason: withheld };
+        const node = nodeFloorProblem(resolved, options);
+        if (node !== null) {
+            return {
+                outcome: "withheld",
+                from: installed,
+                to: resolved.version,
+                reason: node,
+                by: "node",
+            };
+        }
+        const age = releaseAgeProblem(resolved, options.registry);
+        if (age !== null) {
+            return { outcome: "withheld", from: installed, to: resolved.version, reason: age, by: "age" };
         }
     }
     try {
@@ -266,6 +276,16 @@ export async function updateEngine(options = {}) {
         ? { outcome: "installed", to: resolved.version }
         : { outcome: "moved", from: installed, to: resolved.version };
 }
+function nodeFloorProblem(resolved, options) {
+    const running = options.nodeVersion ?? (options.nodePath === undefined ? process.versions.node : null);
+    if (running === null || resolved.enginesNode === null)
+        return null;
+    const floor = belowFloor(running, resolved.enginesNode);
+    if (floor === null)
+        return null;
+    return (`${ENGINE_PACKAGE} ${resolved.version} needs Node ${floor} or newer, and ` +
+        `${options.nodePath ?? process.execPath} is Node ${running}. Install a newer Node to move to it.`);
+}
 export function formatEngineUpdate(update, home = riglineHome()) {
     switch (update.outcome) {
         case "installed":

package/dist/floor.js

@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+export function belowFloor(running, range) {
+    const floor = /^>=\s*(\d+)\.(\d+)\.(\d+)$/.exec((range ?? "").trim());
+    if (floor === null)
+        return null;
+    const have = running.split(".").map(Number);
+    for (let at = 0; at < 3; at++) {
+        const want = Number(floor[at + 1]);
+        const got = have[at] ?? 0;
+        if (got > want)
+            return null;
+        if (got < want)
+            return floor.slice(1).join(".");
+    }
+    return null;
+}
+export function enginesNode() {
+    const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return manifest?.engines?.node;
+}
+//# sourceMappingURL=floor.js.map

package/dist/index.js

@@ -1,30 +1,13 @@
 #!/usr/bin/env node
-import { notice, updateCommand, versionCommand } from "./commands.js";
-import { ensureEngine } from "./engine.js";
-import { UserError } from "./errors.js";
-async function main(argv) {
-    const [command, ...rest] = argv;
-    switch (command) {
-        case "--version":
-        case "-v":
-            return versionCommand();
-        case "update":
-            return await updateCommand(rest);
-        default: {
-            const engine = await ensureEngine();
-            notice(engine.version);
-            return await engine.run(argv);
-        }
-    }
+import { belowFloor, enginesNode } from "./floor.js";
+const floor = belowFloor(process.versions.node, enginesNode());
+if (floor === null) {
+    const { runWrapper } = await import("./main.js");
+    process.exitCode = await runWrapper(process.argv.slice(2));
+}
+else {
+    console.error(`rigline: Rigline needs Node ${floor} or newer, and ${process.execPath} is Node ` +
+        `${process.versions.node}; https://nodejs.org has one.`);
+    process.exitCode = 1;
 }
-main(process.argv.slice(2)).then((code) => {
-    process.exitCode = code;
-}, (error) => {
-    if (error instanceof UserError) {
-        console.error(`rigline: ${error.message}`);
-        process.exitCode = 1;
-        return;
-    }
-    throw error;
-});
 //# sourceMappingURL=index.js.map

package/dist/lock.js

@@ -2,6 +2,7 @@ import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFi
 import { join } from "node:path";
 import { UserError } from "./errors.js";
 const STALE_MS = 60_000;
+const HELD_MAX_MS = 10 * 60_000;
 const WAIT_MS = 30_000;
 const POLL_MS = 250;
 export function lockPath(home) {
@@ -41,8 +42,8 @@ function writtenAt(path) {
 }
 export function isStale(holder, fileTime, now, staleMs, isAlive) {
     const since = holder === null ? fileTime : Date.parse(holder.since);
-    const old = Number.isNaN(since) || now - since >= staleMs;
-    return old && (holder === null || !isAlive(holder.pid));
+    const age = Number.isNaN(since) ? Number.POSITIVE_INFINITY : now - since;
+    return age >= HELD_MAX_MS || (age >= staleMs && (holder === null || !isAlive(holder.pid)));
 }
 export class HomeLockedError extends UserError {
     holder;

package/dist/main.js

@@ -0,0 +1,40 @@
+import { parseArgs } from "node:util";
+import { notice, updateCommand, versionCommand } from "./commands.js";
+import { ensureEngine } from "./engine.js";
+import { UserError } from "./errors.js";
+export async function runWrapper(argv) {
+    try {
+        return await dispatch(argv);
+    }
+    catch (error) {
+        if (!(error instanceof UserError))
+            throw error;
+        console.error(`rigline: ${error.message}`);
+        return 1;
+    }
+}
+async function dispatch(argv) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case "--version":
+        case "-v":
+            noArguments(rest);
+            return versionCommand();
+        case "update":
+            return await updateCommand(rest);
+        default: {
+            const engine = await ensureEngine();
+            notice(engine.version);
+            return await engine.run(argv);
+        }
+    }
+}
+function noArguments(args) {
+    try {
+        parseArgs({ args: [...args], options: {}, strict: true, allowPositionals: false });
+    }
+    catch (error) {
+        throw new UserError(`${error.message}\n\`rigline --help\` lists what each command takes.`);
+    }
+}
+//# sourceMappingURL=main.js.map

package/dist/registry.js

@@ -17,6 +17,7 @@ export async function resolveVersion(spec, options = {}) {
     if (typeof tarball !== "string" || tarball.length === 0) {
         throw new UserError(`${spec.name}@${version} has no tarball on ${registryOf(options)}`);
     }
+    const node = release.engines?.node;
     return {
         name: spec.name,
         version,
@@ -24,6 +25,7 @@ export async function resolveVersion(spec, options = {}) {
         tarball,
         integrity: integrityOf(release, `${spec.name}@${version}`),
         ageMinutes,
+        enginesNode: typeof node === "string" ? node : null,
     };
 }
 export function releaseAgeProblem(resolved, options = {}) {
@@ -35,7 +37,7 @@ export function releaseAgeProblem(resolved, options = {}) {
     return (`${resolved.name}@${resolved.version} was published ${describeAge(resolved.ageMinutes)} ago, ` +
         `and rigline waits ${describeAge(minimum)} before installing a version. That window is where ` +
         "a compromised publish is usually caught, and it costs little here because the urgent repair " +
-        "— an anchor an extension update retired — is a local edit rather than a release (D44). " +
+        "— an anchor an extension update retired — is a local edit rather than a release. " +
         "Wait, or pass --now.");
 }
 export function describeAge(minutes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rigline",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.15",
   "description": "Install, update and develop plugins for the Claude Code VS Code extension",
   "keywords": [
     "rigline",