@kittymi/openclaw-generic-http 0.1.3

package/dist/setup-entry.d.ts

@@ -0,0 +1,351 @@
+export interface GenericHttpSetupFieldDescriptor {
+    key: string;
+    title: string;
+    required: boolean;
+    description: string;
+    secret?: boolean;
+}
+export interface GenericHttpSetupStepDescriptor {
+    id: string;
+    title: string;
+    description: string;
+}
+export interface GenericHttpSetupRegistration {
+    pluginId: "openclaw-generic-http";
+    channelName: "generic-http";
+    title: string;
+    summary: string;
+    configSchemaFile: "./openclaw.config.schema.json";
+    accountFields: GenericHttpSetupFieldDescriptor[];
+    steps: GenericHttpSetupStepDescriptor[];
+}
+export declare function registerSetup(): GenericHttpSetupRegistration;
+export declare const genericHttpSetupEntry: {
+    plugin: {
+        id: string;
+        meta: {
+            id: string;
+            label: string;
+            selectionLabel: string;
+            docsPath: string;
+            blurb: string;
+        };
+        capabilities: {
+            chatTypes: string[];
+            media: boolean;
+            threads: boolean;
+        };
+        reload: {
+            configPrefixes: string[];
+        };
+        configSchema: {
+            validate(value: unknown): {
+                ok: boolean;
+                errors: string[];
+                value?: undefined;
+            } | {
+                ok: boolean;
+                value: object;
+                errors?: undefined;
+            };
+        };
+        config: {
+            listAccountIds(cfg: {
+                channels?: Record<string, unknown>;
+            }): string[];
+            resolveAccount(cfg: {
+                channels?: Record<string, unknown>;
+            }, accountId?: string | null): {
+                accountId: string;
+                enabled: boolean;
+                name?: string;
+                configured: boolean;
+                config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+            };
+            defaultAccountId(cfg: {
+                channels?: Record<string, unknown>;
+            }): string;
+            isEnabled(account: {
+                accountId: string;
+                enabled: boolean;
+                name?: string;
+                configured: boolean;
+                config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+            }): boolean;
+            isConfigured(account: {
+                accountId: string;
+                enabled: boolean;
+                name?: string;
+                configured: boolean;
+                config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+            }): boolean;
+            describeAccount(account: {
+                accountId: string;
+                enabled: boolean;
+                name?: string;
+                configured: boolean;
+                config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+            }): {
+                accountId: string;
+                name: string | undefined;
+                enabled: boolean;
+                configured: boolean;
+                baseUrl: string;
+            };
+            setAccountEnabled(params: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                accountId: string;
+                enabled: boolean;
+            }): {
+                channels?: Record<string, unknown>;
+            };
+        };
+        setup: {
+            resolveAccountId(params: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                accountId?: string;
+            }): string;
+            validateInput(params: {
+                input: {
+                    baseUrl?: string;
+                    url?: string;
+                    token?: string;
+                    secret?: string;
+                };
+            }): "baseUrl is required" | "baseUrl must be a valid absolute URL" | null;
+            applyAccountConfig(params: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                accountId: string;
+                input: {
+                    baseUrl?: string;
+                    url?: string;
+                    token?: string;
+                    secret?: string;
+                };
+            }): {
+                channels?: Record<string, unknown>;
+            };
+        };
+        status: {
+            defaultRuntime: {
+                accountId: string;
+                running: boolean;
+                connected: boolean;
+                lastStartAt: null;
+                lastStopAt: null;
+                lastError: null;
+                lastInboundAt: null;
+                lastOutboundAt: null;
+                lastTransportActivityAt: null;
+            };
+            probeAccount(params: {
+                account: {
+                    accountId: string;
+                    enabled: boolean;
+                    name?: string;
+                    configured: boolean;
+                    config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+                };
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+            }): Promise<import("./channel/probe.js").ProbeResult>;
+            buildAccountSnapshot(params: {
+                account: {
+                    accountId: string;
+                    enabled: boolean;
+                    name?: string;
+                    configured: boolean;
+                    config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+                };
+                runtime?: {
+                    running?: boolean;
+                    connected?: boolean;
+                    lastStartAt?: number | null;
+                    lastStopAt?: number | null;
+                    lastError?: string | null;
+                    lastInboundAt?: number | null;
+                    lastOutboundAt?: number | null;
+                    lastTransportActivityAt?: number | null;
+                    probe?: unknown;
+                    lastProbeAt?: number | null;
+                };
+                probe?: {
+                    status?: string;
+                };
+            }): {
+                accountId: string;
+                name: string | undefined;
+                enabled: boolean;
+                configured: boolean;
+                baseUrl: string;
+                running: boolean;
+                connected: boolean;
+                lastStartAt: number | null;
+                lastStopAt: number | null;
+                lastError: string | null;
+                lastInboundAt: number | null;
+                lastOutboundAt: number | null;
+                lastTransportActivityAt: number | null;
+                probe: {
+                    status?: string;
+                } | undefined;
+                lastProbeAt: number;
+            };
+        };
+        gateway: {
+            startAccount(ctx: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                accountId: string;
+                account: {
+                    accountId: string;
+                    enabled: boolean;
+                    name?: string;
+                    configured: boolean;
+                    config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+                };
+                abortSignal: AbortSignal;
+                log?: {
+                    info?: (message: string) => void;
+                    error?: (message: string) => void;
+                };
+                setStatus: (next: Record<string, unknown>) => void;
+                channelRuntime?: unknown;
+            }): Promise<void>;
+            stopAccount(ctx: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                accountId: string;
+                account: {
+                    accountId: string;
+                    enabled: boolean;
+                    name?: string;
+                    configured: boolean;
+                    config: import("./config/schema.js").GenericHttpPluginConfig["accounts"][string];
+                };
+                abortSignal: AbortSignal;
+                log?: {
+                    info?: (message: string) => void;
+                    error?: (message: string) => void;
+                };
+                setStatus: (next: Record<string, unknown>) => void;
+                channelRuntime?: unknown;
+            }): Promise<void>;
+        };
+        resolver: {
+            resolveTargets(params: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                accountId?: string | null;
+                inputs: string[];
+                kind: "user" | "group";
+            }): Promise<({
+                input: string;
+                resolved: boolean;
+                note: string;
+                id?: undefined;
+                name?: undefined;
+            } | {
+                input: string;
+                resolved: boolean;
+                id: string;
+                name: string;
+                note?: undefined;
+            })[]>;
+        };
+        messaging: {
+            targetPrefixes: string[];
+            normalizeTarget: (raw: string) => string | undefined;
+            parseExplicitTarget(params: {
+                raw: string;
+            }): {
+                to: string;
+                chatType: "group" | "direct" | "channel";
+            } | null;
+            inferTargetChatType(params: {
+                to: string;
+            }): "group" | "direct" | "channel" | undefined;
+            resolveOutboundSessionRoute(params: {
+                agentId: string;
+                accountId?: string | null;
+                target: string;
+                threadId?: string | number | null;
+            }): {
+                sessionKey: string;
+                baseSessionKey: string;
+                peer: {
+                    kind: "group" | "direct" | "channel";
+                    id: string;
+                };
+                chatType: "group" | "direct" | "channel";
+                from: string;
+                to: string;
+                threadId: string;
+            } | null;
+            resolveInboundSessionRoute(params: {
+                agentId: string;
+                accountId?: string | null;
+                conversationId: string;
+                conversationType: "dm" | "group" | "room" | "ticket";
+                threadId?: string | number | null;
+            }): {
+                sessionKey: string;
+                baseSessionKey: string;
+                peer: {
+                    kind: "group" | "direct" | "channel";
+                    id: string;
+                };
+                chatType: "group" | "direct" | "channel";
+                from: string;
+                to: string;
+                threadId: string;
+            } | null;
+        };
+        outbound: {
+            deliveryMode: string;
+            sendText(ctx: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                to: string;
+                text: string;
+                threadId?: string | number | null;
+                accountId?: string | null;
+            }): Promise<{
+                channel: string;
+                messageId: string;
+                conversationId: string;
+                timestamp: number;
+                meta: Record<string, unknown>;
+            }>;
+            sendMedia(ctx: {
+                cfg: {
+                    channels?: Record<string, unknown>;
+                };
+                to: string;
+                text: string;
+                mediaUrl?: string;
+                threadId?: string | number | null;
+                accountId?: string | null;
+            }): Promise<{
+                channel: string;
+                messageId: string;
+                conversationId: string;
+                timestamp: number;
+                meta: Record<string, unknown>;
+            }>;
+        };
+    };
+    registerSetup: typeof registerSetup;
+};
+export default genericHttpSetupEntry;

