@sentropic/h2a-runtime 0.81.0

package/dist/plugin-manifest.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Plugin/MCP DESIRED-STATE manifest + drift diff (remote supervise slice 3) —
+ * ADDITIVE, PURE. No IO, no clock. The watch loop / `plugin sync --check` call
+ * these to RENDER the desired set, HASH it (to gate a sidecar push exactly like
+ * CREDS_HASH_FILE), and DIFF it against what a Pod actually has installed.
+ *
+ * Why a manifest at all: MCP servers + plugin CLIs (track, h2a, harness,
+ * graphify, skills) baked/installed into Pods drift away from the LOCAL
+ * source-of-truth — a Pod restart loses globally-installed plugins, a re-pin
+ * bumps the local version, and nothing today DETECTS the gap (`plugin ls`
+ * prints `REMOTE ?`). The manifest is the canonical "what every Pod SHOULD have"
+ * record; its sha256 is the cheap drift signal (one `kubectl exec cat`), and the
+ * diff is the per-item report.
+ *
+ * BIGGEST REMAINING DRIFT SOURCE (DEFERRED — converge-on-session-start): a
+ * freshly (re)created Pod boots with NO plugins until the next `plugin sync` /
+ * watch pass reconciles it, so its CLI starts WITHOUT track/h2a/etc. Closing
+ * that needs the session-agent / orchestrator to run the sync BEFORE the CLI
+ * launches — a session-agent change that is OUT OF SCOPE this slice. It hooks in
+ * at the session-agent startup path (packages/session-agent, the pane that
+ * launches `<cli>`): before exec'ing the CLI, run the equivalent of
+ * `buildPodSyncScript` for each desired plugin + write this manifest sidecar.
+ * TODO(slice 4): wire converge-on-session-start there; until then the watch-pass
+ * reconcile (compareManifestHash → re-run buildPodSyncScript) is the safety net.
+ *
+ * NOTHING here is a NEW push path: `plugin sync` (no --check) still converges via
+ * the EXISTING buildPodSyncScript, untouched. This module only adds a manifest
+ * artifact + a read-only drift report.
+ */
+import type { PluginEntry } from "./config.js";
+/** One plugin package the Pods should carry (pkg + pinned version). */
+export type ManifestPlugin = {
+    readonly pkg: string;
+    readonly version: string;
+};
+/** One MCP server the Pods should have registered (name + bin/script ref). */
+export type ManifestMcp = {
+    readonly name: string;
+    readonly bin: string;
+};
+/**
+ * The desired-state manifest: the canonical set of plugins + MCP servers (+
+ * optional tracked skills) every live Pod should converge to. Field order /
+ * array order are NORMALIZED by `renderManifest` so the JSON — and therefore the
+ * hash — is independent of config key order.
+ */
+export type PluginManifest = {
+    readonly plugins: ReadonlyArray<ManifestPlugin>;
+    readonly mcp: ReadonlyArray<ManifestMcp>;
+    /** Tracked skills, if any are recorded as desired state (none today; reserved). */
+    readonly skills?: ReadonlyArray<string>;
+};
+/**
+ * Render the CANONICAL desired-state manifest from the configured plugins.
+ * Deterministic: plugins sorted by pkg, MCP servers sorted by name, skills
+ * sorted — so two configs that differ only in array/key ORDER render the SAME
+ * manifest (and hash). PURE. `skills` is emitted only when a non-empty tracked
+ * list is passed (none is tracked in config today — reserved for slice 4).
+ */
+export declare function renderManifest(plugins: ReadonlyArray<PluginEntry>, skills?: ReadonlyArray<string>): PluginManifest;
+/**
+ * The CANONICAL JSON string of a manifest: keys in a FIXED order (plugins, mcp,
+ * skills) and every object's keys emitted in a fixed order, so the serialization
+ * is byte-stable regardless of how the manifest object was built. This is what
+ * gets written to `~/.remote-manifest.json` in the Pod AND what is hashed.
+ */
+export declare function canonicalManifestJson(manifest: PluginManifest): string;
+/**
+ * sha256 (hex) of the canonical manifest JSON — the cheap drift signal. Same
+ * input → same hash; key-order / array-order independent (renderManifest
+ * normalizes order, canonicalManifestJson fixes serialization). Mirrors
+ * `hashAuthBundle` in soft-refresh.ts: the Pod records this hex in
+ * `~/.remote-manifest.sha256`, and a pass compares local vs Pod to gate the
+ * sidecar push + trigger a reconcile.
+ */
+export declare function manifestHash(manifest: PluginManifest): string;
+/**
+ * What a Pod actually has installed, as probed by the thin pod-state reader:
+ *  - `pluginVersions`: pkg -> installed version (from `npm ls -g --json`); a pkg
+ *    absent from the map means it is NOT installed globally in the Pod.
+ *  - `mcpRegistered`: the set of MCP server NAMES the Pod has registered (read
+ *    from the claude/codex/agy config files the existing sync writes).
+ */
+export type PodPluginState = {
+    readonly pluginVersions: Readonly<Record<string, string>>;
+    readonly mcpRegistered: ReadonlyArray<string>;
+};
+/** Drift status for one desired item in one Pod. */
+export type DriftStatus = "ok" | "version-drift" | "missing" | "mcp-unregistered";
+/** One row of the drift report: a desired item's status in a Pod. */
+export type DriftRow = {
+    readonly pod: string;
+    /** "plugin:<pkg>" or "mcp:<name>". */
+    readonly item: string;
+    readonly status: DriftStatus;
+    /** Human detail (e.g. "local@1.2.0 vs pod@1.1.0"); empty for ok. */
+    readonly detail: string;
+};
+/**
+ * DIFF the desired manifest against one Pod's actual state. PURE. One row per
+ * desired plugin + one per desired MCP server:
+ *  - plugin MISSING       → pkg not installed globally in the Pod.
+ *  - plugin VERSION-DRIFT  → installed but at a different version than desired.
+ *  - plugin OK             → installed at the desired version.
+ *  - mcp MCP-UNREGISTERED  → desired MCP name not in the Pod's registered set.
+ *  - mcp OK                → registered.
+ * Rows preserve the manifest's (already-canonical) order, plugins before mcp.
+ */
+export declare function diffManifest(manifest: PluginManifest, pod: string, state: PodPluginState): DriftRow[];
+/** A row is drift when its status is anything other than `ok`. */
+export declare function isDrift(row: DriftRow): boolean;
+/**
+ * The process exit code for a `--check` run: 1 when ANY row across all Pods is
+ * drift, else 0. PURE — the command stays a thin printer around this. An empty
+ * report (no Pods / no desired items) is NOT drift → exit 0.
+ */
+export declare function checkExitCode(rows: ReadonlyArray<DriftRow>): number;
+/**
+ * Parse `npm ls -g --json` output into pkg -> installed version, keeping ONLY
+ * the packages we care about (`wanted`). npm's JSON is
+ * `{ dependencies: { "<pkg>": { version, ... }, ... } }`; a missing/!
+ * unparseable blob yields an empty map (treated downstream as "nothing
+ * installed" → all desired plugins report missing, which is the safe drift
+ * signal). PURE, exported for tests. A pkg present but without a string version
+ * is skipped (can't assert a version → reported missing, never a false "ok").
+ */
+export declare function parseNpmLsVersions(json: string, wanted: ReadonlyArray<string>): Record<string, string>;
+/**
+ * Parse the set of registered MCP server NAMES from the Pod's MCP config blobs.
+ * The existing sync writes either a Claude-style JSON (`{"mcpServers": {...}}` —
+ * ~/.claude.json and agy's mcp_config.json) or codex TOML
+ * (`[mcp_servers.<name>]` sections). We read whatever blobs are present and
+ * union their server names. PURE, exported for tests. A blob that is empty /
+ * unparseable contributes nothing (never throws — an unreadable config is just
+ * "no servers from there", surfacing as mcp-unregistered, the safe drift call).
+ */
+export declare function parseRegisteredMcpServers(blobs: {
+    /** ~/.claude.json and/or agy mcp_config.json bodies (Claude-style JSON). */
+    readonly json?: ReadonlyArray<string>;
+    /** ~/.codex/config.toml body. */
+    readonly toml?: string;
+}): string[];
+//# sourceMappingURL=plugin-manifest.d.ts.map

