@clipbus/plugin-sdk 0.7.0

package/dist/dom/index.js

@@ -0,0 +1,188 @@
+// src/generated/wireConstants.generated.ts
+var STRUCTURED_ERROR_PREFIX = "__clipbus_structured_error__:";
+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 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
+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_NAME = "clipbusPluginCall";
+async function callPluginMethod(method, payload) {
+  const handler = globalThis.webkit?.messageHandlers?.[HANDLER_NAME];
+  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 callWindowSetHeight = (payload) => callPluginMethod("window.setHeight", payload);
+var callConsoleLog = (payload) => callPluginMethod("console.log", payload);
+var callTextInputStateChanged = (payload) => callPluginMethod("textInput.stateChanged", payload);
+
+// 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/dom/autoFit.ts
+function autoFit(options) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const min = options?.min ?? 0;
+  const max = options?.max ?? Infinity;
+  const target = options?.target ?? document.body;
+  let pending = false;
+  function post() {
+    if (pending) return;
+    pending = true;
+    requestAnimationFrame(() => {
+      pending = false;
+      const raw = target.scrollHeight;
+      const clamped = Math.min(max, Math.max(min, raw));
+      callWindowSetHeight({ height: clamped }).catch((err) => {
+        internalConsole.warn("[clipbus-sdk] autoFit: window.setHeight failed:", err);
+      });
+    });
+  }
+  const ro = new ResizeObserver(post);
+  ro.observe(target);
+  const mo = new MutationObserver(post);
+  mo.observe(target, { childList: true, subtree: true, characterData: true, attributes: true });
+  post();
+  return () => {
+    ro.disconnect();
+    mo.disconnect();
+  };
+}
+
+// src/dom/consolePatch.ts
+var _patched = false;
+var _inFlight = 0;
+function patchConsole() {
+  if (_patched) return;
+  _patched = true;
+  const wrap = (level, original) => (...args) => {
+    original(...args);
+    if (_inFlight > 0) return;
+    _inFlight++;
+    Promise.resolve().then(() => callConsoleLog({ level, message: args.map(String).join(" ") })).catch((err) => {
+      internalConsole.warn("[clipbus-sdk] consolePatch: forward to host failed:", err);
+    }).finally(() => {
+      _inFlight--;
+    });
+  };
+  console.log = wrap("info", internalConsole.log);
+  console.warn = wrap("warn", internalConsole.warn);
+  console.error = wrap("error", internalConsole.error);
+}
+
+// src/dom/textInputState.ts
+var _patched2 = false;
+function patchTextInputState() {
+  if (_patched2 || typeof window === "undefined") return;
+  _patched2 = true;
+  let isFocused = false;
+  let isComposing = false;
+  function post() {
+    callTextInputStateChanged({ isFocused, isComposing }).catch((err) => {
+      internalConsole.warn("[clipbus-sdk] textInputState: dispatch failed:", err);
+    });
+  }
+  document.addEventListener("focusin", () => {
+    isFocused = true;
+    post();
+  });
+  document.addEventListener("focusout", () => {
+    isFocused = false;
+    post();
+  });
+  document.addEventListener("compositionstart", () => {
+    isComposing = true;
+    post();
+  });
+  document.addEventListener("compositionend", () => {
+    isComposing = false;
+    post();
+  });
+}
+
+// src/dom/topicAdapter.ts
+function bindTopicTo(topic, set) {
+  set(topic.current());
+  return topic.on((value) => set(value));
+}
+export {
+  autoFit,
+  bindTopicTo,
+  patchConsole,
+  patchTextInputState
+};

package/dist/dom/textInputState.d.ts

@@ -0,0 +1 @@
+export declare function patchTextInputState(): void;

package/dist/dom/topicAdapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Framework-agnostic helper for binding a SDK topic to any reactive state
+ * system (Vue, React, Svelte, plain callbacks, …).
+ *
+ * `Topic<T>` is the interface from sdk/src/internal/topic.ts.
+ * We intentionally replicate the minimal shape here (structural typing) so this
+ * file has zero runtime imports — it works equally well in Node test runners and
+ * browser bundles.
+ */
+/** Minimal structural shape satisfied by Topic<T>. */
+export interface TopicLike<T> {
+    current(): T | undefined;
+    on(listener: (value: T) => void): () => void;
+}
+/**
+ * Bind a topic to a setter function and return an unsubscribe handle.
+ *
+ * Calls `set` immediately with `topic.current()` (which may be `undefined` if
+ * the topic has not yet received a value), then subscribes `set` as a listener
+ * for future updates.
+ *
+ * Usage (Vue):
+ * ```ts
+ * const state = ref<T | undefined>(undefined);
+ * const unsub = bindTopicTo(topic, (v) => { state.value = v; });
+ * // later:
+ * unsub();
+ * ```
+ */
+export declare function bindTopicTo<T>(topic: TopicLike<T>, set: (value: T | undefined) => void): () => void;