package/dist/setup-entry.js

@@ -0,0 +1,73 @@
+import { openClawGenericHttpChannelPlugin } from "./openclaw-entry.js";
+export function registerSetup() {
+    return {
+        pluginId: "openclaw-generic-http",
+        channelName: "generic-http",
+        title: "Generic HTTP Channel Setup",
+        summary: "Configure a bridge/relay account, wire third-party webhooks into bridge ingress, and consume inbound events through stream polling.",
+        configSchemaFile: "./openclaw.config.schema.json",
+        accountFields: [
+            {
+                key: "baseUrl",
+                title: "Bridge Base URL",
+                required: true,
+                description: "Base URL of the bridge or relay service that exposes health, probe, stream, resolve, and outbound endpoints."
+            },
+            {
+                key: "apiKey",
+                title: "API Key",
+                required: false,
+                description: "Optional shared credential sent on signed requests when the bridge requires API key authentication.",
+                secret: true
+            },
+            {
+                key: "signingSecret",
+                title: "Signing Secret",
+                required: false,
+                description: "Shared secret used to sign stream, probe, resolve, and outbound requests from the plugin.",
+                secret: true
+            },
+            {
+                key: "inboundSecret",
+                title: "Inbound Secret",
+                required: false,
+                description: "Optional dedicated secret used by the bridge when validating third-party webhook ingress.",
+                secret: true
+            },
+            {
+                key: "outboundSecret",
+                title: "Outbound Secret",
+                required: false,
+                description: "Optional dedicated secret used when outbound message signing is separated from other transport signing.",
+                secret: true
+            }
+        ],
+        steps: [
+            {
+                id: "configure-account",
+                title: "Configure bridge account",
+                description: "Add at least one account with baseUrl and the shared credentials required by the bridge or relay."
+            },
+            {
+                id: "wire-webhook-ingress",
+                title: "Wire webhook ingress",
+                description: "Send third-party inbound events to POST /webhooks/inbound/messages on the bridge instead of calling a local OpenClaw URL."
+            },
+            {
+                id: "activate-stream-ingress",
+                title: "Activate stream ingress",
+                description: "Let the host activate the plugin so it can poll GET /stream/inbound and acknowledge processed messages through POST /stream/acks."
+            },
+            {
+                id: "verify-outbound-delivery",
+                title: "Verify outbound delivery",
+                description: "Confirm the bridge accepts POST /outbound/messages and that the external system returns successful delivery responses."
+            }
+        ]
+    };
+}
+export const genericHttpSetupEntry = {
+    plugin: openClawGenericHttpChannelPlugin,
+    registerSetup
+};
+export default genericHttpSetupEntry;

