rigline 1.0.0-alpha.6 → 1.0.0-alpha.9

package/README.md

@@ -8,6 +8,12 @@ capability-scoped context to write against, and harvests the identifiers those p
 from whichever extension version you have installed — so an extension update is a diff to read
 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`
+puts every install back to Anthropic's own bytes and needs nothing but Node.
+
 ## Install
 
     npm install -g rigline
@@ -26,6 +32,25 @@ The extension updates about weekly and an update installs a fresh directory, whi
 the injection. Run `install` again afterwards; a window that is already open keeps running the old
 directory until *Developer: Reload Window*.
 
+**That is the whole of Rigline, and it needs nothing else.** Everything below is optional.
+
+## 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.
+
+From then on it watches for the extension update and re-injects behind it, so there is nothing to
+remember after one.
+
+**Decline it and lose nothing.** `install` remains complete on its own, and is the right answer if
+you would rather not add an extension, cannot install one, or simply prefer running the thing
+yourself. `rigline vscode-setup --remove` goes back to that — it takes the companion out and leaves
+your injection alone, and `rigline restore` is what undoes the injection itself.
+
 ## Commands
 
     rigline install    inject every version, bake plugins, report drift, record the baseline

package/dist/engine.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { UserError } from "./errors.js";
+import { withHomeLock } from "./lock.js";
 import { releaseAgeProblem, resolveVersion } from "./registry.js";
 export const ENGINE_PACKAGE = "@rigline/core";
 export const ENGINE_BIN = "rigline-engine";
@@ -120,27 +121,32 @@ async function resolveEngine(options) {
     return await resolveVersion({ name: ENGINE_PACKAGE, version: null, tag: options.tag ?? "latest" }, options.registry);
 }
 async function installEngine(prefix, spec, options) {
-    mkdirSync(prefix, { recursive: true });
-    const argv = engineInstallArgv({ npmCli: findNpmCli(), prefix, specs: [spec] });
-    const run = await capture(process.execPath, argv, options.spawnImpl);
-    if (run.code !== 0) {
-        throw new UserError(`installing ${spec} into ${prefix} failed (npm exited ${run.code}).\n${run.output.trim()}`);
-    }
+    const home = options.home ?? riglineHome();
+    await withHomeLock({ home, what: options.label ?? "rigline", ...options.lock }, async () => {
+        mkdirSync(prefix, { recursive: true });
+        const node = options.nodePath ?? process.execPath;
+        const argv = engineInstallArgv({ npmCli: findNpmCli(node), prefix, specs: [spec] });
+        const run = await capture(node, argv, options.spawnImpl);
+        if (run.code !== 0) {
+            throw new UserError(`installing ${spec} into ${prefix} failed (npm exited ${run.code}).\n${run.output.trim()}`);
+        }
+    });
 }
 function engineAt(state, options) {
     const spawnImpl = options.spawnImpl ?? nodeSpawn;
+    const node = options.nodePath ?? process.execPath;
     return {
         version: state.version,
         entry: state.entry,
         run: (argv) => new Promise((done, fail) => {
-            const child = spawnImpl(process.execPath, [state.entry, ...argv], {
+            const child = spawnImpl(node, [state.entry, ...argv], {
                 stdio: ["inherit", "inherit", "inherit"],
             });
             child.on("error", fail);
             child.on("close", (code) => done(code ?? 1));
         }),
         json: async (argv) => {
-            const run = await capture(process.execPath, [state.entry, ...argv], spawnImpl, "inherit");
+            const run = await capture(node, [state.entry, ...argv], spawnImpl, "inherit");
             if (run.code !== 0) {
                 throw new UserError(`the engine exited ${run.code} for \`${argv.join(" ")}\``);
             }
@@ -195,14 +201,11 @@ export async function updateEngine(options = {}) {
             reason: problem,
         };
     }
-    const withheld = releaseAgeProblem(resolved, options.registry);
-    if (withheld !== null) {
-        return {
-            outcome: "withheld",
-            ...(installed === null ? {} : { from: installed }),
-            to: resolved.version,
-            reason: withheld,
-        };
+    if (installed !== null) {
+        const withheld = releaseAgeProblem(resolved, options.registry);
+        if (withheld !== null) {
+            return { outcome: "withheld", from: installed, to: resolved.version, reason: withheld };
+        }
     }
     try {
         await installEngine(prefix, `${ENGINE_PACKAGE}@${resolved.version}`, options);

package/dist/lock.js

@@ -0,0 +1,88 @@
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { UserError } from "./errors.js";
+const STALE_MS = 60_000;
+const WAIT_MS = 30_000;
+const POLL_MS = 250;
+export function lockPath(home) {
+    return join(home, ".lock");
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function readHolder(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const { pid, since, what } = parsed;
+        if (typeof pid !== "number" || typeof since !== "string" || typeof what !== "string") {
+            return null;
+        }
+        return { pid, since, what };
+    }
+    catch {
+        return null;
+    }
+}
+export function isStale(holder, now, staleMs, isAlive) {
+    if (holder === null)
+        return true;
+    const since = Date.parse(holder.since);
+    const old = Number.isNaN(since) || now - since >= staleMs;
+    return old && !isAlive(holder.pid);
+}
+export class HomeLockedError extends UserError {
+    holder;
+    constructor(path, holder) {
+        super(holder === null
+            ? `another Rigline process is using ${path}. Try again, or delete that file if nothing is.`
+            : `${holder.what} (pid ${holder.pid}) has been working under Rigline's home since ` +
+                `${holder.since}. Try again when it has finished, or delete ${path} if it has not.`);
+        this.holder = holder;
+    }
+}
+export async function withHomeLock(options, work) {
+    const { home, what, waitMs = WAIT_MS, staleMs = STALE_MS, pollMs = POLL_MS, now = Date.now, isAlive = alive, sleep = (ms) => new Promise((done) => setTimeout(done, ms)), } = options;
+    const path = lockPath(home);
+    mkdirSync(home, { recursive: true });
+    const deadline = now() + waitMs;
+    for (;;) {
+        const holder = { pid: process.pid, since: new Date(now()).toISOString(), what };
+        try {
+            const fd = openSync(path, "wx");
+            try {
+                writeFileSync(fd, JSON.stringify(holder, null, 2));
+            }
+            finally {
+                closeSync(fd);
+            }
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const held = readHolder(path);
+            if (isStale(held, now(), staleMs, isAlive)) {
+                rmSync(path, { force: true });
+                continue;
+            }
+            if (now() >= deadline)
+                throw new HomeLockedError(path, held);
+            await sleep(pollMs);
+        }
+    }
+    try {
+        return await work();
+    }
+    finally {
+        rmSync(path, { force: true });
+    }
+}
+//# sourceMappingURL=lock.js.map

package/dist/remote.js

@@ -108,7 +108,7 @@ async function updateOne(name, source, options) {
 }
 export function formatUpdates(updates) {
     if (updates.length === 0)
-        return "no plugins are installed";
+        return "no plugins to update — the bundled ones move with the engine";
     return updates.map(updateLine).join("\n");
 }
 function updateLine(update) {

package/package.json

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