@buzzni/saycode-cli 0.8.1 → 0.8.2

package/channel-extension-host.mjs

@@ -7,89 +7,322 @@ const ASSET_PERMISSIONS = ["assets.read", "assets.write", "files.select", "draft
 function usesAssetWorkflow(permissions) {
   return permissions.some((permission) => ASSET_PERMISSIONS.includes(permission));
 }
+const LONG_RUNNING_PERMISSIONS = ["localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "machine.run"];
+function extensionRequestTimeoutMs(permissions, side) {
+  const long = usesAssetWorkflow(permissions) || permissions.some((permission) => LONG_RUNNING_PERMISSIONS.includes(permission));
+  if (!long) return void 0;
+  return side === "runtime" ? 13e4 : 14e4;
+}
+const ID_PATTERN$2 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+function fail$5(path2, detail) {
+  throw new Error(`${path2}: ${detail}`);
+}
+function record$1(value, path2) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail$5(path2, "expected object");
+  return value;
+}
+function string(value, path2) {
+  if (typeof value !== "string" || value.trim() !== value || value.length === 0) {
+    fail$5(path2, "expected non-empty trimmed string");
+  }
+  return value;
+}
+function id(value, path2) {
+  const parsed = string(value, path2);
+  if (!ID_PATTERN$2.test(parsed) || parsed.includes("..")) fail$5(path2, "invalid stable identifier");
+  return parsed;
+}
+function array(value, path2) {
+  if (!Array.isArray(value)) fail$5(path2, "expected array");
+  return value;
+}
+function assertOnlyKeys(value, allowed, path2) {
+  const unknown = Object.keys(value).find((key) => !allowed.has(key));
+  if (unknown) fail$5(path2, `unknown field ${unknown}`);
+}
+function contributionList(value, path2, allowedKeys, parse) {
+  return array(value, path2).map((raw, index) => {
+    const entryPath = `${path2}[${index}]`;
+    const entry = record$1(raw, entryPath);
+    assertOnlyKeys(entry, new Set(allowedKeys), entryPath);
+    return parse(entry, entryPath);
+  });
+}
+function parseMachineCommands(value, extensionId2, apiVersion) {
+  if (apiVersion < 3) fail$5("manifest.machineCommands", "requires Extension API version 3");
+  const root = record$1(value, "manifest.machineCommands");
+  assertOnlyKeys(root, /* @__PURE__ */ new Set(["version", "profiles"]), "manifest.machineCommands");
+  if (root.version !== 1) fail$5("manifest.machineCommands.version", "unsupported version");
+  const profiles = contributionList(
+    root.profiles,
+    "manifest.machineCommands.profiles",
+    ["id", "executable", "argv", "parameters", "cwd", "envAllowlist", "timeoutMs", "outputLimitBytes", "stdin", "writeScope", "descendantAllowlist"],
+    (entry, path2) => {
+      const profileId = id(entry.id, `${path2}.id`);
+      if (!profileId.startsWith(`${extensionId2}.`)) fail$5(`${path2}.id`, "expected an id declared by the same extension");
+      const executable = string(entry.executable, `${path2}.executable`);
+      if (!/^[a-z][a-z0-9._-]*$/.test(executable) || /^(sh|bash|zsh|fish|cmd|powershell|pwsh|node|nodejs|deno|bun|python|python2|python3|ruby|perl|php|java|awk|gawk|osascript|npm|npx|env|xargs|ssh|tmux|make|cargo)$/i.test(executable)) {
+        fail$5(`${path2}.executable`, "unsupported executable");
+      }
+      const argv = array(entry.argv, `${path2}.argv`).map((arg, index) => {
+        const value2 = string(arg, `${path2}.argv[${index}]`);
+        if (/^(?:--from|--wake|--interactive|--tty|--tui|-i)$/.test(value2) || value2.includes("\\") || value2.includes("/") || value2.includes("..") || value2.includes("{{workspaceRoot}}") && value2 !== "{{workspaceRoot}}") fail$5(`${path2}.argv[${index}]`, "unsafe argument template");
+        return value2;
+      });
+      if (!argv.length || argv.length > 32) fail$5(`${path2}.argv`, "expected 1-32 arguments");
+      const parameters = {};
+      for (const [name, raw] of Object.entries(record$1(entry.parameters, `${path2}.parameters`))) {
+        if (!/^[a-z][a-zA-Z0-9_]{0,63}$/.test(name)) fail$5(`${path2}.parameters`, "invalid parameter name");
+        const parameter = record$1(raw, `${path2}.parameters.${name}`);
+        if (parameter.type === "string") {
+          assertOnlyKeys(parameter, /* @__PURE__ */ new Set(["type", "maxLength", "values"]), `${path2}.parameters.${name}`);
+          if (!Number.isInteger(parameter.maxLength) || Number(parameter.maxLength) < 1 || Number(parameter.maxLength) > 4096) fail$5(`${path2}.parameters.${name}.maxLength`, "invalid maxLength");
+          if (parameter.values !== void 0 && (!Array.isArray(parameter.values) || parameter.values.length === 0 || parameter.values.some((item) => typeof item !== "string" || !item))) fail$5(`${path2}.parameters.${name}.values`, "invalid values");
+          parameters[name] = { type: "string", maxLength: Number(parameter.maxLength), ...parameter.values === void 0 ? {} : { values: parameter.values } };
+        } else if (parameter.type === "integer") {
+          assertOnlyKeys(parameter, /* @__PURE__ */ new Set(["type", "min", "max"]), `${path2}.parameters.${name}`);
+          if (!Number.isSafeInteger(parameter.min) || !Number.isSafeInteger(parameter.max) || Number(parameter.min) > Number(parameter.max)) fail$5(`${path2}.parameters.${name}`, "invalid integer bounds");
+          parameters[name] = { type: "integer", min: Number(parameter.min), max: Number(parameter.max) };
+        } else fail$5(`${path2}.parameters.${name}.type`, "unsupported parameter type");
+      }
+      const cwd = string(entry.cwd, `${path2}.cwd`);
+      if (cwd !== "workspaceRoot" && cwd !== "extensionData" && cwd !== "temp") fail$5(`${path2}.cwd`, "unsupported cwd root");
+      const envAllowlist = array(entry.envAllowlist, `${path2}.envAllowlist`).map((name, index) => {
+        const value2 = string(name, `${path2}.envAllowlist[${index}]`);
+        if (!/^[A-Z][A-Z0-9_]*$/.test(value2) || /^(PATH|LD_PRELOAD|LD_LIBRARY_PATH|LD_AUDIT|DYLD_|NODE_OPTIONS|BASH_ENV|GIT_SSH_COMMAND|GIT_CONFIG_|PYTHONSTARTUP)/.test(value2)) fail$5(`${path2}.envAllowlist[${index}]`, "dangerous environment key");
+        return value2;
+      });
+      if (!Number.isInteger(entry.timeoutMs) || Number(entry.timeoutMs) < 1 || Number(entry.timeoutMs) > 3e5) fail$5(`${path2}.timeoutMs`, "invalid timeout");
+      if (!Number.isInteger(entry.outputLimitBytes) || Number(entry.outputLimitBytes) < 1 || Number(entry.outputLimitBytes) > 1048576) fail$5(`${path2}.outputLimitBytes`, "invalid output limit");
+      if (entry.stdin !== "none") fail$5(`${path2}.stdin`, "stdin must be none");
+      const writeScope = entry.writeScope === void 0 ? "none" : entry.writeScope;
+      if (writeScope !== "none" && writeScope !== "moai" && writeScope !== "project") fail$5(`${path2}.writeScope`, "unsupported write scope");
+      const descendantAllowlist = entry.descendantAllowlist === void 0 ? [] : array(entry.descendantAllowlist, `${path2}.descendantAllowlist`).map((name, index) => {
+        const value2 = string(name, `${path2}.descendantAllowlist[${index}]`);
+        if (!/^[a-z][a-z0-9._-]{0,63}$/.test(value2) || /^(?:sh|bash|zsh|fish|cmd|powershell|node|python|npm|npx|env|xargs|ssh|tmux|vi|vim|nvim|nano|less|more)$/i.test(value2)) fail$5(`${path2}.descendantAllowlist[${index}]`, "unsupported descendant");
+        return value2;
+      });
+      if (descendantAllowlist.length > 8) fail$5(`${path2}.descendantAllowlist`, "expected at most 8 descendants");
+      if (writeScope !== "none" && descendantAllowlist.length === 0) fail$5(`${path2}.descendantAllowlist`, "write profiles must declare descendants");
+      return {
+        id: profileId,
+        executable,
+        argv,
+        parameters,
+        cwd,
+        envAllowlist,
+        timeoutMs: Number(entry.timeoutMs),
+        outputLimitBytes: Number(entry.outputLimitBytes),
+        stdin: "none",
+        ...entry.writeScope === void 0 ? {} : { writeScope },
+        ...entry.descendantAllowlist === void 0 ? {} : { descendantAllowlist }
+      };
+    }
+  );
+  if (!profiles.length || new Set(profiles.map((profile) => profile.id)).size !== profiles.length) fail$5("manifest.machineCommands.profiles", "duplicate profile id");
+  return { version: 1, profiles };
+}
+const ID = /^[a-z][a-z0-9.-]{0,127}$/;
+const HASH = /^[a-f0-9]{64}$/;
+const NAME = /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/;
+function fail$4() {
+  throw new Error("INVALID_TOOL_DESCRIPTOR");
+}
+function row(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail$4();
+  return value;
+}
+function keys(value, allowed) {
+  if (Object.keys(value).some((key) => !allowed.includes(key))) fail$4();
+}
+function text$2(value, limit = 4096) {
+  if (typeof value !== "string" || !value || value.length > limit || /[\x00-\x1f]/.test(value)) fail$4();
+  return value;
+}
+function path(value) {
+  const parsed = text$2(value);
+  if (parsed.startsWith("/") || parsed.includes("\\") || parsed.includes(":") || parsed.split("/").some((part) => !part || part === ".." || part === ".")) fail$4();
+  return parsed;
+}
+function parseManagedLocalTool(value, extensionId2) {
+  const root = row(value);
+  keys(root, ["version", "id", "toolVersion", "platforms", "operations"]);
+  if (root.version !== 1 || !ID.test(text$2(root.id)) || !String(root.id).startsWith(extensionId2 + ".") || !/^\d+\.\d+\.\d+$/.test(text$2(root.toolVersion))) fail$4();
+  const platforms = {};
+  for (const [platform, raw] of Object.entries(row(root.platforms))) {
+    if (!/^(darwin|win32)-(arm64|x64)$/.test(platform)) fail$4();
+    const source = row(raw);
+    keys(source, ["url", "sha256", "archiveRoot", "executable", "executableSha256", "appBundle", "signingTeamId", "existingExecutables"]);
+    const url = new URL(text$2(source.url));
+    if (url.protocol !== "https:" || url.username || url.password || !/\.(tar\.gz|zip)$/.test(url.pathname) || !HASH.test(text$2(source.sha256)) || !HASH.test(text$2(source.executableSha256))) fail$4();
+    if (!Array.isArray(source.existingExecutables) || source.existingExecutables.length > 4 || source.existingExecutables.some((entry) => typeof entry !== "string" || /[\x00-\x1f]/.test(entry) || !/^(\/|[A-Za-z]:\\)/.test(entry) || /(^|[\\/])\.\.([\\/]|$)/.test(entry))) fail$4();
+    if (platform.startsWith("darwin") && (!source.appBundle || !/^[A-Z0-9]{10}$/.test(text$2(source.signingTeamId)))) fail$4();
+    platforms[platform] = {
+      url: url.toString(),
+      sha256: String(source.sha256),
+      archiveRoot: path(source.archiveRoot),
+      executable: path(source.executable),
+      executableSha256: String(source.executableSha256),
+      existingExecutables: source.existingExecutables,
+      ...source.appBundle ? { appBundle: path(source.appBundle), signingTeamId: text$2(source.signingTeamId) } : {}
+    };
+  }
+  const operations = {};
+  for (const [name, raw] of Object.entries(row(root.operations))) {
+    if (!NAME.test(name)) fail$4();
+    const source = row(raw);
+    keys(source, ["permission", "argv", "payload", "inputs"]);
+    if (!["inspect", "control"].includes(String(source.permission)) || !Array.isArray(source.argv) || source.argv.length > 16) fail$4();
+    const argv = source.argv.map((arg) => {
+      const value2 = text$2(arg);
+      if (value2.includes("{{") && value2 !== "{{json}}") fail$4();
+      return value2;
+    });
+    const inputs = {};
+    for (const [name2, raw2] of Object.entries(source.inputs === void 0 ? {} : row(source.inputs))) {
+      if (!NAME.test(name2) || /^(session|token|secret|password|command|argv|env)$/i.test(name2)) fail$4();
+      const input = row(raw2);
+      if (input.type === "integer") {
+        keys(input, ["type", "min", "max"]);
+        if (!Number.isSafeInteger(input.min) || !Number.isSafeInteger(input.max) || Number(input.min) > Number(input.max)) fail$4();
+        inputs[name2] = { type: "integer", min: Number(input.min), max: Number(input.max) };
+      } else if (input.type === "string") {
+        keys(input, ["type", "maxLength", "values"]);
+        if (!Number.isInteger(input.maxLength) || Number(input.maxLength) < 1 || Number(input.maxLength) > 4096 || input.values !== void 0 && (!Array.isArray(input.values) || input.values.some((item) => typeof item !== "string"))) fail$4();
+        inputs[name2] = { type: "string", maxLength: Number(input.maxLength), ...input.values ? { values: input.values } : {} };
+      } else fail$4();
+    }
+    const operation = {
+      permission: source.permission,
+      argv,
+      inputs,
+      ...source.payload === void 0 ? {} : { payload: source.payload }
+    };
+    if (argv.includes("{{json}}") !== (source.payload !== void 0)) fail$4();
+    managedToolArguments(operation, Object.fromEntries(Object.entries(inputs).map(([key, input]) => [key, input.type === "integer" ? input.min : input.values?.[0] ?? "test"])), "validated");
+    operations[name] = operation;
+  }
+  if (!Object.keys(platforms).length || !Object.keys(operations).length || Object.keys(operations).length > 32) fail$4();
+  return { version: 1, id: String(root.id), toolVersion: String(root.toolVersion), platforms, operations };
+}
+function managedToolArguments(operation, parameters, session) {
+  const inputs = operation.inputs ?? {};
+  const invalid = () => {
+    throw new Error("INVALID_TOOL_INPUT");
+  };
+  if (Object.keys(parameters).some((key) => !Object.hasOwn(inputs, key))) invalid();
+  for (const [key, schema] of Object.entries(inputs)) {
+    const value = parameters[key];
+    if (schema.type === "integer") {
+      if (!Number.isSafeInteger(value) || Number(value) < schema.min || Number(value) > schema.max) invalid();
+    } else if (typeof value !== "string" || !value || value.length > schema.maxLength || /[\x00-\x1f]/.test(value) || schema.values && !schema.values.includes(value)) invalid();
+  }
+  const render = (value) => {
+    if (Array.isArray(value)) return value.map(render);
+    if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, render(child)]));
+    if (typeof value !== "string") return value;
+    const exact = value.match(/^\{\{([A-Za-z][A-Za-z0-9_]*)\}\}$/);
+    if (exact) {
+      if (exact[1] === "session") return session;
+      if (!Object.hasOwn(inputs, exact[1])) invalid();
+      return parameters[exact[1]];
+    }
+    return value.replace(/\{\{([A-Za-z][A-Za-z0-9_]*)\}\}/g, (_, key) => {
+      if (key === "session") return session;
+      if (!Object.hasOwn(inputs, key)) invalid();
+      return String(parameters[key]);
+    });
+  };
+  const payload = operation.payload === void 0 ? void 0 : JSON.stringify(render(operation.payload));
+  return operation.argv.map((arg) => arg === "{{json}}" ? payload : arg);
+}
+const EXTENSION_PANEL_SURFACE_SIZES = ["compact", "standard", "wide"];
+function isExtensionPanelSurfaceSize(value) {
+  return EXTENSION_PANEL_SURFACE_SIZES.some((size) => size === value);
+}
 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 ID_PATTERN$1 = /^[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 fail$3(path2, detail) {
+  throw new Error(`${path2}: ${detail}`);
 }
-function record$1(value, path) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) fail$4(path, "expected object");
+function record(value, path2) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail$3(path2, "expected object");
   return value;
 }