package/dist/generated/INDEX.runtime.generated.d.ts

@@ -0,0 +1,6 @@
+export { host } from './runtime.host.generated.js';
+export { definePlugin } from './runtime.definePlugin.generated.js';
+export { actionResult } from './runtime.actionResult.generated.js';
+export type * from './data.generated.js';
+export type * from './capabilityClients.generated.js';
+export type * from './runtime.handlers.generated.js';

package/dist/generated/INDEX.ui.generated.d.ts

@@ -0,0 +1,4 @@
+export { clipbus } from './ui.clipbus.generated.js';
+export type * from './data.generated.js';
+export type * from './capabilityClients.generated.js';
+export { PluginContextError } from './ui.bootstrap.generated.js';

package/dist/generated/capabilityClients.generated.d.ts

@@ -0,0 +1,199 @@
+import type { PluginActionResult, PluginAttachmentMutationEntry, PluginConsoleLogLevel, PluginInfoPanelDocument, PluginSearchExtensionEntry } from './data.generated.js';
+export interface PluginRuntimeInvokePayload {
+    key: string;
+    payload: unknown;
+    timeoutMs?: number;
+}
+export interface PluginRuntimeInvokeResponse {
+    response: unknown;
+}
+export interface PluginItemSetTagsPayload {
+    tags: string[];
+}
+export interface PluginItemSetTagsResponse {
+    tags: string[];
+}
+export interface PluginItemAddTagsPayload {
+    tags: string[];
+}
+export interface PluginItemAddTagsResponse {
+    tags: string[];
+}
+export interface PluginItemRemoveTagsPayload {
+    tags: string[];
+}
+export interface PluginItemRemoveTagsResponse {
+    tags: string[];
+}
+export interface PluginItemSetPinnedPayload {
+    pinned: boolean;
+}
+export interface PluginItemSetPinnedResponse {
+    pinned: boolean;
+}
+export interface PluginItemSetAttachmentsPayload {
+    owner: string;
+    attachmentType: string;
+    attachments: PluginAttachmentMutationEntry[];
+}
+export interface PluginItemSetAttachmentsResponse {
+}
+export interface PluginItemSetSearchExtensionPayload {
+    scope: string;
+    owner: string;
+    entries: PluginSearchExtensionEntry[];
+}
+export interface PluginItemSetSearchExtensionResponse {
+}
+export interface PluginItemMaterializeImagePathPayload {
+}
+export interface PluginItemMaterializeImagePathResponse {
+    path: string;
+}
+export interface PluginItemReadAttachmentPayload {
+    attachmentType: string;
+    attachmentKey: string;
+}
+export interface PluginItemReadAttachmentResponse {
+    payloadJson?: string;
+}
+export interface PluginAssetCurrentItemImageUrlPayload {
+}
+export interface PluginAssetCurrentItemImageUrlResponse {
+    url?: string;
+}
+export interface PluginAssetPathReferenceImageUrlPayload {
+    index: number;
+}
+export interface PluginAssetPathReferenceImageUrlResponse {
+    url?: string;
+}
+export interface PluginAssetRegisterImagePayload {
+    path: string;
+}
+export interface PluginAssetRegisterImageResponse {
+    url: string;
+}
+export interface PluginClipboardCopyTextPayload {
+    text: string;
+}
+export interface PluginClipboardCopyTextResponse {
+}
+export interface PluginNavigationOpenUrlPayload {
+    url: string;
+}
+export interface PluginNavigationOpenUrlResponse {
+}
+export interface PluginNavigationRevealInFinderPayload {
+    path: string;
+}
+export interface PluginNavigationRevealInFinderResponse {
+}
+export interface PluginNavigationOpenFilePathPayload {
+    path: string;
+}
+export interface PluginNavigationOpenFilePathResponse {
+}
+export interface PluginActionAllocateImageTempPathPayload {
+    formatHint: string;
+}
+export interface PluginActionAllocateImageTempPathResponse {
+    path: string;
+}
+export interface PluginActionSetButtonsPayload {
+    buttons: {
+        id: string;
+        title: string;
+        isEnabled?: boolean;
+    }[];
+}
+export interface PluginActionSetButtonsResponse {
+}
+export interface PluginActionCompletePayload {
+    result: PluginActionResult;
+    userMessage?: string;
+}
+export interface PluginActionCompleteResponse {
+}
+export interface PluginAttachmentRendererSetButtonsPayload {
+    buttons: {
+        id: string;
+        title: string;
+        isEnabled?: boolean;
+    }[];
+}
+export interface PluginAttachmentRendererSetButtonsResponse {
+}
+export interface PluginWindowSetHeightPayload {
+    height: number;
+}
+export interface PluginWindowSetHeightResponse {
+}
+export interface PluginWindowAutoFitPayload {
+}
+export interface PluginWindowAutoFitResponse {
+}
+export interface PluginInfoPanelOpenPayload {
+    document: PluginInfoPanelDocument;
+}
+export interface PluginInfoPanelOpenResponse {
+    panelID: string;
+}
+export interface PluginInfoPanelClosePayload {
+    panelID: string;
+}
+export interface PluginInfoPanelCloseResponse {
+}
+export interface PluginSettingsGetPayload {
+    key: string;
+}
+export interface PluginSettingsGetResponse {
+    value: unknown | null;
+}
+export interface PluginSettingsGetAllPayload {
+}
+export interface PluginSettingsGetAllResponse {
+    settings: Record<string, unknown>;
+}
+export interface PluginConsoleLogPayload {
+    level: PluginConsoleLogLevel;
+    message: string;
+}
+export interface PluginConsoleLogResponse {
+}
+export interface PluginTextInputStateChangedPayload {
+    isFocused: boolean;
+    isComposing: boolean;
+}
+export interface PluginTextInputStateChangedResponse {
+}
+export declare const CAPABILITY_METHOD_NAMES: readonly ["runtime.invoke", "item.setTags", "item.addTags", "item.removeTags", "item.setPinned", "item.setAttachments", "item.setSearchExtension", "item.materializeImagePath", "item.readAttachment", "asset.currentItemImageUrl", "asset.pathReferenceImageUrl", "asset.registerImage", "clipboard.copyText", "navigation.openUrl", "navigation.revealInFinder", "navigation.openFilePath", "action.allocateImageTempPath", "action.setButtons", "action.complete", "attachmentRenderer.setButtons", "window.setHeight", "window.autoFit", "infoPanel.open", "infoPanel.close", "settings.get", "settings.getAll", "console.log", "textInput.stateChanged"];
+export type CapabilityMethodName = (typeof CAPABILITY_METHOD_NAMES)[number];
+export declare const callRuntimeInvoke: (payload: PluginRuntimeInvokePayload) => Promise<PluginRuntimeInvokeResponse>;
+export declare const callItemSetTags: (payload: PluginItemSetTagsPayload) => Promise<PluginItemSetTagsResponse>;
+export declare const callItemAddTags: (payload: PluginItemAddTagsPayload) => Promise<PluginItemAddTagsResponse>;
+export declare const callItemRemoveTags: (payload: PluginItemRemoveTagsPayload) => Promise<PluginItemRemoveTagsResponse>;
+export declare const callItemSetPinned: (payload: PluginItemSetPinnedPayload) => Promise<PluginItemSetPinnedResponse>;
+export declare const callItemSetAttachments: (payload: PluginItemSetAttachmentsPayload) => Promise<PluginItemSetAttachmentsResponse>;
+export declare const callItemSetSearchExtension: (payload: PluginItemSetSearchExtensionPayload) => Promise<PluginItemSetSearchExtensionResponse>;
+export declare const callItemMaterializeImagePath: () => Promise<PluginItemMaterializeImagePathResponse>;
+export declare const callItemReadAttachment: (payload: PluginItemReadAttachmentPayload) => Promise<PluginItemReadAttachmentResponse>;
+export declare const callAssetCurrentItemImageUrl: () => Promise<PluginAssetCurrentItemImageUrlResponse>;
+export declare const callAssetPathReferenceImageUrl: (payload: PluginAssetPathReferenceImageUrlPayload) => Promise<PluginAssetPathReferenceImageUrlResponse>;
+export declare const callAssetRegisterImage: (payload: PluginAssetRegisterImagePayload) => Promise<PluginAssetRegisterImageResponse>;
+export declare const callClipboardCopyText: (payload: PluginClipboardCopyTextPayload) => Promise<PluginClipboardCopyTextResponse>;
+export declare const callNavigationOpenUrl: (payload: PluginNavigationOpenUrlPayload) => Promise<PluginNavigationOpenUrlResponse>;
+export declare const callNavigationRevealInFinder: (payload: PluginNavigationRevealInFinderPayload) => Promise<PluginNavigationRevealInFinderResponse>;
+export declare const callNavigationOpenFilePath: (payload: PluginNavigationOpenFilePathPayload) => Promise<PluginNavigationOpenFilePathResponse>;
+export declare const callActionAllocateImageTempPath: (payload: PluginActionAllocateImageTempPathPayload) => Promise<PluginActionAllocateImageTempPathResponse>;
+export declare const callActionSetButtons: (payload: PluginActionSetButtonsPayload) => Promise<PluginActionSetButtonsResponse>;
+export declare const callActionComplete: (payload: PluginActionCompletePayload) => Promise<PluginActionCompleteResponse>;
+export declare const callAttachmentRendererSetButtons: (payload: PluginAttachmentRendererSetButtonsPayload) => Promise<PluginAttachmentRendererSetButtonsResponse>;
+export declare const callWindowSetHeight: (payload: PluginWindowSetHeightPayload) => Promise<PluginWindowSetHeightResponse>;
+export declare const callWindowAutoFit: () => Promise<PluginWindowAutoFitResponse>;
+export declare const callInfoPanelOpen: (payload: PluginInfoPanelOpenPayload) => Promise<PluginInfoPanelOpenResponse>;
+export declare const callInfoPanelClose: (payload: PluginInfoPanelClosePayload) => Promise<PluginInfoPanelCloseResponse>;
+export declare const callSettingsGet: (payload: PluginSettingsGetPayload) => Promise<PluginSettingsGetResponse>;
+export declare const callSettingsGetAll: () => Promise<PluginSettingsGetAllResponse>;
+export declare const callConsoleLog: (payload: PluginConsoleLogPayload) => Promise<PluginConsoleLogResponse>;
+export declare const callTextInputStateChanged: (payload: PluginTextInputStateChangedPayload) => Promise<PluginTextInputStateChangedResponse>;