package/dist/plugin-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-manifest.d.ts","sourceRoot":"","sources":["../src/plugin-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C,uEAAuE;AACvE,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhF,8EAA8E;AAC9E,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAChD,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IACzC,mFAAmF;IACnF,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACzC,CAAC;AAaF;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,EACnC,MAAM,GAAE,aAAa,CAAC,MAAM,CAAM,GACjC,cAAc,CAmBhB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAStE;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAE7D;AAMD;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC/C,CAAC;AAEF,oDAAoD;AACpD,MAAM,MAAM,WAAW,GACnB,IAAI,GACJ,eAAe,GACf,SAAS,GACT,kBAAkB,CAAC;AAEvB,qEAAqE;AACrE,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,cAAc,EACxB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,cAAc,GACpB,QAAQ,EAAE,CAoCZ;AAED,kEAAkE;AAClE,wBAAgB,OAAO,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,MAAM,CAEnE;AAMD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoBxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,iCAAiC;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,MAAM,EAAE,CA2BX"}

package/dist/plugin-manifest.js

@@ -0,0 +1,233 @@
+/**
+ * Plugin/MCP DESIRED-STATE manifest + drift diff (remote supervise slice 3) —
+ * ADDITIVE, PURE. No IO, no clock. The watch loop / `plugin sync --check` call
+ * these to RENDER the desired set, HASH it (to gate a sidecar push exactly like
+ * CREDS_HASH_FILE), and DIFF it against what a Pod actually has installed.
+ *
+ * Why a manifest at all: MCP servers + plugin CLIs (track, h2a, harness,
+ * graphify, skills) baked/installed into Pods drift away from the LOCAL
+ * source-of-truth — a Pod restart loses globally-installed plugins, a re-pin
+ * bumps the local version, and nothing today DETECTS the gap (`plugin ls`
+ * prints `REMOTE ?`). The manifest is the canonical "what every Pod SHOULD have"
+ * record; its sha256 is the cheap drift signal (one `kubectl exec cat`), and the
+ * diff is the per-item report.
+ *
+ * BIGGEST REMAINING DRIFT SOURCE (DEFERRED — converge-on-session-start): a
+ * freshly (re)created Pod boots with NO plugins until the next `plugin sync` /
+ * watch pass reconciles it, so its CLI starts WITHOUT track/h2a/etc. Closing
+ * that needs the session-agent / orchestrator to run the sync BEFORE the CLI
+ * launches — a session-agent change that is OUT OF SCOPE this slice. It hooks in
+ * at the session-agent startup path (packages/session-agent, the pane that
+ * launches `<cli>`): before exec'ing the CLI, run the equivalent of
+ * `buildPodSyncScript` for each desired plugin + write this manifest sidecar.
+ * TODO(slice 4): wire converge-on-session-start there; until then the watch-pass
+ * reconcile (compareManifestHash → re-run buildPodSyncScript) is the safety net.
+ *
+ * NOTHING here is a NEW push path: `plugin sync` (no --check) still converges via
+ * the EXISTING buildPodSyncScript, untouched. This module only adds a manifest
+ * artifact + a read-only drift report.
+ */
+import { createHash } from "node:crypto";
+/**
+ * The MCP "bin" reference recorded in the manifest. We use the package-relative
+ * script path (`scriptRel`, e.g. "dist/mcp.js") when known — it is the stable,
+ * Pod-portable identity (the realpath differs per npm-global root). When a
+ * plugin entry has no scriptRel recorded we fall back to the server name so the
+ * manifest still names the server (a plain presence check downstream).
+ */
+function manifestMcpBin(mcp) {
+    return mcp.scriptRel ?? mcp.name;
+}
+/**
+ * Render the CANONICAL desired-state manifest from the configured plugins.
+ * Deterministic: plugins sorted by pkg, MCP servers sorted by name, skills
+ * sorted — so two configs that differ only in array/key ORDER render the SAME
+ * manifest (and hash). PURE. `skills` is emitted only when a non-empty tracked
+ * list is passed (none is tracked in config today — reserved for slice 4).
+ */
+export function renderManifest(plugins, skills = []) {
+    const manifestPlugins = [...plugins]
+        .map((p) => ({ pkg: p.pkg, version: p.version }))
+        .sort((a, b) => (a.pkg < b.pkg ? -1 : a.pkg > b.pkg ? 1 : 0));
+    const mcp = [];
+    for (const p of plugins) {
+        for (const m of p.mcp) {
+            mcp.push({ name: m.name, bin: manifestMcpBin(m) });
+        }
+    }
+    mcp.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const manifest = { plugins: manifestPlugins, mcp };
+    const uniqueSkills = [...new Set(skills)].sort();
+    if (uniqueSkills.length > 0) {
+        return { ...manifest, skills: uniqueSkills };
+    }
+    return manifest;
+}
+/**
+ * The CANONICAL JSON string of a manifest: keys in a FIXED order (plugins, mcp,
+ * skills) and every object's keys emitted in a fixed order, so the serialization
+ * is byte-stable regardless of how the manifest object was built. This is what
+ * gets written to `~/.remote-manifest.json` in the Pod AND what is hashed.
+ */
+export function canonicalManifestJson(manifest) {
+    const canonical = {
+        plugins: manifest.plugins.map((p) => ({ pkg: p.pkg, version: p.version })),
+        mcp: manifest.mcp.map((m) => ({ name: m.name, bin: m.bin })),
+    };
+    if (manifest.skills && manifest.skills.length > 0) {
+        canonical.skills = [...manifest.skills];
+    }
+    return JSON.stringify(canonical);
+}
+/**
+ * sha256 (hex) of the canonical manifest JSON — the cheap drift signal. Same
+ * input → same hash; key-order / array-order independent (renderManifest
+ * normalizes order, canonicalManifestJson fixes serialization). Mirrors
+ * `hashAuthBundle` in soft-refresh.ts: the Pod records this hex in
+ * `~/.remote-manifest.sha256`, and a pass compares local vs Pod to gate the
+ * sidecar push + trigger a reconcile.
+ */
+export function manifestHash(manifest) {
+    return createHash("sha256").update(canonicalManifestJson(manifest)).digest("hex");
+}
+/**
+ * DIFF the desired manifest against one Pod's actual state. PURE. One row per
+ * desired plugin + one per desired MCP server:
+ *  - plugin MISSING       → pkg not installed globally in the Pod.
+ *  - plugin VERSION-DRIFT  → installed but at a different version than desired.
+ *  - plugin OK             → installed at the desired version.
+ *  - mcp MCP-UNREGISTERED  → desired MCP name not in the Pod's registered set.
+ *  - mcp OK                → registered.
+ * Rows preserve the manifest's (already-canonical) order, plugins before mcp.
+ */
+export function diffManifest(manifest, pod, state) {
+    const rows = [];
+    for (const p of manifest.plugins) {
+        const installed = state.pluginVersions[p.pkg];
+        if (installed === undefined) {
+            rows.push({
+                pod,
+                item: `plugin:${p.pkg}`,
+                status: "missing",
+                detail: `not installed (desired ${p.version})`,
+            });
+        }
+        else if (installed !== p.version) {
+            rows.push({
+                pod,
+                item: `plugin:${p.pkg}`,
+                status: "version-drift",
+                detail: `local@${p.version} vs pod@${installed}`,
+            });
+        }
+        else {
+            rows.push({ pod, item: `plugin:${p.pkg}`, status: "ok", detail: "" });
+        }
+    }
+    const registered = new Set(state.mcpRegistered);
+    for (const m of manifest.mcp) {
+        if (registered.has(m.name)) {
+            rows.push({ pod, item: `mcp:${m.name}`, status: "ok", detail: "" });
+        }
+        else {
+            rows.push({
+                pod,
+                item: `mcp:${m.name}`,
+                status: "mcp-unregistered",
+                detail: "not registered in the pod's MCP config",
+            });
+        }
+    }
+    return rows;
+}
+/** A row is drift when its status is anything other than `ok`. */
+export function isDrift(row) {
+    return row.status !== "ok";
+}
+/**
+ * The process exit code for a `--check` run: 1 when ANY row across all Pods is
+ * drift, else 0. PURE — the command stays a thin printer around this. An empty
+ * report (no Pods / no desired items) is NOT drift → exit 0.
+ */
+export function checkExitCode(rows) {
+    return rows.some(isDrift) ? 1 : 0;
+}
+// ---------------------------------------------------------------------------
+// Pod-state probe PARSERS (pure — the executors that shell out stay thin).
+// ---------------------------------------------------------------------------
+/**
+ * Parse `npm ls -g --json` output into pkg -> installed version, keeping ONLY
+ * the packages we care about (`wanted`). npm's JSON is
+ * `{ dependencies: { "<pkg>": { version, ... }, ... } }`; a missing/!
+ * unparseable blob yields an empty map (treated downstream as "nothing
+ * installed" → all desired plugins report missing, which is the safe drift
+ * signal). PURE, exported for tests. A pkg present but without a string version
+ * is skipped (can't assert a version → reported missing, never a false "ok").
+ */
+export function parseNpmLsVersions(json, wanted) {
+    const want = new Set(wanted);
+    const out = {};
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return out;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return out;
+    const deps = parsed.dependencies;
+    if (!deps || typeof deps !== "object")
+        return out;
+    for (const [pkg, info] of Object.entries(deps)) {
+        if (!want.has(pkg))
+            continue;
+        if (info && typeof info === "object") {
+            const v = info.version;
+            if (typeof v === "string")
+                out[pkg] = v;
+        }
+    }
+    return out;
+}
+/**
+ * Parse the set of registered MCP server NAMES from the Pod's MCP config blobs.
+ * The existing sync writes either a Claude-style JSON (`{"mcpServers": {...}}` —
+ * ~/.claude.json and agy's mcp_config.json) or codex TOML
+ * (`[mcp_servers.<name>]` sections). We read whatever blobs are present and
+ * union their server names. PURE, exported for tests. A blob that is empty /
+ * unparseable contributes nothing (never throws — an unreadable config is just
+ * "no servers from there", surfacing as mcp-unregistered, the safe drift call).
+ */
+export function parseRegisteredMcpServers(blobs) {
+    const names = new Set();
+    for (const body of blobs.json ?? []) {
+        if (!body || !body.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object")
+            continue;
+        const servers = parsed.mcpServers;
+        if (servers && typeof servers === "object" && !Array.isArray(servers)) {
+            for (const name of Object.keys(servers)) {
+                names.add(name);
+            }
+        }
+    }
+    if (blobs.toml) {
+        // `[mcp_servers.<name>]` section headers — name is SAFE_NAME ([A-Za-z0-9_-]).
+        const re = /^\s*\[mcp_servers\.([A-Za-z0-9_-]+)\]\s*$/gm;
+        let m;
+        while ((m = re.exec(blobs.toml)) !== null) {
+            names.add(m[1]);
+        }
+    }
+    return [...names].sort();
+}
+//# sourceMappingURL=plugin-manifest.js.map

package/dist/plugin-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-manifest.js","sourceRoot":"","sources":["../src/plugin-manifest.ts"],"names":[],"mappings":"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"}

package/dist/plugin.d.ts

@@ -0,0 +1,274 @@
+/**
+ * `remote plugin` — install npm "plugin" packages (a CLI + an MCP server, e.g.
+ * @sentropic/track shipping bins `track` and `track-mcp`) for every agent CLI
+ * (claude, codex, agy), both LOCALLY (npm i -g + MCP registration) and inside
+ * live REMOTE session Pods (`remote plugin sync`: kubectl exec → npm i -g +
+ * per-profile MCP registration).
+ *
+ * agy (Antigravity CLI) has NO `agy mcp` subcommand: MCP servers are declared
+ * in ~/.gemini/config/mcp_config.json, a Claude-style `{"mcpServers": {…}}`
+ * JSON file (the agy changelog 1.0.3 calls this the "migrated" path; the old
+ * ~/.gemini/antigravity/mcp_config.json is legacy). We merge idempotently and
+ * keep a one-shot `.bak.<epoch>` backup the first time we touch a non-empty
+ * file.
+ *
+ * KNOWN PITFALL — broken entrypoint guard through the npm-global symlink:
+ * some packages (track@0.2.0) guard their entry script with a
+ * "was-I-run-directly?" check that compares argv[1] with the module path;
+ * invoked through the npm-global bin SYMLINK the two differ and the guard
+ * never fires (the CLI/MCP silently does nothing). So MCP servers are ALWAYS
+ * registered as `node <realpathSync(script)>` — never the bare bin name.
+ *
+ * Baking plugins into the session image is a separate TODO that belongs in
+ * packages/session-agent/Dockerfile (left untouched here): until then a Pod
+ * restart loses globally-installed plugins and `remote plugin sync` must be
+ * re-run.
+ *
+ * DRIFT (remote supervise slice 3, ADDITIVE): a desired-state manifest
+ * (plugin-manifest.ts) + a sidecar pushed to each Pod (~/.remote-manifest.json /
+ * ~/.remote-manifest.sha256, gated EXACTLY like CREDS_HASH_FILE), a read-only
+ * `plugin sync --check` drift report, and a watch-pass reconcile that re-runs
+ * the EXISTING buildPodSyncScript on a hash mismatch (an extra TRIGGER, not a
+ * new push path). The plain `plugin add`/`plugin sync` push is UNCHANGED.
+ *
+ * TODO(slice 4 — converge-on-session-start, the BIGGEST remaining drift source):
+ * a freshly (re)created Pod boots with NO plugins until the next sync/watch pass,
+ * so its CLI launches WITHOUT track/h2a/etc. Closing that needs the session-agent
+ * startup path (packages/session-agent, the pane that launches `<cli>`) to run
+ * the sync + write the manifest sidecar BEFORE exec'ing the CLI — OUT OF SCOPE
+ * here (do not touch session-agent this slice). The watch-pass reconcile is the
+ * interim safety net.
+ */
+import { type PluginEntry, type PluginInstall, type TunnelConfig } from "./config.js";
+import { type DriftRow, type PluginManifest, type PodPluginState } from "./plugin-manifest.js";
+/**
+ * The shell install command for a plugin + a one-line label. Pure, exported for
+ * tests. npm (default): `npm install -g <pkg>@<ver>`. curl: pipe an https
+ * installer (`curl -fsSL <url> | bash`) — the url is single-quoted and must be
+ * a clean https URL. script: an arbitrary shell line straight from the user's
+ * own config (no extra guard — it is the user's command). Same command runs
+ * locally (pluginAdd) and in the Pod (buildPodSyncScript).
+ */
+export declare function buildInstallCommand(plugin: PluginEntry): {
+    cmd: string;
+    label: string;
+};
+/** Split `pkg[@version]` (scope-aware: the leading @ is not a version sep). */
+export declare function splitNpmSpec(spec: string): {
+    pkg: string;
+    version?: string;
+};
+export type McpRequest = {
+    name: string;
+    bin: string;
+};
+/** Parse one `--mcp <name>=<bin>` spec. */
+export declare function parseMcpSpec(spec: string): McpRequest;
+export declare function parseMcpSpecs(specs: readonly string[]): McpRequest[];
+/**
+ * Heuristic when no --mcp is given: every bin ending in `-mcp` is an MCP
+ * server named after the bin minus the suffix (track-mcp → track).
+ */
+export declare function detectMcpBins(bins: Readonly<Record<string, string>>): McpRequest[];
+/** Normalize a package.json `bin` field (string or map) to name -> rel path. */
+export declare function normalizeBins(pkgName: string, bin: unknown): Record<string, string>;
+/** The `[mcp_servers.<name>]` TOML section for ~/.codex/config.toml. */
+export declare function codexMcpServerBlock(name: string, command: string, args: readonly string[]): string;
+/**
+ * Idempotently upsert the `[mcp_servers.<name>]` section in a config.toml
+ * body: an existing section (up to the next `[…]` header) is replaced in
+ * place, otherwise the block is appended. Applying twice is a no-op.
+ */
+export declare function upsertCodexMcpServer(toml: string, name: string, command: string, args: readonly string[]): string;
+/** Idempotent `mcpServers.<name>` merge for a ~/.claude.json body. */
+export declare function mergeClaudeMcpServers(json: string, name: string, command: string, args: readonly string[]): string;
+/**
+ * Idempotent `mcpServers.<name>` merge for agy's
+ * ~/.gemini/config/mcp_config.json (same Claude-style shape — the agy binary
+ * schema accepts command/args/env/url per server; we only emit command+args).
+ */
+export declare function mergeAgyMcpServers(json: string, name: string, command: string, args: readonly string[]): string;
+/**
+ * Pure write plan for agy's mcp_config.json: the merged body, whether it
+ * differs from `before`, and whether a `.bak.<epoch>` backup is owed (only on
+ * the FIRST real modification of a non-empty file — an empty/absent file has
+ * nothing worth backing up, and an unchanged file is never rewritten).
+ */
+export declare function planAgyMcpConfigUpdate(before: string, name: string, command: string, args: readonly string[]): {
+    next: string;
+    changed: boolean;
+    needsBackup: boolean;
+};
+/**
+ * In-Pod ~/.claude.json merge, run as `node -e '<this>' <name> <scriptPath>`.
+ * Double quotes only — the snippet is single-quoted inside the bash script.
+ */
+export declare const POD_CLAUDE_MERGE_JS: string;
+/**
+ * In-Pod ~/.gemini/config/mcp_config.json merge, run as
+ * `node -e '<this>' <name> <scriptPath>`. Double quotes only — the snippet is
+ * single-quoted inside the bash script. Same shape as the claude merge; the
+ * config dir may not exist yet in a fresh Pod, hence mkdirSync.
+ */
+export declare const POD_AGY_MERGE_JS: string;
+/** claude / claude-code → claude; codex → codex; agy / antigravity → agy. */
+export declare function mcpTargetForProfile(profile: string): "claude" | "codex" | "agy" | "todo";
+/**
+ * Bash script run inside a session Pod (`kubectl exec … bash -lc`) by
+ * `remote plugin sync`: installs the plugin globally, recomputes each MCP
+ * script's realpath against the POD's npm global root (the local realpath is
+ * meaningless there), then registers the MCP server for the Pod's profile.
+ * Every step echoes one line — the CLI prints them as the per-session recap.
+ */
+export declare function buildPodSyncScript(plugin: PluginEntry, profile: string): string;
+/** HOME-relative manifest sidecar in the Pod (the desired-state JSON). */
+export declare const MANIFEST_FILE = ".remote-manifest.json";
+/** HOME-relative file recording the sha256 of the last pushed manifest. */
+export declare const MANIFEST_HASH_FILE = ".remote-manifest.sha256";
+/** Render the desired-state manifest for the configured plugins (no tracked skills today). */
+export declare function desiredManifest(): PluginManifest;
+/**
+ * Injectable IO seams for the manifest sidecar + reconcile so the gate is
+ * unit-testable WITHOUT shelling out to kubectl. Production wires the real
+ * execPod against a tunnel (`manifestPodIo`); tests pass a stateful fake Pod and
+ * assert that a converged Pod re-reports NO drift (no resync) next pass.
+ */
+export type ManifestPodIo = {
+    /** Read the Pod's recorded manifest hash ("" when absent/unreadable). */
+    readHash: () => string;
+    /** Persist the manifest JSON + its hash in the Pod (the sidecar write). */
+    writeSidecar: (json: string, hash: string) => void;
+    /** Run one plugin's EXISTING buildPodSyncScript in the Pod; returns its stdout. */
+    runSync: (plugin: PluginEntry) => string;
+};
+/** Production wiring of `ManifestPodIo` against a live Pod (real kubectl exec). */
+export declare function manifestPodIo(tunnel: TunnelConfig, pod: string, profile: string): ManifestPodIo;
+/**
+ * Push the desired-state manifest into a Pod as ~/.remote-manifest.json +
+ * ~/.remote-manifest.sha256, GATED exactly like CREDS_HASH_FILE: read the Pod's
+ * recorded hash first and SKIP the write when it already matches (so a steady
+ * Pod is a single `cat`, no churn). Mirrors soft-refresh's hash-sidecar pattern.
+ * Returns whether the sidecar was (re)written. Best-effort: caller logs errors.
+ */
+export declare function pushManifestSidecar(tunnel: TunnelConfig, pod: string, manifest: PluginManifest): {
+    wrote: boolean;
+    hash: string;
+};
+/** Sidecar push over an injected `ManifestPodIo` (the testable core). PURE-ish. */
+export declare function pushManifestSidecarVia(io: ManifestPodIo, manifest: PluginManifest): {
+    wrote: boolean;
+    hash: string;
+};
+/** The Pod's recorded manifest hash, or "" when absent/unreadable. */
+export declare function readPodManifestHash(tunnel: TunnelConfig, pod: string): string;
+/**
+ * Injectable seams so the pod-state probe is unit-testable WITHOUT kubectl.
+ * `npmLs` runs the argv-safe `npm ls -g --json` and returns its stdout;
+ * `readMcpConfigs` returns the raw MCP config blobs the existing sync writes.
+ */
+export type PodProbeDeps = {
+    /** Run `npm ls -g --json <pkgs…>` in the Pod, return stdout (may be non-zero exit). */
+    npmLs: (pkgs: ReadonlyArray<string>) => string;
+    /** Read the Pod's MCP config blobs: Claude-style JSON bodies + codex TOML. */
+    readMcpConfigs: () => {
+        json: string[];
+        toml: string;
+    };
+};
+/**
+ * Probe ONE Pod's actual plugin/MCP state into a `PodPluginState` (pure shape):
+ * installed versions for the desired pkgs (`npm ls -g --json` → parsed) + the
+ * registered MCP server names (claude/agy JSON + codex TOML → parsed). PURE-ish:
+ * all IO is injected via `deps` (tests never shell out). Exported for tests.
+ */
+export declare function probePodPluginState(desiredPkgs: ReadonlyArray<string>, deps: PodProbeDeps): PodPluginState;
+/**
+ * Watch-pass RECONCILE for ONE live Pod (an EXTRA trigger, NOT a new push path):
+ * compare the local desired-state hash with the Pod's recorded
+ * ~/.remote-manifest.sha256 (one `cat`); on a MISMATCH, re-run the EXISTING
+ * buildPodSyncScript for every plugin (the same mechanism `plugin sync` uses)
+ * and re-push the manifest sidecar. A match is a zero-work no-op. Mirrors the
+ * slice-2 probe→push advisory structure. Best-effort: a per-plugin failure is
+ * logged; the others proceed. Returns what happened. Used by the supervise pass.
+ */
+export declare function reconcilePodManifest(tunnel: TunnelConfig, pod: string, profile: string, manifest: PluginManifest, plugins: ReadonlyArray<PluginEntry>, stderr?: {
+    write: (s: string) => unknown;
+}): {
+    reconciled: boolean;
+    localHash: string;
+    podHash: string;
+    failures: number;
+};
+/**
+ * Reconcile core over an injected `ManifestPodIo` (the testable seam). PURE-ish:
+ * all Pod IO goes through `io`, so tests drive a stateful fake Pod and assert the
+ * gate — a matching hash is a zero-work no-op; an absent/mismatched hash resyncs
+ * ONCE then writes the sidecar so the NEXT pass converges (no re-sync).
+ *
+ * PERSISTENCE FIX (slice-3 regression): the sidecar is written via the SAME `io`
+ * (no second pod read, no `pushManifestSidecar` re-gate that could skip it) and
+ * is written even when some plugin syncs FAILED, so the Pod's recorded hash
+ * always converges to local after a reconcile — otherwise the next pass re-reads
+ * an absent hash and re-reports drift forever. (The dead-pod guard upstream keeps
+ * us off Evicted Pods where the write would throw and never persist at all.)
+ */
+export declare function reconcilePodManifestVia(io: ManifestPodIo, pod: string, manifest: PluginManifest, plugins: ReadonlyArray<PluginEntry>, stderr?: {
+    write: (s: string) => unknown;
+}): {
+    reconciled: boolean;
+    localHash: string;
+    podHash: string;
+    failures: number;
+};
+/**
+ * Production wiring used by the supervise/watch pass: reconcile manifest drift
+ * for ONE session via the configured tunnel. Thin — the decision + the reused
+ * buildPodSyncScript live in `reconcilePodManifest`. No-op (and no error) when
+ * no plugins are configured. Best-effort; never throws into the caller.
+ */
+export declare function reconcileSessionPlugins(sessionId: string, profile: string, stderr?: NodeJS.WriteStream): {
+    reconciled: boolean;
+};
+/**
+ * `remote plugin add <npmPkg> [--mcp name=bin]...` — npm i -g, register the
+ * MCP server(s) with claude + codex + agy, persist in the config.
+ */
+export declare function pluginAdd(npmSpec: string, mcpSpecs: readonly string[], stderr?: NodeJS.WriteStream): PluginEntry;
+/**
+ * `remote plugin add <name> --curl <url>` / `--install "<shell>"` — register a
+ * NON-npm plugin (a tool installed by piping an https script, or an arbitrary
+ * shell command). No local install is run (unlike the npm path, which must read
+ * the package to detect MCP bins): the installer runs in each Pod on
+ * `remote plugin sync`. Validates the command up front so a bad URL fails now.
+ */
+export declare function pluginAddInstaller(name: string, install: PluginInstall, stderr?: NodeJS.WriteStream): PluginEntry;
+/**
+ * `remote plugin ls` — pkg / version / MCPs / where (local ok/missing, remote).
+ *
+ * The REMOTE column is now REAL per-Pod drift status (slice 3), not the old
+ * guess-`?`: when a `url` is passed (the command is connected to the control-
+ * plane) we probe each live Pod via the same drift mechanism `--check` uses and
+ * summarize each plugin's worst per-Pod status across all Pods
+ * (ok / version-drift / missing). Without a url (offline) we still print `?`
+ * with the documented hint — the `?` only remains when we genuinely can't reach
+ * the cluster, never as guesswork when we can.
+ */
+export declare function pluginLs(stdout?: NodeJS.WriteStream, url?: string): Promise<void>;
+/**
+ * `remote plugin sync` — for every live remote session: kubectl exec into the
+ * Pod, `npm i -g <pkg>@<version>`, then register the MCP servers for the
+ * Pod's profile. Prints a per-session recap. Needs the configured tunnel.
+ */
+export declare function pluginSync(url: string, stderr?: NodeJS.WriteStream): Promise<void>;
+/**
+ * `remote plugin sync --check` — a READ-ONLY drift report (converges NOTHING).
+ * For each live Pod it probes the actual installed state (npm ls -g --json for
+ * the desired pkgs + the registered MCP server names from the config files the
+ * existing sync writes) via the argv-safe pod exec, then the pure
+ * `diffManifest` rows it: ok / version-drift / missing / mcp-unregistered.
+ * Prints a table and EXITS 1 when ANY row is drift (via process.exitCode). This
+ * REPLACES the `plugin ls` `REMOTE ?` guesswork with REAL per-Pod status. Pure
+ * decisions live in plugin-manifest.ts; this is the thin probe + printer.
+ */
+export declare function pluginSyncCheck(url: string, stdout?: NodeJS.WriteStream, stderr?: NodeJS.WriteStream): Promise<DriftRow[]>;
+//# sourceMappingURL=plugin.d.ts.map