@ethisyscore/extension-runtime 1.135.0 → 1.137.0

package/dist/plugin/index.cjs

@@ -11,7 +11,347 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var ReactReconciler__default = /*#__PURE__*/_interopDefault(ReactReconciler);
 
-// src/plugin/ExtensionRuntimeProvider.tsx
+// src/bridge/mcp-error.ts
+var MCP_ERROR_CODES = [
+  "unauthorized",
+  "forbidden",
+  "not_found",
+  "invalid_request",
+  "conflict",
+  "rate_limited",
+  "timeout",
+  "unavailable",
+  "internal"
+];
+function isMcpErrorCode(value) {
+  return typeof value === "string" && MCP_ERROR_CODES.includes(value);
+}
+var RETRYABLE = ["rate_limited", "timeout", "unavailable"];
+function isRetryableMcpErrorCode(code) {
+  return RETRYABLE.includes(code);
+}
+var McpToolError = class extends Error {
+  /** Machine-readable classification. `internal` when the host sent none. */
+  code;
+  /**
+   * Marks the instance for {@link isMcpToolError}. A structural marker rather than a prototype
+   * check because the error can be constructed in one bundle and inspected in another, where
+   * `instanceof` compares two different class objects and answers false.
+   */
+  isMcpToolError = true;
+  constructor(message, code = "internal") {
+    super(message);
+    this.name = "McpHostError";
+    this.code = code;
+  }
+  /** True when this failure is worth retrying unchanged. */
+  get retryable() {
+    return isRetryableMcpErrorCode(this.code);
+  }
+};
+function isMcpToolError(value) {
+  return value instanceof McpToolError || value !== null && typeof value === "object" && value.isMcpToolError === true && isMcpErrorCode(value.code);
+}
+function mcpErrorCodeFromHttpStatus(status) {
+  switch (status) {
+    case 401:
+      return "unauthorized";
+    case 403:
+      return "forbidden";
+    case 404:
+      return "not_found";
+    case 400:
+    case 422:
+      return "invalid_request";
+    case 409:
+    case 412:
+      return "conflict";
+    case 429:
+      return "rate_limited";
+    case 408:
+    case 504:
+      return "timeout";
+    case 502:
+    case 503:
+      return "unavailable";
+    default:
+      return "internal";
+  }
+}
+function classifyHostResponse(response) {
+  if (response.ok) {
+    return void 0;
+  }
+  if (isMcpErrorCode(response.mcpErrorCode)) {
+    return response.mcpErrorCode;
+  }
+  return typeof response.status === "number" ? mcpErrorCodeFromHttpStatus(response.status) : "internal";
+}
+function classifyHostError(err) {
+  if (err === null || typeof err !== "object") {
+    return "internal";
+  }
+  const candidate = err;
+  if (isMcpErrorCode(candidate.mcpErrorCode)) {
+    return candidate.mcpErrorCode;
+  }
+  const status = typeof candidate.status === "number" ? candidate.status : typeof candidate.statusCode === "number" ? candidate.statusCode : void 0;
+  if (status !== void 0) {
+    return mcpErrorCodeFromHttpStatus(status);
+  }
+  if (candidate.name === "AbortError" || candidate.name === "TimeoutError") {
+    return "timeout";
+  }
+  return "internal";
+}
+
+// src/plugin/pluginStorageUpload.ts
+var PLUGIN_STORAGE_UPLOAD_MAX_BYTES = 30 * 1024 * 1024;
+var PLUGIN_STORAGE_PREFIX_MAX_LENGTH = 84;
+var PLUGIN_STORAGE_PATH_MAX_LENGTH = 128;
+var PluginStorageUploadError = class extends McpToolError {
+  /** What went wrong, in terms a caller branches on. */
+  reason;
+  /** HTTP status from the server, when the host surfaced one. */
+  status;
+  /** Structural marker for {@link isPluginStorageUploadError}. */
+  isPluginStorageUploadError = true;
+  constructor(message, reason, options = {}) {
+    super(message, options.code ?? codeForReason(reason, options.status));
+    this.name = "PluginStorageUploadError";
+    this.reason = reason;
+    this.status = options.status;
+  }
+};
+function isPluginStorageUploadError(value) {
+  return value instanceof PluginStorageUploadError || isMcpToolError(value) && value.isPluginStorageUploadError === true;
+}
+function pluginStorageUploadReasonFromStatus(status) {
+  switch (status) {
+    case 400:
+      return "invalid_prefix";
+    case 401:
+      return "unauthorized";
+    case 403:
+      return "forbidden";
+    case 413:
+      return "too_large";
+    case 408:
+      return "timeout";
+    case 415:
+      return "unsupported_type";
+    case 503:
+      return "busy";
+    case 507:
+      return "quota_exceeded";
+    case 500:
+      return "storage_failed";
+    default:
+      return "unknown";
+  }
+}
+function toPluginStorageUploadError(err) {
+  if (isPluginStorageUploadError(err)) {
+    return err;
+  }
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Plugin storage upload failed";
+  const candidate = err !== null && typeof err === "object" ? err : {};
+  const status = typeof candidate.status === "number" ? candidate.status : typeof candidate.statusCode === "number" ? candidate.statusCode : void 0;
+  if (status !== void 0) {
+    return new PluginStorageUploadError(message, pluginStorageUploadReasonFromStatus(status), { status });
+  }
+  if (candidate.name === "AbortError") {
+    return new PluginStorageUploadError(message, "aborted", { code: "timeout" });
+  }
+  if (isMcpToolError(err)) {
+    return new PluginStorageUploadError(message, reasonForCode(err.code), { code: err.code });
+  }
+  return new PluginStorageUploadError(message, "unknown");
+}
+function validatePluginStoragePrefix(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return { ok: false, error: "A storage path prefix is required." };
+  }
+  if (raw.length > PLUGIN_STORAGE_PREFIX_MAX_LENGTH) {
+    return {
+      ok: false,
+      error: `The storage path prefix must be at most ${PLUGIN_STORAGE_PREFIX_MAX_LENGTH} characters, so the stored path fits ${PLUGIN_STORAGE_PATH_MAX_LENGTH}.`
+    };
+  }
+  if (!/^[A-Za-z0-9_\-/]+$/.test(raw)) {
+    return {
+      ok: false,
+      error: "The storage path prefix may contain only letters, digits, '-', '_' and '/' separators."
+    };
+  }
+  if (raw.split("/").some((segment) => segment.length === 0)) {
+    return {
+      ok: false,
+      error: "The storage path prefix must not start or end with '/' or contain an empty segment."
+    };
+  }
+  return { ok: true, prefix: raw };
+}
+function assertValidPluginStoragePrefix(raw) {
+  const result = validatePluginStoragePrefix(raw);
+  if (!result.ok) {
+    throw new PluginStorageUploadError(result.error, "invalid_prefix");
+  }
+  return result.prefix;
+}
+var PLUGIN_STORAGE_UPLOAD_CONTENT_TYPES = Object.freeze({
+  pdf: ["application/pdf"],
+  png: ["image/png"],
+  jpg: ["image/jpeg", "image/pjpeg", "image/jpg"],
+  jpeg: ["image/jpeg", "image/pjpeg", "image/jpg"],
+  gif: ["image/gif"],
+  webp: ["image/webp"],
+  doc: ["application/msword"],
+  docx: ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+  xls: ["application/vnd.ms-excel"],
+  xlsx: ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+  ppt: ["application/vnd.ms-powerpoint"],
+  pptx: ["application/vnd.openxmlformats-officedocument.presentationml.presentation"],
+  odt: ["application/vnd.oasis.opendocument.text"],
+  ods: ["application/vnd.oasis.opendocument.spreadsheet"],
+  odp: ["application/vnd.oasis.opendocument.presentation"],
+  txt: ["text/plain"],
+  csv: ["text/csv", "application/vnd.ms-excel", "application/csv", "text/plain"],
+  zip: ["application/zip", "application/x-zip-compressed", "application/x-zip"],
+  mp3: ["audio/mpeg", "audio/mp3"],
+  m4a: ["audio/mp4", "audio/x-m4a"],
+  mp4: ["video/mp4"]
+});
+var OCTET_STREAM = "application/octet-stream";
+function pluginStorageSafeExtension(fileName) {
+  if (typeof fileName !== "string" || fileName.trim().length === 0) {
+    return "";
+  }
+  const leaf = fileName.split(/[\\/]/).pop() ?? "";
+  const dot = leaf.lastIndexOf(".");
+  if (dot < 0) {
+    return "";
+  }
+  const body = leaf.slice(dot + 1);
+  return /^[A-Za-z0-9]{1,10}$/.test(body) ? `.${body.toLowerCase()}` : "";
+}
+function resolvePluginStorageContentType(fileName, declaredContentType) {
+  const extension = pluginStorageSafeExtension(fileName).slice(1);
+  const allowed = extension.length > 0 && Object.prototype.hasOwnProperty.call(PLUGIN_STORAGE_UPLOAD_CONTENT_TYPES, extension) ? PLUGIN_STORAGE_UPLOAD_CONTENT_TYPES[extension] : void 0;
+  if (allowed === void 0) {
+    return {
+      ok: false,
+      error: "This file type is not allowed. Allowed: " + Object.keys(PLUGIN_STORAGE_UPLOAD_CONTENT_TYPES).sort().join(", ") + "."
+    };
+  }
+  const declared = mediaTypeOf(declaredContentType);
+  if (declared === void 0 || declared === OCTET_STREAM || allowed.includes(declared)) {
+    return { ok: true, contentType: allowed[0] };
+  }
+  return {
+    ok: false,
+    error: `The declared content type '${declared}' does not match the file extension '.${extension}'.`
+  };
+}
+function mediaTypeOf(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const mediaType = raw.split(";")[0].trim().toLowerCase();
+  return /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(mediaType) ? mediaType : void 0;
+}
+async function uploadFileToPluginStorage(transport, file, options) {
+  if (typeof transport.uploadToStorage !== "function") {
+    throw new PluginStorageUploadError(
+      "The active McpTransport does not support plugin-storage uploads (no `uploadToStorage`). The host runtime must implement the uploadToStorage request kind.",
+      "unsupported"
+    );
+  }
+  const uploadToStorage = transport.uploadToStorage.bind(transport);
+  const pathPrefix = assertValidPluginStoragePrefix(options.pathPrefix);
+  const maxSizeBytes = Math.min(options.maxSizeBytes ?? PLUGIN_STORAGE_UPLOAD_MAX_BYTES, PLUGIN_STORAGE_UPLOAD_MAX_BYTES);
+  const isBuffer = file instanceof ArrayBuffer || Object.prototype.toString.call(file) === "[object ArrayBuffer]";
+  const size = isBuffer ? file.byteLength : file.size;
+  if (size > maxSizeBytes) {
+    throw new PluginStorageUploadError(
+      `File is ${size} bytes, which exceeds the ${maxSizeBytes}-byte upload limit.`,
+      "too_large"
+    );
+  }
+  const ownName = isBuffer ? void 0 : file.name;
+  const fileName = nonEmpty(options.fileName) ?? (typeof ownName === "string" ? nonEmpty(ownName) : void 0) ?? "upload.bin";
+  const declaredType = nonEmpty(options.contentType) ?? (isBuffer ? void 0 : nonEmpty(file.type));
+  const resolvedType = resolvePluginStorageContentType(fileName, declaredType);
+  if (!resolvedType.ok) {
+    throw new PluginStorageUploadError(resolvedType.error, "unsupported_type");
+  }
+  if (options.signal?.aborted === true) {
+    throw new PluginStorageUploadError("Aborted", "aborted", { code: "timeout" });
+  }
+  try {
+    const buffer = isBuffer ? file : await readBlob(file);
+    const meta = {
+      pathPrefix,
+      fileName,
+      // The canonical type for the extension: always one the server accepts, and the one
+      // it stores.
+      contentType: resolvedType.contentType,
+      sizeBytes: buffer.byteLength
+    };
+    return await uploadToStorage(meta, buffer, options.signal);
+  } catch (err) {
+    throw toPluginStorageUploadError(err);
+  }
+}
+function readBlob(blob) {
+  if (typeof blob.arrayBuffer === "function") {
+    return blob.arrayBuffer();
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error ?? new Error("Could not read the file."));
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function codeForReason(reason, status) {
+  if (status !== void 0) {
+    return mcpErrorCodeFromHttpStatus(status);
+  }
+  switch (reason) {
+    case "invalid_prefix":
+    case "too_large":
+    case "unsupported_type":
+      return "invalid_request";
+    case "timeout":
+      return "timeout";
+    case "unauthorized":
+      return "unauthorized";
+    case "forbidden":
+      return "forbidden";
+    case "busy":
+      return "unavailable";
+    case "aborted":
+      return "timeout";
+    default:
+      return "internal";
+  }
+}
+function reasonForCode(code) {
+  switch (code) {
+    case "unauthorized":
+      return "unauthorized";
+    case "forbidden":
+      return "forbidden";
+    case "unavailable":
+      return "busy";
+    default:
+      return "unknown";
+  }
+}
 var ClientPushContext = react.createContext(null);
 function useClientPushSubscription(options) {
   const { groups, onEvent, onResync, enabled = true } = options;
@@ -568,100 +908,6 @@ function defaultConnectionFactory(port) {
   };
 }
 
-// src/bridge/mcp-error.ts
-var MCP_ERROR_CODES = [
-  "unauthorized",
-  "forbidden",
-  "not_found",
-  "invalid_request",
-  "conflict",
-  "rate_limited",
-  "timeout",
-  "unavailable",
-  "internal"
-];
-function isMcpErrorCode(value) {
-  return typeof value === "string" && MCP_ERROR_CODES.includes(value);
-}
-var RETRYABLE = ["rate_limited", "timeout", "unavailable"];
-function isRetryableMcpErrorCode(code) {
-  return RETRYABLE.includes(code);
-}
-var McpToolError = class extends Error {
-  /** Machine-readable classification. `internal` when the host sent none. */
-  code;
-  /**
-   * Marks the instance for {@link isMcpToolError}. A structural marker rather than a prototype
-   * check because the error can be constructed in one bundle and inspected in another, where
-   * `instanceof` compares two different class objects and answers false.
-   */
-  isMcpToolError = true;
-  constructor(message, code = "internal") {
-    super(message);
-    this.name = "McpHostError";
-    this.code = code;
-  }
-  /** True when this failure is worth retrying unchanged. */
-  get retryable() {
-    return isRetryableMcpErrorCode(this.code);
-  }
-};
-function isMcpToolError(value) {
-  return value instanceof McpToolError || value !== null && typeof value === "object" && value.isMcpToolError === true && isMcpErrorCode(value.code);
-}
-function mcpErrorCodeFromHttpStatus(status) {
-  switch (status) {
-    case 401:
-      return "unauthorized";
-    case 403:
-      return "forbidden";
-    case 404:
-      return "not_found";
-    case 400:
-    case 422:
-      return "invalid_request";
-    case 409:
-    case 412:
-      return "conflict";
-    case 429:
-      return "rate_limited";
-    case 408:
-    case 504:
-      return "timeout";
-    case 502:
-    case 503:
-      return "unavailable";
-    default:
-      return "internal";
-  }
-}
-function classifyHostResponse(response) {
-  if (response.ok) {
-    return void 0;
-  }
-  if (isMcpErrorCode(response.mcpErrorCode)) {
-    return response.mcpErrorCode;
-  }
-  return typeof response.status === "number" ? mcpErrorCodeFromHttpStatus(response.status) : "internal";
-}
-function classifyHostError(err) {
-  if (err === null || typeof err !== "object") {
-    return "internal";
-  }
-  const candidate = err;
-  if (isMcpErrorCode(candidate.mcpErrorCode)) {
-    return candidate.mcpErrorCode;
-  }
-  const status = typeof candidate.status === "number" ? candidate.status : typeof candidate.statusCode === "number" ? candidate.statusCode : void 0;
-  if (status !== void 0) {
-    return mcpErrorCodeFromHttpStatus(status);
-  }
-  if (candidate.name === "AbortError" || candidate.name === "TimeoutError") {
-    return "timeout";
-  }
-  return "internal";
-}
-
 // src/plugin/createPortMcpTransport.ts
 var WIRE_INVOKE_TOOL_REQUEST = "ethisys:mcp:invokeTool";
 var WIRE_INVOKE_TOOL_RESULT = "ethisys:mcp:invokeTool:result";
@@ -671,13 +917,15 @@ var WIRE_GET_RESOURCE_REQUEST = "ethisys:mcp:getResource";
 var WIRE_GET_RESOURCE_RESULT = "ethisys:mcp:getResource:result";
 var WIRE_UPLOAD_DOCUMENT_REQUEST = "ethisys:mcp:uploadDocument";
 var WIRE_UPLOAD_DOCUMENT_RESULT = "ethisys:mcp:uploadDocument:result";
+var WIRE_UPLOAD_TO_STORAGE_REQUEST = "ethisys:mcp:uploadToStorage";
+var WIRE_UPLOAD_TO_STORAGE_RESULT = "ethisys:mcp:uploadToStorage:result";
 var WIRE_ABORT = "ethisys:mcp:abort";
 function isMcpResultEnvelope(value) {
   if (value === null || typeof value !== "object") {
     return false;
   }
   const v = value;
-  return (v.type === WIRE_INVOKE_TOOL_RESULT || v.type === WIRE_INVOKE_OPERATION_RESULT || v.type === WIRE_GET_RESOURCE_RESULT || v.type === WIRE_UPLOAD_DOCUMENT_RESULT) && typeof v.id === "string";
+  return (v.type === WIRE_INVOKE_TOOL_RESULT || v.type === WIRE_INVOKE_OPERATION_RESULT || v.type === WIRE_GET_RESOURCE_RESULT || v.type === WIRE_UPLOAD_DOCUMENT_RESULT || v.type === WIRE_UPLOAD_TO_STORAGE_RESULT) && typeof v.id === "string";
 }
 function createPortMcpTransport(port, options = {}) {
   if (port === void 0 || port === null) {
@@ -701,10 +949,18 @@ function createPortMcpTransport(port, options = {}) {
     if (reply.ok === true) {
       resolver.resolve(reply.data);
     } else {
-      resolver.reject(new McpToolError(
-        typeof reply.error === "string" ? reply.error : "Unknown host error",
-        isMcpErrorCode(reply.code) ? reply.code : "internal"
-      ));
+      const message = typeof reply.error === "string" ? reply.error : "Unknown host error";
+      const code = isMcpErrorCode(reply.code) ? reply.code : "internal";
+      if (reply.type === WIRE_UPLOAD_TO_STORAGE_RESULT) {
+        const status = typeof reply.status === "number" && Number.isInteger(reply.status) ? reply.status : void 0;
+        resolver.reject(new PluginStorageUploadError(
+          message,
+          status !== void 0 ? pluginStorageUploadReasonFromStatus(status) : "unknown",
+          { status, code }
+        ));
+        return;
+      }
+      resolver.reject(new McpToolError(message, code));
     }
   }
   shim.addEventListener("message", onMessage);
@@ -762,6 +1018,15 @@ function createPortMcpTransport(port, options = {}) {
         [buffer]
       );
       return data;
+    },
+    async uploadToStorage(meta, buffer, signal) {
+      const data = await send(
+        WIRE_UPLOAD_TO_STORAGE_REQUEST,
+        { meta, buffer },
+        signal,
+        [buffer]
+      );
+      return data;
     }
   };
 }
