@clipbus/plugin-sdk 0.7.0

package/dist/runtime/index.js

@@ -0,0 +1,132 @@
+// src/internal/internalConsole.ts
+function pick(method) {
+  if (typeof globalThis === "undefined") return () => {
+  };
+  const g = globalThis;
+  const fn = g.console?.[method];
+  if (typeof fn !== "function") return () => {
+  };
+  return fn.bind(g.console);
+}
+var internalConsole = Object.freeze({
+  log: pick("log"),
+  warn: pick("warn"),
+  error: pick("error")
+});
+
+// src/internal/ipcBus.ts
+var _instance = null;
+var ipcBus = new Proxy({}, {
+  get(_target, prop) {
+    if (!_instance) {
+      throw new Error("[clipbus-plugin] ipcBus accessed before configureIpcBus() was called.");
+    }
+    return _instance[prop];
+  }
+});
+
+// src/generated/runtime.host.generated.ts
+var host = {
+  item: {
+    setTags: (payload) => ipcBus.request("item.setTags", payload),
+    addTags: (payload) => ipcBus.request("item.addTags", payload),
+    removeTags: (payload) => ipcBus.request("item.removeTags", payload),
+    setPinned: (payload) => ipcBus.request("item.setPinned", payload),
+    setAttachments: (payload) => ipcBus.request("item.setAttachments", payload),
+    setSearchExtension: (payload) => ipcBus.request("item.setSearchExtension", payload),
+    materializeImagePath: () => ipcBus.request("item.materializeImagePath", {}),
+    readAttachment: (payload) => ipcBus.request("item.readAttachment", payload)
+  },
+  asset: {
+    registerImage: (payload) => ipcBus.request("asset.registerImage", payload)
+  },
+  clipboard: {
+    copyText: (payload) => ipcBus.request("clipboard.copyText", payload)
+  },
+  navigation: {
+    openUrl: (payload) => ipcBus.request("navigation.openUrl", payload),
+    revealInFinder: (payload) => ipcBus.request("navigation.revealInFinder", payload),
+    openFilePath: (payload) => ipcBus.request("navigation.openFilePath", payload)
+  },
+  action: {
+    allocateImageTempPath: (payload) => ipcBus.request("action.allocateImageTempPath", payload)
+  },
+  settings: {
+    get: (payload) => ipcBus.request("settings.get", payload),
+    getAll: () => ipcBus.request("settings.getAll", {})
+  },
+  console: {
+    log: (payload) => ipcBus.request("console.log", payload)
+  }
+};
+
+// src/generated/runtime.definePlugin.generated.ts
+function definePlugin(definition) {
+  if ("setup" in definition) {
+    return {
+      setup() {
+        const registry = definition.setup();
+        validateRegistry(registry);
+        return registry;
+      }
+    };
+  }
+  validateRegistry(definition);
+  return { setup() {
+    return definition;
+  } };
+}
+function validateRegistry(registry) {
+  for (const [id, handler] of Object.entries(registry.attachmentRenderers ?? {})) {
+    if (handler && typeof handler === "object" && "invokeOperation" in handler) {
+      throw new Error(`attachmentRenderers["${id}"]: invokeOperation has been removed.`);
+    }
+  }
+  for (const [id, handler] of Object.entries(registry.actions ?? {})) {
+    if (handler && typeof handler === "object" && "invokeOperation" in handler) {
+      throw new Error(`actions["${id}"]: invokeOperation has been removed.`);
+    }
+  }
+}
+
+// src/generated/runtime.actionResult.generated.ts
+var actionResult = {
+  text: (text, options) => ({
+    result: { resultKind: "text", text },
+    userMessage: options?.userMessage
+  }),
+  image: (imageTempPath, options) => ({
+    result: { resultKind: "image", imageTempPath, ...options && "imageFormatHint" in options ? { imageFormatHint: options.imageFormatHint } : {} },
+    userMessage: options?.userMessage
+  }),
+  none: (options) => ({
+    result: { resultKind: "none" },
+    userMessage: options?.userMessage
+  })
+};
+
+// src/runtime/defineMessage.ts
+function defineMessage(key) {
+  return {
+    key,
+    handle: (fn) => [key, ((req, ctx) => fn(req, ctx))]
+  };
+}
+
+// src/internal/capabilities.ts
+var CapabilityUnsupportedError = class extends Error {
+  capability;
+  constructor(capability) {
+    super(`Capability not supported by host: ${capability}`);
+    this.name = "CapabilityUnsupportedError";
+    this.capability = capability;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+export {
+  CapabilityUnsupportedError,
+  actionResult,
+  defineMessage,
+  definePlugin,
+  host
+};

package/dist/shared/defineMessage.d.ts

@@ -0,0 +1,7 @@
+export interface MessageContract<TReq, TResp> {
+    readonly key: string;
+    readonly __types?: {
+        req: TReq;
+        resp: TResp;
+    };
+}

package/dist/ui/defineMessage.d.ts

@@ -0,0 +1,7 @@
+import type { MessageContract } from '../shared/defineMessage.js';
+export interface UIMessageContract<TReq, TResp> extends MessageContract<TReq, TResp> {
+    invoke(payload: TReq, options?: {
+        timeoutMs?: number;
+    }): Promise<TResp>;
+}
+export declare function defineMessage<TReq, TResp>(key: string): UIMessageContract<TReq, TResp>;

package/dist/ui/index.cjs

@@ -0,0 +1,362 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ui/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CapabilityUnsupportedError: () => CapabilityUnsupportedError,
+  PluginContextError: () => PluginContextError,
+  clipbus: () => clipbus,
+  defineMessage: () => defineMessage
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/generated/wireConstants.generated.ts
+var STRUCTURED_ERROR_PREFIX = "__clipbus_structured_error__:";
+var CAPABILITIES_GLOBAL = "__CLIPBUS_PLUGIN_CAPABILITIES__";
+var CAPABILITY_UNSUPPORTED_ERROR_NAME = "PluginCapabilityUnsupported";
+
+// src/internal/capabilities.ts
+var CapabilityUnsupportedError = class extends Error {
+  capability;
+  constructor(capability) {
+    super(`Capability not supported by host: ${capability}`);
+    this.name = "CapabilityUnsupportedError";
+    this.capability = capability;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function readInjectedCapabilities(global, key) {
+  const obj = global;
+  const raw = obj?.[key];
+  if (Array.isArray(raw?.capabilities)) {
+    return new Set(raw.capabilities);
+  }
+  return /* @__PURE__ */ new Set();
+}
+function createCapabilitiesApi(getSet) {
+  return {
+    has: (name) => getSet().has(name)
+  };
+}
+function mapToCapabilityError(err, unsupportedName) {
+  if (err.name === unsupportedName) {
+    const cap = err.data?.capability ?? "";
+    return new CapabilityUnsupportedError(cap);
+  }
+  const m = /^Unknown method:\s*(.+)$/.exec(err.message);
+  if (m) return new CapabilityUnsupportedError(m[1]);
+  return err;
+}
+
+// src/internal/runtimeInvokeClient.ts
+var HANDLER_NAME = "clipbusPluginCall";
+async function callRuntimeInvokeStrict(payload) {
+  const handler = globalThis.webkit?.messageHandlers?.[HANDLER_NAME];
+  if (!handler) {
+    throw new Error("runtime.invoke is only available inside a Clipbus plugin WebView");
+  }
+  const normalized = JSON.parse(JSON.stringify(payload));
+  let reply;
+  try {
+    reply = await handler.postMessage({ method: "runtime.invoke", payload: normalized });
+  } catch (err) {
+    throw parseReplyError(err);
+  }
+  return reply?.response;
+}
+function parseReplyError(raw) {
+  const message = extractMessage(raw);
+  if (message.startsWith(STRUCTURED_ERROR_PREFIX)) {
+    const json = message.slice(STRUCTURED_ERROR_PREFIX.length);
+    try {
+      const parsed = JSON.parse(json);
+      const err = new Error(typeof parsed.message === "string" ? parsed.message : "");
+      if (typeof parsed.name === "string" && parsed.name.length > 0) {
+        err.name = parsed.name;
+      }
+      if (parsed.data !== void 0) {
+        err.data = parsed.data;
+      }
+      return mapToCapabilityError(err, CAPABILITY_UNSUPPORTED_ERROR_NAME);
+    } catch {
+      return new Error(message);
+    }
+  }
+  return mapToCapabilityError(new Error(message), CAPABILITY_UNSUPPORTED_ERROR_NAME);
+}
+function extractMessage(raw) {
+  if (typeof raw === "string") return raw;
+  if (raw instanceof Error) return raw.message;
+  if (raw && typeof raw === "object" && "message" in raw) {
+    const m = raw.message;
+    if (typeof m === "string") return m;
+  }
+  return String(raw);
+}
+
+// src/generated/capabilityClients.generated.ts
+var HANDLER_NAME2 = "clipbusPluginCall";
+async function callPluginMethod(method, payload) {
+  const handler = globalThis.webkit?.messageHandlers?.[HANDLER_NAME2];
+  if (!handler) {
+    const err = new Error("clipbus." + method + " is only available inside a Clipbus plugin WebView");
+    err.name = "PluginHostBridgeUnavailable";
+    throw err;
+  }
+  const normalized = JSON.parse(JSON.stringify(payload));
+  let reply;
+  try {
+    reply = await handler.postMessage({ method, payload: normalized });
+  } catch (err) {
+    throw parseReplyError(err);
+  }
+  return reply;
+}
+var callItemReadAttachment = (payload) => callPluginMethod("item.readAttachment", payload);
+var callAssetCurrentItemImageUrl = () => callPluginMethod("asset.currentItemImageUrl", {});
+var callAssetPathReferenceImageUrl = (payload) => callPluginMethod("asset.pathReferenceImageUrl", payload);
+var callClipboardCopyText = (payload) => callPluginMethod("clipboard.copyText", payload);
+var callNavigationOpenUrl = (payload) => callPluginMethod("navigation.openUrl", payload);
+var callNavigationRevealInFinder = (payload) => callPluginMethod("navigation.revealInFinder", payload);
+var callNavigationOpenFilePath = (payload) => callPluginMethod("navigation.openFilePath", payload);
+var callActionSetButtons = (payload) => callPluginMethod("action.setButtons", payload);
+var callActionComplete = (payload) => callPluginMethod("action.complete", payload);
+var callAttachmentRendererSetButtons = (payload) => callPluginMethod("attachmentRenderer.setButtons", payload);
+var callWindowSetHeight = (payload) => callPluginMethod("window.setHeight", payload);
+var callWindowAutoFit = () => callPluginMethod("window.autoFit", {});
+var callInfoPanelOpen = (payload) => callPluginMethod("infoPanel.open", payload);
+var callInfoPanelClose = (payload) => callPluginMethod("infoPanel.close", payload);
+var callSettingsGet = (payload) => callPluginMethod("settings.get", payload);
+var callSettingsGetAll = () => callPluginMethod("settings.getAll", {});
+var callConsoleLog = (payload) => callPluginMethod("console.log", payload);
+var callTextInputStateChanged = (payload) => callPluginMethod("textInput.stateChanged", payload);
+
+// src/internal/topic.ts
+function createTopic(initial) {
+  let value = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    current: () => value,
+    on(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    set(next) {
+      value = next;
+      for (const l of listeners) {
+        try {
+          l(value);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function createStream() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    on(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit(event) {
+      for (const l of listeners) {
+        try {
+          l(event);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function readWindowGlobal(key) {
+  if (typeof window === "undefined") return void 0;
+  return window[key];
+}
+
+// src/generated/topicSubscribers.generated.ts
+function onContext(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-context", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-context", handler);
+}
+function onItem(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-item", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-item", handler);
+}
+function onAttachment(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-attachment", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-attachment", handler);
+}
+function onDraft(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-draft", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-draft", handler);
+}
+function onTheme(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-theme", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-theme", handler);
+}
+function onAttachmentHostInvoke(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-attachment-host-invoke", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-attachment-host-invoke", handler);
+}
+function onActionHostInvoke(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-action-host-invoke", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-action-host-invoke", handler);
+}
+function onInfoPanelOnAction(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-info-panel-on-action", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-info-panel-on-action", handler);
+}
+function onInfoPanelOnClose(listener) {
+  const handler = (e) => listener(e.detail);
+  globalThis.addEventListener("clipbus-plugin-info-panel-on-close", handler);
+  return () => globalThis.removeEventListener("clipbus-plugin-info-panel-on-close", handler);
+}
+
+// src/generated/ui.bootstrap.generated.ts
+var _pluginContextTopic = createTopic(readWindowGlobal("__CLIPBUS_PLUGIN_CONTEXT__"));
+onContext((p) => _pluginContextTopic.set(p));
+var _itemTopic = createTopic(readWindowGlobal("__CLIPBUS_PLUGIN_ITEM__"));
+onItem((p) => _itemTopic.set(p));
+var _itemAttachmentTopic = createTopic(readWindowGlobal("__CLIPBUS_PLUGIN_ATTACHMENT__"));
+onAttachment((p) => _itemAttachmentTopic.set(p));
+var _actionDraftTopic = createTopic(readWindowGlobal("__CLIPBUS_PLUGIN_DRAFT__"));
+onDraft((p) => _actionDraftTopic.set(p));
+var _themeTopic = createTopic(readWindowGlobal("__CLIPBUS_PLUGIN_THEME__"));
+onTheme((p) => _themeTopic.set(p));
+var _attachmentRendererOnHostInvokeStream = createStream();
+onAttachmentHostInvoke((p) => _attachmentRendererOnHostInvokeStream.emit(p));
+var _actionOnHostInvokeStream = createStream();
+onActionHostInvoke((p) => _actionOnHostInvokeStream.emit(p));
+var _infoPanelOnActionStream = createStream();
+onInfoPanelOnAction((p) => _infoPanelOnActionStream.emit(p));
+var _infoPanelOnCloseStream = createStream();
+onInfoPanelOnClose((p) => _infoPanelOnCloseStream.emit(p));
+var PluginContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PluginContextError";
+  }
+};
+function guardContext(expected, run) {
+  return (...args) => {
+    const current = _pluginContextTopic.current()?.mode;
+    if (current !== expected) {
+      throw new PluginContextError(
+        `This verb is not available in the current plugin context (expected: ${expected}, got: ${current || "unknown"})`
+      );
+    }
+    return run(...args);
+  };
+}
+
+// src/generated/ui.clipbus.generated.ts
+var clipbus = {
+  capabilities: createCapabilitiesApi(() => readInjectedCapabilities(globalThis, CAPABILITIES_GLOBAL)),
+  runtime: {
+    invoke: (payload) => callRuntimeInvokeStrict(payload)
+  },
+  item: {
+    current: () => _itemTopic.current(),
+    on: (fn) => _itemTopic.on(fn),
+    readAttachment: (payload) => callItemReadAttachment(payload),
+    attachment: {
+      current: () => _itemAttachmentTopic.current(),
+      on: (fn) => _itemAttachmentTopic.on(fn)
+    }
+  },
+  asset: {
+    currentItemImageUrl: () => callAssetCurrentItemImageUrl(),
+    pathReferenceImageUrl: (payload) => callAssetPathReferenceImageUrl(payload)
+  },
+  clipboard: {
+    copyText: (payload) => callClipboardCopyText(payload)
+  },
+  navigation: {
+    openUrl: (payload) => callNavigationOpenUrl(payload),
+    revealInFinder: (payload) => callNavigationRevealInFinder(payload),
+    openFilePath: (payload) => callNavigationOpenFilePath(payload)
+  },
+  action: {
+    setButtons: guardContext("action", (payload) => callActionSetButtons(payload)),
+    complete: guardContext("action", (payload) => callActionComplete(payload)),
+    draft: {
+      current: () => _actionDraftTopic.current(),
+      on: (fn) => _actionDraftTopic.on(fn)
+    },
+    onHostInvoke: {
+      on: (fn) => _actionOnHostInvokeStream.on(fn)
+    }
+  },
+  attachmentRenderer: {
+    setButtons: guardContext("attachmentRenderer", (payload) => callAttachmentRendererSetButtons(payload)),
+    onHostInvoke: {
+      on: (fn) => _attachmentRendererOnHostInvokeStream.on(fn)
+    }
+  },
+  window: {
+    setHeight: (payload) => callWindowSetHeight(payload),
+    autoFit: () => callWindowAutoFit()
+  },
+  infoPanel: {
+    open: (payload) => callInfoPanelOpen(payload),
+    close: (payload) => callInfoPanelClose(payload),
+    onAction: {
+      on: (fn) => _infoPanelOnActionStream.on(fn)
+    },
+    onClose: {
+      on: (fn) => _infoPanelOnCloseStream.on(fn)
+    }
+  },
+  settings: {
+    get: (payload) => callSettingsGet(payload),
+    getAll: () => callSettingsGetAll()
+  },
+  console: {
+    log: (payload) => callConsoleLog(payload)
+  },
+  textInput: {
+    stateChanged: (payload) => callTextInputStateChanged(payload)
+  },
+  pluginContext: {
+    current: () => _pluginContextTopic.current(),
+    on: (fn) => _pluginContextTopic.on(fn)
+  },
+  theme: {
+    current: () => _themeTopic.current(),
+    on: (fn) => _themeTopic.on(fn)
+  }
+};
+
+// src/ui/defineMessage.ts
+function defineMessage(key) {
+  return {
+    key,
+    invoke: async (payload, options) => await clipbus.runtime.invoke({ key, payload, timeoutMs: options?.timeoutMs })
+  };
+}

package/dist/ui/index.d.cts

@@ -0,0 +1,4 @@
+export * from '../generated/INDEX.ui.generated.js';
+export { defineMessage } from './defineMessage.js';
+export type { UIMessageContract } from './defineMessage.js';
+export { CapabilityUnsupportedError } from '../internal/capabilities.js';

package/dist/ui/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../generated/INDEX.ui.generated.js';
+export { defineMessage } from './defineMessage.js';
+export type { UIMessageContract } from './defineMessage.js';
+export { CapabilityUnsupportedError } from '../internal/capabilities.js';