@standardagents/code 0.14.1-issue.658.a1599e → 0.14.1-issue.658.a1599e-linux-x64-gnu

package/lib/standard-plugin-runner/index.mjs

@@ -0,0 +1,1125 @@
+import { createRequire as __standardCreateRequire } from 'node:module'; import { fileURLToPath as __standardFileURLToPath } from 'node:url'; import { dirname as __standardDirname } from 'node:path'; const require = __standardCreateRequire(import.meta.url); const __filename = __standardFileURLToPath(import.meta.url); const __dirname = __standardDirname(__filename);
+
+// src/supervisor.mjs
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+
+// ../plugin-sdk/src/manifest.mjs
+var CAPABILITIES = Object.freeze([
+  "surfaces",
+  "events",
+  "hooks",
+  "panes",
+  "projects",
+  "notifications",
+  "url",
+  "fetch",
+  "secrets",
+  "webhook"
+]);
+var SURFACE_KINDS = Object.freeze([
+  "section",
+  "card",
+  "slot",
+  "badge",
+  "panel",
+  "overlay",
+  "menu",
+  "command",
+  "key",
+  "link"
+]);
+var PRESENTATIONS = Object.freeze(["popover", "column", "pane", "stage"]);
+var MUX_EXPRESSIONS = Object.freeze([
+  "neutral",
+  "blink",
+  "happy",
+  "happy-smile",
+  "sad",
+  "grin",
+  "surprise",
+  "sleepy",
+  "angry",
+  "focus",
+  "question",
+  "exclaim",
+  "cross"
+]);
+var ANCHORS = Object.freeze([
+  "plugins",
+  "machine.before",
+  "machine.after",
+  "project.before",
+  "project.after",
+  "pane.header",
+  "pane.footer",
+  "account",
+  "machine",
+  "project",
+  "pane",
+  "section"
+]);
+var LIMITS = Object.freeze({
+  manifestBytes: 65536,
+  frameBytes: 262144,
+  responseFrameBytes: 64 * 1024 * 1024,
+  pendingRequests: 128,
+  subscriptions: 256,
+  schedules: 128,
+  contributions: 256,
+  queuedBytes: 4 * 1024 * 1024,
+  hookTimeoutMs: 6e4,
+  requestTimeoutMs: 3e4,
+  canvasColumns: 512,
+  canvasRows: 256,
+  canvasHoverBytes: 512,
+  canvasShapes: 256,
+  stateKeys: 256,
+  stateValueBytes: 64 * 1024
+});
+var PluginError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "PluginError";
+    this.code = code;
+  }
+};
+function ensure(condition, code, message) {
+  if (!condition) throw new PluginError(code, message);
+}
+function object(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
+}
+function identifier(value2) {
+  return typeof value2 === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value2);
+}
+function jsonBytes(value2, limit = LIMITS.frameBytes) {
+  const seen = /* @__PURE__ */ new Set();
+  function visit(item, depth) {
+    ensure(depth <= 32, "invalid_payload", "JSON nesting exceeds 32 levels");
+    if (item === null || typeof item === "string" || typeof item === "boolean") return;
+    if (typeof item === "number") {
+      ensure(Number.isFinite(item), "invalid_payload", "JSON numbers must be finite");
+      return;
+    }
+    ensure(object(item) || Array.isArray(item), "invalid_payload", "Payload must contain JSON values");
+    ensure(!seen.has(item), "invalid_payload", "Payload contains a cycle");
+    ensure(Array.isArray(item) || [Object.prototype, null].includes(Object.getPrototypeOf(item)), "invalid_payload", "Payload must contain plain objects");
+    seen.add(item);
+    for (const child of Object.values(item)) visit(child, depth + 1);
+    seen.delete(item);
+  }
+  visit(value2, 0);
+  const text = JSON.stringify(value2);
+  ensure(Buffer.byteLength(text) <= limit, "payload_too_large", `Payload exceeds ${limit} bytes`);
+  return text;
+}
+function freeze(value2) {
+  if (value2 && typeof value2 === "object") {
+    Object.values(value2).forEach(freeze);
+    Object.freeze(value2);
+  }
+  return value2;
+}
+function validateManifest(value2) {
+  ensure(object(value2), "invalid_manifest", "package.json must contain a standardPlugin object");
+  jsonBytes(value2, LIMITS.manifestBytes);
+  const allowed = [
+    "apiVersion",
+    "id",
+    "name",
+    "version",
+    "entry",
+    "singleton",
+    "order",
+    "capabilities",
+    "contributions",
+    "configSchema",
+    "hookTimeoutMs"
+  ];
+  ensure(Object.keys(value2).every((key) => allowed.includes(key)), "invalid_manifest", "Unknown manifest field");
+  const manifest = structuredClone({ singleton: false, order: 0, capabilities: [], contributions: [], hookTimeoutMs: 5e3, ...value2 });
+  ensure(manifest.apiVersion === 1, "incompatible_version", "Plugin requires a different SDK API version");
+  ensure(identifier(manifest.id), "invalid_manifest", "Plugin id must be a stable identifier");
+  ensure(
+    typeof manifest.name === "string" && manifest.name.trim().length > 0 && manifest.name.length <= 128,
+    "invalid_manifest",
+    "Plugin name is required and bounded to 128 characters"
+  );
+  ensure(
+    typeof manifest.version === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?$/.test(manifest.version),
+    "invalid_manifest",
+    "Plugin version must be semantic"
+  );
+  ensure(
+    typeof manifest.entry === "string" && manifest.entry.length <= 512 && !/[\\\u0000?#]/.test(manifest.entry) && !manifest.entry.startsWith("/") && manifest.entry.split("/").every((part) => part && part !== "..") && /\.(?:mjs|cjs|js|mts|ts)$/.test(manifest.entry),
+    "invalid_manifest",
+    "Plugin entry must be a relative JavaScript or TypeScript file"
+  );
+  ensure(
+    typeof manifest.singleton === "boolean" && Number.isSafeInteger(manifest.order) && Math.abs(manifest.order) <= 2147483647,
+    "invalid_manifest",
+    "Invalid singleton or order"
+  );
+  ensure(
+    Number.isSafeInteger(manifest.hookTimeoutMs) && manifest.hookTimeoutMs > 0 && manifest.hookTimeoutMs <= LIMITS.hookTimeoutMs,
+    "invalid_manifest",
+    "Hook timeout must be between 1 and 60000 ms"
+  );
+  ensure(Array.isArray(manifest.capabilities) && manifest.capabilities.every((item) => CAPABILITIES.includes(item)) && new Set(manifest.capabilities).size === manifest.capabilities.length, "invalid_manifest", "Unknown or repeated capability");
+  ensure(
+    Array.isArray(manifest.contributions) && manifest.contributions.length <= LIMITS.contributions,
+    "invalid_manifest",
+    "Too many contributions"
+  );
+  const ids = /* @__PURE__ */ new Set();
+  for (const declaration of manifest.contributions) {
+    ensure(object(declaration) && identifier(declaration.id) && !ids.has(declaration.id) && SURFACE_KINDS.includes(declaration.kind) && ANCHORS.includes(declaration.anchor), "invalid_manifest", "Invalid contribution declaration");
+    ids.add(declaration.id);
+    ensure(
+      declaration.icon === void 0 || ["card", "panel"].includes(declaration.kind) && typeof declaration.icon === "string" && /^[\uE000-\uF8FF\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}]$/u.test(declaration.icon),
+      "invalid_manifest",
+      "Card or panel icon must be one Nerd Font private-use glyph"
+    );
+    ensure(
+      declaration.border === void 0 || typeof declaration.border === "boolean" && declaration.kind === "card",
+      "invalid_manifest",
+      "Only sidebar cards declare a boolean border preference"
+    );
+    for (const [key, choices] of Object.entries({
+      merge: ["by-machine", "by-identity"],
+      width: ["full", "half"],
+      position: ["top", "after-open", "before-danger", "bottom"],
+      presentation: PRESENTATIONS
+    })) {
+      ensure(declaration[key] === void 0 || choices.includes(declaration[key]), "invalid_manifest", `Invalid contribution ${key}`);
+    }
+    for (const key of ["title", "group", "chord", "pattern", "actionId"]) {
+      ensure(
+        declaration[key] === void 0 || typeof declaration[key] === "string" && declaration[key].length <= 512,
+        "invalid_manifest",
+        `Invalid contribution ${key}`
+      );
+    }
+    ensure(declaration.opens === void 0 || identifier(declaration.opens), "invalid_manifest", "Invalid contribution opens");
+    ensure(
+      declaration.presentation === void 0 || ["panel", "card", "command"].includes(declaration.kind),
+      "invalid_manifest",
+      "Only panels, cards, and commands declare a presentation"
+    );
+    ensure(declaration.kind !== "card" || declaration.anchor === "plugins", "invalid_manifest", "Cards use the plugins anchor");
+    ensure(
+      declaration.presentation !== "stage" || declaration.kind !== "panel" || declaration.anchor === "account",
+      "invalid_manifest",
+      "Stage panels use the account anchor"
+    );
+  }
+  for (const declaration of manifest.contributions) {
+    ensure(
+      declaration.opens === void 0 || manifest.contributions.some((item) => item.id === declaration.opens && item.kind === "panel"),
+      "invalid_manifest",
+      "Contribution opens must name a declared panel"
+    );
+  }
+  ensure(!manifest.contributions.length || manifest.capabilities.includes("surfaces"), "invalid_manifest", "Contributions require surfaces capability");
+  ensure(manifest.configSchema === void 0 || object(manifest.configSchema), "invalid_manifest", "Configuration schema must be an object");
+  return freeze(manifest);
+}
+
+// ../plugin-sdk/src/protocol.mjs
+var RUNNER_PROTOCOL_VERSION = 1;
+var OPERATIONS = Object.freeze({
+  "pane.create": "panes",
+  "pane.close": "panes",
+  "pane.restart": "panes",
+  "pane.input": "panes",
+  "pane.focus": "panes",
+  "pane.wait": "panes",
+  "project.create": "projects",
+  "project.remove": "projects",
+  "notification.show": "notifications",
+  "url.open": "url",
+  fetch: "fetch",
+  "secret.get": "secrets",
+  "config.get": null,
+  "state.get": null,
+  "state.set": null,
+  "state.keys": null,
+  "panel.open": "surfaces",
+  "context.get": null,
+  "popover.open": "surfaces",
+  "canvas.write": "surfaces",
+  "remote.request": "surfaces",
+  "canvas.focus": "surfaces",
+  "subscription.add": null,
+  "subscription.remove": null,
+  "health.set": null,
+  "webhook.ack": "webhook"
+});
+var HOST_OPERATIONS = Object.freeze([
+  "runner.start",
+  "runner.stop",
+  "runner.reload",
+  "runner.diagnose",
+  "runner.ping",
+  "runtime.invoke",
+  "runtime.visibility"
+]);
+function authorize(operation, capabilities) {
+  ensure(
+    object(operation) && Object.hasOwn(OPERATIONS, operation.op) && object(operation.args),
+    "unsupported_operation",
+    "Unknown SDK operation or invalid arguments"
+  );
+  let capability = OPERATIONS[operation.op];
+  if (operation.op === "subscription.add") {
+    const { id, kind, name } = operation.args;
+    ensure(
+      identifier(id) && typeof name === "string" && name.length <= 256 && ["event", "hook", "action", "input", "select", "resize", "activate", "deactivate", "visibility"].includes(kind),
+      "invalid_payload",
+      "Invalid subscription"
+    );
+    capability = kind === "hook" ? "hooks" : kind === "event" ? name === "webhook" ? "webhook" : "events" : "surfaces";
+  }
+  ensure(!capability || capabilities.includes(capability), "capability_denied", `Operation requires ${capability} capability`);
+  jsonBytes(operation);
+}
+function validateProducer(producer) {
+  ensure(
+    object(producer) && identifier(producer.pluginId) && typeof producer.machineId === "string" && producer.machineId.length > 0 && producer.machineId.length <= 128 && typeof producer.epoch === "string" && /^(0|[1-9]\d{0,19})$/.test(producer.epoch) && BigInt(producer.epoch) <= 18446744073709551615n,
+    "invalid_payload",
+    "Invalid plugin producer identity"
+  );
+  return producer;
+}
+function sameProducer(a, b) {
+  return a.pluginId === b.pluginId && a.machineId === b.machineId && a.epoch === b.epoch;
+}
+function frameLimit(frame, inbound) {
+  return inbound && object(frame) && frame.kind === "response" ? LIMITS.responseFrameBytes : LIMITS.frameBytes;
+}
+function validateEnvelope(frame, { inbound = false } = {}) {
+  jsonBytes(frame, frameLimit(frame, inbound));
+  ensure(object(frame) && frame.version === RUNNER_PROTOCOL_VERSION, "incompatible_version", "Daemon and runner protocol versions differ");
+  validateProducer(frame.producer);
+  ensure(["request", "response", "cancel", "surface", "report"].includes(frame.kind), "invalid_payload", "Unknown runner frame kind");
+  if (frame.kind === "report") {
+    ensure(
+      identifier(frame.name) && object(frame.entity) && typeof frame.sequence === "string" && /^(0|[1-9]\d{0,19})$/.test(frame.sequence) && BigInt(frame.sequence) <= 18446744073709551615n && Number.isInteger(frame.schemaVersion) && frame.schemaVersion > 0 && frame.schemaVersion <= 65535 && Object.hasOwn(frame, "value") && frame.value !== void 0,
+      "invalid_payload",
+      "Invalid report replacement"
+    );
+  } else if (frame.kind === "surface") {
+    ensure(object(frame.key) && identifier(frame.key.contributionId) && typeof frame.sequence === "string" && /^(0|[1-9]\d{0,19})$/.test(frame.sequence) && BigInt(frame.sequence) <= 18446744073709551615n && Object.hasOwn(frame, "content"), "invalid_payload", "Invalid surface replacement");
+  } else {
+    ensure(typeof frame.id === "string" && frame.id.length > 0 && frame.id.length <= 128, "invalid_payload", "Missing correlation id");
+    if (frame.kind === "request") {
+      ensure(
+        object(frame.operation) && (Object.hasOwn(OPERATIONS, frame.operation.op) || HOST_OPERATIONS.includes(frame.operation.op)) && object(frame.operation.args) && Number.isSafeInteger(frame.timeoutMs) && frame.timeoutMs > 0 && frame.timeoutMs <= LIMITS.hookTimeoutMs,
+        "invalid_payload",
+        "Invalid runner request"
+      );
+    }
+    if (frame.kind === "response") {
+      ensure(
+        object(frame.result) && typeof frame.result.ok === "boolean" && (frame.result.ok ? Object.hasOwn(frame.result, "value") : object(frame.result.error) && typeof frame.result.error.code === "string" && typeof frame.result.error.message === "string"),
+        "invalid_payload",
+        "Invalid runner response"
+      );
+    }
+  }
+  return frame;
+}
+function wireError(error) {
+  return {
+    code: error instanceof PluginError ? error.code : "plugin_error",
+    message: String(error?.message ?? "Plugin operation failed").slice(0, 1024)
+  };
+}
+var realClock = Object.freeze({ now: () => Date.now(), setTimeout: (fn, ms) => setTimeout(fn, ms), clearTimeout: (id) => clearTimeout(id) });
+var RpcPeer = class {
+  constructor({ producer, send, clock = realClock, onRequest, onSurface, onReport, onError = () => {
+  }, idPrefix = "host" }) {
+    this.producer = Object.freeze({ ...validateProducer(producer) });
+    this.send = send;
+    this.clock = clock;
+    this.onRequest = onRequest;
+    this.onSurface = onSurface;
+    this.onReport = onReport;
+    this.onError = onError;
+    this.pending = /* @__PURE__ */ new Map();
+    this.incoming = /* @__PURE__ */ new Map();
+    this.nextId = 0;
+    this.idPrefix = idPrefix;
+    this.closed = false;
+  }
+  frame(kind, values) {
+    return { version: RUNNER_PROTOCOL_VERSION, producer: this.producer, kind, ...values };
+  }
+  transmit(frame) {
+    validateEnvelope(frame);
+    this.send(frame);
+  }
+  request(operation, { signal, timeoutMs = LIMITS.requestTimeoutMs } = {}) {
+    if (this.closed) return Promise.reject(new PluginError("disposed", "Plugin runtime is disposed"));
+    if (signal?.aborted) return Promise.reject(new PluginError("cancelled", "Request was cancelled"));
+    if (this.pending.size >= LIMITS.pendingRequests) return Promise.reject(new PluginError("queue_full", "Too many pending requests"));
+    const id = `${this.idPrefix}-${++this.nextId}`;
+    return new Promise((resolve2, reject) => {
+      let timer;
+      const finish = (error, value2) => {
+        if (!this.pending.delete(id)) return;
+        this.clock.clearTimeout(timer);
+        signal?.removeEventListener("abort", cancel);
+        error ? reject(error) : resolve2(value2);
+      };
+      const cancelWith = (code) => {
+        finish(new PluginError(code, code === "timeout" ? "Request deadline elapsed" : "Request was cancelled"));
+        try {
+          this.transmit(this.frame("cancel", { id }));
+        } catch (error) {
+          this.onError(error);
+        }
+      };
+      const cancel = () => cancelWith("cancelled");
+      this.pending.set(id, { finish });
+      signal?.addEventListener("abort", cancel, { once: true });
+      timer = this.clock.setTimeout(() => cancelWith("timeout"), timeoutMs);
+      try {
+        this.transmit(this.frame("request", { id, operation, timeoutMs }));
+      } catch (error) {
+        finish(error);
+      }
+    });
+  }
+  receive(frame) {
+    if (this.closed) return;
+    validateEnvelope(frame, { inbound: true });
+    ensure(sameProducer(frame.producer, this.producer), "stale_producer", "Frame belongs to another plugin instance");
+    if (frame.kind === "surface") {
+      this.onSurface?.(frame);
+      return;
+    }
+    if (frame.kind === "report") {
+      this.onReport?.(frame);
+      return;
+    }
+    if (frame.kind === "response") {
+      const result = frame.result;
+      this.pending.get(frame.id)?.finish(result.ok ? null : new PluginError(result.error.code, result.error.message), result.value);
+      return;
+    }
+    if (frame.kind === "cancel") {
+      this.incoming.get(frame.id)?.cancel();
+      return;
+    }
+    ensure(!this.incoming.has(frame.id), "duplicate_request", "Request id is still in flight");
+    const respond = (result) => {
+      if (!this.closed) {
+        try {
+          this.transmit(this.frame("response", { id: frame.id, result }));
+        } catch (error) {
+          this.onError(error);
+        }
+      }
+    };
+    if (this.incoming.size >= LIMITS.pendingRequests) {
+      respond({ ok: false, error: { code: "queue_full", message: "Too many incoming requests" } });
+      return;
+    }
+    const controller = new AbortController();
+    const cancel = () => {
+      controller.abort();
+      this.clock.clearTimeout(timer);
+    };
+    const timer = this.clock.setTimeout(() => {
+      cancel();
+      respond({ ok: false, error: { code: "timeout", message: "Handler deadline elapsed" } });
+    }, frame.timeoutMs);
+    this.incoming.set(frame.id, { cancel });
+    Promise.resolve().then(() => {
+      ensure(!controller.signal.aborted, "cancelled", "Request was cancelled");
+      ensure(typeof this.onRequest === "function", "unsupported_operation", "No request handler");
+      return this.onRequest(frame.operation, { signal: controller.signal, timeoutMs: frame.timeoutMs });
+    }).then((value2) => {
+      if (!controller.signal.aborted) respond({ ok: true, value: value2 ?? null });
+    }, (error) => {
+      if (!controller.signal.aborted) respond({ ok: false, error: wireError(error) });
+    }).finally(() => {
+      this.clock.clearTimeout(timer);
+      this.incoming.delete(frame.id);
+    });
+  }
+  dispose() {
+    if (this.closed) return;
+    for (const [id, request] of this.pending) {
+      request.finish(new PluginError("disposed", "Plugin runtime was disposed"));
+      try {
+        this.transmit(this.frame("cancel", { id }));
+      } catch (error) {
+        this.onError(error);
+      }
+    }
+    this.closed = true;
+    for (const request of this.incoming.values()) request.cancel();
+  }
+};
+
+// ../plugin-sdk/src/view.mjs
+var VIEW_LIMITS = Object.freeze({
+  depth: 8,
+  nodes: 4096,
+  tableRows: 512,
+  tableColumns: 12,
+  items: 512,
+  logLines: 2048,
+  cardLines: 6,
+  actionValueBytes: 512
+});
+var TONES = Object.freeze(["ok", "info", "warn", "error", "muted", "accent", "pending", "bright"]);
+function compact(value2) {
+  return Object.fromEntries(Object.entries(value2).filter(([, item]) => item !== void 0));
+}
+var node = (type, fields) => compact({ type, ...fields });
+var clockTime = (at) => `${new Date(at).toISOString().slice(11, 16)} UTC`;
+var timeSpan = (style, at, { text: fallback, tone, weight, mono } = {}) => compact({
+  text: fallback ?? (style === "duration" ? `since ${clockTime(at)}` : clockTime(at)),
+  tone,
+  weight,
+  mono,
+  time: { at: Math.max(0, Math.floor(at)), style }
+});
+var value = (content) => Array.isArray(content) ? { value: content.map((span) => span.text).join(""), valueSpans: content.map(compact) } : { value: content };
+var ui = Object.freeze({
+  view: (root, { title } = {}) => compact({ kind: "view", root, title }),
+  action: (actionId, { value: value2, opens, agentPicker } = {}) => compact({ actionId, value: value2, opens, agentPicker }),
+  span: (content, { tone, weight, mono, time } = {}) => compact({ text: content, tone, weight, mono, time }),
+  elapsed: (since, options) => timeSpan("duration", since, options),
+  relativeTime: (at, options) => timeSpan("relative", at, options),
+  stack: (items, { gap } = {}) => node("stack", { gap, children: items }),
+  row: (items, { align } = {}) => node("row", { children: items, align }),
+  divider: (label) => node("divider", { label }),
+  /** A string sets `text`; an array of spans sets `spans`. */
+  text: (content, { tone, weight, mono } = {}) => node("text", { ...Array.isArray(content) ? { spans: content.map(compact) } : { text: content }, tone, weight, mono }),
+  badge: (label, tone) => node("badge", { label, tone }),
+  dot: (tone) => node("dot", { tone }),
+  progress: (value2, max, { tone, label } = {}) => node("progress", { value: value2, max, tone, label }),
+  segments: (items) => node("segments", { items: items.map(compact) }),
+  card: (items, { title, tone, tags, action, externalAction, footer } = {}) => node("card", { title, tone, tags, action, externalAction, footer, children: items }),
+  stat: (label, content, { tone, hint } = {}) => node("stat", { label, ...value(content), tone, hint }),
+  kv: (items) => node("kv", { items: items.map((item) => compact({ ...item, ...value(item.value) })) }),
+  tabs: (id, items, { filters, action } = {}) => node("tabs", { id, items: items.map(compact), filters, action }),
+  select: (id, label, options, { filters, action } = {}) => node("select", { id, label, options: options.map(compact), filters, action }),
+  table: (id, columns, rows = []) => node("table", { id, columns: columns.map(compact), rows: rows.map(compact) }),
+  log: (lines) => node("log", { lines }),
+  /** `action` is an action object or an action id. */
+  button: (label, action) => node("button", { label, action: typeof action === "string" ? { actionId: action } : action }),
+  input: (id, value2, action, { placeholder, maxLength } = {}) => node("input", { id, value: value2, placeholder, maxLength, action: typeof action === "string" ? { actionId: action } : action })
+});
+
+// ../plugin-sdk/src/runtime.mjs
+var always = Object.freeze({ kind: "always" });
+
+// src/prepare.mjs
+import { constants } from "node:fs";
+import { open, realpath, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+function contained(root, path) {
+  const part = relative(root, path);
+  return part !== ".." && !part.startsWith(`..${sep}`) && !isAbsolute(part);
+}
+async function inspectPlugin(root) {
+  ensure(typeof root === "string" && isAbsolute(root), "invalid_source", "Plugin root must be absolute");
+  root = await realpath(root);
+  const file = await open(join(root, "package.json"), constants.O_RDONLY | constants.O_NOFOLLOW);
+  let source;
+  try {
+    const metadata = await file.stat();
+    ensure(metadata.isFile() && metadata.size > 0 && metadata.size <= LIMITS.manifestBytes, "invalid_manifest", "Package metadata exceeds its size limit");
+    const buffer = Buffer.alloc(LIMITS.manifestBytes + 1);
+    let size = 0;
+    while (size < buffer.length) {
+      const read = await file.read(buffer, size, buffer.length - size, size);
+      if (!read.bytesRead) break;
+      size += read.bytesRead;
+    }
+    ensure(size <= LIMITS.manifestBytes, "invalid_manifest", "Package metadata exceeds its size limit");
+    source = buffer.subarray(0, size).toString("utf8");
+  } finally {
+    await file.close();
+  }
+  const packageMetadata = JSON.parse(source);
+  const manifest = validateManifest(packageMetadata.standardPlugin);
+  const entry = await realpath(resolve(root, manifest.entry));
+  ensure(contained(root, entry) && (await stat(entry)).isFile(), "invalid_source", "Plugin entry must remain inside its source directory");
+  const manifestDigest = createHash("sha256").update(source).digest("hex");
+  return Object.freeze({ root, entry, manifest, manifestDigest });
+}
+async function preparePlugin({ root, manifestDigest, capabilities }) {
+  const prepared = await inspectPlugin(root);
+  ensure(prepared.manifestDigest === manifestDigest, "manifest_changed", "Plugin metadata changed after preparation or consent");
+  ensure(
+    Array.isArray(capabilities) && prepared.manifest.capabilities.every((capability) => capabilities.includes(capability)),
+    "consent_required",
+    "Plugin capabilities require installation consent"
+  );
+  return prepared;
+}
+
+// src/channel.mjs
+var framed = (message) => message?.type === "frame" ? message.frame : message;
+var Outbox = class {
+  constructor(write) {
+    this.write = write;
+    this.queue = [];
+    this.bytes = 0;
+    this.closed = false;
+  }
+  push(message) {
+    ensure(!this.closed, "disposed", "Output channel is closed");
+    const frame = framed(message);
+    const serialized = jsonBytes(message, frameLimit(frame, true));
+    const size = Buffer.byteLength(serialized);
+    const key = frame.kind === "surface" ? JSON.stringify(["surface", frame.producer, frame.key]) : frame.kind === "report" ? JSON.stringify(["report", frame.producer, frame.name, frame.entity]) : null;
+    const previous = key === null ? -1 : this.queue.findIndex((item2) => item2.key === key);
+    const replaced = previous < 0 ? 0 : this.queue[previous].size;
+    const budget = LIMITS.queuedBytes + (frame.kind === "response" ? LIMITS.responseFrameBytes : 0);
+    ensure(
+      this.bytes - replaced + size <= budget && (previous >= 0 || this.queue.length < 256),
+      "queue_full",
+      "Runner output queue is full"
+    );
+    const item = { message: JSON.parse(serialized), size, key };
+    if (previous >= 0) this.queue.splice(previous, 1);
+    this.queue.push(item);
+    this.bytes += size - replaced;
+    this.flush();
+  }
+  flush() {
+    while (!this.closed && this.queue.length && this.write(this.queue[0].message)) {
+      this.bytes -= this.queue.shift().size;
+    }
+  }
+  dispose() {
+    this.closed = true;
+    this.queue.length = 0;
+    this.bytes = 0;
+  }
+};
+function portChannel(port, receive, onError) {
+  let credits = 16;
+  let closed = false;
+  const outbox = new Outbox((message) => {
+    if (!credits) return false;
+    port.postMessage({ type: "delivery", message });
+    credits--;
+    return true;
+  });
+  function listener(envelope) {
+    if (closed) return;
+    try {
+      if (envelope?.type === "credit") {
+        ensure(credits < 16, "invalid_payload", "Unexpected port credit");
+        credits++;
+        outbox.flush();
+      } else {
+        ensure(envelope?.type === "delivery", "invalid_payload", "Invalid port message");
+        jsonBytes(envelope.message, frameLimit(framed(envelope.message), true));
+        receive(envelope.message);
+        port.postMessage({ type: "credit" });
+      }
+    } catch (error) {
+      onError(error);
+    }
+  }
+  port.on("message", listener);
+  return { send: (message) => outbox.push(message), dispose() {
+    closed = true;
+    outbox.dispose();
+    port.off("message", listener);
+  } };
+}
+function stdioChannel(input, output, receive, onError) {
+  let blocked = false;
+  let buffer = Buffer.alloc(0);
+  const outbox = new Outbox((frame) => {
+    if (blocked) return false;
+    blocked = !output.write(`${JSON.stringify(frame)}
+`);
+    return true;
+  });
+  const drain = () => {
+    blocked = false;
+    outbox.flush();
+  };
+  const data = (chunk) => {
+    try {
+      let start = 0;
+      for (let index = 0; index < chunk.length; index++) {
+        if (chunk[index] !== 10) continue;
+        const part = chunk.subarray(start, index);
+        ensure(buffer.length + part.length <= LIMITS.responseFrameBytes, "payload_too_large", "Runner input frame is too large");
+        const line = buffer.length ? Buffer.concat([buffer, part]) : part;
+        buffer = Buffer.alloc(0);
+        if (line.length) receive(JSON.parse(line.toString("utf8")));
+        start = index + 1;
+      }
+      const tail = chunk.subarray(start);
+      ensure(buffer.length + tail.length <= LIMITS.responseFrameBytes, "payload_too_large", "Runner input frame is too large");
+      buffer = Buffer.concat([buffer, tail]);
+    } catch (error) {
+      onError(error);
+    }
+  };
+  input.on("data", data);
+  output.on("drain", drain);
+  output.on("error", onError);
+  input.on("error", onError);
+  return { send: (frame) => outbox.push(frame), dispose() {
+    outbox.dispose();
+    input.off("data", data);
+    output.off("drain", drain);
+    input.off("error", onError);
+    output.off("error", onError);
+  } };
+}
+
+// src/node.mjs
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var NODE_MINIMUM_MAJOR = 20;
+function nodeDiagnostic(executable = process.execPath, version = process.versions.node) {
+  const supported = /^\d+\.\d+\.\d+$/.test(version) && Number(version.split(".")[0]) >= NODE_MINIMUM_MAJOR;
+  return {
+    executable,
+    version,
+    supported,
+    minimumMajor: NODE_MINIMUM_MAJOR,
+    protocolVersion: RUNNER_PROTOCOL_VERSION,
+    isolation: "worker-thread",
+    message: supported ? "Node supports the plugin runner" : "Plugins require Node.js 20 or newer"
+  };
+}
+
+// src/supervisor.mjs
+var bundled = true;
+var sdkUrl = new URL(bundled ? "./sdk.mjs" : "../../plugin-sdk/src/index.mjs", import.meta.url);
+var loaderUrl = new URL("./loader.mjs", import.meta.url);
+var PluginSupervisor = class {
+  constructor({ send, env = process.env, onDiagnostic = () => {
+  } }) {
+    this.send = send;
+    this.env = env;
+    this.onDiagnostic = onDiagnostic;
+    this.slots = /* @__PURE__ */ new Map();
+    this.closed = false;
+    this.nextWorker = 0;
+  }
+  /**
+   * The daemon's input. A frame this supervisor refuses fails by itself: the
+   * daemon gets an error answer when the frame was a request, and every other
+   * plugin keeps running. Only a broken channel ends the process.
+   */
+  accept(frame) {
+    try {
+      this.receive(frame);
+    } catch (error) {
+      this.onDiagnostic(error);
+      if (frame?.kind !== "request" || typeof frame.id !== "string" || !frame.producer) return;
+      try {
+        this.send({
+          version: RUNNER_PROTOCOL_VERSION,
+          producer: frame.producer,
+          kind: "response",
+          id: frame.id,
+          result: { ok: false, error: wireError(error) }
+        });
+      } catch (failure) {
+        this.onDiagnostic(failure);
+      }
+    }
+  }
+  receive(frame) {
+    validateEnvelope(frame, { inbound: true });
+    ensure(!this.closed, "disposed", "Runner is shutting down");
+    const key = `${frame.producer.machineId}/${frame.producer.pluginId}`;
+    let slot = this.slots.get(key);
+    if (slot && !sameProducer(frame.producer, slot.producer) && frame.kind === "request" && frame.operation.op === "runner.start") {
+      const retired = slot;
+      retired.desired = false;
+      clearTimeout(retired.restarting);
+      this.slots.delete(key);
+      void this.stopWorker(retired).catch(this.onDiagnostic).finally(() => retired.peer.dispose());
+      slot = void 0;
+    }
+    if (!slot) {
+      ensure(
+        frame.kind === "request" && ["runner.start", "runner.diagnose", "runner.ping"].includes(frame.operation.op),
+        "plugin_not_running",
+        "Plugin has no runner slot"
+      );
+      ensure(this.slots.size < 64, "queue_full", "Runner supports at most 64 plugin slots");
+      slot = this.createSlot(frame.producer);
+      this.slots.set(key, slot);
+    }
+    ensure(sameProducer(frame.producer, slot.producer), "stale_producer", "Stop the previous slot before replacing its epoch");
+    if (frame.kind === "response" || frame.kind === "cancel") {
+      if (slot.outgoing.has(frame.id)) {
+        const entry = slot.outgoing.get(frame.id);
+        if (entry.worker === slot.worker) slot.channel?.send({ type: "frame", frame: { ...frame, id: entry.id } });
+        if (frame.kind === "response") slot.outgoing.delete(frame.id);
+        return;
+      }
+    }
+    slot.peer.receive(frame);
+  }
+  createSlot(producer) {
+    const slot = {
+      producer: Object.freeze({ ...producer }),
+      source: null,
+      worker: null,
+      channel: null,
+      outgoing: /* @__PURE__ */ new Map(),
+      sequence: 0n,
+      failures: 0,
+      restarting: null,
+      health: "stopped",
+      busy: false,
+      surfaces: /* @__PURE__ */ new Map(),
+      reports: /* @__PURE__ */ new Map(),
+      subscriptions: /* @__PURE__ */ new Set(),
+      desired: false,
+      generation: 0,
+      bridge: null
+    };
+    slot.peer = new RpcPeer({
+      producer,
+      send: this.send,
+      onError: this.onDiagnostic,
+      onRequest: async (operation, options) => {
+        if (operation.op === "runner.ping") return { protocolVersion: RUNNER_PROTOCOL_VERSION, health: slot.health };
+        if (operation.op === "runner.diagnose") return { ...nodeDiagnostic(), health: slot.health, pluginId: producer.pluginId };
+        if (operation.op.startsWith("runtime.")) {
+          ensure(slot.bridge && slot.health === "running", "plugin_not_running", "Plugin worker is unavailable");
+          return slot.bridge.request(operation, options);
+        }
+        ensure(["runner.start", "runner.reload", "runner.stop"].includes(operation.op), "unsupported_operation", "Operation belongs to the daemon");
+        ensure(!slot.busy, "operation_in_progress", "Plugin lifecycle operation is in progress");
+        slot.busy = true;
+        try {
+          if (operation.op === "runner.stop") {
+            slot.desired = false;
+            clearTimeout(slot.restarting);
+            await this.stopWorker(slot);
+            setImmediate(() => {
+              if (!slot.busy && !slot.desired) {
+                slot.peer.dispose();
+                const key = `${producer.machineId}/${producer.pluginId}`;
+                if (this.slots.get(key) === slot) this.slots.delete(key);
+              }
+            });
+            return null;
+          }
+          if (operation.op === "runner.start") ensure(!slot.desired, "plugin_running", "Plugin is running");
+          if (operation.op === "runner.reload") ensure(
+            operation.args.linked === true || slot.source?.linked === true,
+            "invalid_source",
+            "Linked reload requires a linked source"
+          );
+          const prepared = await preparePlugin(operation.args);
+          ensure(prepared.manifest.id === producer.pluginId, "identity_mismatch", "Static plugin id differs from its runner slot");
+          ensure(!options.signal.aborted, "cancelled", "Plugin start was cancelled");
+          slot.desired = false;
+          clearTimeout(slot.restarting);
+          await this.stopWorker(slot);
+          ensure(!options.signal.aborted, "cancelled", "Plugin start was cancelled");
+          slot.source = { ...operation.args, root: prepared.root };
+          slot.manifest = prepared.manifest;
+          slot.failures = 0;
+          slot.desired = true;
+          await this.startWorker(slot, options.signal);
+          return { health: slot.health, manifestDigest: prepared.manifestDigest };
+        } finally {
+          slot.busy = false;
+        }
+      }
+    });
+    return slot;
+  }
+  async startWorker(slot, signal) {
+    ensure(!this.closed && slot.desired, "disposed", "Plugin start is no longer desired");
+    const diagnostic = nodeDiagnostic();
+    ensure(diagnostic.supported, "node_unsupported", diagnostic.message);
+    const generation = ++this.nextWorker;
+    const worker = new Worker(new URL("./worker.mjs", import.meta.url), {
+      workerData: { version: RUNNER_PROTOCOL_VERSION, source: slot.source, producer: slot.producer, generation },
+      env: { ...this.env, STANDARD_PLUGIN_SDK_URL: sdkUrl.href },
+      execArgv: ["--experimental-loader", fileURLToPath(loaderUrl)],
+      stdout: true,
+      stderr: true,
+      resourceLimits: { maxOldGenerationSizeMb: 128, maxYoungGenerationSizeMb: 32, stackSizeMb: 4 }
+    });
+    slot.worker = worker;
+    slot.generation = generation;
+    slot.health = "starting";
+    worker.stdout.resume();
+    worker.stderr.resume();
+    let settle;
+    let settled = false;
+    let startupTimer;
+    let abort;
+    const started = new Promise((resolve2, reject) => {
+      settle = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(startupTimer);
+        signal?.removeEventListener("abort", abort);
+        error ? reject(error) : resolve2();
+      };
+      abort = () => {
+        slot.desired = false;
+        settle(new PluginError("cancelled", "Plugin activation was cancelled"));
+        void this.stopWorker(slot).catch(this.onDiagnostic);
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      startupTimer = setTimeout(() => fail(new PluginError("timeout", "Plugin activation exceeded 30 seconds")), 3e4);
+    });
+    let failed = false;
+    const fail = (error) => {
+      if (failed || slot.worker !== worker || slot.stopping) return;
+      failed = true;
+      settle(error);
+      this.onDiagnostic(error);
+      void this.stopWorker(slot).then(() => {
+        if (slot.desired && !this.closed) {
+          slot.health = "backoff";
+          const delay = Math.min(6e4, 250 * 2 ** Math.min(slot.failures++, 8));
+          slot.restarting = setTimeout(() => {
+            slot.restarting = null;
+            if (slot.desired && !this.closed) void this.startWorker(slot).catch(this.onDiagnostic);
+          }, delay);
+        }
+      }).catch(this.onDiagnostic);
+    };
+    slot.channel = portChannel(worker, (message) => {
+      if (slot.worker !== worker) return;
+      switch (message.type) {
+        case "ready":
+          slot.health = "running";
+          settle();
+          return;
+        case "stopped":
+          slot.stopped?.();
+          return;
+        case "failure":
+          fail(new PluginError(message.error.code, message.error.message));
+          return;
+        case "diagnostic":
+          this.onDiagnostic(new PluginError(message.error.code, message.error.message));
+          return;
+        case "frame":
+          this.fromWorker(slot, worker, message.frame);
+          return;
+        default:
+          fail(new PluginError("invalid_payload", "Invalid worker message"));
+      }
+    }, fail);
+    slot.bridge = new RpcPeer({
+      producer: slot.producer,
+      send: (frame) => slot.channel.send({ type: "frame", frame }),
+      onError: fail
+    });
+    worker.on("error", fail);
+    worker.on("exit", (code) => fail(new PluginError("worker_exit", `Plugin worker exited with code ${code}`)));
+    if (signal?.aborted) abort();
+    return started;
+  }
+  fromWorker(slot, worker, frame) {
+    validateEnvelope(frame);
+    ensure(sameProducer(frame.producer, slot.producer), "stale_producer", "Worker changed its producer identity");
+    if (frame.kind === "response") {
+      slot.bridge.receive(frame);
+      return;
+    }
+    if (frame.kind === "cancel") {
+      const id = `worker-${slot.generation}-${frame.id}`;
+      if (slot.outgoing.delete(id)) this.send({ ...frame, id });
+      return;
+    }
+    if (frame.kind === "surface") {
+      ensure(
+        slot.manifest.capabilities.includes("surfaces") && slot.manifest.contributions.some((item) => item.id === frame.key.contributionId && item.anchor === frame.key.anchor),
+        "capability_denied",
+        "Worker published an undeclared surface"
+      );
+      const key = JSON.stringify(frame.key);
+      ensure(frame.content === null || slot.surfaces.has(key) || slot.surfaces.size < LIMITS.contributions, "queue_full", "Too many live surfaces");
+      if (frame.content === null) slot.surfaces.delete(key);
+      else slot.surfaces.set(key, frame.key);
+      this.send({ ...frame, sequence: String(++slot.sequence) });
+      return;
+    }
+    if (frame.kind === "report") {
+      ensure(slot.manifest.capabilities.includes("surfaces"), "capability_denied", "Worker cannot publish reports");
+      const key = JSON.stringify([frame.name, frame.entity]);
+      ensure(
+        frame.value === null || slot.reports.has(key) || slot.reports.size < LIMITS.contributions,
+        "queue_full",
+        "Too many live reports"
+      );
+      if (frame.value === null) slot.reports.delete(key);
+      else slot.reports.set(key, { name: frame.name, entity: frame.entity });
+      this.send({ ...frame, sequence: String(++slot.sequence) });
+      return;
+    }
+    try {
+      authorize(frame.operation, slot.manifest.capabilities);
+      if (frame.operation.op === "subscription.add") {
+        ensure(
+          slot.subscriptions.has(frame.operation.args.id) || slot.subscriptions.size < LIMITS.subscriptions,
+          "queue_full",
+          "Worker has too many subscriptions"
+        );
+        slot.subscriptions.add(frame.operation.args.id);
+      }
+      if (frame.operation.op === "subscription.remove") slot.subscriptions.delete(frame.operation.args.id);
+      ensure(slot.outgoing.size < LIMITS.pendingRequests, "queue_full", "Worker has too many pending requests");
+      const id = `worker-${slot.generation}-${frame.id}`;
+      ensure(!slot.outgoing.has(id), "duplicate_request", "Worker request id is in flight");
+      slot.outgoing.set(id, { worker, id: frame.id });
+      try {
+        this.send({ ...frame, id });
+      } catch (error) {
+        slot.outgoing.delete(id);
+        throw error;
+      }
+    } catch (error) {
+      slot.channel.send({ type: "frame", frame: {
+        version: RUNNER_PROTOCOL_VERSION,
+        producer: slot.producer,
+        kind: "response",
+        id: frame.id,
+        result: { ok: false, error: wireError(error) }
+      } });
+    }
+  }
+  async stopWorker(slot) {
+    if (slot.stopping) return slot.stopping;
+    const worker = slot.worker;
+    if (!worker) return;
+    slot.stopping = (async () => {
+      let timer;
+      await new Promise((resolve2) => {
+        slot.stopped = resolve2;
+        timer = setTimeout(resolve2, 1e3);
+        try {
+          slot.channel.send({ type: "stop" });
+        } catch {
+          resolve2();
+        }
+      });
+      clearTimeout(timer);
+      slot.stopped = null;
+      slot.worker = null;
+      slot.bridge?.dispose();
+      slot.bridge = null;
+      slot.channel?.dispose();
+      slot.channel = null;
+      await worker.terminate();
+      for (const id of slot.outgoing.keys()) {
+        try {
+          this.send({ version: RUNNER_PROTOCOL_VERSION, producer: slot.producer, kind: "cancel", id });
+        } catch (error) {
+          this.onDiagnostic(error);
+        }
+      }
+      slot.outgoing.clear();
+      await Promise.allSettled([...slot.subscriptions].map((id) => slot.peer.request(
+        { op: "subscription.remove", args: { id } },
+        { timeoutMs: 1e3 }
+      )));
+      slot.subscriptions.clear();
+      for (const key of slot.surfaces.values()) {
+        try {
+          this.send({
+            version: RUNNER_PROTOCOL_VERSION,
+            producer: slot.producer,
+            kind: "surface",
+            key,
+            sequence: String(++slot.sequence),
+            content: null
+          });
+        } catch (error) {
+          this.onDiagnostic(error);
+        }
+      }
+      slot.surfaces.clear();
+      for (const report of slot.reports.values()) {
+        try {
+          this.send({
+            version: RUNNER_PROTOCOL_VERSION,
+            producer: slot.producer,
+            kind: "report",
+            ...report,
+            sequence: String(++slot.sequence),
+            schemaVersion: 1,
+            value: null
+          });
+        } catch (error) {
+          this.onDiagnostic(error);
+        }
+      }
+      slot.reports.clear();
+      slot.health = "stopped";
+    })().finally(() => {
+      slot.stopping = null;
+    });
+    return slot.stopping;
+  }
+  async dispose() {
+    this.closed = true;
+    await Promise.all([...this.slots.values()].map(async (slot) => {
+      slot.desired = false;
+      clearTimeout(slot.restarting);
+      await this.stopWorker(slot);
+      slot.peer.dispose();
+    }));
+    this.slots.clear();
+  }
+};
+
+// src/index.mjs
+if (process.argv.includes("--doctor")) {
+  const diagnostic = nodeDiagnostic();
+  process.stdout.write(`${JSON.stringify(diagnostic)}
+`);
+  if (!diagnostic.supported) process.exitCode = 1;
+} else {
+  let stopping = false;
+  let supervisor;
+  const diagnostic = (error) => process.stderr.write(`${JSON.stringify(wireError(error))}
+`);
+  const fail = (error) => {
+    diagnostic(error);
+    process.exitCode = 1;
+    void shutdown();
+  };
+  const channel = stdioChannel(process.stdin, process.stdout, (frame) => supervisor.accept(frame), fail);
+  supervisor = new PluginSupervisor({ send: channel.send, onDiagnostic: diagnostic });
+  async function shutdown() {
+    if (stopping) return;
+    stopping = true;
+    process.stdin.pause();
+    try {
+      await supervisor.dispose();
+    } finally {
+      channel.dispose();
+      process.exit(process.exitCode ?? 0);
+    }
+  }
+  process.stdin.on("end", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+}