rigline 1.0.0-alpha.12 → 1.0.0-alpha.14

package/README.md

@@ -10,8 +10,9 @@ rather than a breakage to chase.
 
 **This modifies files belonging to Anthropic's extension, on your machine, and that is your call to
 make.** [Anthropic compliance](https://github.com/Rigline/Rigline/blob/main/docs/anthropic-compliance.md)
-is a straight account of what Rigline does and does not do — no credentials, no network calls, no
-rerouting of Claude usage, no redistribution — and how we read Anthropic's terms. `rigline restore`
+is a straight account of what Rigline does to that extension and what it does not — no credentials,
+no network calls from the panel, no rerouting of Claude usage, no redistribution — and how we read
+Anthropic's terms. `rigline restore`
 puts every install back to Anthropic's own bytes and needs nothing but Node.
 
 ## Install
@@ -21,7 +22,8 @@ puts every install back to Anthropic's own bytes and needs nothing but Node.
 
 The first command you run fetches the engine, [`@rigline/core`](https://www.npmjs.com/package/@rigline/core),
 into `~/.rigline/engine` and runs it from there. It takes a few seconds and needs the registry;
-after that nothing reaches the network unless you ask it to. If that directory is ever in a bad
+after that nothing reaches the network unless you ask it to, or install the companion below, which
+asks the registry for a newer engine each time a window starts. If that directory is ever in a bad
 state, delete it and run any command again.
 
 `install` finds every installed version of the extension, harvests it, bakes the discovered plugins
@@ -34,14 +36,20 @@ 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
 
 If running `install` after every update is a chore, this installs a companion extension that does it
-for you — into every VS Code found on your `PATH`, Insiders, VSCodium, Cursor and Windsurf included,
-from a VSIX that ships inside the engine. Nothing is downloaded, and the companion moves when the
-engine does. It injects as it goes, so it is a step *instead of* `install` rather than after it.
+for you — into VS Code, found on your `PATH`, from a VSIX that ships inside the engine. Nothing is
+downloaded, and the companion moves when the engine does. It injects as it goes, so it is a step
+*instead of* `install` rather than after it.
 
 From then on it watches for the extension update and re-injects behind it, so there is nothing to
 remember after one. It goes into every VS Code profile that has Claude Code, and into any profile
@@ -58,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
@@ -79,17 +89,17 @@ 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
 
-`rigline` is a small retrieval layer. It fetches bytes — a plugin tarball, the engine — checks them,
-and hands them over; `@rigline/core` does everything else and answers every verb above. The split is
-not decoration: a process cannot replace the package it is running out of, so whatever performs an
-update has to sit above the thing being updated.
+`rigline` is a small retrieval layer. It installs the engine and runs it, and `@rigline/core` answers
+every verb above, fetching plugins included. The split is not decoration: a process cannot replace
+the package it is running out of, so `update` moves the engine from here and then hands the rest to
+it. Nothing updates `rigline` itself, so when the engine you have is newer, `rigline` says so and
+names the command.
 
 **It belongs in no project's dependencies.** If you are writing plugins, your workspace declares
 `@rigline/core` and runs `rigline-engine`; `npm create rigline-plugin` scaffolds it that way. A
@@ -97,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

@@ -0,0 +1,62 @@
+import { ENGINE_PACKAGE, engineDir, ensureEngine, formatEngineUpdate, handOffProblem, newerWrapper, readEngineState, riglineHome, updateEngine, wrapperVersion, } from "./engine.js";
+import { UserError } from "./errors.js";
+export function splitUpdateArgs(args) {
+    let tag;
+    let now = false;
+    const forward = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--") {
+            forward.push(...args.slice(i));
+            break;
+        }
+        if (arg === "--tag" || arg.startsWith("--tag=")) {
+            tag = arg === "--tag" ? args[++i] : arg.slice("--tag=".length);
+            if (tag === undefined || tag === "")
+                throw new UserError("--tag needs a dist-tag");
+            continue;
+        }
+        if (arg === "--now")
+            now = true;
+        forward.push(arg);
+    }
+    return { ...(tag === undefined ? {} : { tag }), now, forward };
+}
+export async function updateCommand(args, options = {}) {
+    const { tag, now, forward } = splitUpdateArgs(args);
+    const given = {
+        ...options,
+        registry: { ...options.registry, ignoreReleaseAge: now },
+    };
+    const moved = await updateEngine({ ...given, ...(tag === undefined ? {} : { tag }) });
+    console.log(formatEngineUpdate(moved, options.home ?? riglineHome()));
+    const engine = await ensureEngine(given);
+    const wrapper = options.version ?? wrapperVersion();
+    const problem = handOffProblem(wrapper, engine.version);
+    if (problem !== null)
+        throw new UserError(problem);
+    notice(engine.version, wrapper);
+    const code = await engine.run(["update", ...forward]);
+    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);
+    if (line !== null)
+        console.error(line);
+}
+export function versionCommand() {
+    const prefix = engineDir();
+    const state = readEngineState(prefix);
+    const wrapper = wrapperVersion();
+    console.log(`rigline ${wrapper}`);
+    console.log(state.kind === "none"
+        ? `engine: none in ${prefix} — the next command installs one`
+        : `engine: ${ENGINE_PACKAGE} ${state.version} in ${prefix}` +
+            (state.kind === "unusable" ? ` (unusable: ${state.why})` : ""));
+    const newer = state.kind === "none" ? null : newerWrapper(wrapper, state.version);
+    if (newer !== null)
+        console.log(newer);
+    return 0;
+}
+//# sourceMappingURL=commands.js.map

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,18 +61,71 @@ 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);
+    const y = parseVersion(b);
+    if (x === null || y === null)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        const diff = x.release[i] - y.release[i];
+        if (diff !== 0)
+            return diff;
+    }
+    if (x.pre.length === 0 || y.pre.length === 0)
+        return y.pre.length - x.pre.length;
+    for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+        const p = x.pre[i];
+        const q = y.pre[i];
+        if (p === undefined)
+            return -1;
+        if (q === undefined)
+            return 1;
+        if (p === q)
+            continue;
+        const pNumeric = /^\d+$/.test(p);
+        const qNumeric = /^\d+$/.test(q);
+        if (pNumeric && qNumeric)
+            return Number(p) - Number(q);
+        if (pNumeric !== qNumeric)
+            return pNumeric ? -1 : 1;
+        return p < q ? -1 : 1;
+    }
+    return 0;
+}
+function parseVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+    if (match === null)
+        return null;
+    return {
+        release: [Number(match[1]), Number(match[2]), Number(match[3])],
+        pre: match[4] === undefined ? [] : match[4].split("."),
+    };
+}
+export function newerWrapper(wrapper, engine) {
+    const order = compareVersions(engine, wrapper);
+    if (order === null || order <= 0)
+        return null;
+    return `rigline ${engine} is out, and this is ${wrapper}: npm i -g rigline@${engine}`;
+}
+const LAST_WITHOUT_UPDATE = "1.0.0-alpha.12";
+export function handOffProblem(wrapper, engine) {
+    const behind = compareVersions(engine, wrapper);
+    const old = compareVersions(engine, LAST_WITHOUT_UPDATE);
+    if (behind === null || old === null || behind >= 0 || old > 0)
+        return null;
+    return (`${ENGINE_PACKAGE} ${engine} does no update of its own, so no plugin was updated. ` +
+        `Run rigline update again once the engine has moved past ${LAST_WITHOUT_UPDATE}.`);
 }
 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;
 }
