@vibearound/plugin-channel-sdk 0.3.0 → 0.4.0

package/src/renderer.ts

@@ -25,36 +25,30 @@
  *
  * ## Usage
  *
+ * Subclass and implement `sendText` + `sendBlock` (+ optionally `editBlock`):
+ *
  * ```ts
  * class MyRenderer extends BlockRenderer<string> {
- *   protected async sendBlock(channelId, kind, content) {
- *     const msg = await myApi.sendMessage(channelId, content);
+ *   protected async sendText(chatId, text) {
+ *     await myApi.sendMessage(chatId, text);
+ *   }
+ *   protected async sendBlock(chatId, kind, content) {
+ *     const msg = await myApi.sendMessage(chatId, content);
  *     return msg.id;
  *   }
- *   protected async editBlock(channelId, ref, kind, content, sealed) {
+ *   protected async editBlock(chatId, ref, kind, content, sealed) {
  *     await myApi.editMessage(ref, content);
  *   }
  * }
- *
- * // In main.ts:
- * const renderer = new MyRenderer({ verbose: { showThinking: false } });
- *
- * // When user sends a message:
- * renderer.onPromptSent(channelId);
- * try {
- *   await agent.prompt({ sessionId, content });
- *   await renderer.onTurnEnd(channelId);
- * } catch (e) {
- *   await renderer.onTurnError(channelId, String(e));
- * }
- *
- * // In the ACP client's sessionUpdate handler:
- * renderer.onSessionUpdate(notification);
  * ```
+ *
+ * The SDK's `runChannelPlugin` wires all ACP events to this renderer
+ * automatically — plugins don't call onSessionUpdate/onPromptSent/etc
+ * directly.
  */
 
 import type { SessionNotification } from "@agentclientprotocol/sdk";
