@buzzni/saycode-cli 0.6.0 → 0.7.0

package/channel-extension-host.mjs

@@ -0,0 +1,1349 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline";
+import { readFile } from "node:fs/promises";
+import { resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+const EXTENSION_ARTIFACT_ACTION_OPERATIONS = ["publishPublic"];
+const EXTENSION_ARTIFACT_SOURCE_TYPES = ["project-file", "personal-chat-file"];
+const ID_PATTERN$2 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const LOCALE_PATTERN$1 = /^[a-z]{2,3}(?:-[A-Z]{2})?$/;
+const EXTENSION_PATTERN = /^[a-z0-9]+$/;
+const MAX_ACTIONS = 32;
+const MAX_TITLE_CHARACTERS = 120;
+const MAX_LOCALES = 16;
+const MAX_EXTENSIONS = 16;
+function fail$4(path, detail) {
+  throw new Error(`${path}: ${detail}`);
+}
+function record$1(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail$4(path, "expected object");
+  return value;
+}
+function exactKeys$1(value, required, optional, path) {
+  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+  const unknown = Object.keys(value).find((key) => !allowed.has(key));
+  if (unknown) fail$4(path, `unknown field ${unknown}`);
+  const missing = required.find((key) => !(key in value));
+  if (missing) fail$4(path, `missing field ${missing}`);
+}
+function text$1(value, path) {
+  if (typeof value !== "string" || !value || value.trim() !== value) {
+    fail$4(path, "expected non-empty trimmed string");
+  }
+  return value;
+}
+function title(value, path) {
+  const parsed = text$1(value, path);
+  if ([...parsed].length > MAX_TITLE_CHARACTERS) fail$4(path, "title exceeds 120 characters");
+  return parsed;
+}
+function uniqueList(values, path) {
+  if (new Set(values).size !== values.length) fail$4(path, "duplicate value");
+  return values;
+}
+function parseLocalizations(value, path) {
+  const localizations = record$1(value, path);
+  if (Object.keys(localizations).length > MAX_LOCALES) fail$4(path, "too many locales");
+  return Object.fromEntries(Object.entries(localizations).map(([locale, raw]) => {
+    if (!LOCALE_PATTERN$1.test(locale)) fail$4(path, `invalid locale ${locale}`);
+    const localizationPath = `${path}.${locale}`;
+    const localization = record$1(raw, localizationPath);
+    exactKeys$1(localization, ["title"], [], localizationPath);
+    return [locale, { title: title(localization.title, `${localizationPath}.title`) }];
+  }));
+}
+function parseSourceTypes(value, path) {
+  if (!Array.isArray(value) || value.length === 0) fail$4(path, "expected non-empty array");
+  const parsed = value.map((sourceType, index) => {
+    if (!EXTENSION_ARTIFACT_SOURCE_TYPES.includes(sourceType)) {
+      fail$4(`${path}[${index}]`, "unsupported source type");
+    }
+    return sourceType;
+  });
+  return uniqueList(parsed, path);
+}
+function parseExtensions(value, path) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_EXTENSIONS) {
+    fail$4(path, "expected 1-16 extensions");
+  }
+  const parsed = value.map((extension, index) => {
+    if (typeof extension !== "string" || !EXTENSION_PATTERN.test(extension)) {
+      fail$4(`${path}[${index}]`, "expected lowercase extension without a dot");
+    }
+    return extension;
+  });
+  return uniqueList(parsed, path);
+}
+function parseExtensionArtifactActions(value, path = "manifest.contributes.artifactActions") {
+  if (!Array.isArray(value) || value.length > MAX_ACTIONS) fail$4(path, "expected at most 32 actions");
+  return value.map((raw, index) => {
+    const actionPath = `${path}[${index}]`;
+    const action = record$1(raw, actionPath);
+    exactKeys$1(action, ["id", "title", "operation", "when"], ["localizations"], actionPath);
+    const parsedId = text$1(action.id, `${actionPath}.id`);
+    if (!ID_PATTERN$2.test(parsedId) || parsedId.includes("..")) fail$4(`${actionPath}.id`, "invalid stable identifier");
+    if (!EXTENSION_ARTIFACT_ACTION_OPERATIONS.includes(action.operation)) {
+      fail$4(`${actionPath}.operation`, "unsupported operation");
+    }
+    const when = record$1(action.when, `${actionPath}.when`);
+    exactKeys$1(when, ["sourceTypes", "extensions"], [], `${actionPath}.when`);
+    return {
+      id: parsedId,
+      title: title(action.title, `${actionPath}.title`),
+      ...action.localizations === void 0 ? {} : { localizations: parseLocalizations(action.localizations, `${actionPath}.localizations`) },
+      operation: action.operation,
+      when: {
+        sourceTypes: parseSourceTypes(when.sourceTypes, `${actionPath}.when.sourceTypes`),
+        extensions: parseExtensions(when.extensions, `${actionPath}.when.extensions`)
+      }
+    };
+  });
+}
+const CHANNEL_API_VERSION = 1;
+const CHANNEL_MINIMUM_API_VERSION = 1;
+const CHANNEL_PROVIDERS = ["telegram", "slack", "discord"];
+const CHANNEL_COMMAND_SCHEMA = Object.freeze({
+  pair: Object.freeze(["code!"]),
+  projects: Object.freeze([]),
+  new: Object.freeze(["project!", "agent", "model", "effort"]),
+  use: Object.freeze(["session_id!"]),
+  prompt: Object.freeze(["text!"]),
+  status: Object.freeze([]),
+  stop: Object.freeze([]),
+  // No options, like `status` and `stop`. Declarable because a provider that registers commands
+  // ahead of time is where its users find them — leaving it out would mean Discord users could
+  // only reach `/clear` by typing it as a message, while every other command sits in the picker.
+  // `reset` is deliberately not here: Core carries it as an unlisted alias of the same intent, and
+  // registering both would put two identical entries in that picker.
+  clear: Object.freeze([])
+});
+const MAX_DESCRIPTION = 100;
+const ENTRY_KEYS$1 = /* @__PURE__ */ new Set(["id", "description", "options"]);
+const OPTION_KEYS = /* @__PURE__ */ new Set(["name", "description", "required"]);
+function fail$3(path, detail) {
+  throw new Error(`${path}: ${detail}`);
+}
+function hasControlCharacter(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+function description(value, path) {
+  if (typeof value !== "string" || value.trim().length === 0 || value.length > MAX_DESCRIPTION) {
+    fail$3(path, "invalid description");
+  }
+  if (hasControlCharacter(value)) fail$3(path, "invalid description");
+  return value;
+}
+function parseChannelCommandDeclarations(value, path) {
+  if (!Array.isArray(value)) fail$3(path, "expected array");
+  const names = Object.keys(CHANNEL_COMMAND_SCHEMA);
+  if (value.length === 0 || value.length > names.length) {
+    fail$3(path, `expected between 1 and ${names.length} commands`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return value.map((item, index) => {
+    const entryPath = `${path}[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) fail$3(entryPath, "expected object");
+    const source = item;
+    const extra = Object.keys(source).find((key) => !ENTRY_KEYS$1.has(key));
+    if (extra !== void 0) fail$3(entryPath, `unknown field ${extra}`);
+    const id2 = source.id;
+    if (typeof id2 !== "string" || !Object.prototype.hasOwnProperty.call(CHANNEL_COMMAND_SCHEMA, id2)) {
+      fail$3(`${entryPath}.id`, "unknown command");
+    }
+    if (seen.has(id2)) fail$3(path, `duplicate command ${id2}`);
+    seen.add(id2);
+    return {
+      id: id2,
+      description: description(source.description, `${entryPath}.description`),
+      options: parseOptions(source.options, `${entryPath}.options`, CHANNEL_COMMAND_SCHEMA[id2])
+    };
+  });
+}
+function parseOptions(value, path, expected) {
+  if (value === void 0) {
+    if (expected.length > 0) fail$3(path, `expected ${expected.length} options`);
+    return Object.freeze([]);
+  }
+  if (!Array.isArray(value)) fail$3(path, "expected array");
+  if (value.length !== expected.length) fail$3(path, `expected ${expected.length} options`);
+  return Object.freeze(value.map((item, index) => {
+    const optionPath = `${path}[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) fail$3(optionPath, "expected object");
+    const source = item;
+    const extra = Object.keys(source).find((key) => !OPTION_KEYS.has(key));
+    if (extra !== void 0) fail$3(optionPath, `unknown field ${extra}`);
+    const spec = expected[index];
+    const required = spec.endsWith("!");
+    const name = required ? spec.slice(0, -1) : spec;
+    if (source.name !== name) fail$3(`${optionPath}.name`, `expected ${name}`);
+    if (source.required !== required) fail$3(`${optionPath}.required`, `expected ${required}`);
+    return Object.freeze({
+      name,
+      required,
+      description: description(source.description, `${optionPath}.description`)
+    });
+  }));
+}
+const MAX_CHANNEL_CONTRIBUTIONS = CHANNEL_PROVIDERS.length;
+const ID_PATTERN$1 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const ENTRY_KEYS = /* @__PURE__ */ new Set(["id", "provider", "commands"]);
+function fail$2(path, detail) {
+  throw new Error(`${path}: ${detail}`);
+}
+function parseExtensionChannelContributions(value) {
+  if (!Array.isArray(value)) fail$2("manifest.contributes.channels", "expected array");
+  if (value.length === 0 || value.length > MAX_CHANNEL_CONTRIBUTIONS) {
+    fail$2("manifest.contributes.channels", `expected between 1 and ${MAX_CHANNEL_CONTRIBUTIONS} adapters`);
+  }
+  const providers = /* @__PURE__ */ new Set();
+  return value.map((item, index) => {
+    const path = `manifest.contributes.channels[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) fail$2(path, "expected object");
+    const source = item;
+    const extra = Object.keys(source).find((key) => !ENTRY_KEYS.has(key));
+    if (extra !== void 0) fail$2(path, `unknown field ${extra}`);
+    const id2 = source.id;
+    if (typeof id2 !== "string" || !ID_PATTERN$1.test(id2) || id2.includes("..")) {
+      fail$2(`${path}.id`, "invalid identifier");
+    }
+    const provider = source.provider;
+    if (typeof provider !== "string" || !CHANNEL_PROVIDERS.includes(provider)) {
+      fail$2(`${path}.provider`, "unsupported provider");
+    }
+    if (providers.has(provider)) fail$2("manifest.contributes.channels", "duplicate provider");
+    providers.add(provider);
+    const commands = source.commands === void 0 ? void 0 : parseChannelCommandDeclarations(source.commands, `${path}.commands`);
+    return {
+      id: id2,
+      provider,
+      ...commands ? { commands } : {}
+    };
+  });
+}
+const EXTENSION_PERMISSIONS = [
+  "projects.read",
+  "remoteFiles.read",
+  "remoteFiles.write",
+  "machine.execute",
+  "network.fetch",
+  "notifications.show",
+  "storage.read",
+  "storage.write",
+  "browserViewer.open",
+  "browserViewer.install",
+  "browserViewer.installChrome",
+  "artifacts.publishPublic",
+  // One permission per channel wire method (`src/domain/channelProtocol.ts`), deliberately not a
+  // single adapter grant. Receiving and acking messages is transport work; reading a session,
+  // driving it, or approving a tool call once are three larger and separately-refusable
+  // authorities, and a blanket permission would hand all of them to anything that could merely
+  // read a message. Declaring one here only makes it askable — every call is still checked
+  // against the live grant at dispatch.
+  "channels.receive",
+  "channels.ack",
+  "channels.send",
+  "channels.transport",
+  "sessions.read",
+  "sessions.control",
+  "sessions.approveOnce"
+];
+const SAYCODE_EXTENSION_API_VERSION = 3;
+const SAYCODE_EXTENSION_MINIMUM_API_VERSION = 2;
+const MAX_EXTENSION_API_WINDOW_WIDTH = 2;
+const SAYCODE_EXTENSION_ENGINE_VERSION = "1.0.0";
+const SAYCODE_CHANNEL_API_VERSION = CHANNEL_API_VERSION;
+const SAYCODE_CHANNEL_MINIMUM_API_VERSION = CHANNEL_MINIMUM_API_VERSION;
+class UnsupportedChannelApiVersionError extends Error {
+  constructor(channelApiVersion) {
+    super(`manifest.channelApiVersion: channel API version ${String(channelApiVersion)} is unsupported; Desktop supports ${String(SAYCODE_CHANNEL_API_VERSION)}`);
+    this.channelApiVersion = channelApiVersion;
+  }
+  name = "UnsupportedChannelApiVersionError";
+}
+class UnsupportedExtensionApiVersionError extends Error {
+  constructor(apiVersion, minimumSupportedApiVersion, supportedApiVersion) {
+    super(`manifest.apiVersion: Extension API version ${String(apiVersion)} is unsupported; Desktop supports ${minimumSupportedApiVersion === supportedApiVersion ? String(supportedApiVersion) : `${minimumSupportedApiVersion}-${supportedApiVersion}`}`);
+    this.apiVersion = apiVersion;
+    this.minimumSupportedApiVersion = minimumSupportedApiVersion;
+    this.supportedApiVersion = supportedApiVersion;
+  }
+  name = "UnsupportedExtensionApiVersionError";
+}
+const ID_PATTERN = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const ENGINE_RANGE_PATTERN = /^(?:\^|~|>=|<=|>|<)?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const ENTRYPOINT_PATTERN = /\.(?:cjs|mjs|js)$/;
+const LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Z]{2})?$/;
+const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["commands", "settings", "panels", "projectTemplates", "machineActions", "artifactActions", "channels"]);
+const V2_PERMISSIONS = /* @__PURE__ */ new Set([
+  "browserViewer.open",
+  "browserViewer.install",
+  "browserViewer.installChrome"
+]);
+const V3_PERMISSIONS = /* @__PURE__ */ new Set(["artifacts.publishPublic"]);
+const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
+  "channels.receive",
+  "channels.ack",
+  "channels.send",
+  "channels.transport",
+  "sessions.read",
+  "sessions.control",
+  "sessions.approveOnce"
+]);
+const TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "version",
+  "apiVersion",
+  "channelApiVersion",
+  "engines",
+  "entrypoint",
+  "permissions",
+  "activationEvents",
+  "contributes"
+]);
+function semver(value) {
+  const [major, minor, patch] = value.split(/[+-]/, 1)[0].split(".").map(Number);
+  return [major ?? 0, minor ?? 0, patch ?? 0];
+}
+function compareSemver(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    const difference = left[index] - right[index];
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function engineSupports(range, version) {
+  const operator = range.match(/^(\^|~|>=|<=|>|<)/)?.[0] ?? "";
+  const base = semver(range.slice(operator.length));
+  const candidate = semver(version);
+  const compared = compareSemver(candidate, base);
+  if (operator === "^") {
+    if (compared < 0 || candidate[0] !== base[0]) return false;
+    if (base[0] > 0) return true;
+    if (candidate[1] !== base[1]) return false;
+    return base[1] > 0 || candidate[2] === base[2];
+  }
+  if (operator === "~") return candidate[0] === base[0] && candidate[1] === base[1] && compared >= 0;
+  if (operator === ">=") return compared >= 0;
+  if (operator === "<=") return compared <= 0;
+  if (operator === ">") return compared > 0;
+  if (operator === "<") return compared < 0;
+  return compared === 0;
+}
+function fail$1(path, detail) {
+  throw new Error(`${path}: ${detail}`);
+}
+function parseApiVersion(value, options) {
+  const current = options.supportedApiVersion;
+  const floor = options.minimumSupportedApiVersion ?? current;
+  if (floor > current || current - floor + 1 > MAX_EXTENSION_API_WINDOW_WIDTH) {
+    fail$1(
+      "manifest.apiVersion",
+      `invalid Desktop API support window [${floor}, ${current}]`
+    );
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < floor || value > current) {
+    throw new UnsupportedExtensionApiVersionError(value, floor, current);
+  }
+  return value;
+}
+function record(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail$1(path, "expected object");
+  return value;
+}
+function string(value, path) {
+  if (typeof value !== "string" || value.trim() !== value || value.length === 0) {
+    fail$1(path, "expected non-empty trimmed string");
+  }
+  return value;
+}
+function id(value, path) {
+  const parsed = string(value, path);
+  if (!ID_PATTERN.test(parsed) || parsed.includes("..")) fail$1(path, "invalid stable identifier");
+  return parsed;
+}
+function relativePath(value, path, requireScript = false) {
+  const parsed = string(value, path);
+  const segments = parsed.split("/");
+  if (parsed.startsWith("/") || parsed.includes("\\") || segments.some((segment) => segment === "" || segment === "." || segment === "..") || requireScript && !ENTRYPOINT_PATTERN.test(parsed)) {
+    fail$1(path, "expected safe relative path");
+  }
+  return parsed;
+}
+function array(value, path) {
+  if (!Array.isArray(value)) fail$1(path, "expected array");
+  return value;
+}
+function assertOnlyKeys(value, allowed, path) {
+  const unknown = Object.keys(value).find((key) => !allowed.has(key));
+  if (unknown) fail$1(path, `unknown field ${unknown}`);
+}
+function contributionList(value, path, allowedKeys, parse) {
+  return array(value, path).map((raw, index) => {
+    const entryPath = `${path}[${index}]`;
+    const entry = record(raw, entryPath);
+    assertOnlyKeys(entry, new Set(allowedKeys), entryPath);
+    return parse(entry, entryPath);
+  });
+}
+function parseChannelApiVersion(value, apiVersion) {
+  if (value === void 0) return void 0;
+  if (apiVersion < 3) fail$1("manifest.channelApiVersion", "requires Extension API version 3");
+  if (typeof value !== "number" || !Number.isInteger(value) || value < SAYCODE_CHANNEL_MINIMUM_API_VERSION || value > SAYCODE_CHANNEL_API_VERSION) throw new UnsupportedChannelApiVersionError(value);
+  return value;
+}
+function parseContributions(value, apiVersion, channelApiVersion) {
+  const parsed = record(value, "manifest.contributes");
+  assertOnlyKeys(parsed, CONTRIBUTION_KEYS, "manifest.contributes");
+  if (parsed.channels !== void 0) {
+    if (apiVersion < 3) fail$1("manifest.contributes.channels", "requires Extension API version 3");
+    if (channelApiVersion === void 0) {
+      fail$1("manifest.contributes.channels", "requires manifest.channelApiVersion");
+    }
+  }
+  if (apiVersion < 2 && parsed.machineActions !== void 0) {
+    fail$1("manifest.contributes.machineActions", "requires Extension API version 2");
+  }
+  if (apiVersion < 3 && parsed.artifactActions !== void 0) {
+    fail$1("manifest.contributes.artifactActions", "requires Extension API version 3");
+  }
+  const result = {};
+  if (parsed.commands !== void 0) {
+    result.commands = contributionList(
+      parsed.commands,
+      "manifest.contributes.commands",
+      ["id", "title", "panelId"],
+      (entry, path) => ({
+        id: id(entry.id, `${path}.id`),
+        title: string(entry.title, `${path}.title`),
+        ...entry.panelId === void 0 ? {} : { panelId: id(entry.panelId, `${path}.panelId`) }
+      })
+    );
+  }
+  if (parsed.settings !== void 0) {
+    result.settings = contributionList(
+      parsed.settings,
+      "manifest.contributes.settings",
+      ["id", "title", "type"],
+      (entry, path) => {
+        const type = string(entry.type, `${path}.type`);
+        if (type !== "boolean" && type !== "number" && type !== "string") {
+          fail$1(`${path}.type`, "unsupported setting type");
+        }
+        return { id: id(entry.id, `${path}.id`), title: string(entry.title, `${path}.title`), type };
+      }
+    );
+  }
+  if (parsed.panels !== void 0) {
+    result.panels = contributionList(
+      parsed.panels,
+      "manifest.contributes.panels",
+      ["id", "title", "entrypoint"],
+      (entry, path) => ({
+        id: id(entry.id, `${path}.id`),
+        title: string(entry.title, `${path}.title`),
+        entrypoint: relativePath(entry.entrypoint, `${path}.entrypoint`)
+      })
+    );
+  }
+  if (parsed.projectTemplates !== void 0) {
+    result.projectTemplates = contributionList(
+      parsed.projectTemplates,
+      "manifest.contributes.projectTemplates",
+      [
+        "id",
+        "title",
+        "description",
+        "stack",
+        "firstPrompt",
+        "devServerCommand",
+        "assetsRoot",
+        "localizations"
+      ],
+      (entry, path) => {
+        let localizations;
+        if (entry.localizations !== void 0) {
+          const rawLocalizations = record(entry.localizations, `${path}.localizations`);
+          localizations = {};
+          for (const [locale, rawLocalization] of Object.entries(rawLocalizations)) {
+            if (!LOCALE_PATTERN.test(locale)) fail$1(`${path}.localizations`, `invalid locale ${locale}`);
+            const localizationPath = `${path}.localizations.${locale}`;
+            const localization = record(rawLocalization, localizationPath);
+            assertOnlyKeys(
+              localization,
+              /* @__PURE__ */ new Set(["title", "description", "firstPrompt"]),
+              localizationPath
+            );
+            localizations[locale] = {
+              ...localization.title === void 0 ? {} : { title: string(localization.title, `${localizationPath}.title`) },
+              ...localization.description === void 0 ? {} : { description: string(localization.description, `${localizationPath}.description`) },
+              ...localization.firstPrompt === void 0 ? {} : { firstPrompt: string(localization.firstPrompt, `${localizationPath}.firstPrompt`) }
+            };
+          }
+        }
+        return {
+          id: id(entry.id, `${path}.id`),
+          title: string(entry.title, `${path}.title`),
+          assetsRoot: relativePath(entry.assetsRoot, `${path}.assetsRoot`),
+          ...entry.description === void 0 ? {} : { description: string(entry.description, `${path}.description`) },
+          ...entry.stack === void 0 ? {} : { stack: string(entry.stack, `${path}.stack`) },
+          ...entry.firstPrompt === void 0 ? {} : { firstPrompt: string(entry.firstPrompt, `${path}.firstPrompt`) },
+          ...entry.devServerCommand === void 0 ? {} : { devServerCommand: string(entry.devServerCommand, `${path}.devServerCommand`) },
+          ...localizations === void 0 ? {} : { localizations }
+        };
+      }
+    );
+  }
+  if (parsed.machineActions !== void 0) {
+    result.machineActions = contributionList(
+      parsed.machineActions,
+      "manifest.contributes.machineActions",
+      ["id", "title", "command", "when"],
+      (entry, path) => {
+        const when = record(entry.when, `${path}.when`);
+        assertOnlyKeys(when, /* @__PURE__ */ new Set(["online"]), `${path}.when`);
+        if (when.online !== true) fail$1(`${path}.when.online`, "expected true");
+        return {
+          id: id(entry.id, `${path}.id`),
+          title: string(entry.title, `${path}.title`),
+          command: id(entry.command, `${path}.command`),
+          when: { online: true }
+        };
+      }
+    );
+  }
+  if (parsed.artifactActions !== void 0) {
+    result.artifactActions = parseExtensionArtifactActions(parsed.artifactActions);
+  }
+  if (parsed.channels !== void 0) {
+    result.channels = parseExtensionChannelContributions(parsed.channels);
+  }
+  const ids = [
+    ...result.commands ?? [],
+    ...result.settings ?? [],
+    ...result.panels ?? [],
+    ...result.projectTemplates ?? [],
+    ...result.machineActions ?? [],
+    ...result.artifactActions ?? [],
+    ...result.channels ?? []
+  ].map((entry) => entry.id);
+  if (new Set(ids).size !== ids.length) fail$1("manifest.contributes", "duplicate contribution id");
+  return result;
+}
+function parseExtensionManifest(value, options) {
+  const manifest = record(value, "manifest");
+  assertOnlyKeys(manifest, TOP_LEVEL_KEYS, "manifest");
+  const parsedId = id(manifest.id, "manifest.id");
+  const version = string(manifest.version, "manifest.version");
+  if (!SEMVER_PATTERN.test(version)) fail$1("manifest.version", "expected semantic version");
+  const apiVersion = parseApiVersion(manifest.apiVersion, options);
+  const channelApiVersion = parseChannelApiVersion(manifest.channelApiVersion, apiVersion);
+  const engines = record(manifest.engines, "manifest.engines");
+  assertOnlyKeys(engines, /* @__PURE__ */ new Set(["saycode"]), "manifest.engines");
+  const saycodeEngine = string(engines.saycode, "manifest.engines.saycode");
+  if (!ENGINE_RANGE_PATTERN.test(saycodeEngine)) {
+    fail$1("manifest.engines.saycode", "expected simple semantic version range");
+  }
+  if (options.saycodeVersion && !engineSupports(saycodeEngine, options.saycodeVersion)) {
+    fail$1(
+      "manifest.engines.saycode",
+      `extension requires Saycode ${saycodeEngine}, but Desktop provides ${options.saycodeVersion}`
+    );
+  }
+  const permissions = array(manifest.permissions, "manifest.permissions").map((permission, index) => {
+    const parsed = string(permission, `manifest.permissions[${index}]`);
+    if (!EXTENSION_PERMISSIONS.includes(parsed)) {
+      fail$1("manifest.permissions", `unknown permission ${parsed}`);
+    }
+    const typed = parsed;
+    if (apiVersion < 2 && V2_PERMISSIONS.has(typed)) {
+      fail$1(`manifest.permissions[${index}]`, "requires Extension API version 2");
+    }
+    if (apiVersion < 3 && V3_PERMISSIONS.has(typed)) {
+      fail$1(`manifest.permissions[${index}]`, "requires Extension API version 3");
+    }
+    if (CHANNEL_PERMISSIONS.has(typed)) {
+      if (apiVersion < 3) fail$1(`manifest.permissions[${index}]`, "requires Extension API version 3");
+      if (channelApiVersion === void 0) {
+        fail$1(`manifest.permissions[${index}]`, "requires manifest.channelApiVersion");
+      }
+    }
+    return typed;
+  });
+  if (new Set(permissions).size !== permissions.length) {
+    fail$1("manifest.permissions", "duplicate permission");
+  }
+  const activationEvents = array(manifest.activationEvents, "manifest.activationEvents").map(
+    (event, index) => string(event, `manifest.activationEvents[${index}]`)
+  );
+  const contributes = parseContributions(manifest.contributes, apiVersion, channelApiVersion);
+  if (contributes.channels?.length && !permissions.includes("channels.receive")) {
+    fail$1("manifest.contributes.channels", "requires channels.receive permission");
+  }
+  const strandedChannelPermission = permissions.find((permission) => CHANNEL_PERMISSIONS.has(permission));
+  if (strandedChannelPermission !== void 0 && contributes.channels === void 0) {
+    fail$1("manifest.permissions", `${strandedChannelPermission} requires a channels contribution`);
+  }
+  for (const [index, channel] of (contributes.channels ?? []).entries()) {
+    if (!channel.id.startsWith(`${parsedId}.`)) {
+      fail$1(
+        `manifest.contributes.channels[${index}].id`,
+        "expected an id declared by the same extension"
+      );
+    }
+  }
+  if (contributes.artifactActions?.length && !permissions.includes("artifacts.publishPublic")) {
+    fail$1("manifest.contributes.artifactActions", "requires artifacts.publishPublic permission");
+  }
+  for (const [index, action] of (contributes.artifactActions ?? []).entries()) {
+    if (!action.id.startsWith(`${parsedId}.`)) {
+      fail$1(
+        `manifest.contributes.artifactActions[${index}].id`,
+        "expected an id declared by the same extension"
+      );
+    }
+  }
+  const panelIds = new Set((contributes.panels ?? []).map((panel) => panel.id));
+  for (const [index, command] of (contributes.commands ?? []).entries()) {
+    if (command.panelId !== void 0 && (!command.panelId.startsWith(`${parsedId}.`) || !panelIds.has(command.panelId))) {
+      fail$1(
+        `manifest.contributes.commands[${index}].panelId`,
+        "expected a panel declared by the same extension"
+      );
+    }
+  }
+  const commandIds = new Set((contributes.commands ?? []).map((command) => command.id));
+  for (const [index, action] of (contributes.machineActions ?? []).entries()) {
+    if (!action.id.startsWith(`${parsedId}.`) || !action.command.startsWith(`${parsedId}.`) || !commandIds.has(action.command)) {
+      fail$1(
+        `manifest.contributes.machineActions[${index}].id/command`,
+        "expected ids declared by the same extension"
+      );
+    }
+  }
+  return {
+    id: parsedId,
+    version,
+    apiVersion,
+    ...channelApiVersion === void 0 ? {} : { channelApiVersion },
+    engines: { saycode: saycodeEngine },
+    entrypoint: relativePath(manifest.entrypoint, "manifest.entrypoint", true),
+    permissions,
+    activationEvents,
+    contributes
+  };
+}
+function fail(detail) {
+  throw new Error(`extension wire message must be JSON-serializable: ${detail}`);
+}
+function plainRecord(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail(`${path} must be an object`);
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) fail(`${path} must be a plain object`);
+  return value;
+}
+function text(value, path) {
+  if (typeof value !== "string" || value.length === 0) fail(`${path} must be a non-empty string`);
+  return value;
+}
+function exactKeys(value, keys, path) {
+  const allowed = new Set(keys);
+  const unknown = Object.keys(value).find((key) => !allowed.has(key));
+  if (unknown) fail(`${path} contains unknown field ${unknown}`);
+  const missing = keys.find((key) => !(key in value));
+  if (missing) fail(`${path} is missing ${missing}`);
+}
+const MAX_CHANNEL_NATIVE_PAYLOAD_BYTES = 4096;
+function parseChannelReplyFormatResult(value, request) {
+  const result = plainRecord(value, "channel format result");
+  const permitted = request.approval ? ["chunks", "blocks", "components"] : ["chunks"];
+  const unexpected = Object.keys(result).find((key) => !permitted.includes(key));
+  if (unexpected) fail(`channel format result contains unknown field ${unexpected}`);
+  if (!("chunks" in result)) fail("channel format result is missing chunks");
+  if (!Array.isArray(result.chunks) || result.chunks.length < 1 || result.chunks.length > request.maxChunks) {
+    fail("invalid channel chunk count");
+  }
+  const chunks = result.chunks.map((chunk) => {
+    const part = text(chunk, "channel chunk");
+    if (part.length > request.maxChunkUtf16Units || /[\uD800-\uDFFF]/.test(part.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, ""))) fail("invalid channel chunk");
+    return part;
+  });
+  if (chunks.join("") !== request.text) fail("channel chunks differ from approved reply");
+  const blocks = result.blocks === void 0 ? void 0 : asArray(result.blocks, "channel blocks");
+  const components = result.components === void 0 ? void 0 : asArray(result.components, "channel components");
+  if (blocks && components) fail("a reply may carry one provider payload, not both");
+  for (const payload of [blocks, components]) {
+    if (payload && new TextEncoder().encode(JSON.stringify(payload)).length > MAX_CHANNEL_NATIVE_PAYLOAD_BYTES) {
+      fail("channel provider payload exceeds its size budget");
+    }
+  }
+  return {
+    chunks,
+    ...blocks ? { blocks } : {},
+    ...components ? { components } : {}
+  };
+}
+function asArray(value, detail) {
+  if (!Array.isArray(value)) fail(`invalid ${detail}`);
+  return value;
+}
+function parseChannelApprovalRequest(value) {
+  const approval = plainRecord(value, "request.params.approval");
+  exactKeys(approval, ["approvalHandle", "approveLabel", "denyLabel"], "request.params.approval");
+  const approvalHandle = text(approval.approvalHandle, "request.params.approval.approvalHandle");
+  const approveLabel = text(approval.approveLabel, "request.params.approval.approveLabel");
+  const denyLabel = text(approval.denyLabel, "request.params.approval.denyLabel");
+  if (approvalHandle.length > 80 || approveLabel.length > 75 || denyLabel.length > 75) {
+    fail("invalid channel approval bounds");
+  }
+  return { approvalHandle, approveLabel, denyLabel };
+}
+function finiteNumber(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) fail(`${path} must be a finite number`);
+  return value;
+}
+function jsonValue(value, path, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return finiteNumber(value, path);
+  if (typeof value !== "object") fail(`${path} contains ${typeof value}`);
+  if (ancestors.has(value)) fail(`${path} contains a cycle`);
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((item, index) => jsonValue(item, `${path}[${index}]`, ancestors));
+    const source = plainRecord(value, path);
+    const result = {};
+    for (const [key, item] of Object.entries(source)) {
+      result[key] = jsonValue(item, `${path}.${key}`, ancestors);
+    }
+    return result;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function parseRequest(message) {
+  exactKeys(message, ["kind", "id", "method", "params"], "request");
+  const id2 = text(message.id, "request.id");
+  const method = text(message.method, "request.method");
+  const params = plainRecord(message.params, "request.params");
+  switch (method) {
+    case "handshake":
+      exactKeys(params, ["apiVersion", "extensionId", "extensionVersion"], "request.params");
+      return {
+        kind: "request",
+        id: id2,
+        method,
+        params: {
+          apiVersion: finiteNumber(params.apiVersion, "request.params.apiVersion"),
+          extensionId: text(params.extensionId, "request.params.extensionId"),
+          extensionVersion: text(params.extensionVersion, "request.params.extensionVersion")
+        }
+      };
+    case "activate":
+      exactKeys(params, ["activationEvent"], "request.params");
+      return {
+        kind: "request",
+        id: id2,
+        method,
+        params: { activationEvent: text(params.activationEvent, "request.params.activationEvent") }
+      };
+    case "deactivate":
+      exactKeys(params, ["reason"], "request.params");
+      return { kind: "request", id: id2, method, params: { reason: text(params.reason, "request.params.reason") } };
+    case "channel.lifecycle": {
+      exactKeys(params, ["apiVersion", "channelId", "state", "connectionId", "provider", "connectionRevision"], "request.params");
+      if (params.apiVersion !== 1 || params.state !== "start" && params.state !== "stop" || !["telegram", "slack", "discord"].includes(String(params.provider)) || !Number.isSafeInteger(params.connectionRevision) || Number(params.connectionRevision) < 1) fail("invalid channel lifecycle");
+      const channelId = text(params.channelId, "request.params.channelId");
+      const connectionId = text(params.connectionId, "request.params.connectionId");
+      if (channelId.length > 200 || connectionId.length > 200) fail("channel lifecycle identifier too long");
+      return { kind: "request", id: id2, method, params: {
+        apiVersion: 1,
+        channelId,
+        connectionId,
+        state: params.state,
+        provider: params.provider,
+        connectionRevision: Number(params.connectionRevision)
+      } };
+    }
+    case "channel.formatReply": {
+      const formatKeys = [
+        "apiVersion",
+        "channelId",
+        "connectionId",
+        "provider",
+        "connectionRevision",
+        "requestId",
+        "kind",
+        "text",
+        "maxChunkUtf16Units",
+        "maxChunks"
+      ];
+      exactKeys(
+        params,
+        "approval" in params ? [...formatKeys, "approval"] : formatKeys,
+        "request.params"
+      );
+      const lifecycle = parseRequest({ kind: "request", id: id2, method: "channel.lifecycle", params: {
+        apiVersion: params.apiVersion,
+        channelId: params.channelId,
+        connectionId: params.connectionId,
+        provider: params.provider,
+        connectionRevision: params.connectionRevision,
+        state: "start"
+      } });
+      if (lifecycle.method !== "channel.lifecycle") fail("invalid channel formatter");
+      const requestId = text(params.requestId, "request.params.requestId");
+      const body = text(params.text, "request.params.text");
+      if (requestId.length > 200 || new TextEncoder().encode(body).length > 65536 || params.kind !== "final" && params.kind !== "status" && params.kind !== "approval" || !Number.isSafeInteger(params.maxChunks) || Number(params.maxChunks) < 1 || Number(params.maxChunks) > 64 || !Number.isSafeInteger(params.maxChunkUtf16Units) || Number(params.maxChunkUtf16Units) < 1 || Number(params.maxChunkUtf16Units) > 65536) fail("invalid channel format bounds");
+      if (params.approval !== void 0 !== (params.kind === "approval")) {
+        fail("invalid channel approval request");
+      }
+      const approval = params.approval === void 0 ? void 0 : parseChannelApprovalRequest(params.approval);
+      const { state: _state, ...identity } = lifecycle.params;
+      return { kind: "request", id: id2, method, params: {
+        ...identity,
+        requestId,
+        text: body,
+        kind: params.kind,
+        maxChunks: Number(params.maxChunks),
+        maxChunkUtf16Units: Number(params.maxChunkUtf16Units),
+        ...approval ? { approval } : {}
+      } };
+    }
+    case "invokeCommand": {
+      exactKeys(params, ["commandId", "args"], "request.params");
+      if (!Array.isArray(params.args)) fail("request.params.args must be an array");
+      return {
+        kind: "request",
+        id: id2,
+        method,
+        params: {
+          commandId: text(params.commandId, "request.params.commandId"),
+          args: params.args.map((item, index) => jsonValue(item, `request.params.args[${index}]`))
+        }
+      };
+    }
+    case "capability.invoke": {
+      exactKeys(params, ["permission", "action", "args"], "request.params");
+      const permission = text(params.permission, "request.params.permission");
+      if (!EXTENSION_PERMISSIONS.includes(permission)) {
+        fail(`request.params.permission is unknown permission ${permission}`);
+      }
+      return {
+        kind: "request",
+        id: id2,
+        method,
+        params: {
+          permission,
+          action: text(params.action, "request.params.action"),
+          args: jsonValue(params.args, "request.params.args")
+        }
+      };
+    }
+    default:
+      throw new Error(`unknown request method: ${method}`);
+  }
+}
+function parseResponse(message) {
+  const id2 = text(message.id, "response.id");
+  if (message.ok === true) {
+    exactKeys(message, ["kind", "id", "ok", "result"], "response");
+    return { kind: "response", id: id2, ok: true, result: jsonValue(message.result, "response.result") };
+  }
+  if (message.ok === false) {
+    exactKeys(message, ["kind", "id", "ok", "error"], "response");
+    const error = plainRecord(message.error, "response.error");
+    exactKeys(error, ["code", "message"], "response.error");
+    return {
+      kind: "response",
+      id: id2,
+      ok: false,
+      error: { code: text(error.code, "response.error.code"), message: text(error.message, "response.error.message") }
+    };
+  }
+  fail("response.ok must be boolean");
+}
+function parseEvent(message) {
+  exactKeys(message, ["kind", "event", "payload"], "event");
+  const event = text(message.event, "event.event");
+  const payload = plainRecord(message.payload, "event.payload");
+  if (event === "ready") {
+    exactKeys(payload, ["apiVersion"], "event.payload");
+    return { kind: "event", event, payload: { apiVersion: finiteNumber(payload.apiVersion, "event.payload.apiVersion") } };
+  }
+  if (event === "log") {
+    exactKeys(payload, ["level", "message"], "event.payload");
+    const level = text(payload.level, "event.payload.level");
+    if (level !== "debug" && level !== "info" && level !== "warn" && level !== "error") {
+      fail("event.payload.level is unsupported");
+    }
+    return { kind: "event", event, payload: { level, message: text(payload.message, "event.payload.message") } };
+  }
+  if (event === "contributionsChanged") {
+    exactKeys(payload, [], "event.payload");
+    return { kind: "event", event, payload: {} };
+  }
+  fail(`unknown event ${event}`);
+}
+function parseExtensionWireMessage(value) {
+  const message = plainRecord(value, "message");
+  if (message.kind === "request") return parseRequest(message);
+  if (message.kind === "response") return parseResponse(message);
+  if (message.kind === "event") return parseEvent(message);
+  fail("message.kind is unknown");
+}
+const TIMEOUT = Symbol("extension-request-timeout");
+function requestEnvelope(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record2 = value;
+  if (record2.kind !== "request" || typeof record2.id !== "string" || typeof record2.method !== "string") return null;
+  if (!record2.id || !record2.method) return null;
+  return { id: record2.id, method: record2.method };
+}
+function responseId(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record2 = value;
+  if (record2.kind !== "response" || typeof record2.id !== "string" || !record2.id) return null;
+  return record2.id;
+}
+class ExtensionHostRuntime {
+  constructor(options) {
+    this.options = options;
+  }
+  channelHandlers = /* @__PURE__ */ new Map();
+  channelFormatters = /* @__PURE__ */ new Map();
+  channelStates = /* @__PURE__ */ new Map();
+  channelCalls = /* @__PURE__ */ new Map();
+  channelEpoch = 0;
+  deactivating = false;
+  active = false;
+  disposed = false;
+  handshaken = false;
+  inFlight = 0;
+  activating = false;
+  activation = null;
+  module = null;
+  commandHandlers = /* @__PURE__ */ new Map();
+  ongoingRequestIds = /* @__PURE__ */ new Set();
+  respondedIds = /* @__PURE__ */ new Set();
+  pendingCapabilityRequests = /* @__PURE__ */ new Map();
+  capabilityRequestSeq = 0;
+  /** Lets the loaded extension module ask Desktop to run a capability on its behalf. */
+  invokeCapability(permission, action, args) {
+    if (this.disposed) return Promise.reject(new Error("extension host is disposed"));
+    if (!this.handshaken) return Promise.reject(new Error("capability invoke requires a completed handshake"));
+    if (!this.active && !this.activating) {
+      return Promise.reject(new Error("capability invoke requires an active extension"));
+    }
+    const id2 = `capability:${this.options.manifest.id}:${++this.capabilityRequestSeq}`;
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingCapabilityRequests.delete(id2);
+        reject(new Error(`capability.invoke ${permission}/${action} timed out`));
+      }, this.options.requestTimeoutMs ?? 5e3);
+      this.pendingCapabilityRequests.set(id2, {
+        resolve: (result) => {
+          clearTimeout(timer);
+          resolve2(result);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+      try {
+        this.options.send({ kind: "request", id: id2, method: "capability.invoke", params: { permission, action, args } });
+      } catch (error) {
+        this.pendingCapabilityRequests.delete(id2);
+        clearTimeout(timer);
+        reject(error instanceof Error ? error : new Error("capability.invoke request could not be sent"));
+      }
+    });
+  }
+  start() {
+    if (this.disposed) throw new Error("extension host is disposed");
+    this.options.send({
+      kind: "event",
+      event: "ready",
+      payload: { apiVersion: this.options.manifest.apiVersion }
+    });
+  }
+  async receive(value) {
+    const pendingId = responseId(value);
+    if (pendingId && this.pendingCapabilityRequests.has(pendingId)) {
+      const pending = this.pendingCapabilityRequests.get(pendingId);
+      this.pendingCapabilityRequests.delete(pendingId);
+      let message;
+      try {
+        message = parseExtensionWireMessage(value);
+      } catch (error) {
+        pending.reject(error instanceof Error ? error : new Error("invalid capability.invoke response"));
+        return;
+      }
+      if (message.kind !== "response") {
+        pending.reject(new Error("expected a capability.invoke response"));
+        return;
+      }
+      if (message.ok) pending.resolve(message.result);
+      else pending.reject(new Error(message.error.message));
+      return;
+    }
+    const envelope = requestEnvelope(value);
+    if (!envelope || this.ongoingRequestIds.has(envelope.id) || this.respondedIds.has(envelope.id)) return;
+    this.rememberRequestId(envelope.id);
+    if (this.disposed) {
+      this.sendError(envelope.id, "HOST_DISPOSED", "extension host is disposed");
+      return;
+    }
+    let request;
+    try {
+      const message = parseExtensionWireMessage(value);
+      if (message.kind !== "request") throw new Error("host accepts requests only");
+      request = message;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid request";
+      const code = message.startsWith("unknown request method:") ? "UNKNOWN_METHOD" : "INVALID_REQUEST";
+      this.sendError(envelope.id, code, message);
+      return;
+    }
+    const maxConcurrent = this.options.maxConcurrentRequests ?? 8;
+    if (this.inFlight >= maxConcurrent) {
+      this.sendError(request.id, "HOST_BUSY", "extension host request limit reached");
+      return;
+    }
+    this.ongoingRequestIds.add(request.id);
+    this.inFlight += 1;
+    const operation = this.dispatch(request).finally(() => {
+      this.ongoingRequestIds.delete(request.id);
+      this.inFlight -= 1;
+    });
+    try {
+      const result = await this.withTimeout(operation);
+      if (result === TIMEOUT) {
+        this.sendError(request.id, "REQUEST_TIMEOUT", `extension request ${request.method} timed out`);
+      } else {
+        this.options.send({ kind: "response", id: request.id, ok: true, result });
+      }
+    } catch (error) {
+      const failure = this.failure(error);
+      this.sendError(request.id, failure.code, failure.message);
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.channelEpoch += 1;
+    for (const [id2, pending] of this.pendingCapabilityRequests) {
+      this.pendingCapabilityRequests.delete(id2);
+      pending.reject(new Error("extension host is disposed"));
+    }
+    try {
+      if (this.active) await this.module?.deactivate?.("host-disposed");
+    } finally {
+      this.active = false;
+      this.module = null;
+      this.commandHandlers.clear();
+      this.channelHandlers.clear();
+      this.channelFormatters.clear();
+      this.channelStates.clear();
+      this.channelCalls.clear();
+    }
+  }
+  async dispatch(request) {
+    if (request.method === "handshake") {
+      const manifest = this.options.manifest;
+      const params = request.params;
+      if (params.apiVersion !== manifest.apiVersion || params.extensionId !== manifest.id || params.extensionVersion !== manifest.version) {
+        throw { code: "HANDSHAKE_MISMATCH", message: "Desktop handshake does not match the extension manifest" };
+      }
+      this.handshaken = true;
+      return null;
+    }
+    if (!this.handshaken) throw { code: "HANDSHAKE_REQUIRED", message: "extension host handshake is required" };
+    if (request.method === "activate") {
+      if (this.deactivating) throw { code: "NOT_ACTIVE", message: "extension host is stopping" };
+      if (this.active) return null;
+      if (!this.options.manifest.activationEvents.includes(request.params.activationEvent)) {
+        throw { code: "ACTIVATION_DENIED", message: "activation event is not declared in the manifest" };
+      }
+      await this.ensureActivated();
+      return null;
+    }
+    if (request.method === "deactivate") {
+      if (this.deactivating) throw { code: "NOT_ACTIVE", message: "extension host is stopping" };
+      this.deactivating = true;
+      this.channelEpoch += 1;
+      if (this.activation) {
+        try {
+          await this.activation;
+        } catch {
+        }
+      }
+      try {
+        if (this.active) await this.module?.deactivate?.(request.params.reason);
+      } finally {
+        this.active = false;
+        this.commandHandlers.clear();
+        this.channelHandlers.clear();
+        this.channelFormatters.clear();
+        this.channelStates.clear();
+        this.channelCalls.clear();
+        this.deactivating = false;
+      }
+      return null;
+    }
+    if (request.method === "capability.invoke") {
+      throw { code: "UNSUPPORTED_DIRECTION", message: "capability.invoke is extension-initiated and cannot be dispatched to the host" };
+    }
+    if (!this.active) {
+      throw { code: "NOT_ACTIVE", message: "extension command handler is not active" };
+    }
+    if (request.method === "channel.lifecycle") return this.deliverChannel(request.params);
+    if (request.method === "channel.formatReply") return this.formatChannelReply(request.params);
+    const handler = this.commandHandlers.get(request.params.commandId);
+    if (!handler) {
+      throw { code: "COMMAND_NOT_REGISTERED", message: `extension command is not registered: ${request.params.commandId}` };
+    }
+    const result = await handler(...request.params.args);
+    const validated = parseExtensionWireMessage({ kind: "response", id: "result", ok: true, result });
+    if (validated.kind !== "response" || !validated.ok) throw new Error("extension returned an invalid result");
+    return validated.result;
+  }
+  async deliverChannel(event) {
+    const contribution = this.options.manifest.contributes.channels?.find((channel) => channel.id === event.channelId);
+    if (this.options.manifest.channelApiVersion !== 1 || !contribution || contribution.provider !== event.provider) {
+      throw { code: "CHANNEL_NOT_DECLARED", message: "channel contribution/provider is not declared" };
+    }
+    const key = JSON.stringify([event.channelId, event.connectionId]);
+    if (!this.channelStates.has(key) && !this.channelCalls.has(key) && (/* @__PURE__ */ new Set([...this.channelStates.keys(), ...this.channelCalls.keys()])).size >= 256) {
+      throw { code: "CHANNEL_CAPACITY", message: "channel lifecycle capacity reached" };
+    }
+    const epoch = this.channelEpoch;
+    const prior = this.channelCalls.get(key) ?? Promise.resolve();
+    const next = prior.catch(() => void 0).then(async () => {
+      if (this.disposed || !this.active || this.deactivating || epoch !== this.channelEpoch) {
+        throw { code: "NOT_ACTIVE", message: "channel host is not active" };
+      }
+      const previous = this.channelStates.get(key);
+      if (previous && (event.connectionRevision < previous.connectionRevision || event.connectionRevision === previous.connectionRevision && previous.state === "stop" && event.state === "start")) {
+        throw { code: "STALE_CHANNEL", message: "channel lifecycle generation is stale" };
+      }
+      if (previous?.connectionRevision === event.connectionRevision && previous.state === event.state) return null;
+      const handler = this.channelHandlers.get(event.channelId);
+      if (!handler) throw { code: "CHANNEL_NOT_REGISTERED", message: "channel handler is not registered" };
+      this.channelStates.set(key, Object.freeze({ ...event }));
+      if (previous?.state === "start" && event.state === "start") {
+        await handler(Object.freeze({ ...previous, state: "stop" }));
+        if (this.disposed || !this.active || this.deactivating || epoch !== this.channelEpoch) {
+          throw { code: "NOT_ACTIVE", message: "channel host stopped" };
+        }
+      }
+      await handler(Object.freeze({ ...event }));
+      return null;
+    });
+    this.channelCalls.set(key, next);
+    try {
+      return await next;
+    } finally {
+      if (this.channelCalls.get(key) === next) this.channelCalls.delete(key);
+    }
+  }
+  async formatChannelReply(input) {
+    const key = JSON.stringify([input.channelId, input.connectionId]);
+    const current = this.channelStates.get(key);
+    const epoch = this.channelEpoch;
+    const formatter = this.channelFormatters.get(input.channelId);
+    const isCurrent = () => !this.disposed && !this.deactivating && this.active && epoch === this.channelEpoch && this.channelStates.get(key) === current && current?.state === "start" && current.provider === input.provider && current.connectionRevision === input.connectionRevision;
+    if (!isCurrent() || !formatter) throw { code: "CHANNEL_FORMAT_UNAVAILABLE", message: "channel formatter is not active" };
+    const result = await formatter(Object.freeze({ ...input }));
+    if (!isCurrent()) throw { code: "CHANNEL_FORMAT_WITHDRAWN", message: "channel formatter stopped" };
+    return parseChannelReplyFormatResult(result, input);
+  }
+  async withTimeout(operation) {
+    let timer;
+    const timeout = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2(TIMEOUT), this.options.requestTimeoutMs ?? 5e3);
+    });
+    try {
+      return await Promise.race([operation, timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async ensureActivated() {
+    if (this.active) return;
+    if (!this.activation) {
+      const activation = this.activateExtension();
+      this.activation = activation;
+      void activation.finally(() => {
+        if (this.activation === activation) this.activation = null;
+      }).catch(() => void 0);
+    }
+    await this.activation;
+  }
+  async activateExtension() {
+    this.activating = true;
+    try {
+      const loaded = this.module ?? extensionModule(
+        await this.options.loadModule(this.options.manifest.entrypoint)
+      );
+      if (this.disposed) throw { code: "HOST_DISPOSED", message: "extension host is disposed" };
+      const registered = /* @__PURE__ */ new Map();
+      const registeredChannels = /* @__PURE__ */ new Map();
+      const registeredFormatters = /* @__PURE__ */ new Map();
+      await loaded.activate({
+        extensionId: this.options.manifest.id,
+        channels: {
+          register: (channelId, handler) => {
+            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredChannels.has(channelId)) {
+              throw { code: "INVALID_CHANNEL_REGISTRATION", message: "channel must be declared and registered once" };
+            }
+            registeredChannels.set(channelId, handler);
+          },
+          registerFormatter: (channelId, formatter) => {
+            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof formatter !== "function" || registeredFormatters.has(channelId)) {
+              throw { code: "INVALID_CHANNEL_REGISTRATION", message: "formatter must be declared and registered once" };
+            }
+            registeredFormatters.set(channelId, formatter);
+          }
+        },
+        commands: {
+          register: (commandId, handler) => {
+            this.validateCommandRegistration(commandId, handler, registered);
+            registered.set(commandId, handler);
+          }
+        },
+        invokeCapability: (permission, action, args) => this.invokeCapability(permission, action, args)
+      });
+      if (this.disposed) {
+        await loaded.deactivate?.("host-disposed");
+        throw { code: "HOST_DISPOSED", message: "extension host is disposed" };
+      }
+      this.module = loaded;
+      this.channelHandlers.clear();
+      this.channelFormatters.clear();
+      for (const [id2, formatter] of registeredFormatters) this.channelFormatters.set(id2, formatter);
+      for (const [id2, handler] of registeredChannels) this.channelHandlers.set(id2, handler);
+      this.commandHandlers.clear();
+      for (const [commandId, handler] of registered) this.commandHandlers.set(commandId, handler);
+      this.active = true;
+    } finally {
+      this.activating = false;
+    }
+  }
+  rememberRequestId(id2) {
+    this.respondedIds.add(id2);
+    const limit = Math.max(1, this.options.maxRememberedRequestIds ?? 4096);
+    while (this.respondedIds.size > limit) {
+      const oldest = this.respondedIds.values().next().value;
+      if (!oldest) return;
+      this.respondedIds.delete(oldest);
+    }
+  }
+  failure(error) {
+    if (error && typeof error === "object") {
+      const record2 = error;
+      if (typeof record2.code === "string" && typeof record2.message === "string") {
+        return { code: record2.code, message: record2.message };
+      }
+    }
+    return { code: "EXTENSION_ERROR", message: error instanceof Error ? error.message : "extension request failed" };
+  }
+  sendError(id2, code, message) {
+    this.options.send({ kind: "response", id: id2, ok: false, error: { code, message } });
+  }
+  validateCommandRegistration(commandId, handler, registered) {
+    if (!commandId.startsWith(`${this.options.manifest.id}.`)) {
+      throw new Error(`command must be namespaced by ${this.options.manifest.id}: ${commandId}`);
+    }
+    if (!this.options.manifest.contributes.commands?.some((command) => command.id === commandId)) {
+      throw new Error(`command is not declared in the manifest: ${commandId}`);
+    }
+    if (typeof handler !== "function") throw new Error(`command handler must be a function: ${commandId}`);
+    if (registered.has(commandId)) throw new Error(`duplicate command registration: ${commandId}`);
+  }
+}
+function extensionModule(imported) {
+  if ("default" in imported) return imported.default;
+  return imported;
+}
+function protocolUrl(extensionId2, relativePath2) {
+  return `saycode-extension://${extensionId2}/${relativePath2}`;
+}
+async function startExtensionHost(deps) {
+  const manifestText = await deps.fetchText(protocolUrl(deps.extensionId, "extension.json"));
+  const manifest = parseExtensionManifest(JSON.parse(manifestText), {
+    supportedApiVersion: SAYCODE_EXTENSION_API_VERSION,
+    // Must match what main accepted at install time, or an extension inside the support
+    // window would install fine and then fail to boot in its own renderer.
+    minimumSupportedApiVersion: SAYCODE_EXTENSION_MINIMUM_API_VERSION,
+    saycodeVersion: SAYCODE_EXTENSION_ENGINE_VERSION
+  });
+  const runtime = new ExtensionHostRuntime({
+    manifest,
+    loadModule: (entrypoint) => deps.importModule(protocolUrl(deps.extensionId, entrypoint)),
+    send: (message) => deps.bridge.send(message)
+  });
+  deps.bridge.onMessage((message) => {
+    void runtime.receive(message);
+  });
+  runtime.start();
+  return runtime;
+}
+const PROTOCOL = "saycode-extension://";
+function resolveExtensionFile(extensionDir2, extensionId2, url) {
+  const prefix = `${PROTOCOL}${extensionId2}/`;
+  if (!url.startsWith(prefix)) throw new Error("extension file outside this extension");
+  const relative = decodeURIComponent(url.slice(prefix.length));
+  const root = resolve(extensionDir2);
+  const target = resolve(root, relative);
+  if (target !== root && !target.startsWith(root + sep)) throw new Error("extension file outside this extension");
+  return target;
+}
+async function startNodeExtensionHost(input) {
+  const listeners = /* @__PURE__ */ new Set();
+  input.input.onLine((line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    for (const listener of listeners) listener(message);
+  });
+  return startExtensionHost({
+    extensionId: input.extensionId,
+    bridge: {
+      send: (message) => input.write(JSON.stringify(message)),
+      onMessage: (listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      }
+    },
+    fetchText: (url) => readFile(resolveExtensionFile(input.extensionDir, input.extensionId, url), "utf8"),
+    importModule: (url) => import(
+      /* @vite-ignore */
+      pathToFileURL(resolveExtensionFile(input.extensionDir, input.extensionId, url)).href
+    )
+  });
+}
+const [extensionId, extensionDir] = process.argv.slice(2);
+if (!extensionId || !extensionDir) process.exit(2);
+const lines = createInterface({ input: process.stdin });
+lines.on("close", () => process.exit(0));
+void startNodeExtensionHost({
+  extensionId,
+  extensionDir,
+  input: { onLine: (listener) => {
+    lines.on("line", listener);
+  } },
+  write: (line) => {
+    process.stdout.write(`${line}
+`);
+  }
+}).catch(() => process.exit(1));