agentplugged 0.0.0-stage → 1.0.0

package/dist/helpers2.js

@@ -0,0 +1 @@
+export { A as cose, g as decodeAttestationObject, f as decodeCredentialPublicKey, c as parseAuthenticatorData } from "./helpers.js";

package/dist/launcher-env.js

@@ -0,0 +1,13 @@
+//#region src/launcher-env.ts
+/**
+* What the launcher of the MCP server tells the engine it runs, by environment
+* variables: kept apart from the launcher so that the engine reads them without loading it.
+*/
+/** Marks the process the launcher runs: the engine itself (the server), not a launcher again. */
+const ENGINE_CHILD_ENV = "AGENTPLUGGED_ENGINE_CHILD";
+/** The name the server gives its session, kept across children (`server:<id>`). */
+const SESSION_INSTANCE_ENV = "AGENTPLUGGED_SESSION_INSTANCE";
+/** The secret that seals the state of a form, kept across children (64 hexadecimal characters). */
+const SESSION_KEY_ENV = "AGENTPLUGGED_SESSION_KEY";
+//#endregion
+export { SESSION_INSTANCE_ENV as n, SESSION_KEY_ENV as r, ENGINE_CHILD_ENV as t };

package/dist/launcher.js

@@ -0,0 +1,308 @@
+import { n as SESSION_INSTANCE_ENV, r as SESSION_KEY_ENV, t as ENGINE_CHILD_ENV } from "./launcher-env.js";
+import { et as installedEntry, n as productRootOf, nt as isReleaseVersion, t as PRODUCT_CONFIG_PATH } from "./product-root.js";
+import { i as randomBytes } from "./webauthn.js";
+import "./agent-commands.js";
+import { readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+//#region src/launcher.ts
+/**
+* The MCP server of the AI tool as a stable launcher. `agentplugged mcp` no longer is
+* the engine: it is a small relay that runs the engine of one version in a child process (the same
+* program, told by `AGENTPLUGGED_ENGINE_CHILD`) and passes the protocol's lines both ways. Between two
+* calls, when the product pins a newer version of the engine than the one running and that version
+* is installed in its own folder (`~/.agentplugged/engines/<version>/`), it starts that version's
+* child, replays it the handshake the AI tool made, hands it the next call, and lets the old child
+* end. The connection with the AI tool never closes, no call in flight is ever cut (the move waits
+* for none to be), and nothing is replaced in place: a running engine locks its native keychain
+* module on Windows, so every version lives in a folder of its own.
+*
+* What the launcher is not: it does not read the protocol beyond what it needs (the ids of the calls
+* in flight, the handshake), it never installs anything, and it asks no one anything.
+*/
+/** How long a new child has to answer the replayed handshake. */
+const HANDSHAKE_TIMEOUT_MS = 2e4;
+/** How long an old child has to end by itself once its input is closed. */
+const RETIRE_TIMEOUT_MS = 1e4;
+/** The id of the probe sent to a new child when the AI tool made no handshake (revision 2026-07-28). */
+const PROBE_ID = "agentplugged-launcher-probe";
+/**
+* Release versions compared as numbers: negative when `a` < `b`. The core's `compareSemver` does
+* the same; it is written again here so that the launcher does not load the core.
+*/
+function compareRelease(a, b) {
+	const x = a.split(".").map(Number);
+	const y = b.split(".").map(Number);
+	for (let i = 0; i < 3; i++) {
+		const diff = (x[i] ?? 0) - (y[i] ?? 0);
+		if (diff !== 0) return Math.sign(diff);
+	}
+	return 0;
+}
+/**
+* The engine version the product pins (`engine_version` of `method.yaml`), or undefined. A line of
+* the file read as is, never parsed: the launcher loads neither the core nor a YAML reader.
+*/
+function pinnedEngineOf(root) {
+	try {
+		const text = readFileSync(join(root, PRODUCT_CONFIG_PATH), "utf8");
+		return /^engine_version:[ \t]*["']?([0-9]+\.[0-9]+\.[0-9]+)["']?[ \t]*(?:#.*)?$/m.exec(text)?.[1];
+	} catch {
+		return;
+	}
+}
+/**
+* The engine the session should run now: the version the product pins when it is newer than the one
+* running (at the start: the package that runs the launcher) and installed in its own folder, and not
+* one that already failed to start in this session; else the one running.
+*/
+function chooseEngine(options) {
+	const own = {
+		version: options.running,
+		entry: options.runningEntry
+	};
+	const pinned = pinnedEngineOf(productRootOf(options.cwd));
+	if (pinned === void 0 || !isReleaseVersion(options.running) || compareRelease(pinned, options.running) <= 0 || options.failed?.has(pinned) === true) return own;
+	const entry = installedEntry(pinned, options.home);
+	return entry === void 0 ? own : {
+		version: pinned,
+		entry
+	};
+}
+function parse(line) {
+	try {
+		const value = JSON.parse(line);
+		return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/** An id as a key: `1` and `"1"` are two ids. */
+function idKey(id) {
+	return typeof id === "string" || typeof id === "number" ? `${typeof id}:${id}` : void 0;
+}
+/** Splits a stream of text into its lines. */
+var Lines = class {
+	#decoder = new StringDecoder("utf8");
+	#rest = "";
+	push(chunk) {
+		this.#rest += typeof chunk === "string" ? chunk : this.#decoder.write(chunk);
+		const lines = this.#rest.split("\n");
+		this.#rest = lines.pop() ?? "";
+		return lines.map((line) => line.replace(/\r$/, "")).filter((line) => line !== "");
+	}
+	end() {
+		const last = (this.#rest + this.#decoder.end()).replace(/\r$/, "");
+		this.#rest = "";
+		return last === "" ? [] : [last];
+	}
+};
+/**
+* Runs the launcher until the AI tool closes the connection (or the engine ends). Returns the exit
+* code: the engine's.
+*/
+async function runLauncher(options) {
+	const instance = `server:${Buffer.from(randomBytes(16)).toString("hex")}`;
+	const key = Buffer.from(randomBytes(32)).toString("hex");
+	const childEnv = {
+		...options.env,
+		[ENGINE_CHILD_ENV]: "1",
+		[SESSION_INSTANCE_ENV]: instance,
+		[SESSION_KEY_ENV]: key
+	};
+	const start = options.spawnEngine ?? ((entry, args, env) => spawn(process.execPath, [
+		entry,
+		"mcp",
+		...args
+	], {
+		cwd: options.cwd,
+		env,
+		stdio: [
+			"pipe",
+			"pipe",
+			"inherit"
+		],
+		windowsHide: true
+	}));
+	const failed = /* @__PURE__ */ new Set();
+	const engines = /* @__PURE__ */ new Set();
+	/** The calls the AI tool made that no answer closed, and those the engine made to the AI tool. */
+	const fromClient = /* @__PURE__ */ new Set();
+	const fromEngine = /* @__PURE__ */ new Set();
+	/** The handshake the AI tool made, to replay to the next engine. */
+	let initialize;
+	let initialized;
+	let finished = false;
+	let current;
+	let resolveDone = () => void 0;
+	const done = new Promise((resolve) => {
+		resolveDone = resolve;
+	});
+	const finish = (code) => {
+		if (finished) return;
+		finished = true;
+		for (const engine of engines) if (!engine.exited && engine.mode !== "retired") engine.child.kill();
+		resolveDone(code);
+	};
+	/** A call or a question the other side gave up (`notifications/cancelled`) is never answered. */
+	const forget = (pending, message) => {
+		if (message.method !== "notifications/cancelled") return;
+		const id = idKey(message.params?.requestId);
+		if (id !== void 0) pending.delete(id);
+	};
+	const startEngine = (choice, mode) => {
+		const child = start(choice.entry, options.args, childEnv);
+		const engine = {
+			choice,
+			child,
+			mode,
+			exited: false
+		};
+		engines.add(engine);
+		const lines = new Lines();
+		const onLine = (line) => {
+			const message = parse(line);
+			if (engine.mode === "trial") {
+				if (message !== void 0) engine.onTrialMessage?.(message);
+				return;
+			}
+			if (engine.mode === "retired") return;
+			if (message !== void 0) {
+				const id = idKey(message.id);
+				if (id !== void 0) {
+					if (message.method === void 0) fromClient.delete(id);
+					else fromEngine.add(id);
+				}
+				forget(fromEngine, message);
+			}
+			options.stdout.write(`${line}\n`);
+		};
+		child.stdout?.on("data", (chunk) => {
+			for (const line of lines.push(chunk)) onLine(line);
+		});
+		child.stdout?.on("end", () => {
+			for (const line of lines.end()) onLine(line);
+		});
+		child.stdin?.on("error", () => void 0);
+		child.on("error", (error) => {
+			engine.exited = true;
+			if (engine.mode === "live") {
+				options.stderr(`agentplugged mcp: ${error.message}\n`);
+				finish(1);
+			} else engine.onTrialEnd?.();
+		});
+		child.on("close", (code) => {
+			engine.exited = true;
+			if (engine.mode === "live") finish(code ?? 1);
+			else if (engine.mode === "trial") engine.onTrialEnd?.();
+		});
+		return engine;
+	};
+	/** Starts the engine of `choice` and tells whether it answers the handshake the session made. */
+	const tryEngine = async (choice) => {
+		const engine = startEngine(choice, "trial");
+		const ok = await new Promise((resolve) => {
+			const timer = setTimeout(() => resolve(false), options.handshakeTimeoutMs ?? HANDSHAKE_TIMEOUT_MS);
+			const wanted = idKey(initialize === void 0 ? PROBE_ID : parse(initialize)?.id);
+			engine.onTrialEnd = () => {
+				clearTimeout(timer);
+				resolve(false);
+			};
+			engine.onTrialMessage = (message) => {
+				if (message.method === void 0 && idKey(message.id) === wanted) {
+					clearTimeout(timer);
+					resolve(initialize === void 0 || message.error === void 0);
+				}
+			};
+			engine.child.stdin?.write(`${initialize ?? JSON.stringify({
+				jsonrpc: "2.0",
+				id: PROBE_ID,
+				method: "ping"
+			})}\n`);
+		});
+		delete engine.onTrialMessage;
+		delete engine.onTrialEnd;
+		if (!ok) {
+			engine.mode = "retired";
+			engine.child.kill();
+			return;
+		}
+		if (initialized !== void 0) engine.child.stdin?.write(`${initialized}\n`);
+		return engine;
+	};
+	/** Moves the session to `choice`: false (the old engine stays) when it does not start. */
+	const moveTo = async (choice) => {
+		const next = await tryEngine(choice);
+		if (next === void 0) {
+			failed.add(choice.version);
+			options.stderr(`agentplugged mcp: engine ${choice.version} did not answer; staying on ${current.choice.version}\n`);
+			return false;
+		}
+		const old = current;
+		next.mode = "live";
+		current = next;
+		old.mode = "retired";
+		old.child.stdin?.end();
+		setTimeout(() => {
+			if (!old.exited) old.child.kill();
+		}, options.retireTimeoutMs ?? RETIRE_TIMEOUT_MS).unref();
+		options.stderr(`agentplugged mcp: engine ${old.choice.version} replaced by ${next.choice.version}\n`);
+		return true;
+	};
+	current = startEngine(chooseEngine({
+		cwd: options.cwd,
+		running: options.version,
+		runningEntry: options.selfEntry,
+		...options.home === void 0 ? {} : { home: options.home }
+	}), "live");
+	/** The lines of the AI tool, one after the other: a move holds the ones behind it. */
+	let chain = Promise.resolve();
+	const handle = async (line) => {
+		if (finished) return;
+		const message = parse(line);
+		const id = message === void 0 ? void 0 : idKey(message.id);
+		const idle = fromClient.size === 0 && fromEngine.size === 0;
+		if (message?.method === "tools/call" && id !== void 0 && idle) {
+			const wanted = chooseEngine({
+				cwd: options.cwd,
+				running: current.choice.version,
+				runningEntry: current.choice.entry,
+				failed,
+				...options.home === void 0 ? {} : { home: options.home }
+			});
+			if (wanted.version !== current.choice.version) await moveTo(wanted);
+		}
+		if (message !== void 0) {
+			if (message.method === "initialize" && id !== void 0) initialize = line;
+			else if (message.method === "notifications/initialized") initialized = line;
+			if (id !== void 0) {
+				if (message.method === void 0) fromEngine.delete(id);
+				else fromClient.add(id);
+			}
+			forget(fromClient, message);
+		}
+		current.child.stdin?.write(`${line}\n`);
+	};
+	const clientLines = new Lines();
+	const enqueue = (lines) => {
+		for (const line of lines) chain = chain.then(() => handle(line)).catch(() => void 0);
+	};
+	/** The AI tool closed the connection: the engine's input ends after the lines already received. */
+	const closeInput = () => {
+		enqueue(clientLines.end());
+		chain = chain.then(() => {
+			current.child.stdin?.end();
+		});
+	};
+	options.stdin.on("data", (chunk) => enqueue(clientLines.push(chunk)));
+	options.stdin.on("end", closeInput);
+	options.stdin.on("error", closeInput);
+	options.stdout.on("error", () => void 0);
+	const code = await done;
+	options.stdin.removeAllListeners("data");
+	options.stdin.pause();
+	return code;
+}
+//#endregion
+export { runLauncher };