package/dist/generated/data.generated.d.ts

@@ -0,0 +1,193 @@
+export interface PluginAttachmentMutationEntry {
+    attachmentKey: string;
+    payloadJson: string;
+    syncScope: string;
+    createdAtMs?: number;
+    updatedAtMs?: number;
+}
+export interface PluginSearchExtensionEntry {
+    entryKey: string;
+    searchText: string;
+    label?: string;
+    updatedAtMs?: number;
+}
+export interface PluginActionResultText {
+    resultKind: 'text';
+    text: string;
+}
+export interface PluginActionResultImage {
+    resultKind: 'image';
+    imageTempPath: string;
+    imageFormatHint?: string;
+}
+export interface PluginActionResultNone {
+    resultKind: 'none';
+}
+export type PluginActionResult = PluginActionResultText | PluginActionResultImage | PluginActionResultNone;
+export type PluginInfoPanelTextStyle = 'body' | 'mono' | 'muted';
+export type PluginInfoPanelCodeLanguage = 'plain' | 'json';
+export interface PluginInfoPanelField {
+    key: string;
+    value: string;
+    isMono?: boolean;
+}
+export interface PluginInfoPanelBlockLabel {
+    type: 'label';
+    text: string;
+}
+export interface PluginInfoPanelBlockText {
+    type: 'text';
+    text: string;
+    style: PluginInfoPanelTextStyle;
+}
+export interface PluginInfoPanelBlockCode {
+    type: 'code';
+    text: string;
+    language: PluginInfoPanelCodeLanguage;
+}
+export interface PluginInfoPanelBlockQrCode {
+    type: 'qrCode';
+    value: string;
+}
+export interface PluginInfoPanelBlockFields {
+    type: 'fields';
+    fields: PluginInfoPanelField[];
+}
+export interface PluginInfoPanelBlockTags {
+    type: 'tags';
+    tags: string[];
+}
+export interface PluginInfoPanelBlockDivider {
+    type: 'divider';
+}
+export type PluginInfoPanelBlock = PluginInfoPanelBlockLabel | PluginInfoPanelBlockText | PluginInfoPanelBlockCode | PluginInfoPanelBlockQrCode | PluginInfoPanelBlockFields | PluginInfoPanelBlockTags | PluginInfoPanelBlockDivider;
+export interface PluginInfoPanelAction {
+    id: string;
+    label: string;
+    isPrimary?: boolean;
+}
+export interface PluginInfoPanelDocument {
+    icon?: string;
+    title: string;
+    subtitle?: string;
+    badges?: string[];
+    blocks: PluginInfoPanelBlock[];
+    actions: PluginInfoPanelAction[];
+}
+export type PluginConsoleLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface PluginClipboardItem {
+    id: string;
+    type: string;
+    tags: string[];
+    sourceAppID: string;
+}
+export interface PluginAttachmentEntry {
+    historyID: string;
+    owner: string;
+    attachmentType: string;
+    attachmentKey: string;
+    payloadJson: string;
+}
+export interface PluginAttachmentPayload {
+    item: PluginClipboardItem;
+    attachment: PluginAttachmentEntry;
+}
+export interface PluginThemeTokens {
+    surface: string;
+    surfaceElevated: string;
+    textPrimary: string;
+    textSecondary: string;
+    textTertiary: string;
+    accent: string;
+    accentContrast: string;
+    border: string;
+    divider: string;
+    success: string;
+    warning: string;
+    danger: string;
+}
+export interface PluginThemeTokenSnapshot {
+    scheme: string;
+    tokens: PluginThemeTokens;
+}
+export interface PluginPathEntry {
+    kind: 'file' | 'folder';
+    path: string;
+    displayName: string;
+}
+export interface PluginContentEnvelopeText {
+    kind: 'text';
+    text: string;
+}
+export interface PluginContentEnvelopeImage {
+    kind: 'image';
+    width: number;
+    height: number;
+    format: string;
+    bytes: number;
+}
+export interface PluginContentEnvelopePath_reference {
+    kind: 'path_reference';
+    entries: PluginPathEntry[];
+}
+export type PluginContentEnvelope = PluginContentEnvelopeText | PluginContentEnvelopeImage | PluginContentEnvelopePath_reference;
+export interface PluginAttachmentRef {
+    attachmentType: string;
+    attachmentKey: string;
+}
+export interface PluginResolveAttachmentInput {
+    item: PluginClipboardItem;
+    content: PluginContentEnvelope;
+    attachments: PluginAttachmentRef[];
+    attachment: PluginAttachmentEntry;
+}
+export interface PluginActionButton {
+    id: string;
+    title: string;
+    isEnabled?: boolean;
+}
+export interface PluginAttachmentResolveResult {
+    shouldDisplay?: boolean;
+    displayName?: string;
+    tintHex?: string;
+    buttons?: PluginActionButton[];
+}
+export interface PluginDetectorInput {
+    item: PluginClipboardItem;
+    content: PluginContentEnvelope;
+    attachments: PluginAttachmentRef[];
+}
+export interface PluginDetectorSearchProjection {
+    scope: string;
+    searchText: string;
+    label?: string;
+}
+export interface PluginDetectorArtifact {
+    attachmentType: string;
+    attachmentKey: string;
+    payloadJson: string;
+    searchProjection?: PluginDetectorSearchProjection;
+    attachmentSyncScope?: string;
+    createdAtMs?: number;
+    updatedAtMs?: number;
+}
+export interface PluginResolveActionSessionInput {
+    item: PluginClipboardItem;
+    content: PluginContentEnvelope;
+    attachments: PluginAttachmentRef[];
+}
+export interface PluginActionResolveResult {
+    displayName?: string;
+    buttons: PluginActionButton[];
+    defaultButtonID?: string;
+    initialDraft: Record<string, unknown>;
+}
+export interface PluginAutoRunActionInput {
+    item: PluginClipboardItem;
+    content: PluginContentEnvelope;
+    attachments: PluginAttachmentRef[];
+}
+export interface PluginActionOperationResult {
+    result: PluginActionResult;
+    userMessage?: string;
+}