@@ -1022,7 +1287,13 @@ exports.ExtensionRuntimeProvider = ExtensionRuntimeProvider;
 exports.HostIdentityContext = HostIdentityContext;
 exports.MCP_ERROR_CODES = MCP_ERROR_CODES;
 exports.McpToolError = McpToolError;
+exports.PLUGIN_STORAGE_PATH_MAX_LENGTH = PLUGIN_STORAGE_PATH_MAX_LENGTH;
+exports.PLUGIN_STORAGE_PREFIX_MAX_LENGTH = PLUGIN_STORAGE_PREFIX_MAX_LENGTH;
+exports.PLUGIN_STORAGE_UPLOAD_CONTENT_TYPES = PLUGIN_STORAGE_UPLOAD_CONTENT_TYPES;
+exports.PLUGIN_STORAGE_UPLOAD_MAX_BYTES = PLUGIN_STORAGE_UPLOAD_MAX_BYTES;
 exports.PluginRealtimeContext = PluginRealtimeContext;
+exports.PluginStorageUploadError = PluginStorageUploadError;
+exports.assertValidPluginStoragePrefix = assertValidPluginStoragePrefix;
 exports.classifyHostError = classifyHostError;
 exports.classifyHostResponse = classifyHostResponse;
 exports.createPortBridgeClient = createPortBridgeClient;