-function exactKeys$1(value, required, optional, path) {
+function exactKeys$1(value, required, optional, path2) {
   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}`);
+  if (unknown) fail$3(path2, `unknown field ${unknown}`);
   const missing = required.find((key) => !(key in value));
-  if (missing) fail$4(path, `missing field ${missing}`);
+  if (missing) fail$3(path2, `missing field ${missing}`);
 }
-function text$1(value, path) {
+function text$1(value, path2) {
   if (typeof value !== "string" || !value || value.trim() !== value) {
-    fail$4(path, "expected non-empty trimmed string");
+    fail$3(path2, "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");
+function title(value, path2) {
+  const parsed = text$1(value, path2);
+  if ([...parsed].length > MAX_TITLE_CHARACTERS) fail$3(path2, "title exceeds 120 characters");
   return parsed;
 }
-function uniqueList(values, path) {
-  if (new Set(values).size !== values.length) fail$4(path, "duplicate value");
+function uniqueList(values, path2) {
+  if (new Set(values).size !== values.length) fail$3(path2, "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");
+function parseLocalizations(value, path2) {
+  const localizations = record(value, path2);
+  if (Object.keys(localizations).length > MAX_LOCALES) fail$3(path2, "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);
+    if (!LOCALE_PATTERN$1.test(locale)) fail$3(path2, `invalid locale ${locale}`);
+    const localizationPath = `${path2}.${locale}`;
+    const localization = record(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");
+function parseSourceTypes(value, path2) {
+  if (!Array.isArray(value) || value.length === 0) fail$3(path2, "expected non-empty array");
   const parsed = value.map((sourceType, index) => {
     if (!EXTENSION_ARTIFACT_SOURCE_TYPES.includes(sourceType)) {
-      fail$4(`${path}[${index}]`, "unsupported source type");
+      fail$3(`${path2}[${index}]`, "unsupported source type");
     }
     return sourceType;
   });
-  return uniqueList(parsed, path);
+  return uniqueList(parsed, path2);
 }
-function parseExtensions(value, path) {
+function parseExtensions(value, path2) {
   if (!Array.isArray(value) || value.length === 0 || value.length > MAX_EXTENSIONS) {
-    fail$4(path, "expected 1-16 extensions");
+    fail$3(path2, "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");
+      fail$3(`${path2}[${index}]`, "expected lowercase extension without a dot");
     }
     return extension;
   });
-  return uniqueList(parsed, path);
+  return uniqueList(parsed, path2);
 }
-function parseExtensionArtifactActions(value, path = "manifest.contributes.artifactActions") {
-  if (!Array.isArray(value) || value.length > MAX_ACTIONS) fail$4(path, "expected at most 32 actions");
+function parseExtensionArtifactActions(value, path2 = "manifest.contributes.artifactActions") {
+  if (!Array.isArray(value) || value.length > MAX_ACTIONS) fail$3(path2, "expected at most 32 actions");
   return value.map((raw, index) => {
-    const actionPath = `${path}[${index}]`;
-    const action = record$1(raw, actionPath);
+    const actionPath = `${path2}[${index}]`;
+    const action = record(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 (!ID_PATTERN$1.test(parsedId) || parsedId.includes("..")) fail$3(`${actionPath}.id`, "invalid stable identifier");
     if (!EXTENSION_ARTIFACT_ACTION_OPERATIONS.includes(action.operation)) {
-      fail$4(`${actionPath}.operation`, "unsupported operation");
+      fail$3(`${actionPath}.operation`, "unsupported operation");
     }
-    const when = record$1(action.when, `${actionPath}.when`);
+    const when = record(action.when, `${actionPath}.when`);
     exactKeys$1(when, ["sourceTypes", "extensions"], [], `${actionPath}.when`);
     return {
       id: parsedId,
@@ -119,13 +352,14 @@ const CHANNEL_COMMAND_SCHEMA = Object.freeze({
   // 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([])
+  clear: Object.freeze([]),
+  settings: Object.freeze(["agent", "model", "effort"])
 });
 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 fail$2(path2, detail) {
+  throw new Error(`${path2}: ${detail}`);
 }
 function hasControlCharacter(value) {
   for (const character of value) {
@@ -134,31 +368,31 @@ function hasControlCharacter(value) {
   }
   return false;
 }
-function description(value, path) {
+function description(value, path2) {
   if (typeof value !== "string" || value.trim().length === 0 || value.length > MAX_DESCRIPTION) {
-    fail$3(path, "invalid description");
+    fail$2(path2, "invalid description");
   }
-  if (hasControlCharacter(value)) fail$3(path, "invalid description");
+  if (hasControlCharacter(value)) fail$2(path2, "invalid description");
   return value;
 }
-function parseChannelCommandDeclarations(value, path) {
-  if (!Array.isArray(value)) fail$3(path, "expected array");
+function parseChannelCommandDeclarations(value, path2) {
+  if (!Array.isArray(value)) fail$2(path2, "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`);
+    fail$2(path2, `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 entryPath = `${path2}[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) fail$2(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}`);
+    if (extra !== void 0) fail$2(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");
+      fail$2(`${entryPath}.id`, "unknown command");
     }
-    if (seen.has(id2)) fail$3(path, `duplicate command ${id2}`);
+    if (seen.has(id2)) fail$2(path2, `duplicate command ${id2}`);
     seen.add(id2);
     return {
       id: id2,
@@ -167,24 +401,24 @@ function parseChannelCommandDeclarations(value, path) {
     };
   });
 }
-function parseOptions(value, path, expected) {
+function parseOptions(value, path2, expected) {
   if (value === void 0) {
-    if (expected.length > 0) fail$3(path, `expected ${expected.length} options`);
+    if (expected.length > 0) fail$2(path2, `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`);
+  if (!Array.isArray(value)) fail$2(path2, "expected array");
+  if (value.length !== expected.length) fail$2(path2, `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 optionPath = `${path2}[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) fail$2(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}`);
+    if (extra !== void 0) fail$2(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}`);
+    if (source.name !== name) fail$2(`${optionPath}.name`, `expected ${name}`);
+    if (source.required !== required) fail$2(`${optionPath}.required`, `expected ${required}`);
     return Object.freeze({
       name,
       required,
@@ -193,34 +427,34 @@ function parseOptions(value, path, expected) {
   }));
 }
 const MAX_CHANNEL_CONTRIBUTIONS = CHANNEL_PROVIDERS.length;
-const ID_PATTERN$1 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const ID_PATTERN = /^[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 fail$1(path2, detail) {
+  throw new Error(`${path2}: ${detail}`);
 }
 function parseExtensionChannelContributions(value) {
-  if (!Array.isArray(value)) fail$2("manifest.contributes.channels", "expected array");
+  if (!Array.isArray(value)) fail$1("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`);
+    fail$1("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 path2 = `manifest.contributes.channels[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) fail$1(path2, "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}`);
+    if (extra !== void 0) fail$1(path2, `unknown field ${extra}`);
     const id2 = source.id;
-    if (typeof id2 !== "string" || !ID_PATTERN$1.test(id2) || id2.includes("..")) {
-      fail$2(`${path}.id`, "invalid identifier");
+    if (typeof id2 !== "string" || !ID_PATTERN.test(id2) || id2.includes("..")) {
+      fail$1(`${path2}.id`, "invalid identifier");
     }
     const provider = source.provider;
     if (typeof provider !== "string" || !CHANNEL_PROVIDERS.includes(provider)) {
-      fail$2(`${path}.provider`, "unsupported provider");
+      fail$1(`${path2}.provider`, "unsupported provider");
     }
-    if (providers.has(provider)) fail$2("manifest.contributes.channels", "duplicate provider");
+    if (providers.has(provider)) fail$1("manifest.contributes.channels", "duplicate provider");
     providers.add(provider);
-    const commands = source.commands === void 0 ? void 0 : parseChannelCommandDeclarations(source.commands, `${path}.commands`);
+    const commands = source.commands === void 0 ? void 0 : parseChannelCommandDeclarations(source.commands, `${path2}.commands`);
     return {
       id: id2,
       provider,
@@ -237,6 +471,11 @@ const EXTENSION_PERMISSIONS = [
   "remoteFiles.read",
   "remoteFiles.write",
   "machine.execute",
+  "machine.run",
+  "localTools.inspect",
+  "localTools.install",
+  "localTools.control",
+  "localBrowser.setup",
   "network.fetch",
   "notifications.show",
   "storage.read",
@@ -281,7 +520,6 @@ class UnsupportedExtensionApiVersionError extends Error {
   }
   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)$/;
@@ -292,7 +530,7 @@ const V2_PERMISSIONS = /* @__PURE__ */ new Set([
   "browserViewer.install",
   "browserViewer.installChrome"
 ]);
-const V3_PERMISSIONS = /* @__PURE__ */ new Set(["artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare"]);
+const V3_PERMISSIONS = /* @__PURE__ */ new Set(["machine.run", "artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare", "localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup"]);
 const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
   "channels.receive",
   "channels.ack",
@@ -307,6 +545,8 @@ const TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "version",
   "apiVersion",
   "channelApiVersion",
+  "managedLocalTool",
+  "machineCommands",
   "engines",
   "entrypoint",
   "permissions",
@@ -342,14 +582,11 @@ function engineSupports(range, version) {
   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(
+    fail$5(
       "manifest.apiVersion",
       `invalid Desktop API support window [${floor}, ${current}]`
     );
@@ -359,65 +596,34 @@ function parseApiVersion(value, options) {
   }
   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);
+function relativePath(value, path2, requireScript = false) {
+  const parsed = string(value, path2);
   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");
+    fail$5(path2, "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 (apiVersion < 3) fail$5("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");
+  const parsed = record$1(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 (apiVersion < 3) fail$5("manifest.contributes.channels", "requires Extension API version 3");
     if (channelApiVersion === void 0) {
-      fail$1("manifest.contributes.channels", "requires manifest.channelApiVersion");
+      fail$5("manifest.contributes.channels", "requires manifest.channelApiVersion");
     }
   }
   if (apiVersion < 2 && parsed.machineActions !== void 0) {
-    fail$1("manifest.contributes.machineActions", "requires Extension API version 2");
+    fail$5("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");
+    fail$5("manifest.contributes.artifactActions", "requires Extension API version 3");
   }
   const result = {};
   if (parsed.commands !== void 0) {
@@ -425,10 +631,10 @@ function parseContributions(value, apiVersion, channelApiVersion) {
       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`) }