@@ -88,10 +143,7 @@ export function engineInstallArgv(options) {
         ...options.specs,
     ];
 }
-const nodeSpawn = (command, args, options) => spawn(command, [...args], {
-    stdio: [...options.stdio],
-    ...(options.env === undefined ? {} : { env: options.env }),
-});
+const nodeSpawn = (command, args, options) => spawn(command, [...args], { stdio: [...options.stdio], windowsHide: true });
 export async function ensureEngine(options = {}) {
     const prefix = engineDir(options.home ?? riglineHome());
     const version = options.version ?? wrapperVersion();
@@ -111,7 +163,7 @@ export async function ensureEngine(options = {}) {
     const problem = majorProblem(version, resolved.version);
     if (problem !== null)
         throw new UserError(problem);
-    console.log(`rigline: installing the engine, ${ENGINE_PACKAGE} ${resolved.version}`);
+    console.error(`rigline: installing the engine, ${ENGINE_PACKAGE} ${resolved.version}`);
     await installEngine(prefix, `${ENGINE_PACKAGE}@${resolved.version}`, options);
     const installed = readEngineState(prefix);
     if (installed.kind !== "ready") {
@@ -141,32 +193,18 @@ function engineAt(state, options) {
     return {
         version: state.version,
         entry: state.entry,
-        run: (argv, env) => new Promise((done, fail) => {
+        run: (argv) => new Promise((done, fail) => {
             const child = spawnImpl(node, [state.entry, ...argv], {
                 stdio: ["inherit", "inherit", "inherit"],
-                ...(env === undefined ? {} : { env: { ...process.env, ...env } }),
             });
             child.on("error", fail);
             child.on("close", (code) => done(code ?? 1));
         }),
-        json: async (argv, options) => {
-            const stderr = options?.quiet ? "ignore" : "inherit";
-            const run = await capture(node, [state.entry, ...argv], spawnImpl, stderr);
-            if (run.code !== 0) {
-                throw new UserError(`the engine exited ${run.code} for \`${argv.join(" ")}\``);
-            }
-            try {
-                return JSON.parse(run.output);
-            }
-            catch {
-                throw new UserError(`the engine answered \`${argv.join(" ")}\` with something that is not JSON`);
-            }
-        },
     };
 }
-async function capture(command, argv, spawnImpl = nodeSpawn, stderr = "pipe") {
+async function capture(command, argv, spawnImpl = nodeSpawn) {
     return await new Promise((done, fail) => {
-        const child = spawnImpl(command, argv, { stdio: ["ignore", "pipe", stderr] });
+        const child = spawnImpl(command, argv, { stdio: ["ignore", "pipe", "pipe"] });
         let output = "";
         child.stdout?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
@@ -208,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 {
@@ -228,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,110 +1,13 @@
 #!/usr/bin/env node
-import { parseArgs } from "node:util";
-import { ENGINE_PACKAGE, engineDir, ensureEngine, formatEngineUpdate, readEngineState, updateEngine, wrapperVersion, } from "./engine.js";
-import { UserError } from "./errors.js";
-import { addFromNpm, formatUpdates, updatePlugins } from "./remote.js";
-function isPathSpec(spec) {
-    if (spec.startsWith("@"))
-        return false;
-    return spec.startsWith(".") || spec.includes("/") || spec.includes("\\");
+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));
 }
-async function addCommand(args) {
-    const { values, positionals } = parseArgs({
-        args,
-        options: { now: { type: "boolean", default: false } },
-        allowPositionals: true,
-    });
-    if (positionals.length !== 1) {
-        throw new UserError("add needs exactly one plugin directory or npm package");
-    }
-    const spec = positionals[0];
-    const engine = await ensureEngine();
-    if (isPathSpec(spec))
-        return await engine.run(["add", spec]);
-    return await addFromNpm({
-        spec,
-        engine: engine.run,
-        registry: { ignoreReleaseAge: values.now },
-    });
+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;
 }
-async function listed(engine) {
-    const answer = await engine.json(["list", "--json"]);
-    if (!Array.isArray(answer))
-        throw new UserError("the engine's plugin list was not a list");
-    return answer;
-}
-const DEFER_INJECT = "RIGLINE_DEFER_INJECT";
-async function updateCommand(args) {
-    const { values, positionals } = parseArgs({
-        args,
-        options: { now: { type: "boolean", default: false }, tag: { type: "string" } },
-        allowPositionals: true,
-    });
-    const registry = { ignoreReleaseAge: values.now };
-    const engineUpdate = await updateEngine({ registry, ...(values.tag ? { tag: values.tag } : {}) });
-    console.log(formatEngineUpdate(engineUpdate));
-    const engine = await ensureEngine({ registry });
-    const updates = await updatePlugins({
-        listed: await listed(engine),
-        engine: (argv) => engine.run(argv, { [DEFER_INJECT]: "1" }),
-        ...(positionals.length > 0 ? { names: positionals } : {}),
-        registry,
-    });
-    console.log(formatUpdates(updates));
-    await addCompanions(engine);
-    const moved = engineUpdate.outcome === "moved" ||
-        engineUpdate.outcome === "installed" ||
-        updates.some((u) => u.outcome === "updated");
-    let injected = 0;
-    if (moved) {
-        console.log("");
-        injected = await engine.run(["install"]);
-    }
-    const failed = updates.some((u) => u.outcome === "failed") || engineUpdate.outcome === "failed";
-    return failed || injected !== 0 ? 1 : 0;
-}
-async function addCompanions(engine) {
-    const answer = (await engine.json(["companion-profiles"], { quiet: true }).catch(() => null));
-    if (answer?.v !== 1 || !Array.isArray(answer.lines))
-        return;
-    for (const line of answer.lines)
-        if (typeof line === "string")
-            console.log(line);
-}
-function versionCommand() {
-    const prefix = engineDir();
-    const state = readEngineState(prefix);
-    console.log(`rigline ${wrapperVersion()}`);
-    console.log(state.kind === "none"
-        ? `engine: none in ${prefix} — the next command installs one`
-        : `engine: ${ENGINE_PACKAGE} ${state.version} in ${prefix}` +
-            (state.kind === "unusable" ? ` (unusable: ${state.why})` : ""));
-    return 0;
-}
-async function main(argv) {
-    const [command, ...rest] = argv;
-    switch (command) {
-        case "--version":
-        case "-v":
-            return versionCommand();
-        case "add":
-            return await addCommand(rest);
-        case "update":
-            return await updateCommand(rest);
-        default: {
-            const engine = await ensureEngine();
-            return await engine.run(argv);
-        }
-    }
-}
-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

@@ -1,21 +1,6 @@
-import { createHash } from "node:crypto";
 import { UserError } from "./errors.js";
 export const DEFAULT_REGISTRY = "https://registry.npmjs.org";
 export const MINIMUM_RELEASE_AGE_MINUTES = 1440;
-export function parsePluginSpec(spec) {
-    const at = spec.lastIndexOf("@");
-    const scoped = spec.startsWith("@");
-    if (at <= 0 || (scoped && at === 0)) {
-        return { name: spec, version: null, tag: null };
-    }
-    const name = spec.slice(0, at);
-    const rest = spec.slice(at + 1);
-    if (rest.length === 0)
-        return { name, version: null, tag: null };
-    return /^\d+\.\d+\.\d+(?:[-+].*)?$/.test(rest)
-        ? { name, version: rest, tag: null }
-        : { name, version: null, tag: rest };
-}
 export async function resolveVersion(spec, options = {}) {
     const packument = await fetchPackument(spec.name, options);
     const tag = spec.version === null ? (spec.tag ?? "latest") : null;
@@ -32,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,
@@ -39,35 +25,9 @@ export async function resolveVersion(spec, options = {}) {
         tarball,
         integrity: integrityOf(release, `${spec.name}@${version}`),
         ageMinutes,
+        enginesNode: typeof node === "string" ? node : null,
     };
 }
-export async function fetchTarball(resolved, options = {}) {
-    const response = await request(resolved.tarball, options);
-    const bytes = Buffer.from(await response.arrayBuffer());
-    const problem = integrityProblem(bytes, resolved.integrity);
-    if (problem !== null) {
-        throw new UserError(`${resolved.name}@${resolved.version} from ${resolved.tarball} ${problem}. ` +
-            "Nothing was written.");
-    }
-    return bytes;
-}
-export function integrityProblem(bytes, integrity) {
-    const dash = integrity.indexOf("-");
-    if (dash <= 0)
-        return `has an integrity string this cannot read ("${integrity}")`;
-    const algorithm = integrity.slice(0, dash);
-    const expected = integrity.slice(dash + 1);
-    let actual;
-    try {
-        actual = createHash(algorithm).update(bytes).digest("base64");
-    }
-    catch {
-        return `names a digest this cannot compute ("${algorithm}")`;
-    }
-    return actual === expected
-        ? null
-        : `does not match its recorded integrity (${algorithm}-${actual} against ${integrity})`;
-}
 export function releaseAgeProblem(resolved, options = {}) {
     if (options.ignoreReleaseAge)
         return null;
@@ -77,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.12",
+  "version": "1.0.0-alpha.14",
   "description": "Install, update and develop plugins for the Claude Code VS Code extension",
   "keywords": [
     "rigline",

package/dist/remote.js

@@ -1,132 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { UserError } from "./errors.js";
-import { fetchTarball, parsePluginSpec, releaseAgeProblem, resolveVersion, } from "./registry.js";
-import { readPackageTarball } from "./tarball.js";
-export async function addFromNpm(options) {
-    const resolved = await resolveVersion(parsePluginSpec(options.spec), options.registry);
-    const withheld = releaseAgeProblem(resolved, options.registry);
-    if (withheld !== null)
-        throw new UserError(withheld);
-    return await stageAndAdd(resolved, options);
-}
-async function stageAndAdd(resolved, options) {
-    const label = `${resolved.name}@${resolved.version}`;
-    const files = readPackageTarball(await fetchTarball(resolved, options.registry), label);
-    const staged = mkdtempSync(join(tmpdir(), "rigline-add-"));
-    try {
-        for (const file of files) {
-            const target = join(staged, file.path);
-            mkdirSync(dirname(target), { recursive: true });
-            writeFileSync(target, file.bytes);
-        }
-        const source = {
-            kind: "npm",
-            name: resolved.name,
-            version: resolved.version,
-            tag: resolved.tag,
-            integrity: resolved.integrity,
-            addedAt: (options.now?.() ?? new Date()).toISOString(),
-        };
-        return await options.engine(["add", staged, "--source", JSON.stringify(source)]);
-    }
-    finally {
-        rmSync(staged, { recursive: true, force: true });
-    }
-}
-export async function updatePlugins(options) {
-    const managed = options.listed.filter((plugin) => plugin.managed);
-    const byName = new Map(managed.map((plugin) => [plugin.name, plugin]));
-    const names = options.names ?? managed.map((plugin) => plugin.name);
-    const updates = [];
-    for (const name of names) {
-        const plugin = byName.get(name);
-        if (plugin === undefined) {
-            updates.push({ name, outcome: "failed", reason: "not installed by rigline" });
-            continue;
-        }
-        const source = plugin.source;
-        if (source === null) {
-            updates.push({ name, outcome: "unmanaged" });
-            continue;
-        }
-        if (source.kind === "path") {
-            updates.push({
-                name,
-                outcome: "local",
-                reason: typeof source.from === "string" ? source.from : "a directory",
-            });
-            continue;
-        }
-        if (source.kind !== "npm") {
-            updates.push({ name, outcome: "unmanaged", reason: `source kind "${source.kind}"` });
-            continue;
-        }
-        if (source.name === undefined || source.version === undefined) {
-            updates.push({ name, outcome: "failed", reason: "its npm source is incomplete" });
-            continue;
-        }
-        if (source.tag === null || source.tag === undefined) {
-            updates.push({ name, outcome: "pinned", from: source.version });
-            continue;
-        }
-        updates.push(await updateOne(name, { name: source.name, version: source.version, tag: source.tag }, options));
-    }
-    return updates;
-}
-async function updateOne(name, source, options) {
-    try {
-        const resolved = await resolveVersion({ name: source.name, version: null, tag: source.tag }, options.registry);
-        if (resolved.version === source.version) {
-            return { name, outcome: "current", from: source.version };
-        }
-        const withheld = releaseAgeProblem(resolved, options.registry);
-        if (withheld !== null) {
-            return {
-                name,
-                outcome: "withheld",
-                from: source.version,
-                to: resolved.version,
-                reason: withheld,
-            };
-        }
-        const code = await stageAndAdd(resolved, options);
-        if (code !== 0) {
-            return { name, outcome: "failed", from: source.version, reason: `the engine exited ${code}` };
-        }
-        return { name, outcome: "updated", from: source.version, to: resolved.version };
-    }
-    catch (error) {
-        return {
-            name,
-            outcome: "failed",
-            from: source.version,
-            reason: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-export function formatUpdates(updates) {
-    if (updates.length === 0)
-        return "no plugins to update — the bundled ones move with the engine";
-    return updates.map(updateLine).join("\n");
-}
-function updateLine(update) {
-    switch (update.outcome) {
-        case "updated":
-            return `${update.name}: ${update.from} -> ${update.to}`;
-        case "current":
-            return `${update.name}: ${update.from}, which is what its tag resolves to`;
-        case "pinned":
-            return `${update.name}: pinned to ${update.from}; add it again to move it`;
-        case "local":
-            return `${update.name}: added from ${update.reason}; run rigline add again to refresh it`;
-        case "unmanaged":
-            return `${update.name}: placed by hand, so there is nowhere to fetch a newer one from`;
-        case "withheld":
-            return `${update.name}: staying on ${update.from} — ${update.reason}`;
-        default:
-            return `${update.name}: FAILED — ${update.reason}`;
-    }
-}
-//# sourceMappingURL=remote.js.map

package/dist/tarball.js

@@ -1,125 +0,0 @@
-import { gunzipSync } from "node:zlib";
-import { UserError } from "./errors.js";
-const BLOCK = 512;
-const TYPE_FILE = 0x30;
-const TYPE_FILE_LEGACY = 0x00;
-const TYPE_DIRECTORY = 0x35;
-const TYPE_PAX_ENTRY = 0x78;
-const TYPE_PAX_GLOBAL = 0x67;
-const MAX_ENTRIES = 2000;
-const MAX_FILE_BYTES = 16 * 1024 * 1024;
-const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
-export function readPackageTarball(gzipped, label) {
-    let tar;
-    try {
-        tar = gunzipSync(gzipped);
-    }
-    catch (error) {
-        throw new UserError(`${label} is not a gzipped tarball: ${error.message}`);
-    }
-    const members = [];
-    let total = 0;
-    let offset = 0;
-    while (offset + BLOCK <= tar.length) {
-        const header = tar.subarray(offset, offset + BLOCK);
-        if (isEndOfArchive(header))
-            break;
-        offset += BLOCK;
-        const name = readHeaderName(header, label);
-        const size = readOctal(header, 124, 12, `${label}: entry "${name}" has an unreadable size`);
-        const type = header[156] ?? 0;
-        const body = tar.subarray(offset, offset + size);
-        offset += Math.ceil(size / BLOCK) * BLOCK;
-        if (type === TYPE_PAX_ENTRY || type === TYPE_PAX_GLOBAL)
-            continue;
-        if (type === TYPE_DIRECTORY)
-            continue;
-        if (type !== TYPE_FILE && type !== TYPE_FILE_LEGACY) {
-            throw new UserError(`${label} carries "${name}", which is not a regular file (tar type ` +
-                `"${String.fromCharCode(type)}"). A plugin is files; nothing here unpacks a link, a ` +
-                "device or an archive member of any other kind.");
-        }
-        if (size > MAX_FILE_BYTES) {
-            throw new UserError(`${label}: "${name}" is ${size} bytes, over the ${MAX_FILE_BYTES} cap`);
-        }
-        total += size;
-        if (total > MAX_TOTAL_BYTES || members.length >= MAX_ENTRIES) {
-            throw new UserError(`${label} unpacks to more than ${MAX_ENTRIES} files or ${MAX_TOTAL_BYTES} bytes`);
-        }
-        if (body.length < size) {
-            throw new UserError(`${label} ends inside "${name}", so it is truncated`);
-        }
-        const path = safePath(name, label);
-        if (path === null)
-            continue;
-        members.push({ path, bytes: Buffer.from(body) });
-    }
-    return strip(members, label);
-}
-function strip(members, label) {
-    const first = members[0];
-    if (first === undefined) {
-        throw new UserError(`${label} has no files in it`);
-    }
-    const root = first.path.split("/")[0];
-    const files = [];
-    const seen = new Set();
-    for (const member of members) {
-        const segments = member.path.split("/");
-        if (segments[0] !== root) {
-            throw new UserError(`${label} carries "${member.path}", which is outside "${root}/"; every member of a ` +
-                "published tarball sits under one directory, and this one has two");
-        }
-        const path = segments.slice(1).join("/");
-        if (path.length === 0)
-            continue;
-        if (seen.has(path)) {
-            throw new UserError(`${label} carries "${path}" twice`);
-        }
-        seen.add(path);
-        files.push({ path, bytes: member.bytes });
-    }
-    if (files.length === 0) {
-        throw new UserError(`${label} has nothing under "${root}/"`);
-    }
-    return files;
-}
-function isEndOfArchive(header) {
-    for (const byte of header) {
-        if (byte !== 0)
-            return false;
-    }
-    return true;
-}
-function readHeaderName(header, label) {
-    const name = readString(header, 0, 100);
-    const prefix = readString(header, 345, 155);
-    if (name.length === 0) {
-        throw new UserError(`${label} carries an entry with no name`);
-    }
-    return prefix.length > 0 ? `${prefix}/${name}` : name;
-}
-function readString(header, at, length) {
-    const field = header.subarray(at, at + length);
-    const end = field.indexOf(0);
-    return field.subarray(0, end === -1 ? field.length : end).toString("utf8");
-}
-function readOctal(header, at, length, problem) {
-    const text = readString(header, at, length).trim();
-    const value = text.length === 0 ? 0 : Number.parseInt(text, 8);
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new UserError(problem);
-    return value;
-}
-function safePath(name, label) {
-    const path = name.replace(/\\/g, "/").replace(/\/+$/, "");
-    if (path.length === 0)
-        return null;
-    const segments = path.split("/");
-    if (name.startsWith("/") ||
-        segments.some((segment) => segment === "" || segment === "." || segment === ".." || /^[a-zA-Z]:/.test(segment))) {
-        throw new UserError(`${label} carries "${name}", which does not stay inside the directory it unpacks into`);
-    }
-    return path;
-}
-//# sourceMappingURL=tarball.js.map