package/dist/generated/hostClients.generated.d.ts

@@ -0,0 +1,38 @@
+import type { PluginActionAllocateImageTempPathPayload, PluginActionAllocateImageTempPathResponse, PluginAssetRegisterImagePayload, PluginAssetRegisterImageResponse, PluginClipboardCopyTextPayload, PluginClipboardCopyTextResponse, PluginConsoleLogPayload, PluginConsoleLogResponse, PluginItemAddTagsPayload, PluginItemAddTagsResponse, PluginItemMaterializeImagePathResponse, PluginItemReadAttachmentPayload, PluginItemReadAttachmentResponse, PluginItemRemoveTagsPayload, PluginItemRemoveTagsResponse, PluginItemSetAttachmentsPayload, PluginItemSetAttachmentsResponse, PluginItemSetPinnedPayload, PluginItemSetPinnedResponse, PluginItemSetSearchExtensionPayload, PluginItemSetSearchExtensionResponse, PluginItemSetTagsPayload, PluginItemSetTagsResponse, PluginNavigationOpenFilePathPayload, PluginNavigationOpenFilePathResponse, PluginNavigationOpenUrlPayload, PluginNavigationOpenUrlResponse, PluginNavigationRevealInFinderPayload, PluginNavigationRevealInFinderResponse, PluginSettingsGetAllResponse, PluginSettingsGetPayload, PluginSettingsGetResponse } from './capabilityClients.generated.js';
+export interface IPCBus {
+    request<Req, Resp>(method: string, payload: Req): Promise<Resp>;
+}
+export interface HostClient {
+    action: {
+        allocateImageTempPath(payload: PluginActionAllocateImageTempPathPayload): Promise<PluginActionAllocateImageTempPathResponse>;
+    };
+    asset: {
+        registerImage(payload: PluginAssetRegisterImagePayload): Promise<PluginAssetRegisterImageResponse>;
+    };
+    clipboard: {
+        copyText(payload: PluginClipboardCopyTextPayload): Promise<PluginClipboardCopyTextResponse>;
+    };
+    console: {
+        log(payload: PluginConsoleLogPayload): Promise<PluginConsoleLogResponse>;
+    };
+    item: {
+        setTags(payload: PluginItemSetTagsPayload): Promise<PluginItemSetTagsResponse>;
+        addTags(payload: PluginItemAddTagsPayload): Promise<PluginItemAddTagsResponse>;
+        removeTags(payload: PluginItemRemoveTagsPayload): Promise<PluginItemRemoveTagsResponse>;
+        setPinned(payload: PluginItemSetPinnedPayload): Promise<PluginItemSetPinnedResponse>;
+        setAttachments(payload: PluginItemSetAttachmentsPayload): Promise<PluginItemSetAttachmentsResponse>;
+        setSearchExtension(payload: PluginItemSetSearchExtensionPayload): Promise<PluginItemSetSearchExtensionResponse>;
+        materializeImagePath(): Promise<PluginItemMaterializeImagePathResponse>;
+        readAttachment(payload: PluginItemReadAttachmentPayload): Promise<PluginItemReadAttachmentResponse>;
+    };
+    navigation: {
+        openUrl(payload: PluginNavigationOpenUrlPayload): Promise<PluginNavigationOpenUrlResponse>;
+        revealInFinder(payload: PluginNavigationRevealInFinderPayload): Promise<PluginNavigationRevealInFinderResponse>;
+        openFilePath(payload: PluginNavigationOpenFilePathPayload): Promise<PluginNavigationOpenFilePathResponse>;
+    };
+    settings: {
+        get(payload: PluginSettingsGetPayload): Promise<PluginSettingsGetResponse>;
+        getAll(): Promise<PluginSettingsGetAllResponse>;
+    };
+}
+export declare function createHostClient(bus: IPCBus): HostClient;

package/dist/generated/runtime.actionResult.generated.d.ts

@@ -0,0 +1,28 @@
+export interface ActionResultOptions {
+    userMessage?: string;
+}
+export declare const actionResult: {
+    text: (text: string, options?: ActionResultOptions) => {
+        result: {
+            resultKind: "text";
+            text: string;
+        };
+        userMessage: string | undefined;
+    };
+    image: (imageTempPath: string, options?: {
+        imageFormatHint?: string;
+    } & ActionResultOptions) => {
+        result: {
+            resultKind: "image";
+            imageTempPath: string;
+            imageFormatHint?: string;
+        };
+        userMessage: string | undefined;
+    };
+    none: (options?: ActionResultOptions) => {
+        result: {
+            resultKind: "none";
+        };
+        userMessage: string | undefined;
+    };
+};