@@ -1033,9 +1304,15 @@ exports.defineDeclarativePlugin = defineDeclarativePlugin;
 exports.defineEthisysPlugin = defineEthisysPlugin;
 exports.isMcpErrorCode = isMcpErrorCode;
 exports.isMcpToolError = isMcpToolError;
+exports.isPluginStorageUploadError = isPluginStorageUploadError;
 exports.isRetryableMcpErrorCode = isRetryableMcpErrorCode;
 exports.mcpErrorCodeFromHttpStatus = mcpErrorCodeFromHttpStatus;
+exports.pluginStorageSafeExtension = pluginStorageSafeExtension;
+exports.pluginStorageUploadReasonFromStatus = pluginStorageUploadReasonFromStatus;
+exports.resolvePluginStorageContentType = resolvePluginStorageContentType;
+exports.toPluginStorageUploadError = toPluginStorageUploadError;
 exports.unwrapItems = unwrapItems;
+exports.uploadFileToPluginStorage = uploadFileToPluginStorage;
 exports.useAuth = useAuth;
 exports.useBridgeClient = useBridgeClient;
 exports.useBridgeLocale = useBridgeLocale;
@@ -1051,5 +1328,6 @@ exports.useModuleQuery = useModuleQuery;
 exports.useModuleTool = useModuleTool;
 exports.useOptionalExtensionRuntimeTransport = useOptionalExtensionRuntimeTransport;
 exports.usePluginRealtimeSource = usePluginRealtimeSource;
+exports.validatePluginStoragePrefix = validatePluginStoragePrefix;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map