-import type { BlockKind, BlockRendererOptions, VerboseConfig } from "./types.js";
+import type { BlockKind, BlockRendererOptions, CommandEntry, VerboseConfig } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Local ACP session-update narrowing
@@ -100,7 +94,7 @@ type ConsumedSessionUpdate =
 
 interface ManagedBlock<TRef> {
   /** Channel this block belongs to. Captured at creation time. */
-  channelId: string;
+  chatId: string;
   kind: BlockKind;
   content: string;
   /** Platform message reference set after the first successful send. */
@@ -139,13 +133,21 @@ const DEFAULT_MIN_EDIT_INTERVAL_MS = 1000;
  *   return type of `sendBlock` and the first argument of `editBlock`.
  */
 export abstract class BlockRenderer<TRef = string> {
+  /** When true, blocks are sent and edited in real-time. When false, each
+   *  block is held until complete, then sent once (send-only mode). */
+  protected readonly streaming: boolean;
   protected readonly flushIntervalMs: number;
   protected readonly minEditIntervalMs: number;
   protected readonly verbose: VerboseConfig;
 
   private states = new Map<string, ChannelState<TRef>>();
 
+  /** The chatId of the most recent prompt. Used as fallback target for
+   *  notifications that arrive without an explicit chatId. */
+  private lastActiveChatId: string | null = null;
+
   constructor(options: BlockRendererOptions = {}) {
+    this.streaming = options.streaming ?? true;
     this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
     this.minEditIntervalMs = options.minEditIntervalMs ?? DEFAULT_MIN_EDIT_INTERVAL_MS;
     this.verbose = {
@@ -155,21 +157,31 @@ export abstract class BlockRenderer<TRef = string> {
   }
 
   // ---------------------------------------------------------------------------
-  // Abstract / overridable — subclass implements these
+  // Abstract — plugin MUST implement these
   // ---------------------------------------------------------------------------
 
   /**
-   * Send a new block message to the platform.
+   * Send a plain text message to the IM. Used for system text, agent ready
+   * notifications, session ready, and error messages.
+   */
+  protected abstract sendText(chatId: string, text: string): Promise<void>;
+
+  /**
+   * Send a new streaming block message to the platform.
    *
    * Return the platform message reference that will be passed to future
    * `editBlock` calls. Return `null` if editing is not supported.
    */
   protected abstract sendBlock(
-    channelId: string,
+    chatId: string,
     kind: BlockKind,
     content: string,
   ): Promise<TRef | null>;
 
+  // ---------------------------------------------------------------------------
+  // Optional overrides — plugin MAY implement these
+  // ---------------------------------------------------------------------------
+
   /**
    * Edit an existing block message in-place.
    *
@@ -180,7 +192,7 @@ export abstract class BlockRenderer<TRef = string> {
    *   Use to switch from a "streaming" card format to a finalized one.
    */
   protected editBlock?(
-    channelId: string,
+    chatId: string,
     ref: TRef,
     kind: BlockKind,
     content: string,
@@ -207,31 +219,18 @@ export abstract class BlockRenderer<TRef = string> {
 
   /**
    * Called after the last block has been flushed and the turn is complete.
-   * Override to perform cleanup (e.g. remove a "typing" indicator, a
-   * processing reaction, etc.).
-   */
-  protected onAfterTurnEnd(_channelId: string): Promise<void> {
-    return Promise.resolve();
-  }
-
-  /**
-   * Called after a turn error, once state has been cleaned up.
-   * Override to send an error message to the user.
+   * Override to perform cleanup (e.g. remove a "typing" indicator).
    */
-  protected onAfterTurnError(_channelId: string, _error: string): Promise<void> {
+  protected onAfterTurnEnd(_chatId: string): Promise<void> {
     return Promise.resolve();
   }
 
   /**
-   * Map an ACP `sessionId` to the channel ID used internally.
-   *
-   * Default: identity (sessionId === channelId).
-   *
-   * Override if your plugin namespaces channel IDs (e.g. Feishu uses
-   * `"feishu:<sessionId>"`, WeChat uses `"weixin-openclaw-bridge:<sessionId>"`).
+   * Called after a turn error. Default sends an error message via sendText.
+   * Override for platform-specific error rendering (e.g. error card).
    */
-  protected sessionIdToChannelId(sessionId: string): string {
-    return sessionId;
+  protected async onAfterTurnError(chatId: string, error: string): Promise<void> {
+    await this.sendText(chatId, `❌ Error: ${error}`);
   }
 
   // ---------------------------------------------------------------------------
@@ -244,14 +243,12 @@ export abstract class BlockRenderer<TRef = string> {
    * Routes the event to the correct block based on its variant, appending
    * deltas to the current block or starting a new one when the kind changes.
    *
-   * Call this from the ACP `Client.sessionUpdate` handler.
+   * Called automatically by `runChannelPlugin` — plugins don't call this directly.
    */
   onSessionUpdate(notification: SessionNotification): void {
-    const sessionId = notification.sessionId;
-    // Narrow through the local ConsumedSessionUpdate union — see the type
-    // declaration above this class for why we re-declare it locally instead
-    // of importing the SDK's own union. Variants other than the four we
-    // handle are treated as no-ops.
+    // sessionId from ACP = chatId (the host replaces the real agent session
+    // ID with the chat ID before forwarding to the plugin).
+    const chatId = notification.sessionId;
     const rawUpdate = notification.update as unknown as { sessionUpdate: string };
     const variant = rawUpdate.sessionUpdate;
     if (
@@ -263,47 +260,44 @@ export abstract class BlockRenderer<TRef = string> {
       return;
     }
     const update = rawUpdate as ConsumedSessionUpdate;
-    const channelId = this.sessionIdToChannelId(sessionId);
 
     switch (update.sessionUpdate) {
       case "agent_message_chunk": {
         const delta = update.content?.text ?? "";
-        if (delta) this.appendToBlock(channelId, "text", delta);
+        if (delta) this.appendToBlock(chatId, "text", delta);
         break;
       }
       case "agent_thought_chunk": {
-        if (!this.verbose.showThinking) return; // skip — no block, no boundary
+        if (!this.verbose.showThinking) return;
         const delta = update.content?.text ?? "";
-        if (delta) this.appendToBlock(channelId, "thinking", delta);
+        if (delta) this.appendToBlock(chatId, "thinking", delta);
         break;
       }
       case "tool_call": {
-        if (!this.verbose.showToolUse) return; // skip
-        if (update.title) this.appendToBlock(channelId, "tool", `🔧 ${update.title}\n`);
+        if (!this.verbose.showToolUse) return;
+        if (update.title) this.appendToBlock(chatId, "tool", `🔧 ${update.title}\n`);
         break;
       }
       case "tool_call_update": {
-        if (!this.verbose.showToolUse) return; // skip
+        if (!this.verbose.showToolUse) return;
         const title = update.title ?? "tool";
         if (update.status === "completed" || update.status === "error") {
-          this.appendToBlock(channelId, "tool", `✅ ${title}\n`);
+          this.appendToBlock(chatId, "tool", `✅ ${title}\n`);
         }
         break;
       }
-      // Unknown / unconsumed variant — ignore.
     }
   }
 
   /**
-   * Call this before sending a prompt to the agent.
-   *
-   * Clears any leftover state from a previous turn so the new turn starts
-   * with a clean slate.
+   * Call before sending a prompt. Tracks the active chatId and clears
+   * leftover state from a previous turn.
    */
-  onPromptSent(channelId: string): void {
-    const old = this.states.get(channelId);
+  onPromptSent(chatId: string): void {
+    this.lastActiveChatId = chatId;
+    const old = this.states.get(chatId);
     if (old?.flushTimer) clearTimeout(old.flushTimer);
-    this.states.set(channelId, {
+    this.states.set(chatId, {
       blocks: [],
       flushTimer: null,
       lastEditMs: 0,
@@ -311,14 +305,70 @@ export abstract class BlockRenderer<TRef = string> {
     });
   }
 
+  // ---------------------------------------------------------------------------
+  // Host notification handlers — built-in defaults, no per-plugin duplication
+  // ---------------------------------------------------------------------------
+
+  /** Handle `va/system_text` from host. */
+  onSystemText(chatId: string, text: string): void {
+    this.sendText(chatId, text).catch(() => {});
+  }
+
+  /** Handle `va/agent_ready` from host. */
+  onAgentReady(chatId: string, agent: string, version: string): void {
+    this.sendText(chatId, `🤖 Agent: ${agent} v${version}`).catch(() => {});
+  }
+
+  /** Handle `va/session_ready` from host. */
+  onSessionReady(chatId: string, sessionId: string): void {
+    this.sendText(chatId, `📋 Session: ${sessionId}`).catch(() => {});
+  }
+
+  /**
+   * Handle `va/command_menu` from host — display available commands.
+   *
+   * Default renders a plain-text list. Override for platform-specific
+   * rendering (e.g. Feishu interactive card, Slack Block Kit, Telegram
+   * inline keyboard).
+   */
+  onCommandMenu(
+    chatId: string,
+    systemCommands: CommandEntry[],
+    agentCommands: CommandEntry[],
+  ): void {
+    const lines: string[] = [];
+
+    lines.push("System commands:");
+    for (const cmd of systemCommands) {
+      const usage = cmd.args ? `/${cmd.name} ${cmd.args}` : `/${cmd.name}`;
+      lines.push(`  ${usage} — ${cmd.description}`);
+    }
+
+    if (agentCommands.length > 0) {
+      lines.push("");
+      lines.push("Agent commands (use /agent <command>):");
+      for (const cmd of agentCommands) {
+        const desc = cmd.description.length > 80
+          ? `${cmd.description.slice(0, 77)}...`
+          : cmd.description;
+        lines.push(`  /${cmd.name} — ${desc}`);
+      }
+    } else {
+      lines.push("");
+      lines.push("Agent commands will appear after sending your first message.");
+    }
+
+    this.sendText(chatId, lines.join("\n")).catch(() => {});
+  }
+
   /**
    * Call this after `agent.prompt()` resolves (turn complete).
    *
    * Seals and flushes the last block, then waits for all pending sends/edits
    * to complete before calling `onAfterTurnEnd`.
    */
-  async onTurnEnd(channelId: string): Promise<void> {
-    const state = this.states.get(channelId);
+  async onTurnEnd(chatId: string): Promise<void> {
+    const state = this.states.get(chatId);
     if (!state) return;
 
     if (state.flushTimer) {
@@ -332,35 +382,33 @@ export abstract class BlockRenderer<TRef = string> {
       this.enqueueFlush(state, last);
     }
 
-    // Wait for the entire chain to drain before cleanup
     await state.sendChain;
-    this.states.delete(channelId);
-    await this.onAfterTurnEnd(channelId);
+    this.states.delete(chatId);
+    await this.onAfterTurnEnd(chatId);
   }
 
   /**
    * Call this when `agent.prompt()` throws (turn error).
    *
-   * Discards pending state and calls `onAfterTurnError` so the subclass can
-   * send an error message to the user.
+   * Discards pending state and calls `onAfterTurnError`.
    */
-  async onTurnError(channelId: string, error: string): Promise<void> {
-    const state = this.states.get(channelId);
+  async onTurnError(chatId: string, error: string): Promise<void> {
+    const state = this.states.get(chatId);
     if (state?.flushTimer) clearTimeout(state.flushTimer);
-    this.states.delete(channelId);
-    await this.onAfterTurnError(channelId, error);
+    this.states.delete(chatId);
+    await this.onAfterTurnError(chatId, error);
   }
 
   // ---------------------------------------------------------------------------
   // Internal — block management
   // ---------------------------------------------------------------------------
 
-  private appendToBlock(channelId: string, kind: BlockKind, delta: string): void {
-    let state = this.states.get(channelId);
+  private appendToBlock(chatId: string, kind: BlockKind, delta: string): void {
+    let state = this.states.get(chatId);
     if (!state) {
       // Auto-create state if onPromptSent wasn't called (e.g. host-initiated turns)
       state = { blocks: [], flushTimer: null, lastEditMs: 0, sendChain: Promise.resolve() };
-      this.states.set(channelId, state);
+      this.states.set(chatId, state);
     }
 
     const last = state.blocks.at(-1);
@@ -379,33 +427,30 @@ export abstract class BlockRenderer<TRef = string> {
         }
         this.enqueueFlush(state, last);
       }
-      state.blocks.push({ channelId, kind, content: delta, ref: null, creating: false, sealed: false });
+      state.blocks.push({ chatId, kind, content: delta, ref: null, creating: false, sealed: false });
     }
 
-    this.scheduleFlush(channelId, state);
+    this.scheduleFlush(chatId, state);
   }
 
-  private scheduleFlush(channelId: string, state: ChannelState<TRef>): void {
+  private scheduleFlush(chatId: string, state: ChannelState<TRef>): void {
     if (state.flushTimer) return; // already scheduled
 
     state.flushTimer = setTimeout(() => {
       state.flushTimer = null;
-      this.flush(channelId, state);
+      this.flush(chatId, state);
     }, this.flushIntervalMs);
   }
 
-  private flush(channelId: string, state: ChannelState<TRef>): void {
+  private flush(chatId: string, state: ChannelState<TRef>): void {
     const block = state.blocks.at(-1);
     if (!block || block.sealed || !block.content) return;
 
-    // Send-only mode: subclasses that don't override `editBlock` (e.g.
-    // QQ Bot, where the platform has no edit support) would otherwise
-    // POST a new message for every debounced flush, so the user sees a
-    // partial chunk followed by the full message as two separate
-    // deliveries. Defer intermediate sends; only `onTurnEnd` and block
-    // boundary transitions inside `appendToBlock` (which seal the block
-    // first) will actually POST.
-    if (!this.editBlock) {
+    // Send-only mode (streaming=false): defer intermediate sends.
+    // Only sealed blocks (from onTurnEnd or block boundary transitions)
+    // will actually POST. This prevents the user seeing a partial chunk
+    // followed by the full message as two separate messages.
+    if (!this.streaming) {
       return;
     }
 
@@ -416,7 +461,7 @@ export abstract class BlockRenderer<TRef = string> {
       if (!state.flushTimer) {
         state.flushTimer = setTimeout(() => {
           state.flushTimer = null;
-          this.flush(channelId, state);
+          this.flush(chatId, state);
         }, delay);
       }
       return;
@@ -439,12 +484,12 @@ export abstract class BlockRenderer<TRef = string> {
       if (block.ref === null && !block.creating) {
         // First send — use sentinel to prevent concurrent creates
         block.creating = true;
-        block.ref = await this.sendBlock(block.channelId, block.kind, content);
+        block.ref = await this.sendBlock(block.chatId, block.kind, content);
         block.creating = false;
         state.lastEditMs = Date.now();
-      } else if (block.ref !== null && !block.creating && this.editBlock) {
-        // Subsequent update — edit in-place
-        await this.editBlock(block.channelId, block.ref, block.kind, content, block.sealed);
+      } else if (block.ref !== null && !block.creating && this.streaming && this.editBlock) {
+        // Subsequent update — edit in-place (streaming mode only)
+        await this.editBlock(block.chatId, block.ref, block.kind, content, block.sealed);
         state.lastEditMs = Date.now();
       }
       // else: create is in-flight (creating === true) — skip

package/src/types.ts

@@ -43,6 +43,18 @@ export interface PluginManifest {
   capabilities?: PluginCapabilities;
 }
 
+// ---------------------------------------------------------------------------
+// Command menu
+// ---------------------------------------------------------------------------
+
+/** A command entry from the host's command list. */
+export interface CommandEntry {
+  name: string;
+  description: string;
+  args?: string;
+  aliases?: string[];
+}
+
 // ---------------------------------------------------------------------------
 // Block rendering
 // ---------------------------------------------------------------------------
@@ -58,6 +70,18 @@ export interface VerboseConfig {
 }
 
 export interface BlockRendererOptions {
+  /**
+   * Whether the IM platform supports message editing (streaming mode).
+   *
+   * - `true` (default): blocks stream in real-time — `sendBlock()` creates
+   *   the message, `editBlock()` updates it as more content arrives.
+   * - `false`: each block is held until complete, then sent once via
+   *   `sendBlock()`. `editBlock()` is never called.
+   *
+   * Set to `false` for platforms that don't support editing sent messages
+   * (e.g. QQ Bot, WhatsApp, WeChat, LINE).
+   */
+  streaming?: boolean;
   /**
    * Debounce interval before flushing an unsealed block (ms).
    * Controls how often in-progress blocks are sent to the platform.

package/dist/run-plugin.d.ts

@@ -1,95 +0,0 @@
-/**
- * runChannelPlugin — shared main.ts boilerplate for every channel plugin.
- *
- * Each channel plugin used to have a ~120-line `main.ts` that was 85%
- * identical across Slack, Telegram, Discord, DingTalk, WeCom, etc:
- * connect to host, validate config keys, wire the standard sessionUpdate
- * and extNotification handlers, create the stream handler, start the bot,
- * wait for disconnect, stop. This helper absorbs that boilerplate so each
- * plugin's `main.ts` reduces to ~20 lines — a factory for the bot and a
- * factory for the stream handler.
- *
- * ## Usage
- *
- * ```ts
- * import { runChannelPlugin } from "@vibearound/plugin-channel-sdk";
- * import { SlackBot } from "./bot.js";
- * import { AgentStreamHandler } from "./agent-stream.js";
- *
- * runChannelPlugin({
- *   name: "vibearound-slack",
- *   version: "0.1.0",
- *   requiredConfig: ["bot_token", "app_token"],
- *   createBot: ({ config, agent, log, cacheDir }) =>
- *     new SlackBot(
- *       { bot_token: config.bot_token as string, app_token: config.app_token as string },
- *       agent,
- *       log,
- *       cacheDir,
- *     ),
- *   createStreamHandler: (bot, log, verbose) =>
- *     new AgentStreamHandler(bot, log, verbose),
- * });
- * ```
- */
-import type { Agent } from "@agentclientprotocol/sdk";
-import type { SessionNotification } from "./types.js";
-export type ChannelPluginLogger = (level: string, msg: string) => void;
-export interface ChannelStreamHandler {
-    onSessionUpdate(params: SessionNotification): void;
-    onSystemText(text: string): void;
-    onAgentReady(agent: string, version: string): void;
-    onSessionReady(sessionId: string): void;
-}
-export interface ChannelBot<THandler extends ChannelStreamHandler = ChannelStreamHandler> {
-    setStreamHandler(handler: THandler): void;
-    start(): Promise<void> | void;
-    stop(): Promise<void> | void;
-}
-export interface CreateBotContext {
-    config: Record<string, unknown>;
-    agent: Agent;
-    log: ChannelPluginLogger;
-    cacheDir: string;
-}
-export interface VerboseOptions {
-    showThinking: boolean;
-    showToolUse: boolean;
-}
-export interface RunChannelPluginSpec<TBot extends ChannelBot<THandler>, THandler extends ChannelStreamHandler> {
-    /** Plugin name reported during ACP initialize (e.g. "vibearound-slack"). */
-    name: string;
-    /** Plugin version reported during ACP initialize. */
-    version: string;
-    /**
-     * Config keys that MUST be present on `meta.config`. Plugin startup
-     * fails with a clear error if any are missing. Keep to primitives
-     * (strings/booleans); deeper validation belongs in the bot constructor.
-     */
-    requiredConfig?: string[];
-    /** Factory: build the platform bot from host-supplied config + agent. */
-    createBot: (ctx: CreateBotContext) => TBot | Promise<TBot>;
-    /**
-     * Factory: build the agent stream handler for this plugin. The handler
-     * is wired to the bot via `bot.setStreamHandler(handler)` before the
-     * bot is started.
-     */
-    createStreamHandler: (bot: TBot, log: ChannelPluginLogger, verbose: VerboseOptions) => THandler;
-    /**
-     * Optional hook invoked after the bot has been constructed but before
-     * `start()` is called. Use this for one-off initialization that needs
-     * to log diagnostic info (e.g. Telegram's `probe()`).
-     */
-    afterCreate?: (bot: TBot, log: ChannelPluginLogger) => Promise<void> | void;
-}
-/**
- * Run a channel plugin to completion.
- *
- * Performs the ACP initialize handshake, validates required config,
- * constructs the bot + stream handler, starts the bot, waits for the host
- * connection to close, then stops the bot and exits the process.
- *
- * Never returns under normal operation — the process exits at the end.
- */
-export declare function runChannelPlugin<TBot extends ChannelBot<THandler>, THandler extends ChannelStreamHandler>(spec: RunChannelPluginSpec<TBot, THandler>): Promise<void>;
-//# sourceMappingURL=run-plugin.d.ts.map

package/dist/run-plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-plugin.d.ts","sourceRoot":"","sources":["../src/run-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAItD,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAMpB,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;AAEvE,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACnD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,UAAU,CAAC,QAAQ,SAAS,oBAAoB,GAAG,oBAAoB;IACtF,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,mBAAmB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB,CACnC,IAAI,SAAS,UAAU,CAAC,QAAQ,CAAC,EACjC,QAAQ,SAAS,oBAAoB;IAErC,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IAEb,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAE1B,yEAAyE;IACzE,SAAS,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3D;;;;OAIG;IACH,mBAAmB,EAAE,CACnB,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,mBAAmB,EACxB,OAAO,EAAE,cAAc,KACpB,QAAQ,CAAC;IAEd;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC7E;AAMD;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,SAAS,UAAU,CAAC,QAAQ,CAAC,EACjC,QAAQ,SAAS,oBAAoB,EACrC,IAAI,EAAE,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3D"}

package/dist/run-plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-plugin.js","sourceRoot":"","sources":["../src/run-plugin.ts"],"names":[],"mappings":"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"}