@zaflun/lumio-sdk 0.2.0 → 0.6.3

package/dist/server.d.ts

@@ -1,3 +1,5 @@
+import { LumioEventType } from '@zaflun/lumio-protocol';
+
 interface Validator {
     type: string;
     isOptional: boolean;
@@ -135,4 +137,251 @@ declare function filter(field: string, op: string, value: unknown): {
     value: unknown;
 };
 
-export { type ActionDefinition, type DeleteRowDefinition, type DeleteRowOptions, type FetchActionDefinition, type FetchActionOptions, type HandlerConfig, type HandlerContext, type InsertRowDefinition, type InsertRowOptions, type MutationDefinition, type PatchRowDefinition, type PatchRowOptions, type QueryDefinition, type QueryRowsDefinition, type SchemaDefinition, type TableDefinition, type Validator, action, arg, defineSchema, defineTable, deleteRow, fetchAction, filter, identity, insertRow, mutation, patchRow, query, queryRows, secret, v };
+interface BotModuleContext {
+    auth: {
+        userId: string | null;
+        accountId: string | null;
+        role: string;
+    };
+    user: {
+        id: string;
+        name: string;
+        displayName: string;
+        platform: string;
+        role: string;
+        isMod: boolean;
+        isVip: boolean;
+        isSub: boolean;
+    } | null;
+    config: Record<string, unknown>;
+    db: {
+        get: (table: string, id: string) => Promise<Record<string, unknown> | null>;
+        list: (table: string) => Promise<Record<string, unknown>[]>;
+        insert: (table: string, row: Record<string, unknown>) => Promise<string>;
+        patch: (table: string, id: string, row: Record<string, unknown>) => Promise<void>;
+        delete: (table: string, id: string) => Promise<void>;
+    };
+    cache: {
+        get: (key: string) => Promise<unknown | null>;
+        set: (key: string, value: unknown, ttl?: number) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        increment: (key: string, by?: number) => Promise<number>;
+    };
+    secrets: {
+        get: (key: string) => Promise<string | null>;
+    };
+    fetch: (url: string, options?: RequestInit) => Promise<Response>;
+    defer: (fn: () => Promise<void>) => void;
+}
+interface HandlerResponse {
+    reply?: string;
+    actions?: Array<{
+        action: string;
+        params: Record<string, unknown>;
+    }>;
+}
+interface ModerationResponse {
+    block: boolean;
+    action?: "delete" | "timeout" | "ban";
+    duration?: number;
+    reason?: string;
+}
+interface ChatMessage {
+    text: string;
+    platformMessageId: string;
+}
+type CommandHandler = (ctx: BotModuleContext, args: string[]) => Promise<HandlerResponse | null>;
+type KeywordHandler = (ctx: BotModuleContext, message: ChatMessage) => Promise<HandlerResponse | null>;
+type PatternHandler = (ctx: BotModuleContext, message: ChatMessage, matched: string) => Promise<HandlerResponse | null>;
+type EventHandler = (ctx: BotModuleContext, event: Record<string, unknown>) => Promise<HandlerResponse | null>;
+type TimerHandler = (ctx: BotModuleContext) => Promise<HandlerResponse | null>;
+type ModerateHandler = (ctx: BotModuleContext, message: ChatMessage) => Promise<ModerationResponse>;
+declare function command(name: string, handler: CommandHandler): CommandHandler & {
+    __type: string;
+    __trigger: string;
+};
+declare function keyword(trigger: string, handler: KeywordHandler): KeywordHandler & {
+    __type: string;
+    __trigger: string;
+};
+declare function pattern(regex: string, handler: PatternHandler): PatternHandler & {
+    __type: string;
+    __trigger: string;
+};
+declare function event(eventType: LumioEventType | string, handler: EventHandler): EventHandler & {
+    __type: string;
+    __trigger: string;
+};
+declare function timer(name: string, handler: TimerHandler): TimerHandler & {
+    __type: string;
+    __trigger: string;
+};
+declare function moderate(handler: ModerateHandler): ModerateHandler & {
+    __type: string;
+};
+interface ModerateContext extends BotModuleContext {
+    message: ChatMessage;
+}
+interface ModerateResult {
+    action: "allow" | "delete" | "timeout" | "warn" | "ban";
+    duration?: number;
+    reason?: string;
+    message?: string;
+}
+interface ModerateDefinition {
+    __type: "moderate";
+    handler: (ctx: ModerateContext) => Promise<ModerateResult>;
+}
+/**
+ * Define a moderation handler with a unified context.
+ *
+ * The handler receives a single `ctx` object that includes `config`,
+ * `user`, and `message`. Return `{ action: "allow" }` to pass, or
+ * `{ action: "delete" | "timeout" | "ban" | "warn", reason?, duration?, message? }`.
+ *
+ * ```ts
+ * import { defineModerate } from "@zaflun/lumio-sdk/server";
+ *
+ * export default defineModerate(async (ctx) => {
+ *   if (ctx.message.text.includes("spam")) {
+ *     return { action: "delete", reason: "Spam detected" };
+ *   }
+ *   return { action: "allow" };
+ * });
+ * ```
+ */
+declare function defineModerate(handler: (ctx: ModerateContext) => Promise<ModerateResult>): ModerateDefinition;
+type TimerContext = BotModuleContext;
+interface TimerDefinition {
+    __type: "timer";
+    handler: (ctx: TimerContext) => Promise<HandlerResponse | null>;
+}
+/**
+ * Define a timer handler with a unified context.
+ *
+ * The handler is called on a configurable interval. Return a
+ * `HandlerResponse` with `reply` / `actions`, or `null` to skip.
+ *
+ * ```ts
+ * import { defineTimer } from "@zaflun/lumio-sdk/server";
+ *
+ * export default defineTimer(async (ctx) => {
+ *   return { reply: "Remember to follow!", actions: [] };
+ * });
+ * ```
+ */
+declare function defineTimer(handler: (ctx: TimerContext) => Promise<HandlerResponse | null>): TimerDefinition;
+
+interface AutomationNodeContext {
+    /** HTTP fetch with egress allowlist enforcement. */
+    fetch: (url: string, options?: RequestInit) => Promise<Response>;
+    /** Scoped Redis cache (per extension per account). */
+    cache: {
+        get: (key: string) => Promise<unknown | null>;
+        set: (key: string, value: unknown, ttl?: number) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+    };
+    /** Extension-level config from extension_installs.config. */
+    installConfig: Record<string, unknown>;
+    /** Per-node instance config from automation_nodes.config. */
+    nodeConfig: Record<string, unknown>;
+    /** Data from upstream node (action/logic) or webhook/poll payload (trigger). */
+    inputData: Record<string, unknown>;
+    /** Auth context. */
+    auth: {
+        accountId: string;
+        extensionId: string;
+        installId: string;
+    };
+}
+/** Extended context for trigger handlers — includes webhook body. */
+interface TriggerNodeContext extends AutomationNodeContext {
+    /** Raw webhook request body (only available in onWebhook). */
+    webhookBody: Record<string, unknown>;
+}
+interface ActionResult {
+    output: Record<string, unknown>;
+    status: "success" | "error";
+    error_message?: string;
+}
+interface TriggerResult {
+    fired: boolean;
+    output?: Record<string, unknown>;
+}
+type ActionHandler = (ctx: AutomationNodeContext) => Promise<ActionResult>;
+type LogicHandler = (ctx: AutomationNodeContext) => Promise<string>;
+interface TriggerHandlers {
+    onWebhook?: (ctx: TriggerNodeContext) => Promise<TriggerResult | null>;
+    onPoll?: (ctx: AutomationNodeContext) => Promise<TriggerResult | null>;
+}
+interface AutomationActionDefinition {
+    __type: "automation_action";
+    handler: ActionHandler;
+}
+interface AutomationTriggerDefinition {
+    __type: "automation_trigger";
+    onWebhook?: TriggerHandlers["onWebhook"];
+    onPoll?: TriggerHandlers["onPoll"];
+}
+interface AutomationLogicDefinition {
+    __type: "automation_logic";
+    handler: LogicHandler;
+}
+/**
+ * Define an automation action node handler.
+ *
+ * The handler receives upstream data via `ctx.inputData` and must return
+ * an `ActionResult` with output matching the manifest's `output_schema`.
+ *
+ * ```ts
+ * import { defineAutomationAction } from "@zaflun/lumio-sdk/server";
+ *
+ * defineAutomationAction(async (ctx) => {
+ *   const res = await ctx.fetch("https://api.example.com/data");
+ *   const data = await res.json();
+ *   return { output: { result: data.value }, status: "success" };
+ * });
+ * ```
+ */
+declare function defineAutomationAction(handler: ActionHandler): AutomationActionDefinition;
+/**
+ * Define an automation trigger node handler.
+ *
+ * Triggers support `onWebhook` (external HTTP) and/or `onPoll` (periodic check).
+ * Return `{ fired: true, output: { ... } }` to fire the automation.
+ *
+ * ```ts
+ * import { defineAutomationTrigger } from "@zaflun/lumio-sdk/server";
+ *
+ * defineAutomationTrigger({
+ *   onWebhook: async (ctx) => {
+ *     if (ctx.webhookBody.event !== "order.created") return { fired: false };
+ *     return { fired: true, output: { order_id: ctx.webhookBody.id } };
+ *   },
+ *   onPoll: async (ctx) => {
+ *     const res = await ctx.fetch("https://api.example.com/events");
+ *     const events = await res.json();
+ *     if (events.length === 0) return null;
+ *     return { fired: true, output: events[0] };
+ *   },
+ * });
+ * ```
+ */
+declare function defineAutomationTrigger(handlers: TriggerHandlers): AutomationTriggerDefinition;
+/**
+ * Define an automation logic node handler.
+ *
+ * The handler must return a branch key string (e.g. "true", "false", "match").
+ * The automation engine follows the output handle matching this key.
+ *
+ * ```ts
+ * import { defineAutomationLogic } from "@zaflun/lumio-sdk/server";
+ *
+ * defineAutomationLogic(async (ctx) => {
+ *   return ctx.inputData.amount > ctx.nodeConfig.threshold ? "above" : "below";
+ * });
+ * ```
+ */
+declare function defineAutomationLogic(handler: LogicHandler): AutomationLogicDefinition;
+
+export { type ActionDefinition, type ActionResult, type AutomationActionDefinition, type AutomationLogicDefinition, type AutomationNodeContext, type AutomationTriggerDefinition, type BotModuleContext, type ChatMessage, type DeleteRowDefinition, type DeleteRowOptions, type FetchActionDefinition, type FetchActionOptions, type HandlerConfig, type HandlerContext, type HandlerResponse, type InsertRowDefinition, type InsertRowOptions, type ModerateContext, type ModerateDefinition, type ModerateResult, type ModerationResponse, type MutationDefinition, type PatchRowDefinition, type PatchRowOptions, type QueryDefinition, type QueryRowsDefinition, type SchemaDefinition, type TableDefinition, type TimerContext, type TimerDefinition, type TriggerNodeContext, type TriggerResult, type Validator, action, arg, command, defineAutomationAction, defineAutomationLogic, defineAutomationTrigger, defineModerate, defineSchema, defineTable, defineTimer, deleteRow, event, fetchAction, filter, identity, insertRow, keyword, moderate, mutation, patchRow, pattern, query, queryRows, secret, timer, v };

package/dist/server.js

@@ -112,20 +112,89 @@ function secret(name) {
 function filter(field, op, value) {
   return { __expr: "filter", field, op, value };
 }
+
+// src/server/bot-module.ts
+function command(name, handler) {
+  const fn = handler;
+  fn.__type = "command";
+  fn.__trigger = name;
+  return fn;
+}
+function keyword(trigger, handler) {
+  const fn = handler;
+  fn.__type = "keyword";
+  fn.__trigger = trigger;
+  return fn;
+}
+function pattern(regex, handler) {
+  const fn = handler;
+  fn.__type = "pattern";
+  fn.__trigger = regex;
+  return fn;
+}
+function event(eventType, handler) {
+  const fn = handler;
+  fn.__type = "event";
+  fn.__trigger = eventType;
+  return fn;
+}
+function timer(name, handler) {
+  const fn = handler;
+  fn.__type = "timer";
+  fn.__trigger = name;
+  return fn;
+}
+function moderate(handler) {
+  const fn = handler;
+  fn.__type = "moderate";
+  return fn;
+}
+function defineModerate(handler) {
+  return { __type: "moderate", handler };
+}
+function defineTimer(handler) {
+  return { __type: "timer", handler };
+}
+
+// src/server/automation-node.ts
+function defineAutomationAction(handler) {
+  return { __type: "automation_action", handler };
+}
+function defineAutomationTrigger(handlers) {
+  return {
+    __type: "automation_trigger",
+    onWebhook: handlers.onWebhook,
+    onPoll: handlers.onPoll
+  };
+}
+function defineAutomationLogic(handler) {
+  return { __type: "automation_logic", handler };
+}
 export {
   action,
   arg,
+  command,
+  defineAutomationAction,
+  defineAutomationLogic,
+  defineAutomationTrigger,
+  defineModerate,
   defineSchema,
   defineTable,
+  defineTimer,
   deleteRow,
+  event,
   fetchAction,
   filter,
   identity,
   insertRow,
+  keyword,
+  moderate,
   mutation,
   patchRow,
+  pattern,
   query,
   queryRows,
   secret,
+  timer,
   v
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaflun/lumio-sdk",
-  "version": "0.2.0",
+  "version": "0.6.3",
   "description": "Lumio Extension SDK — React components, hooks, and server utilities for building Lumio extensions",
   "type": "module",
   "main": "dist/index.js",
@@ -23,8 +23,8 @@
   ],
   "dependencies": {
     "react-reconciler": "^0.32.0",
-    "@zaflun/lumio-extension-types": "0.1.0",
-    "@zaflun/lumio-protocol": "0.1.1"
+    "@zaflun/lumio-protocol": "0.2.3",
+    "@zaflun/lumio-extension-types": "0.3.2"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
@@ -36,10 +36,12 @@
     "@types/react-dom": "^19.1.0",
     "@types/react-reconciler": "^0.32.0",
     "jsdom": "^26.1.0",
+    "lucide-static": "^1.16.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
+    "unicode-emoji-json": "^0.9.0",
     "vitest": "^3.1.4"
   },
   "license": "MIT",
@@ -62,6 +64,8 @@
     "email": "developers@zaflun.com"
   },
   "scripts": {
+    "generate:data": "node scripts/generate-lucide-data.mjs && node scripts/generate-emoji-data.mjs",
+    "prebuild": "pnpm generate:data",
     "build": "tsup src/index.ts src/server.ts --format esm --dts --clean && pnpm build:runtime",
     "build:runtime": "tsup --config tsup.runtime.ts",
     "test": "vitest run",