rigline 1.0.0-alpha.10 → 1.0.0-alpha.12

package/README.md

@@ -44,7 +44,10 @@ from a VSIX that ships inside the engine. Nothing is downloaded, and the compani
 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.
+remember after one. It goes into every VS Code profile that has Claude Code, and into any profile
+that gets Claude Code later; the `companion` settings in
+[`~/.rigline/config.yaml`](https://github.com/Rigline/Rigline/blob/main/docs/config.md) keep it out
+of the profiles you name.
 
 **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
@@ -64,6 +67,7 @@ your injection alone, and `rigline restore` is what undoes the injection itself.
     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
     rigline list       every plugin, in load order: version, origin, source, switch, what it can do
+    rigline layout     where each plugin's elements are; place, order or reset them, and re-inject
 
     rigline build      build a plugin to one browser ES module
     rigline dev        rebuild and re-inject as you edit

package/dist/engine.js

@@ -88,7 +88,10 @@ export function engineInstallArgv(options) {
         ...options.specs,
     ];
 }
-const nodeSpawn = (command, args, options) => spawn(command, [...args], { stdio: [...options.stdio] });
+const nodeSpawn = (command, args, options) => spawn(command, [...args], {
+    stdio: [...options.stdio],
+    ...(options.env === undefined ? {} : { env: options.env }),
+});
 export async function ensureEngine(options = {}) {
     const prefix = engineDir(options.home ?? riglineHome());
     const version = options.version ?? wrapperVersion();
@@ -138,15 +141,17 @@ function engineAt(state, options) {
     return {
         version: state.version,
         entry: state.entry,
-        run: (argv) => new Promise((done, fail) => {
+        run: (argv, env) => 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) => {
-            const run = await capture(node, [state.entry, ...argv], spawnImpl, "inherit");
+        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(" ")}\``);
             }
@@ -198,6 +203,7 @@ export async function updateEngine(options = {}) {
         return {
             outcome: "failed",
             ...(installed === null ? {} : { from: installed }),
+            to: resolved.version,
             reason: problem,
         };
     }

package/dist/index.js

@@ -33,6 +33,7 @@ async function listed(engine) {
         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,
@@ -45,18 +46,31 @@ async function updateCommand(args) {
     const engine = await ensureEngine({ registry });
     const updates = await updatePlugins({
         listed: await listed(engine),
-        engine: engine.run,
+        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 (engineUpdate.outcome === "moved" || engineUpdate.outcome === "installed") {
+    if (moved) {
+        console.log("");
         injected = await engine.run(["install"]);
     }
-    console.log(formatUpdates(updates));
     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);

package/dist/lock.js

@@ -1,4 +1,4 @@
-import { closeSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { UserError } from "./errors.js";
 const STALE_MS = 60_000;
@@ -31,12 +31,18 @@ function readHolder(path) {
         return null;
     }
 }
-export function isStale(holder, now, staleMs, isAlive) {
-    if (holder === null)
-        return true;
-    const since = Date.parse(holder.since);
+function writtenAt(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return Number.NaN;
+    }
+}
+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 && !isAlive(holder.pid);
+    return old && (holder === null || !isAlive(holder.pid));
 }
 export class HomeLockedError extends UserError {
     holder;
@@ -69,7 +75,7 @@ export async function withHomeLock(options, work) {
             if (error.code !== "EEXIST")
                 throw error;
             const held = readHolder(path);
-            if (isStale(held, now(), staleMs, isAlive)) {
+            if (isStale(held, writtenAt(path), now(), staleMs, isAlive)) {
                 rmSync(path, { force: true });
                 continue;
             }

package/package.json

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