the-campfire 0.1.0

package/server/openclaw-channel/channel.ts

@@ -0,0 +1,188 @@
+/**
+ * Campfire channel plugin for OpenClaw.
+ *
+ * This plugin enables OpenClaw users to interact with their agents
+ * through Campfire's rich web UI — with cost tracking, session replay,
+ * permission voting, session gallery, and collaboration features
+ * that OpenClaw's native UI doesn't have.
+ *
+ * Architecture:
+ *   Browser (Campfire React UI)
+ *       ↕ WebSocket
+ *   Campfire Server (Hono/Bun)
+ *       ↕ HTTP webhook + outbound API
+ *   OpenClaw Gateway
+ *       ↕ Agent runtime
+ *   AI Agent (Claude, GPT, Gemini, etc.)
+ */
+
+import type {
+  ChannelPlugin,
+  InboundMessage,
+} from "./types.js";
+
+// ─── Active account tracking ────────────────────────────────────────────────
+
+interface ActiveAccount {
+  accountId: string;
+  campfireUrl: string;
+  onMessage: (msg: InboundMessage) => void;
+}
+
+const activeAccounts = new Map<string, ActiveAccount>();
+
+// ─── Channel Plugin implementation ─────────────────────────────────────────
+
+export const campfirePlugin: ChannelPlugin = {
+  meta: {
+    id: "campfire",
+    label: "Campfire",
+    icon: "🔥",
+    docsPath: "/channels/campfire",
+    blurb: "Rich web UI with cost tracking, session replay, and collaboration",
+  },
+
+  capabilities: {
+    chatTypes: ["direct"],
+    media: true,
+  },
+
+  config: {
+    fields: [
+      {
+        key: "campfireUrl",
+        label: "Campfire Server URL",
+        type: "url",
+        required: true,
+        placeholder: "http://localhost:4567",
+        help: "The URL of your running Campfire server",
+      },
+      {
+        key: "campfirePort",
+        label: "Campfire Port",
+        type: "number",
+        required: false,
+        placeholder: "4567",
+        help: "Port number (default: 4567)",
+      },
+    ],
+
+    validate(values: Record<string, string>): { valid: boolean; error?: string } {
+      const url = values.campfireUrl;
+      if (!url) {
+        return { valid: false, error: "Campfire Server URL is required" };
+      }
+      try {
+        new URL(url);
+        return { valid: true };
+      } catch {
+        return { valid: false, error: "Invalid URL format" };
+      }
+    },
+  },
+
+  outbound: {
+    /**
+     * Send a text message from the OpenClaw agent to Campfire.
+     * Posts to Campfire's inbound webhook endpoint.
+     */
+    async sendText(opts: {
+      accountId: string;
+      recipientId: string;
+      text: string;
+      metadata?: Record<string, unknown>;
+    }): Promise<{ success: boolean; error?: string }> {
+      const account = activeAccounts.get(opts.accountId);
+      if (!account) {
+        return { success: false, error: `Account ${opts.accountId} is not active` };
+      }
+
+      try {
+        const res = await fetch(`${account.campfireUrl}/api/openclaw/inbound`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            senderId: "openclaw-agent",
+            sessionId: opts.recipientId,
+            text: opts.text,
+            metadata: opts.metadata,
+          }),
+          signal: AbortSignal.timeout(10_000),
+        });
+
+        if (!res.ok) {
+          const body = await res.text().catch(() => "unknown error");
+          return { success: false, error: `HTTP ${res.status}: ${body}` };
+        }
+
+        return { success: true };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+    },
+  },
+
+  gateway: {
+    /**
+     * Start an account: register with Campfire for inbound messages.
+     * When a user sends a message in Campfire, Campfire will POST
+     * to the OpenClaw webhook to route it to the agent.
+     */
+    async startAccount(opts: {
+      accountId: string;
+      config: Record<string, string>;
+      onMessage: (msg: InboundMessage) => void;
+    }): Promise<void> {
+      const campfireUrl = opts.config.campfireUrl || "http://localhost:4567";
+
+      activeAccounts.set(opts.accountId, {
+        accountId: opts.accountId,
+        campfireUrl,
+        onMessage: opts.onMessage,
+      });
+
+      console.log(`[campfire-channel] Started account ${opts.accountId} → ${campfireUrl}`);
+    },
+
+    /**
+     * Stop an account: unregister from Campfire.
+     */
+    async stopAccount(accountId: string): Promise<void> {
+      activeAccounts.delete(accountId);
+      console.log(`[campfire-channel] Stopped account ${accountId}`);
+    },
+  },
+};
+
+/**
+ * Handle an inbound webhook from Campfire.
+ * Called when a user sends a message in the Campfire UI
+ * and it needs to be routed to the OpenClaw agent.
+ */
+export function handleCampfireWebhook(body: {
+  accountId: string;
+  senderId: string;
+  text: string;
+  metadata?: Record<string, unknown>;
+}): { ok: boolean; error?: string } {
+  const account = activeAccounts.get(body.accountId);
+  if (!account) {
+    return { ok: false, error: `Account ${body.accountId} not found` };
+  }
+
+  account.onMessage({
+    senderId: body.senderId,
+    text: body.text,
+    metadata: body.metadata,
+  });
+
+  return { ok: true };
+}
+
+/** Get the list of active account IDs (for status checking). */
+export function getActiveAccounts(): string[] {
+  return Array.from(activeAccounts.keys());
+}

package/server/openclaw-channel/index.ts

