codiedev 0.9.71 → 0.9.72

package/dist/managedPi.d.ts

@@ -43,5 +43,6 @@ export declare function runManagedPi(opts: {
     skillPaths?: string[];
     agentSecurityEnabled: boolean;
     env?: NodeJS.ProcessEnv;
-    bin?: string;
+    /** Test seam: resolve the pi CLI entry without installing. */
+    resolvePi?: () => string;
 }): number;

package/dist/managedPi.js

@@ -66,6 +66,7 @@ const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const codieLauncher_1 = require("./codieLauncher");
+const piRuntime_1 = require("./piRuntime");
 const utils_1 = require("./utils");
 exports.PI_PROVIDER_ID = "codiedev";
 /** Env vars pi reads provider credentials from (`pi --help`, pi 0.73). */
@@ -268,16 +269,19 @@ function runManagedPi(opts) {
         skillPaths: opts.skillPaths, agentSecurityEnabled: opts.agentSecurityEnabled,
     });
     const args = managedPiArgs(opts.args, extensions);
-    const bin = opts.bin ?? env.CODIEDEV_PI_BIN ?? "pi";
-    const result = (0, child_process_1.spawnSync)(bin, args, {
+    // CODIEDEV_PI_BIN runs a specific pi binary (tests, canaries pinned to a
+    // version). Otherwise pi is Codiedev's own pinned install, fetched on first
+    // use like the Codie engine and run on this Node.
+    const bin = env.CODIEDEV_PI_BIN?.trim();
+    const [command, commandArgs] = bin
+        ? [bin, args]
+        : [process.execPath, [(opts.resolvePi ?? (() => (0, piRuntime_1.ensurePiRuntime)({ stateDir: opts.stateDir })))(), ...args]];
+    const result = (0, child_process_1.spawnSync)(command, commandArgs, {
         stdio: "inherit",
         env: managedPiEnv(env, agentDir, opts.key),
-        // pi's npm launcher is a .cmd shim on Windows.
-        shell: process.platform === "win32",
+        // A pi binary given as an npm launcher is a .cmd shim on Windows.
+        shell: Boolean(bin) && process.platform === "win32",
     });
-    if (result.error && result.error.code === "ENOENT") {
-        throw new Error("pi isn't installed. Install it with `npm install -g @mariozechner/pi-coding-agent`, then run `codie --pi` again.");
-    }
     if (result.error)
         throw result.error;
     return result.status === null ? 1 : result.status;

package/dist/piRuntime.d.ts

@@ -0,0 +1,25 @@
+export declare const PI_PACKAGE = "@mariozechner/pi-coding-agent";
+export declare const PI_VERSION = "0.73.1";
+export declare const PI_RUNTIME_SPEC = "@mariozechner/pi-coding-agent@0.73.1";
+export declare function piRuntimeDir(stateDir: string): string;
+/** The installed pi's CLI entry, when it is the pinned version. */
+export declare function installedPiEntry(installDir: string, readFile?: (file: string) => string): string | null;
+export interface PiRuntimeDeps {
+    stateDir: string;
+    exists?: (file: string) => boolean;
+    readFile?: (file: string) => string;
+    makeStagingDir?: () => string;
+    run?: (args: string[]) => {
+        status: number | null;
+        stderr: string;
+    };
+    rename?: (from: string, to: string) => void;
+    remove?: (target: string) => void;
+    log?: (message: string) => void;
+}
+/**
+ * The pi CLI entry to run, installing the pinned version first if it is
+ * missing or a different version. Staged then renamed, so an interrupted
+ * download never leaves a half-installed pi that looks ready.
+ */
+export declare function ensurePiRuntime(deps: PiRuntimeDeps): string;

package/dist/piRuntime.js

@@ -0,0 +1,125 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PI_RUNTIME_SPEC = exports.PI_VERSION = exports.PI_PACKAGE = void 0;
+exports.piRuntimeDir = piRuntimeDir;
+exports.installedPiEntry = installedPiEntry;
+exports.ensurePiRuntime = ensurePiRuntime;
+// pi for `codie --pi`, installed on first use like the Codie engine
+// (codieRuntimeInstall.ts): developers never run a second npm install, and
+// every machine runs the version Codiedev tested its capture against.
+//
+// pi is plain JavaScript, so it runs on the same Node as `codie` from its
+// package entry: no PATH lookup, no Windows .cmd shim, and no dependency on
+// whatever `pi` (if any) the developer installed globally.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
+exports.PI_PACKAGE = "@mariozechner/pi-coding-agent";
+exports.PI_VERSION = "0.73.1";
+exports.PI_RUNTIME_SPEC = `${exports.PI_PACKAGE}@${exports.PI_VERSION}`;
+function piRuntimeDir(stateDir) {
+    return path.join(stateDir, "runtime-pi");
+}
+function packageDir(installDir) {
+    return path.join(installDir, "node_modules", ...exports.PI_PACKAGE.split("/"));
+}
+/** The installed pi's CLI entry, when it is the pinned version. */
+function installedPiEntry(installDir, readFile = (f) => fs.readFileSync(f, "utf8")) {
+    try {
+        const pkg = JSON.parse(readFile(path.join(packageDir(installDir), "package.json")));
+        if (pkg.version !== exports.PI_VERSION)
+            return null;
+        const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.pi;
+        return typeof bin === "string" ? path.join(packageDir(installDir), bin) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The pi CLI entry to run, installing the pinned version first if it is
+ * missing or a different version. Staged then renamed, so an interrupted
+ * download never leaves a half-installed pi that looks ready.
+ */
+function ensurePiRuntime(deps) {
+    const installDir = piRuntimeDir(deps.stateDir);
+    const exists = deps.exists ?? fs.existsSync;
+    const readFile = deps.readFile ?? ((f) => fs.readFileSync(f, "utf8"));
+    const ready = installedPiEntry(installDir, readFile);
+    if (ready && exists(ready))
+        return ready;
+    const remove = deps.remove ?? ((target) => fs.rmSync(target, { recursive: true, force: true }));
+    const rename = deps.rename ?? fs.renameSync;
+    const log = deps.log ?? ((message) => console.error(message));
+    const staging = (deps.makeStagingDir ?? (() => {
+        fs.mkdirSync(deps.stateDir, { recursive: true });
+        return fs.mkdtempSync(path.join(deps.stateDir, ".runtime-pi-"));
+    }))();
+    const run = deps.run ?? ((args) => {
+        const result = (0, child_process_1.spawnSync)(process.platform === "win32" ? "npm.cmd" : "npm", args, {
+            encoding: "utf8", stdio: ["ignore", "ignore", "pipe"], shell: process.platform === "win32",
+        });
+        if (result.error)
+            throw result.error;
+        return { status: result.status, stderr: result.stderr ?? "" };
+    });
+    log(`Installing pi (${exports.PI_RUNTIME_SPEC}). This runs once, and only for \`codie --pi\`.`);
+    try {
+        const result = run((0, codieRuntimeInstall_1.buildRuntimeInstallArgs)(staging, exports.PI_RUNTIME_SPEC));
+        if (result.status !== 0)
+            throw new Error(result.stderr?.trim() || `npm exited with ${result.status}`);
+        // Trust the artifact, not the exit code.
+        const staged = installedPiEntry(staging, readFile);
+        if (!staged || !exists(staged)) {
+            throw new Error(`the install did not produce pi. Check that ${exports.PI_RUNTIME_SPEC} is available from your npm registry.`);
+        }
+        remove(installDir);
+        rename(staging, installDir);
+    }
+    catch (error) {
+        throw new Error(`Couldn't install pi: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        // No-op after a successful promote; otherwise it keeps a ~200MB staging
+        // dir from being orphaned.
+        remove(staging);
+    }
+    const entry = installedPiEntry(installDir, readFile);
+    if (!entry)
+        throw new Error("Couldn't install pi: the installed package has no CLI entry.");
+    return entry;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.71",
+  "version": "0.9.72",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",