+      (entry, path2) => ({
+        id: id(entry.id, `${path2}.id`),
+        title: string(entry.title, `${path2}.title`),
+        ...entry.panelId === void 0 ? {} : { panelId: id(entry.panelId, `${path2}.panelId`) }
       })
     );
   }
@@ -437,12 +643,12 @@ function parseContributions(value, apiVersion, channelApiVersion) {
       parsed.settings,
       "manifest.contributes.settings",
       ["id", "title", "type"],
-      (entry, path) => {
-        const type = string(entry.type, `${path}.type`);
+      (entry, path2) => {
+        const type = string(entry.type, `${path2}.type`);
         if (type !== "boolean" && type !== "number" && type !== "string") {
-          fail$1(`${path}.type`, "unsupported setting type");
+          fail$5(`${path2}.type`, "unsupported setting type");
         }
-        return { id: id(entry.id, `${path}.id`), title: string(entry.title, `${path}.title`), type };
+        return { id: id(entry.id, `${path2}.id`), title: string(entry.title, `${path2}.title`), type };
       }
     );
   }
@@ -450,11 +656,12 @@ function parseContributions(value, apiVersion, channelApiVersion) {
     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`)
+      ["id", "title", "entrypoint", "surfaceSize"],
+      (entry, path2) => ({
+        id: id(entry.id, `${path2}.id`),
+        title: string(entry.title, `${path2}.title`),
+        entrypoint: relativePath(entry.entrypoint, `${path2}.entrypoint`),
+        ...entry.surfaceSize === void 0 ? {} : { surfaceSize: isExtensionPanelSurfaceSize(entry.surfaceSize) ? entry.surfaceSize : fail$5(`${path2}.surfaceSize`, "expected compact, standard or wide") }
       })
     );
   }
@@ -472,15 +679,15 @@ function parseContributions(value, apiVersion, channelApiVersion) {
         "assetsRoot",
         "localizations"
       ],
-      (entry, path) => {
+      (entry, path2) => {
         let localizations;
         if (entry.localizations !== void 0) {
-          const rawLocalizations = record(entry.localizations, `${path}.localizations`);
+          const rawLocalizations = record$1(entry.localizations, `${path2}.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);
+            if (!LOCALE_PATTERN.test(locale)) fail$5(`${path2}.localizations`, `invalid locale ${locale}`);
+            const localizationPath = `${path2}.localizations.${locale}`;
+            const localization = record$1(rawLocalization, localizationPath);
             assertOnlyKeys(
               localization,
               /* @__PURE__ */ new Set(["title", "description", "firstPrompt"]),
@@ -494,13 +701,13 @@ function parseContributions(value, apiVersion, channelApiVersion) {
           }
         }
         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`) },
+          id: id(entry.id, `${path2}.id`),
+          title: string(entry.title, `${path2}.title`),
+          assetsRoot: relativePath(entry.assetsRoot, `${path2}.assetsRoot`),
+          ...entry.description === void 0 ? {} : { description: string(entry.description, `${path2}.description`) },
+          ...entry.stack === void 0 ? {} : { stack: string(entry.stack, `${path2}.stack`) },
+          ...entry.firstPrompt === void 0 ? {} : { firstPrompt: string(entry.firstPrompt, `${path2}.firstPrompt`) },
+          ...entry.devServerCommand === void 0 ? {} : { devServerCommand: string(entry.devServerCommand, `${path2}.devServerCommand`) },
           ...localizations === void 0 ? {} : { localizations }
         };
       }
@@ -511,14 +718,14 @@ function parseContributions(value, apiVersion, channelApiVersion) {
       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");
+      (entry, path2) => {
+        const when = record$1(entry.when, `${path2}.when`);
+        assertOnlyKeys(when, /* @__PURE__ */ new Set(["online"]), `${path2}.when`);
+        if (when.online !== true) fail$5(`${path2}.when.online`, "expected true");
         return {
-          id: id(entry.id, `${path}.id`),
-          title: string(entry.title, `${path}.title`),
-          command: id(entry.command, `${path}.command`),
+          id: id(entry.id, `${path2}.id`),
+          title: string(entry.title, `${path2}.title`),
+          command: id(entry.command, `${path2}.command`),
           when: { online: true }
         };
       }
@@ -539,25 +746,25 @@ function parseContributions(value, apiVersion, channelApiVersion) {
     ...result.artifactActions ?? [],
     ...result.channels ?? []
   ].map((entry) => entry.id);
-  if (new Set(ids).size !== ids.length) fail$1("manifest.contributes", "duplicate contribution id");
+  if (new Set(ids).size !== ids.length) fail$5("manifest.contributes", "duplicate contribution id");
   return result;
 }
 function parseExtensionManifest(value, options) {
-  const manifest = record(value, "manifest");
+  const manifest = record$1(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");
+  if (!SEMVER_PATTERN.test(version)) fail$5("manifest.version", "expected semantic version");
   const apiVersion = parseApiVersion(manifest.apiVersion, options);
   const channelApiVersion = parseChannelApiVersion(manifest.channelApiVersion, apiVersion);
-  const engines = record(manifest.engines, "manifest.engines");
+  const engines = record$1(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");
+    fail$5("manifest.engines.saycode", "expected simple semantic version range");
   }
   if (options.saycodeVersion && !engineSupports(saycodeEngine, options.saycodeVersion)) {
-    fail$1(
+    fail$5(
       "manifest.engines.saycode",
       `extension requires Saycode ${saycodeEngine}, but Desktop provides ${options.saycodeVersion}`
     );
@@ -565,51 +772,57 @@ function parseExtensionManifest(value, options) {
   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}`);
