@zibby/workflow-templates 0.3.0 → 0.4.2

package/browser-test-automation/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.5","results":[[":__tests__/preflight-early-exit.test.mjs",{"duration":6.5747499999999945,"failed":false}]]}

package/browser-test-automation/package.json

@@ -7,6 +7,7 @@
   "main": "graph.mjs",
   "dependencies": {
     "@zibby/core": "^0.5.1",
+    "@zibby/ui-memory": "^1.0.0",
     "zod": "^3.23.0"
   }
 }

package/code-analysis/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.5","results":[[":nodes/__tests__/middleware.integration.test.js",{"duration":0,"failed":true}],[":nodes/__tests__/finalizeNode.test.js",{"duration":8.396791000000007,"failed":false}]]}

package/code-analysis/nodes/generate-code-node.js

@@ -5,8 +5,9 @@
  */
 
 import { spawn } from 'child_process';
-import { join, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
 import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
 import Handlebars from 'handlebars';
 import { invokeAgent } from '@zibby/core';
 import { generatePRMeta } from './services/prMetaService.js';
@@ -14,6 +15,14 @@ import { adfToText } from '@zibby/core/utils/adf-converter.js';
 import { getRepoPath } from './utils/get-repo-path.js';
 import { z } from 'zod';
 
+// Prompts ship inside the workflow bundle at `<template>/prompts/`.
+// state.promptsDir is the runner-injection slot for callers that want
+// to override (legacy analyze-graph CLI set it explicitly); when unset,
+// resolve relative to this node file so the template is self-contained
+// and works for any runner.
+const __nodeDir = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_PROMPTS_DIR = join(__nodeDir, '..', 'prompts');
+
 const CodeImplementationOutputSchema = z.object({
   success: z.boolean(),
   codeImplementation: z.object({
@@ -60,7 +69,8 @@ export function createCodeGenerationNode(options = {}) {
       const mode = commitAndPush ? 'implementing' : 'generating preview of';
       console.log(`\n💻 ${commitAndPush ? 'Implementing' : 'Generating'} code implementation...`);
       
-      const { workspace, ticketContext, repos, promptsDir, model, nodeConfigs = {} } = state;
+      const { workspace, ticketContext, repos, model, nodeConfigs = {} } = state;
+      const promptsDir = state.promptsDir || DEFAULT_PROMPTS_DIR;
       const aiModel = model || ticketContext.model || 'auto';
       const _nodeConfig = nodeConfigs[nodeName] || {};
       const analysis = state.analyze_ticket?.analysis;

package/index.js

@@ -165,6 +165,241 @@ export const TEMPLATES = {
         'Produce specs that an AI agent can execute end-to-end',
       ],
     },
+  },
+
+  // ── notify-slack: reusable notifier child workflow ────────────────
+  // Dispatched as a sub-graph from any parent that wants Slack alerts.
+  // Single-node graph, no LLM, deterministic API call.
+  'notify-slack': {
+    name: 'notify-slack',
+    displayName: 'Notify Slack',
+    description: 'Reusable child workflow — posts a structured Block Kit alert to a Slack channel. Dispatched by other workflows (Sentry triage, autofix, incident) via sub-graph.',
+    path: join(__dirname, 'notify-slack'),
+    defaultSlug: 'alert-slack',
+    deps: { zod: '^3.23.0' },
+    features: [
+      'Single-node, no LLM — deterministic ~500ms post',
+      'Block Kit message with severity-coded color + emoji',
+      'Optional Sentry-flavored fields (users affected, events, release)',
+      'Action buttons + caller-supplied @-mentions',
+      'Returns messageTs so parent can thread follow-ups',
+    ],
+    marketplace: {
+      slug: 'notify-slack',
+      tagline: 'Reusable Slack alert worker — dispatch from any workflow.',
+      iconPrompt: [
+        'Flat geometric vector illustration with subtle clean gradients, in the spirit of Linear / Notion / Stripe iconography — crisp, no painterly textures.',
+        'Subject: the iconic Slack pinwheel mark — four chunky rounded-rectangle "petals" arranged in a plus / asterisk configuration, colored with Slack\'s signature palette (top-left red #E01E5A, top-right yellow #ECB22E, bottom-right green #2EB67D, bottom-left blue #36C5F0), painted as if it\'s the focal brand mark of the icon. A small bright magenta notification dot floats in the upper-right corner of the pinwheel suggesting an incoming alert/ping.',
+        'Background: deep navy (#0B0F1A) rounded square (1024×1024) with a faint radial glow centered behind the pinwheel so the colors pop without becoming oversaturated.',
+        'Centered composition with the pinwheel as the dominant focal element, the notification dot as a small secondary accent in the upper-right; plenty of breathing room so the silhouette reads at 64×64 in the marketplace grid.',
+        'Mood: focused, energetic, signal-not-noise — the canonical Slack-flavored notification worker.',
+        'NO text, NO letters, NO photo-realism, NO sleek 3D render, NO literal Slack wordmark — the colored pinwheel shape is allowed as the brand reference.',
+      ].join('\n'),
+      category: 'Notifications',
+      tags: ['slack', 'notification', 'alert', 'child-workflow'],
+      capabilities: [
+        'Severity-coded Block Kit message (low/medium/high/critical)',
+        'Code snippet + action button + caller mentions',
+        'Sub-graph dispatchable from any parent workflow',
+        'Returns messageTs for thread replies',
+      ],
+      conversationStarters: [
+        'Post a CRITICAL alert to #incidents from this workflow',
+        'Send a daily summary to #dev-updates',
+        'Notify @oncall when a Sentry issue exceeds threshold',
+        'Forward the deploy-fail message to #ops',
+      ],
+    },
+  },
+
+  // ── notify-lark: same as notify-slack, Lark / Feishu variant ─────
+  'notify-lark': {
+    name: 'notify-lark',
+    displayName: 'Notify Lark',
+    description: 'Reusable child workflow — posts a structured Interactive Card to a Lark / Feishu chat. Dispatched by other workflows via sub-graph.',
+    path: join(__dirname, 'notify-lark'),
+    defaultSlug: 'alert-lark',
+    deps: { zod: '^3.23.0' },
+    features: [
+      'Single-node, no LLM',
+      'Lark Interactive Card with severity template (red/orange/yellow/grey)',
+      'Optional Sentry-flavored metadata fields',
+      'Token cache across multiple sends in one task',
+      'Returns messageId for threaded replies',
+    ],
+    marketplace: {
+      slug: 'notify-lark',
+      tagline: 'Reusable Lark / Feishu alert worker — dispatch from any workflow.',
+      iconPrompt: [
+        'A clean, modern app icon for a Lark / Feishu notification worker.',
+        '',
+        'Visual style: flat geometric vector with subtle gradient, complementary to the notify-slack icon (same family).',
+        'Subject: a stylized speech-bubble silhouette in Lark-cyan-to-blue gradient (#00D6B9 → #1664FF) with a checkmark inside. Gentle motion lines behind it.',
+        'Background: deep navy (#0B0F1A) rounded square (1024×1024).',
+        'Mood: focused, professional, signal-not-noise.',
+        'NO Lark / Feishu logo trademark, NO text, NO photo-realism.',
+      ].join('\n'),
+      category: 'Notifications',
+      tags: ['lark', 'feishu', 'notification', 'alert', 'child-workflow'],
+      capabilities: [
+        'Severity-coded Lark Interactive Card',
+        'Auto-detects receive_id_type from id prefix (chat_id / open_id / email)',
+        'Sub-graph dispatchable from any parent workflow',
+        'Per-process token cache for fan-out efficiency',
+      ],
+      conversationStarters: [
+        'Send a CRITICAL alert to the engineering Lark group',
+        'Notify the on-call group chat when Sentry issue spikes',
+        'Forward deploy notifications to our Lark channel',
+      ],
+    },
+  },
+
+  // ── notify-notion: same as notify-slack/-lark, Notion variant ────
+  // Two write modes: create a new page in a database, or append blocks
+  // to an existing page. Rich-mode delegates to
+  // @zibby/skills/report's reportToNotionBlocks. See notify-notion/README.md.
+  'notify-notion': {
+    name: 'notify-notion',
+    displayName: 'Notify Notion',
+    description: 'Reusable child workflow — creates a Notion page in a database OR appends blocks to an existing page. Dispatched by other workflows (digest, incident archives, weekly reports) via sub-graph.',
+    path: join(__dirname, 'notify-notion'),
+    defaultSlug: 'archive-notion',
+    deps: { zod: '^3.23.0', '@zibby/skills': '^0.1.25' },
+    features: [
+      'Single-node, no LLM — deterministic ~1-2s Notion REST call',
+      'Two write modes: create page in database OR append children to existing page',
+      'Rich-mode renders report objects via @zibby/skills/report (heading, callouts, tables, trend code blocks)',
+      'Legacy-mode renders simple severity / title / body alerts (sentry-triage et al.)',
+      'Severity-mapped page-icon emoji (low/medium/high/critical or rich-mode delta severity)',
+      'Surfaces typed errors for 401 (token revoked), 404 (target not shared with bot), 429 (rate-limited)',
+      'Returns pageId + pageUrl for downstream linkage from notify-slack / notify-lark messages',
+    ],
+    marketplace: {
+      slug: 'notify-notion',
+      tagline: 'Reusable Notion archiver — durable record for any workflow.',
+      iconPrompt: [
+        'Hand-painted gouache illustration with soft brushwork and gentle painterly texture, in the same family as the sentry-triage and generate-test-cases marketplace icons but with its own distinct character.',
+        'Subject: a friendly anthropomorphic notebook-document mascot — a small rounded notebook character with two big smiling eyes and a rosy blush, its open pages showing three painted horizontal ink-lines and a tiny checkmark in the corner. A soft halo of two or three little pastel page-flutter sparkles dance around it, suggesting a freshly-written entry being archived.',
+        'Background: a pale neutral Notion-flavored off-white gradient — warm cream at the top blending into a soft dove-grey at the base (#F7F3EC → #E8E4DA), with a single faint paper-grain texture and a couple of small floating pastel ink-spot dots for friendliness.',
+        'Centered composition with the notebook character as the focal point in the lower-center, sparkles arcing across the upper third; plenty of breathing room so the silhouette reads at 64×64 in the marketplace grid.',
+        'Mood is calm, archival, gently studious — the friendly notebook companion that keeps a tidy record, NOT corporate productivity or wall-of-text database.',
+        'Soft rounded square 1024×1024 canvas with a subtle paper-grain texture.',
+        'NO text, NO logo or trademarked marks, NO photo-realism, NO sleek 3D render, NO literal Notion trademark.',
+      ].join('\n'),
+      category: 'Operations',
+      tags: ['notion', 'docs', 'reporting', 'knowledge-base', 'archive'],
+      capabilities: [
+        'Create a new page in a Notion database (POST /v1/pages)',
+        'Append blocks to an existing page (PATCH /v1/blocks/{pageId}/children)',
+        'Renders rich report-objects to native Notion blocks (headings, callouts, tables, code, embeds)',
+        'Severity-mapped page-icon emoji + colored callout backgrounds',
+        'Sub-graph dispatchable from any parent workflow',
+        'Maps 401 / 404 / 429 to typed errors so callers can react cleanly',
+      ],
+      conversationStarters: [
+        'Archive the weekly digest to our Notion reports database',
+        'Append today\'s incident summary to the on-call runbook page',
+        'Create a Notion page for every new Sentry CRITICAL',
+        'Drop the deploy-summary into our engineering Notion every Friday',
+      ],
+    },
+  },
+
+  // ── sentry-triage: parent workflow that uses notify-slack/-lark ──
+  'sentry-triage': {
+    name: 'sentry-triage',
+    displayName: 'Sentry Triage Bot',
+    description: 'Hourly Sentry triage — pulls new issues, drops obvious noise with a regex pre-filter, classifies survivors with LLM (CRITICAL/HIGH/MEDIUM/LOW/NOISE), and fans out alerts to a notify-slack OR notify-lark child workflow.',
+    path: join(__dirname, 'sentry-triage'),
+    defaultSlug: 'sentry-triage',
+    deps: { zod: '^3.23.0' },
+    features: [
+      '4-node graph: fetch → filter_noise → classify → dispatch_alerts',
+      'Regex noise filter before LLM cuts ~80% of classification cost',
+      'LLM severity classifier with explicit rubric (rules 1-5)',
+      'Sub-graph fan-out to notify-slack OR notify-lark (choose at deploy)',
+      'Per-issue failure isolation — one Slack hiccup doesn\'t stall the run',
+      'Configurable severityThreshold (don\'t notify on LOW noise)',
+      'Cron-friendly: hourly schedule, default sinceMinutes=60',
+    ],
+    marketplace: {
+      slug: 'sentry-triage',
+      tagline: 'Filter noise, classify severity, ping the right channel — every hour.',
+      iconPrompt: [
+        'Hand-painted storybook illustration in a warm gouache style with soft brushwork and gentle painterly texture, featuring the friendly round lighthouse mascot character with two big smiling eyes and a rosy blush on its white-and-coral-striped tower body, perched on a tiny mint-green island and clutching a small glowing purple SHIELD BADGE in front of its body — the badge is a rounded geometric emblem in Sentry\'s signature deep violet (#362D59 / #7553FF) with a stylized white "S"-mark inside it formed from overlapping rounded parallelogram shapes, painted with the same soft gouache brushstrokes as the rest of the scene so it feels integrated rather than corporate.',
+        'The lighthouse lantern emits a soft golden beam that catches one glowing amber alert orb while three faded grey noise specks drift harmlessly past, reinforcing the "filter the signal, calm the noise" idea.',
+        'Background is a soft sunrise gradient of pale peach at the top blending through buttercream into a gentle wash of dusty lavender at the base, tying the warm scene to the violet of the badge; a few small fluffy pastel clouds float in for friendliness.',
+        'Centered composition with the purple shield badge as the immediate focal point in the lower-center, the lighthouse rising behind and slightly above it, beam angled diagonally; plenty of breathing room so the silhouette reads at 64×64 with the violet badge clearly visible at a glance.',
+        'Mood is warm, reassuring, optimistic — the friendly Sentry-flavored night-watch character, NOT tactical or corporate or alarming.',
+        'Soft rounded square 1024×1024 canvas with a subtle paper-grain texture.',
+        'NO text, NO letters, NO photo-realism, NO sleek 3D render, NO magnifying glass, NO speech bubbles, NO dark navy or near-black backgrounds, NO bug or insect imagery, NO literal Sentry wordmark.',
+      ].join('\n'),
+      category: 'Operations',
+      tags: ['sentry', 'observability', 'on-call', 'triage', 'alerting'],
+      capabilities: [
+        'Hourly scheduled triage of new Sentry issues',
+        'Deterministic regex filter drops Script error / ResizeObserver / extension noise',
+        'LLM severity classifier with auditable rubric',
+        'Dispatches to notify-slack or notify-lark (sub-graph, ~5ms in-process)',
+        'CRITICAL alerts get caller-supplied @-mentions; lower severities don\'t',
+        'Configurable severity threshold per deploy',
+      ],
+      conversationStarters: [
+        'Triage all new Sentry issues from the last hour',
+        'Notify #sentry-alerts when severity is HIGH or above',
+        'Run hourly and post a summary to our team Slack',
+        'Page on-call when a CRITICAL error appears in checkout',
+      ],
+    },
+  },
+
+  // ── ai-spend-weekly-digest: cross-silo billing digest ─────────────
+  'ai-spend-weekly-digest': {
+    name: 'ai-spend-weekly-digest',
+    displayName: 'AI Spend Weekly Digest',
+    description: 'Weekly digest of OpenAI / Anthropic / Cursor admin billing — pulls trailing-28d cost+usage across all three providers, detects per-project anomalies vs 3-week baseline, and posts a rich report card to Lark and/or Slack via in-process sub-graph dispatch.',
+    path: join(__dirname, 'ai-spend-weekly-digest'),
+    defaultSlug: 'ai-spend-weekly-digest',
+    deps: { zod: '^3.23.0', '@zibby/skills': '^0.1.25' },
+    features: [
+      '3-node graph: fetch_spending → analyze (LLM narrative) → dispatch_digest',
+      'Parallel admin-API fetch via Promise.allSettled — one provider down doesn\'t kill the run',
+      'Customer attribution via OpenAI project / Anthropic workspace / Cursor user metadata (no manual mapping required)',
+      'Anomaly detection over per-key σ + ratio fallback — flags spend spikes vs 3-week baseline',
+      'Renders to native Slack Block-Kit / Lark Card via reportToBlockKit / reportToLarkCard — zero chart-image dependency',
+      'Parallel sub-graph dispatch to notify-slack + notify-lark (~5ms in-process overhead)',
+      'Cron-friendly: weekly schedule, default Monday 08:00 local',
+    ],
+    marketplace: {
+      slug: 'ai-spend-weekly-digest',
+      tagline: 'Track and explain your OpenAI / Anthropic / Cursor spending — every Monday morning, in Lark or Slack.',
+      iconPrompt: [
+        'Hand-painted gouache illustration with soft brushwork and gentle painterly texture, featuring a friendly chubby pastel-pink piggy-bank character with two big smiling eyes and rosy blush, its body marked with a soft glowing dollar-sign sigil; the piggy is gently cradling a small stack of three coloured coins floating just above its back — a sky-blue coin for OpenAI-ish, a warm violet coin for Anthropic-ish, and a soft mint-green coin for Cursor-ish — each coin painted in the same loose gouache style with no logos or text on them, just abstract round chips.',
+        'A thin painterly trend-line ribbon arcs gently upward behind the piggy from lower-left to upper-right, suggesting "money over time", rendered as a soft watercolor ribbon in dusty rose with a tiny gentle peak near the top right.',
+        'Background is a calm sunrise gradient of pale buttercream at the top blending through soft peach into a gentle wash of pale mint at the base, with a few small pastel clouds for friendliness.',
+        'Centered composition with the piggy as the immediate focal point in the lower-center, the floating coins arcing across the upper third, the trend ribbon as background scaffolding; plenty of breathing room so the silhouette reads at 64×64.',
+        'Mood is warm, optimistic, gently informative — feels like a thoughtful finance friend, NOT corporate spreadsheet, NOT alarmist red.',
+        'Soft rounded square 1024×1024 canvas with a subtle paper-grain texture.',
+        'NO text, NO letters, NO numbers, NO photo-realism, NO sleek 3D render, NO chart axes or grid lines, NO dark navy or near-black backgrounds, NO literal OpenAI / Anthropic / Cursor logos or wordmarks, NO bar charts.',
+      ].join('\n'),
+      category: 'Operations',
+      tags: ['cost', 'finance', 'reporting', 'openai', 'anthropic', 'cursor', 'digest', 'weekly'],
+      capabilities: [
+        'Pulls org-wide cost+usage from OpenAI, Anthropic, and Cursor admin APIs in parallel',
+        'Joins customer attribution from provider-native project / workspace / member metadata',
+        'Detects per-project anomalies (σ + ratio) against a 3-week rolling baseline',
+        'Drafts the leadership-grade narrative with an LLM, falls back to deterministic copy if model is unavailable',
+        'Posts a rich Block-Kit / Lark Card report (trend bars, top spenders table, anomalies, provider breakdown)',
+        'Fan-out to Lark + Slack in parallel — partial-failure resilient',
+      ],
+      conversationStarters: [
+        'Run a weekly AI spend digest every Monday morning',
+        'Tell me which OpenAI projects spiked spending this week',
+        'Compare Anthropic spend vs the 3-week baseline',
+        'Post the digest to our #leadership Lark group + #eng Slack channel',
+      ],
+    },
   }
 };
 

package/notify-lark/README.md

@@ -0,0 +1,88 @@
+# notify-lark
+
+A reusable **child workflow** that posts an Interactive Card alert to a Lark / Feishu chat.
+
+Companion to `notify-slack` — same provider-neutral input shape, so a parent workflow can fan out to BOTH Slack and Lark with the same `input` block (just swap `channel` → `receiveId`).
+
+## What it does
+
+- Takes a provider-neutral payload (severity, title, body, optional Sentry-flavored context)
+- Builds a Lark Interactive Card with severity-coded header template + emoji + action buttons
+- Resolves `tenant_access_token` from the app id/secret stored in your Lark integration
+- POSTs to `/open-apis/im/v1/messages` with the right `receive_id_type` inferred from the id prefix
+
+No LLM call — single deterministic API request, typically <500ms (or <1s on cold token cache).
+
+## Dispatch shape (parent workflow)
+
+```js
+graph.addNode('alert', {
+  workflow: 'notify-lark',
+  async: false,
+  input: (state) => ({
+    severity:   'critical',
+    title:      'Checkout: TypeError on session.user.id',
+    body:       '**12 users** affected in the last 1h. Likely regression from `1.42.0`.',
+    receiveId:  'oc_abc123def456...',                      // chat id, open id, or email
+    sentryLink: 'https://sentry.io/.../1234567890/',
+    affectedUsers: 12,
+    events:     47,
+    release:    '1.42.0',
+    firstSeen:  '8 min ago',
+    codeSnippet:'src/handlers/checkout.ts:142\nconst userId = session.user.id;',
+    mentions:   ['<at user_id="ou_oncall_group">@backend-oncall</at>'],
+  }),
+  output: 'notify_lark.messageId',
+});
+```
+
+## receiveId formats
+
+The `receive_id_type` query param is inferred from the prefix:
+
+| Prefix | Type | Description |
+|---|---|---|
+| `oc_` | `chat_id` | Group chat or DM (most common) |
+| `ou_` | `open_id` | Direct message to a specific user |
+| `on_` | `union_id` | Cross-app stable user id |
+| `cli_` | `app_id` | App-to-app message |
+| `<email>@…` | `email` | Send to user by email |
+
+If you don't know your chat id, DM the bot `whoami` and it'll respond with the caller's `open_id`. Group chat ids appear in the URL when you open the chat in browser.
+
+## Output
+
+```js
+{ delivered: true, receiveId: 'oc_abc...', receiveIdType: 'chat_id', messageId: 'om_xxxxx' }
+```
+
+The `messageId` lets the parent post threaded replies later (e.g. incident-commander progress updates).
+
+## Prerequisites
+
+Project must have the **Lark** integration connected with:
+- `im:message` scope (send messages)
+- `im:message.group_msg` scope (send to group chats)
+
+## Severity → header template
+
+| Severity | Lark template | Emoji |
+|---|---|---|
+| low | `grey` | ⚪ |
+| medium | `yellow` | 🟡 |
+| high | `orange` | 🟠 |
+| critical | `red` | 🚨 |
+
+## Tests
+
+```bash
+cd packages/workflow-templates/notify-lark
+npm test
+```
+
+Tests cover:
+- Card rendering for each severity
+- Conditional sections (fields/body/code/actions only when input present)
+- receive_id_type inference per prefix
+- Tenant token caching across multiple sends
+- Error mapping (invalid receive_id, scope missing, network blip)

package/notify-lark/graph.mjs

@@ -0,0 +1,43 @@
+/**
+ * notify-lark — single-node child workflow.
+ *
+ * Companion to notify-slack; same provider-neutral input shape so a
+ * parent can `dispatchSubgraph('notify-slack')` AND
+ * `dispatchSubgraph('notify-lark')` with the same input block, just
+ * swapping `channel` → `receiveId`. (See notify-slack/graph.mjs for the
+ * Slack-flavored example.)
+ *
+ * Returns `{ delivered, receiveId, receiveIdType, messageId }`. The
+ * `messageId` can be used for thread replies via Lark's reply API in
+ * follow-up dispatches.
+ */
+
+import { WorkflowAgent, WorkflowGraph } from '@zibby/core';
+import { notifyLarkNode } from './nodes/notify-lark-node.js';
+import {
+  notifyLarkInputSchema,
+  notifyLarkContextSchema,
+} from './state.js';
+
+export class NotifyLarkAgent extends WorkflowAgent {
+  buildGraph() {
+    const graph = new WorkflowGraph();
+    graph
+      .setInputSchema(notifyLarkInputSchema)
+      .setContextSchema(notifyLarkContextSchema);
+
+    graph.addNode('notify_lark', notifyLarkNode);
+    graph.setEntryPoint('notify_lark');
+    graph.addEdge('notify_lark', 'END');
+
+    return graph;
+  }
+
+  async onComplete(result) {
+    const delivered = !!result?.state?.notify_lark?.delivered;
+    const mid = result?.state?.notify_lark?.messageId || '?';
+    console.log(`[notify-lark] ${delivered ? 'delivered' : 'failed'} (messageId=${mid})`);
+  }
+}
+
+export default NotifyLarkAgent;