@alfe.ai/openclaw-chat 0.0.1

package/README.md

@@ -0,0 +1,38 @@
+# packages/openclaw-chat (`@alfe.ai/openclaw-chat`)
+
+OpenClaw chat plugin for Alfe — web widget and mobile app channels
+
+## What It Does
+
+OpenClaw plugin that registers the `alfe-chat` channel with the OpenClaw agent runtime. Follows the standard OpenClaw plugin pattern:
+
+- Exports a plugin object with `id`, `name`, `activate`, `deactivate`
+- Connects to the Alfe daemon IPC for capability registration
+- Gracefully degrades if the daemon is unavailable
+
+## Key Files
+
+```
+src/
+├── plugin.ts           # Plugin entry point (activate/deactivate lifecycle)
+├── index.ts            # Public re-exports
+└── types.ts            # Plugin-specific type definitions
+```
+
+## Development
+
+```bash
+pnpm install
+pnpm --filter @alfe.ai/openclaw-chat build
+```
+
+## Testing
+
+```bash
+pnpm --filter @alfe.ai/openclaw-chat test
+```
+
+## Dependencies
+
+- **@alfe.ai/openclaw** — OpenClaw runtime plugin API
+- **openclaw** — OpenClaw runtime plugin API

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { a as AlfeResolvedAccount, c as OpenClawConfig, d as createAlfeChannelPlugin, i as AlfePluginConfig, l as OpenClawModule, n as AlfeChannelAccountConfig, o as IPCClient, r as AlfeChannelConfig, s as Logger, t as plugin, u as OpenClawPluginApi } from "./plugin.js";
+
+//#region src/session-store.d.ts
+
+/**
+ * Session Store — persists chat sessions to the local filesystem.
+ *
+ * Storage layout:
+ *   ~/.alfe/sessions/chat/{sessionId}.json
+ *
+ * Each session file contains metadata and the full message history.
+ * Sessions are written on every message to ensure durability.
+ */
+interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+  timestamp: number;
+}
+interface SessionData {
+  sessionId: string;
+  agentId: string;
+  channel: string;
+  tenantId?: string;
+  userId?: string;
+  createdAt: string;
+  updatedAt: string;
+  messages: ChatMessage[];
+}
+interface SessionSummary {
+  sessionId: string;
+  agentId: string;
+  channel: string;
+  createdAt: string;
+  lastMessageAt?: string;
+  preview?: string;
+  messageCount: number;
+}
+//#endregion
+export { AlfeChannelAccountConfig, AlfeChannelConfig, AlfePluginConfig, AlfeResolvedAccount, type ChatMessage, IPCClient, Logger, OpenClawConfig, OpenClawModule, OpenClawPluginApi, type SessionData, type SessionSummary, createAlfeChannelPlugin, plugin as default, plugin };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { n as createAlfeChannelPlugin, t as plugin } from "./plugin2.js";
+export { createAlfeChannelPlugin, plugin as default, plugin };

package/dist/plugin.d.ts