+      fail$5("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");
+      fail$5(`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");
+      fail$5(`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 (apiVersion < 3) fail$5(`manifest.permissions[${index}]`, "requires Extension API version 3");
       if (channelApiVersion === void 0) {
-        fail$1(`manifest.permissions[${index}]`, "requires manifest.channelApiVersion");
+        fail$5(`manifest.permissions[${index}]`, "requires manifest.channelApiVersion");
       }
     }
     return typed;
   });
   if (new Set(permissions).size !== permissions.length) {
-    fail$1("manifest.permissions", "duplicate permission");
+    fail$5("manifest.permissions", "duplicate permission");
+  }
+  const managedLocalTool = manifest.managedLocalTool === void 0 ? void 0 : parseManagedLocalTool(manifest.managedLocalTool, parsedId);
+  const machineCommands = manifest.machineCommands === void 0 ? void 0 : parseMachineCommands(manifest.machineCommands, parsedId, apiVersion);
+  if (machineCommands !== void 0 !== permissions.includes("machine.run")) {
+    fail$5("manifest.machineCommands", "machineCommands and machine.run permission must be declared together");
   }
+  if (permissions.some((permission) => permission.startsWith("localTools.")) && (!managedLocalTool || apiVersion < 3)) fail$5("manifest.managedLocalTool", "managed tool metadata and API 3 required");
   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");