@@ -0,0 +1,68 @@
+/**
+ * Campfire Channel Plugin for OpenClaw
+ *
+ * When installed in OpenClaw (~/.openclaw/extensions/campfire/),
+ * this plugin:
+ * 1. Registers a "Campfire" channel in OpenClaw's channel list
+ * 2. Routes messages between OpenClaw agents and Campfire's browser UI
+ * 3. Exposes an HTTP webhook route for inbound messages from Campfire
+ *
+ * Install: Copy this directory to ~/.openclaw/extensions/campfire/
+ *   or: npm install @campfire/openclaw-channel
+ */
+
+import type { OpenClawPluginApi, HttpRouteHandler } from "./types.js";
+import { campfirePlugin, handleCampfireWebhook, getActiveAccounts } from "./channel.js";
+
+const webhookHandler: HttpRouteHandler = async (req) => {
+  if (req.method !== "POST") {
+    return { status: 405, body: { ok: false, error: "Method not allowed" } };
+  }
+
+  const body = req.body as {
+    accountId?: string;
+    senderId?: string;
+    text?: string;
+    metadata?: Record<string, unknown>;
+  };
+
+  if (!body.accountId || !body.text) {
+    return {
+      status: 400,
+      body: { ok: false, error: "accountId and text are required" },
+    };
+  }
+
+  const result = handleCampfireWebhook({
+    accountId: body.accountId,
+    senderId: body.senderId || "campfire-user",
+    text: body.text,
+    metadata: body.metadata,
+  });
+
+  return {
+    status: result.ok ? 200 : 404,
+    body: result,
+  };
+};
+
+export default {
+  id: "campfire",
+  name: "Campfire",
+  description: "Rich web UI for OpenClaw agents with cost tracking, session replay, and collaboration",
+
+  register(api: OpenClawPluginApi) {
+    // Register the Campfire channel with OpenClaw
+    api.registerChannel({ plugin: campfirePlugin });
+
+    // Register the inbound webhook route for Campfire → OpenClaw messages
+    api.registerHttpRoute({
+      path: "/webhook/campfire",
+      handler: webhookHandler,
+    });
+  },
+};
+
+// Re-export for direct usage
+export { campfirePlugin, handleCampfireWebhook, getActiveAccounts };
+export type { OpenClawPluginApi } from "./types.js";

package/server/openclaw-channel/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@campfire/openclaw-channel",
+  "version": "1.0.0",
+  "description": "Campfire web UI channel plugin for OpenClaw",
+  "type": "module",
+  "main": "index.ts",
+  "openclaw": {
+    "extensions": ["./index.ts"],
+    "channel": {
+      "id": "campfire",
+      "label": "Campfire",
+      "docsPath": "/channels/campfire",
+      "blurb": "Rich web UI with cost tracking, session replay, and collaboration",
+      "order": 100
+    }
+  },
+  "keywords": ["openclaw", "channel", "campfire", "ai-assistant"],
+  "license": "MIT"
+}

package/server/openclaw-channel/types.ts

@@ -0,0 +1,93 @@
+/**
+ * Types for the Campfire OpenClaw channel plugin.
+ *
+ * These are simplified versions of the OpenClaw plugin SDK types
+ * that define the contract between Campfire and OpenClaw.
+ */
+
+// ─── Plugin SDK types (subset) ──────────────────────────────────────────────
+
+export interface OpenClawPluginApi {
+  registerChannel(opts: { plugin: ChannelPlugin }): void;
+  registerHttpRoute(opts: { path: string; handler: HttpRouteHandler }): void;
+}
+
+export type HttpRouteHandler = (req: InboundRequest) => Promise<HttpResponse> | HttpResponse;
+
+export interface InboundRequest {
+  method: string;
+  path: string;
+  headers: Record<string, string>;
+  body: unknown;
+}
+
+export interface HttpResponse {
+  status: number;
+  body: unknown;
+}
+
+// ─── Channel Plugin interface ───────────────────────────────────────────────
+
+export interface ChannelPlugin {
+  meta: ChannelMeta;
+  capabilities: ChannelCapabilities;
+  config: ChannelConfig;
+  outbound: ChannelOutbound;
+  gateway: ChannelGateway;
+}
+
+export interface ChannelMeta {
+  id: string;
+  label: string;
+  icon: string;
+  docsPath: string;
+  blurb: string;
+}
+
+export interface ChannelCapabilities {
+  chatTypes: ("direct" | "group")[];
+  media: boolean;
+}
+
+export interface ChannelConfig {
+  /** Define the fields required to configure an account for this channel. */
+  fields: ChannelConfigField[];
+  /** Validate an account configuration. */
+  validate(values: Record<string, string>): { valid: boolean; error?: string };
+}
+
+export interface ChannelConfigField {
+  key: string;
+  label: string;
+  type: "text" | "url" | "number";
+  required: boolean;
+  placeholder?: string;
+  help?: string;
+}
+
+export interface ChannelOutbound {
+  /** Send a text message from the agent to the channel. */
+  sendText(opts: {
+    accountId: string;
+    recipientId: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<{ success: boolean; error?: string }>;
+}
+
+export interface ChannelGateway {
+  /** Start an account: register webhooks, open connections, etc. */
+  startAccount(opts: {
+    accountId: string;
+    config: Record<string, string>;
+    onMessage: (msg: InboundMessage) => void;
+  }): Promise<void>;
+  /** Stop an account: unregister webhooks, close connections. */
+  stopAccount(accountId: string): Promise<void>;
+}
+
+export interface InboundMessage {
+  senderId: string;
+  text: string;
+  metadata?: Record<string, unknown>;
+}