@@ -0,0 +1,207 @@
+//#region src/alfe-channel.d.ts
+
+/**
+ * Creates the Alfe ChannelPlugin object for registration with OpenClaw.
+ *
+ * This follows the same pattern as built-in channels (Telegram, Discord, etc.)
+ * but is registered dynamically via api.registerChannel().
+ */
+declare function createAlfeChannelPlugin(): {
+  id: string;
+  meta: {
+    id: string;
+    label: string;
+    selectionLabel: string;
+    detailLabel: string;
+    docsPath: string;
+    docsLabel: string;
+    blurb: string;
+    systemImage: string;
+    order: number;
+    aliases: string[];
+    forceAccountBinding: boolean;
+    showConfigured: boolean;
+  };
+  capabilities: {
+    chatTypes: ("direct" | "group")[];
+    reactions: boolean;
+    edit: boolean;
+    unsend: boolean;
+    reply: boolean;
+    effects: boolean;
+    groupManagement: boolean;
+    threads: boolean;
+    media: boolean;
+    nativeCommands: boolean;
+    polls: boolean;
+  };
+  config: {
+    /**
+     * List configured account IDs.
+     * Supports multi-account via channels.alfe.accounts, with a
+     * default account derived from the top-level channels.alfe section.
+     */
+    listAccountIds(cfg: OpenClawConfig): string[];
+    /**
+     * Resolve account config for a given account ID.
+     */
+    resolveAccount(cfg: OpenClawConfig, accountId?: string | null): AlfeResolvedAccount;
+    /**
+     * Default account ID.
+     */
+    defaultAccountId(): string;
+    /**
+     * Check if account is enabled.
+     */
+    isEnabled(account: AlfeResolvedAccount): boolean;
+    /**
+     * Check if account is configured (always true for Alfe — no external tokens needed).
+     */
+    isConfigured(): boolean;
+    /**
+     * Describe the account state for status display.
+     */
+    describeAccount(account: AlfeResolvedAccount): {
+      accountId: string;
+      enabled: boolean;
+      configured: boolean;
+      dmPolicy: string | undefined;
+    };
+    /**
+     * Resolve allow-from list for an account.
+     */
+    resolveAllowFrom(params: {
+      cfg: OpenClawConfig;
+      accountId?: string | null;
+    }): string[];
+    /**
+     * Resolve default outbound target.
+     */
+    resolveDefaultTo(params: {
+      cfg: OpenClawConfig;
+      accountId?: string | null;
+    }): string | undefined;
+  };
+  /**
+   * Outbound delivery via gateway.
+   * The chat relay service on Fly.io handles actual delivery
+   * to connected web/mobile clients via the gateway.
+   */
+  outbound: {
+    deliveryMode: "gateway";
+    textChunkLimit: number;
+  };
+  /**
+   * Setup adapter — minimal for Alfe since no external tokens are needed.
+   */
+  setup: {
+    resolveAccountId(params: {
+      cfg: OpenClawConfig;
+      accountId?: string;
+      input?: Record<string, unknown>;
+    }): string;
+    applyAccountConfig(params: {
+      cfg: OpenClawConfig;
+      accountId: string;
+      input: Record<string, unknown>;
+    }): OpenClawConfig;
+  };
+};
+//#endregion
+//#region src/types.d.ts
+/**
+ * Types for the Alfe chat channel plugin.
+ *
+ * The Alfe channel registers with OpenClaw as a first-class channel,
+ * allowing web and mobile clients to share conversation sessions.
+ */
+interface AlfeChannelAccountConfig {
+  /** Whether this account is enabled. */
+  enabled?: boolean;
+  /** Allowed sender identifiers (user IDs, email addresses). */
+  allowFrom?: string | string[];
+  /** Default delivery target. */
+  defaultTo?: string;
+  /** DM policy (open, allowlist, etc.). */
+  dmPolicy?: string;
+}
+interface AlfeChannelConfig {
+  /** Whether the Alfe channel is enabled. */
+  enabled?: boolean;
+  /** Allowed sender identifiers. */
+  allowFrom?: string | string[];
+  /** Default delivery target for outbound messages. */
+  defaultTo?: string;
+  /** DM policy. */
+  dmPolicy?: string;
+  /** Named accounts (multi-account support). */
+  accounts?: Record<string, AlfeChannelAccountConfig>;
+}
+interface AlfeResolvedAccount {
+  accountId: string;
+  enabled: boolean;
+  allowFrom: string[];
+  defaultTo?: string;
+  dmPolicy?: string;
+}
+interface AlfePluginConfig {
+  /** Alfe daemon IPC socket path override. */
+  daemonSocket?: string;
+  /** Agent ID this plugin is associated with. */
+  agentId?: string;
+}
+interface Logger {
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+  debug(msg: string, ...args: unknown[]): void;
+}
+interface OpenClawConfig {
+  channels?: {
+    alfe?: AlfeChannelConfig;
+    [key: string]: unknown;
+  };
+  plugins?: {
+    entries?: Record<string, {
+      config?: AlfePluginConfig;
+      [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+interface OpenClawPluginApi {
+  logger: Logger;
+  config?: OpenClawConfig;
+  registerChannel(channel: ReturnType<typeof createAlfeChannelPlugin>): void;
+  registerGatewayMethod?(name: string, handler: (...args: unknown[]) => Promise<unknown>): void;
+  on(event: string, handler: (...args: unknown[]) => void | Promise<void>, options?: {
+    priority?: number;
+  }): void;
+}
+interface IPCClient {
+  on(event: string, handler: (...args: unknown[]) => void | Promise<void>): void;
+  start(): void;
+  stop(): void;
+  request(method: string, params: Record<string, unknown>): Promise<{
+    ok: boolean;
+    error?: {
+      message: string;
+    };
+  }>;
+}
+interface OpenClawModule {
+  IPCClient: new (socketPath: string, log: Logger) => IPCClient;
+}
+//#endregion
+//#region src/plugin.d.ts
+declare const plugin: {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  activate(api: OpenClawPluginApi): Promise<void>;
+  deactivate(api: OpenClawPluginApi): void;
+};
+//#endregion
+export { AlfeResolvedAccount as a, OpenClawConfig as c, createAlfeChannelPlugin as d, AlfePluginConfig as i, OpenClawModule as l, AlfeChannelAccountConfig as n, IPCClient as o, AlfeChannelConfig as r, Logger as s, plugin as t, OpenClawPluginApi as u };

package/dist/plugin.js

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin2.js";
+export { plugin as default };

package/dist/plugin2.d.ts

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin.js";
+export { plugin as default };

package/dist/plugin2.js

@@ -0,0 +1,381 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+//#region src/alfe-channel.ts
+const CHANNEL_ID = "alfe";
+const DEFAULT_ACCOUNT_ID = "default";
+function getChannelSection(cfg) {
+	return cfg.channels?.alfe ?? {};
+}
+function normalizeAllowFrom(raw) {
+	if (!raw) return [];
+	if (typeof raw === "string") return [raw];
+	return raw;
+}
+/**
+* Creates the Alfe ChannelPlugin object for registration with OpenClaw.
+*
+* This follows the same pattern as built-in channels (Telegram, Discord, etc.)
+* but is registered dynamically via api.registerChannel().
+*/
+function createAlfeChannelPlugin() {
+	return {
+		id: CHANNEL_ID,
+		meta: {
+			id: CHANNEL_ID,
+			label: "Alfe",
+			selectionLabel: "Alfe (Web & Mobile)",
+			detailLabel: "Alfe Chat",
+			docsPath: "/channels/alfe",
+			docsLabel: "alfe",
+			blurb: "Alfe native chat — web widget and mobile app conversations.",
+			systemImage: "bubble.left.and.text.bubble.right",
+			order: 100,
+			aliases: ["alfe-web", "alfe-mobile"],
+			forceAccountBinding: false,
+			showConfigured: true
+		},
+		capabilities: {
+			chatTypes: ["direct", "group"],
+			reactions: false,
+			edit: false,
+			unsend: false,
+			reply: true,
+			effects: false,
+			groupManagement: false,
+			threads: false,
+			media: true,
+			nativeCommands: false,
+			polls: false
+		},
+		config: {
+			listAccountIds(cfg) {
+				const section = getChannelSection(cfg);
+				const ids = [];
+				if (section.enabled !== false && (section.allowFrom ?? section.defaultTo ?? section.dmPolicy)) ids.push(DEFAULT_ACCOUNT_ID);
+				if (section.accounts) {
+					for (const id of Object.keys(section.accounts)) if (!ids.includes(id)) ids.push(id);
+				}
+				if (ids.length === 0 && section.enabled !== false) ids.push(DEFAULT_ACCOUNT_ID);
+				return ids;
+			},
+			resolveAccount(cfg, accountId) {
+				const section = getChannelSection(cfg);
+				const id = accountId ?? DEFAULT_ACCOUNT_ID;
+				const accountSection = section.accounts?.[id];
+				if (accountSection) return {
+					accountId: id,
+					enabled: accountSection.enabled !== false,
+					allowFrom: normalizeAllowFrom(accountSection.allowFrom),
+					defaultTo: accountSection.defaultTo,
+					dmPolicy: accountSection.dmPolicy
+				};
+				return {
+					accountId: id,
+					enabled: section.enabled !== false,
+					allowFrom: normalizeAllowFrom(section.allowFrom),
+					defaultTo: section.defaultTo,
+					dmPolicy: section.dmPolicy
+				};
+			},
+			defaultAccountId() {
+				return DEFAULT_ACCOUNT_ID;
+			},
+			isEnabled(account) {
+				return account.enabled;
+			},
+			isConfigured() {
+				return true;
+			},
+			describeAccount(account) {
+				return {
+					accountId: account.accountId,
+					enabled: account.enabled,
+					configured: true,
+					dmPolicy: account.dmPolicy
+				};
+			},
+			resolveAllowFrom(params) {
+				const section = getChannelSection(params.cfg);
+				const id = params.accountId ?? DEFAULT_ACCOUNT_ID;
+				return normalizeAllowFrom((section.accounts?.[id])?.allowFrom ?? section.allowFrom);
+			},
+			resolveDefaultTo(params) {
+				const section = getChannelSection(params.cfg);
+				const id = params.accountId ?? DEFAULT_ACCOUNT_ID;
+				return section.accounts?.[id]?.defaultTo ?? section.defaultTo;
+			}
+		},
+		outbound: {
+			deliveryMode: "gateway",
+			textChunkLimit: 4e3
+		},
+		setup: {
+			resolveAccountId(params) {
+				return params.accountId ?? DEFAULT_ACCOUNT_ID;
+			},
+			applyAccountConfig(params) {
+				const cfg = { ...params.cfg };
+				cfg.channels ??= {};
+				cfg.channels.alfe ??= {};
+				const section = cfg.channels.alfe;
+				if (params.accountId === DEFAULT_ACCOUNT_ID) section.enabled = true;
+				else {
+					section.accounts ??= {};
+					section.accounts[params.accountId] = {
+						enabled: true,
+						...params.input
+					};
+				}
+				return cfg;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/session-store.ts
+/**
+* Session Store — persists chat sessions to the local filesystem.
+*
+* Storage layout:
+*   ~/.alfe/sessions/chat/{sessionId}.json
+*
+* Each session file contains metadata and the full message history.
+* Sessions are written on every message to ensure durability.
+*/
+const SESSIONS_DIR = join(homedir(), ".alfe", "sessions", "chat");
+async function ensureDir() {
+	if (!existsSync(SESSIONS_DIR)) await mkdir(SESSIONS_DIR, { recursive: true });
+}
+function sessionPath(sessionId) {
+	return join(SESSIONS_DIR, `${sessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+}
+async function getSession(sessionId) {
+	try {
+		const data = await readFile(sessionPath(sessionId), "utf-8");
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+async function saveSession(session) {
+	await ensureDir();
+	session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await writeFile(sessionPath(session.sessionId), JSON.stringify(session, null, 2), "utf-8");
+}
+async function createSession(sessionId, agentId, channel, tenantId, userId) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const session = {
+		sessionId,
+		agentId,
+		channel,
+		tenantId,
+		userId,
+		createdAt: now,
+		updatedAt: now,
+		messages: []
+	};
+	await saveSession(session);
+	return session;
+}
+async function addMessage(sessionId, role, content) {
+	const session = await getSession(sessionId);
+	if (!session) return;
+	session.messages.push({
+		role,
+		content,
+		timestamp: Date.now()
+	});
+	await saveSession(session);
+}
+async function listSessions(filters) {
+	await ensureDir();
+	let files;
+	try {
+		files = await readdir(SESSIONS_DIR);
+	} catch {
+		return [];
+	}
+	const jsonFiles = files.filter((f) => f.endsWith(".json"));
+	const summaries = [];
+	for (const file of jsonFiles) try {
+		const data = await readFile(join(SESSIONS_DIR, file), "utf-8");
+		const session = JSON.parse(data);
+		if (filters?.agentId && session.agentId !== filters.agentId) continue;
+		if (filters?.channel && session.channel !== filters.channel) continue;
+		if (filters?.tenantId && session.tenantId !== filters.tenantId) continue;
+		const lastMsg = session.messages.at(-1);
+		summaries.push({
+			sessionId: session.sessionId,
+			agentId: session.agentId,
+			channel: session.channel,
+			createdAt: session.createdAt,
+			lastMessageAt: lastMsg ? new Date(lastMsg.timestamp).toISOString() : void 0,
+			preview: lastMsg?.content.slice(0, 100),
+			messageCount: session.messages.length
+		});
+	} catch {}
+	summaries.sort((a, b) => {
+		const aTime = a.lastMessageAt ?? a.createdAt;
+		return (b.lastMessageAt ?? b.createdAt).localeCompare(aTime);
+	});
+	return summaries;
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-chat — OpenClaw chat channel plugin.
+*
+* Registers the 'alfe' channel with OpenClaw, creating a first-class
+* channel for Alfe conversations. Web and mobile clients share the
+* same channel and conversation sessions.
+*
+* This follows the same pattern as the voice-gateway plugin:
+*   - Registers channel via api.registerChannel()
+*   - Connects to the Alfe daemon IPC for capability registration
+*   - Registers gateway RPC methods for message delivery and session queries
+*   - Hooks into session lifecycle events
+*   - Persists chat sessions to ~/.alfe/sessions/chat/
+*   - Gracefully degrades if the daemon is unavailable
+*/
+const DEFAULT_SOCKET_PATH = join(homedir(), ".alfe", "gateway.sock");
+const CHAT_CAPABILITIES = [
+	"chat.web",
+	"chat.mobile",
+	"chat.sessions"
+];
+let daemonIpcClient = null;
+/**
+* Attempt to connect to the Alfe daemon IPC socket.
+* Returns null if @alfe.ai/openclaw is not available or daemon is unreachable.
+*/
+async function connectToDaemon(socketPath, log) {
+	try {
+		const IPCClientCtor = (await import("@alfe.ai/openclaw")).IPCClient;
+		const client = new IPCClientCtor(socketPath, log);
+		client.on("connected", async () => {
+			log.info("Connected to Alfe daemon — registering chat capabilities...");
+			const response = await client.request("capability.register", {
+				plugin: "@alfe.ai/openclaw-chat",
+				capabilities: [...CHAT_CAPABILITIES]
+			});
+			if (response.ok) log.info("Chat capabilities registered with daemon");
+			else log.warn(`Failed to register chat capabilities: ${response.error?.message ?? "unknown"}`);
+		});
+		client.on("disconnected", (reason) => {
+			log.warn(`Disconnected from Alfe daemon: ${String(reason)}`);
+		});
+		client.on("error", (err) => {
+			log.debug(`Daemon IPC error: ${err.message}`);
+		});
+		client.start();
+		return client;
+	} catch {
+		log.info("Alfe daemon not available — chat plugin running standalone");
+		return null;
+	}
+}
+const plugin = {
+	id: "@alfe.ai/openclaw-chat",
+	name: "Alfe Chat Plugin",
+	description: "Alfe conversation channel — web widget and mobile app share unified chat sessions",
+	version: "0.3.0",
+	async activate(api) {
+		if (globalThis.__alfeChatPluginActivated) {
+			api.logger.debug("Alfe Chat plugin already activated, skipping re-init");
+			return;
+		}
+		globalThis.__alfeChatPluginActivated = true;
+		const log = api.logger;
+		log.info("Alfe Chat plugin activating...");
+		const pluginConfig = (api.config ?? {}).plugins?.entries?.["@alfe.ai/openclaw-chat"]?.config ?? {};
+		const alfeChannel = createAlfeChannelPlugin();
+		api.registerChannel(alfeChannel);
+		log.info(`Registered channel: ${alfeChannel.id} (${alfeChannel.meta.label})`);
+		daemonIpcClient = await connectToDaemon(pluginConfig.daemonSocket ?? process.env.ALFE_GATEWAY_SOCKET ?? DEFAULT_SOCKET_PATH, log);
+		if (typeof api.registerGatewayMethod === "function") {
+			api.registerGatewayMethod("chat.send", (...args) => {
+				const { sessionId, content, clientType } = args[0];
+				log.info(`chat.send RPC: session=${sessionId}, client=${clientType ?? "unknown"}, content=${content.slice(0, 50)}...`);
+				return Promise.resolve({
+					ok: true,
+					sessionId,
+					channel: "alfe"
+				});
+			});
+			log.info("Registered gateway RPC method: chat.send");
+			api.registerGatewayMethod("sessions.list", async (...args) => {
+				const params = args[0];
+				log.info(`sessions.list RPC: agentId=${params.agentId ?? "*"}, channel=${params.channel ?? "*"}`);
+				return { sessions: await listSessions({
+					agentId: params.agentId,
+					channel: params.channel,
+					tenantId: params.tenantId
+				}) };
+			});
+			log.info("Registered gateway RPC method: sessions.list");
+			api.registerGatewayMethod("sessions.get", async (...args) => {
+				const params = args[0];
+				log.info(`sessions.get RPC: sessionId=${params.sessionId}`);
+				const session = await getSession(params.sessionId);
+				if (!session) return {
+					ok: false,
+					error: "Session not found"
+				};
+				return {
+					sessionId: session.sessionId,
+					agentId: session.agentId,
+					channel: session.channel,
+					createdAt: session.createdAt,
+					messages: session.messages.map((m) => ({
+						id: `msg-${String(m.timestamp)}`,
+						role: m.role,
+						content: m.content,
+						timestamp: m.timestamp
+					}))
+				};
+			});
+			log.info("Registered gateway RPC method: sessions.get");
+		}
+		api.on("session_start", async (...eventArgs) => {
+			const key = eventArgs[0].sessionKey;
+			if (!key) return;
+			if (!(key.startsWith("chat-") || key.includes("alfe:") || key.includes(":alfe:"))) return;
+			log.info(`Alfe chat session starting: ${key}`);
+			const parts = key.split("-");
+			await createSession(key, parts.length >= 3 ? parts[2] : "", "alfe", parts.length >= 2 ? parts[1] : "");
+		}, { priority: 50 });
+		api.on("message", async (...eventArgs) => {
+			const event = eventArgs[0];
+			const key = event.sessionKey;
+			if (!key) return;
+			if (!(key.startsWith("chat-") || key.includes("alfe:") || key.includes(":alfe:"))) return;
+			await addMessage(key, event.role, event.content);
+		});
+		api.on("session_end", (...eventArgs) => {
+			const key = eventArgs[0].sessionKey;
+			if (!key) return;
+			if (!(key.startsWith("chat-") || key.includes("alfe:") || key.includes(":alfe:"))) return;
+			log.info(`Alfe chat session ending: ${key}`);
+		});
+		log.info("Alfe Chat plugin activated");
+	},
+	deactivate(api) {
+		globalThis.__alfeChatPluginActivated = false;
+		const log = api.logger;
+		log.info("Alfe Chat plugin deactivating...");
+		if (daemonIpcClient) {
+			try {
+				daemonIpcClient.stop();
+				log.info("Disconnected from Alfe daemon");
+			} catch (err) {
+				log.debug(`Error disconnecting from daemon: ${err.message}`);
+			}
+			daemonIpcClient = null;
+		}
+		log.info("Alfe Chat plugin deactivated");
+	}
+};
+//#endregion
+export { createAlfeChannelPlugin as n, plugin as t };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@alfe.ai/openclaw-chat",
+  "version": "0.0.1",
+  "description": "OpenClaw chat plugin for Alfe — web widget and mobile app channels",
+  "type": "module",
+  "main": "./dist/plugin.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./plugin": {
+      "import": "./dist/plugin.js",
+      "types": "./dist/plugin.d.ts"
+    }
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/plugin.js"
+    ]
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}