+    fail$5("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`);
+    fail$5("manifest.permissions", `${strandedChannelPermission} requires a channels contribution`);
   }
   for (const [index, channel] of (contributes.channels ?? []).entries()) {
     if (!channel.id.startsWith(`${parsedId}.`)) {
-      fail$1(
+      fail$5(
         `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");
+    fail$5("manifest.contributes.artifactActions", "requires artifacts.publishPublic permission");
   }
   for (const [index, action] of (contributes.artifactActions ?? []).entries()) {
     if (!action.id.startsWith(`${parsedId}.`)) {
-      fail$1(
+      fail$5(
         `manifest.contributes.artifactActions[${index}].id`,
         "expected an id declared by the same extension"
       );
@@ -618,7 +831,7 @@ function parseExtensionManifest(value, options) {
   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(
+      fail$5(
         `manifest.contributes.commands[${index}].panelId`,
         "expected a panel declared by the same extension"
       );
@@ -627,7 +840,7 @@ function parseExtensionManifest(value, options) {
   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(
+      fail$5(
         `manifest.contributes.machineActions[${index}].id/command`,
         "expected ids declared by the same extension"
       );
@@ -639,6 +852,8 @@ function parseExtensionManifest(value, options) {
     apiVersion,
     ...channelApiVersion === void 0 ? {} : { channelApiVersion },
     engines: { saycode: saycodeEngine },
+    ...managedLocalTool ? { managedLocalTool } : {},
+    ...machineCommands ? { machineCommands } : {},
     entrypoint: relativePath(manifest.entrypoint, "manifest.entrypoint", true),
     permissions,
     activationEvents,
@@ -648,22 +863,22 @@ function parseExtensionManifest(value, options) {
 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`);
+function plainRecord(value, path2) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail(`${path2} must be an object`);
   const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) fail(`${path} must be a plain object`);
+  if (prototype !== Object.prototype && prototype !== null) fail(`${path2} 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`);
+function text(value, path2) {
+  if (typeof value !== "string" || value.length === 0) fail(`${path2} must be a non-empty string`);
   return value;
 }
-function exactKeys(value, keys, path) {
-  const allowed = new Set(keys);
+function exactKeys(value, keys2, path2) {
+  const allowed = new Set(keys2);
   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}`);
+  if (unknown) fail(`${path2} contains unknown field ${unknown}`);
+  const missing = keys2.find((key) => !(key in value));
+  if (missing) fail(`${path2} is missing ${missing}`);
 }
 const MAX_CHANNEL_NATIVE_PAYLOAD_BYTES = 4096;
 function parseChannelReplyFormatResult(value, request) {
@@ -710,22 +925,22 @@ function parseChannelApprovalRequest(value) {
   }
   return { approvalHandle, approveLabel, denyLabel };
 }
-function finiteNumber(value, path) {
-  if (typeof value !== "number" || !Number.isFinite(value)) fail(`${path} must be a finite number`);
+function finiteNumber(value, path2) {
+  if (typeof value !== "number" || !Number.isFinite(value)) fail(`${path2} must be a finite number`);
   return value;
 }
-function jsonValue(value, path, ancestors = /* @__PURE__ */ new Set()) {
+function jsonValue(value, path2, 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`);
+  if (typeof value === "number") return finiteNumber(value, path2);
+  if (typeof value !== "object") fail(`${path2} contains ${typeof value}`);
+  if (ancestors.has(value)) fail(`${path2} 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);
+    if (Array.isArray(value)) return value.map((item, index) => jsonValue(item, `${path2}[${index}]`, ancestors));
+    const source = plainRecord(value, path2);
     const result = {};
     for (const [key, item] of Object.entries(source)) {
-      result[key] = jsonValue(item, `${path}.${key}`, ancestors);
+      result[key] = jsonValue(item, `${path2}.${key}`, ancestors);
     }
     return result;
   } finally {
@@ -996,7 +1211,7 @@ class ExtensionHostRuntime {
         return;
       }
       if (message.ok) pending.resolve(message.result);
-      else pending.reject(new Error(message.error.message));
+      else pending.reject(Object.assign(new Error(message.error.message), { code: message.error.code }));
       return;
     }
     const envelope = requestEnvelope(value);
@@ -1292,7 +1507,7 @@ async function startExtensionHost(deps) {
   });
   const runtime = new ExtensionHostRuntime({
     manifest,
-    requestTimeoutMs: usesAssetWorkflow(manifest.permissions) ? 13e4 : void 0,
+    requestTimeoutMs: extensionRequestTimeoutMs(manifest.permissions, "runtime"),
     loadModule: (entrypoint) => deps.importModule(protocolUrl(deps.extensionId, entrypoint)),
     send: (message) => deps.bridge.send(message)
   });