package/dist/utils/json.d.ts

@@ -0,0 +1 @@
+export declare function parseJson<T>(value: string): T;

package/dist/utils/json.js

@@ -0,0 +1,3 @@
+export function parseJson(value) {
+    return JSON.parse(value);
+}

package/dist/utils/log.d.ts

@@ -0,0 +1 @@
+export declare function logInfo(message: string): void;

package/dist/utils/log.js

@@ -0,0 +1,3 @@
+export function logInfo(message) {
+    console.log(message);
+}

package/dist/utils/time.d.ts

@@ -0,0 +1 @@
+export declare function nowEpochSeconds(): number;

package/dist/utils/time.js

@@ -0,0 +1,3 @@
+export function nowEpochSeconds() {
+    return Math.floor(Date.now() / 1000);
+}

package/openclaw.config.schema.json

@@ -0,0 +1,80 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Generic HTTP Channel Config",
+  "description": "Configuration for the OpenClaw generic HTTP channel plugin using bridge/relay webhook and stream ingress.",
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether the generic HTTP channel is enabled.",
+      "default": false
+    },
+    "defaultAccount": {
+      "type": "string",
+      "title": "Default Account",
+      "description": "Default account ID used when the host does not specify one."
+    },
+    "accounts": {
+      "type": "object",
+      "title": "Accounts",
+      "description": "Per-account bridge and outbound transport settings.",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "baseUrl": {
+            "type": "string",
+            "format": "uri",
+            "title": "Bridge Base URL",
+            "description": "Bridge or relay base URL used for probe, resolve, stream ingress, and outbound delivery."
+          },
+          "apiKey": {
+            "type": "string",
+            "title": "API Key",
+            "description": "Optional shared credential for bridge authentication."
+          },
+          "signingSecret": {
+            "type": "string",
+            "title": "Signing Secret",
+            "description": "Shared secret used for signing outbound and stream transport requests."
+          },
+          "inboundSecret": {
+            "type": "string",
+            "title": "Inbound Secret",
+            "description": "Optional dedicated secret for inbound webhook validation on the bridge side."
+          },
+          "outboundSecret": {
+            "type": "string",
+            "title": "Outbound Secret",
+            "description": "Optional dedicated secret for outbound signing when outbound trust is split from inbound."
+          },
+          "connectTimeoutMillis": {
+            "type": "number",
+            "minimum": 0,
+            "title": "Connect Timeout (ms)",
+            "description": "HTTP connect timeout in milliseconds.",
+            "default": 5000
+          },
+          "readTimeoutMillis": {
+            "type": "number",
+            "minimum": 0,
+            "title": "Read Timeout (ms)",
+            "description": "HTTP read timeout in milliseconds.",
+            "default": 10000
+          },
+          "maxRetries": {
+            "type": "number",
+            "minimum": 0,
+            "title": "Max Retries",
+            "description": "Maximum retry count for retryable outbound HTTP failures.",
+            "default": 0
+          }
+        },
+        "required": ["baseUrl"],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": ["enabled", "defaultAccount", "accounts"],
+  "additionalProperties": false
+}