botinabox 0.1.0

package/dist/channels/slack/index.js

@@ -0,0 +1,80 @@
+import {
+  parseSlackEvent
+} from "../../chunk-QLA6YOFN.js";
+
+// src/channels/slack/outbound.ts
+function formatForSlack(text) {
+  let result = text.replace(/\*\*(.+?)\*\*/gs, "*$1*");
+  result = result.replace(/__(.+?)__/gs, "*$1*");
+  return result;
+}
+
+// src/channels/slack/adapter.ts
+var SlackAdapter = class {
+  id = "slack";
+  meta = {
+    displayName: "Slack",
+    icon: "https://slack.com/favicon.ico",
+    homepage: "https://slack.com"
+  };
+  capabilities = {
+    chatTypes: ["direct", "group", "channel"],
+    threads: true,
+    reactions: true,
+    editing: true,
+    media: true,
+    polls: false,
+    maxTextLength: 4e4,
+    formattingMode: "mrkdwn"
+  };
+  onMessage;
+  connected = false;
+  config = null;
+  client;
+  constructor(client) {
+    this.client = client ?? null;
+  }
+  async connect(config) {
+    this.config = config;
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.config = null;
+  }
+  async healthCheck() {
+    return { ok: this.connected };
+  }
+  async send(target, payload) {
+    if (!this.connected) {
+      return { success: false, error: "Not connected" };
+    }
+    const text = formatForSlack(payload.text);
+    if (this.client) {
+      try {
+        const result = await this.client.postMessage(target.peerId, text, target.threadId);
+        return { success: result.ok, messageId: result.ts };
+      } catch (err) {
+        return { success: false, error: String(err) };
+      }
+    }
+    return { success: true };
+  }
+  /** Simulate receiving an inbound message (for testing/webhooks). */
+  async receive(event) {
+    if (this.onMessage) {
+      const { parseSlackEvent: parseSlackEvent2 } = await import("../../inbound-AFOHYNUY.js");
+      const msg = parseSlackEvent2(event);
+      await this.onMessage(msg);
+    }
+  }
+};
+function createSlackAdapter(client) {
+  return new SlackAdapter(client);
+}
+export {
+  SlackAdapter,
+  createSlackAdapter as default,
+  formatForSlack,
+  parseSlackEvent
+};

package/dist/channels/webhook/index.d.ts

@@ -0,0 +1,72 @@
+import { C as ChannelAdapter, c as ChannelMeta, a as ChannelCapabilities, I as InboundMessage, b as ChannelConfig, H as HealthStatus, O as OutboundPayload, S as SendResult } from '../../channel-m9f7MFD7.js';
+
+/**
+ * WebhookAdapter — ChannelAdapter implementation for webhook-based channels.
+ * Story 4.7
+ */
+
+declare class WebhookAdapter implements ChannelAdapter {
+    readonly id = "webhook";
+    readonly meta: ChannelMeta;
+    readonly capabilities: ChannelCapabilities;
+    onMessage?: (message: InboundMessage) => Promise<void>;
+    private connected;
+    private config;
+    private webhookServer;
+    connect(config: ChannelConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    send(target: {
+        peerId: string;
+        threadId?: string;
+    }, payload: OutboundPayload): Promise<SendResult>;
+}
+/** Factory function — default export for auto-discovery. */
+declare function createWebhookAdapter(): WebhookAdapter;
+
+/**
+ * Minimal HTTP server for webhook inbound messages.
+ * Story 4.7
+ */
+
+interface WebhookServerOpts {
+    port?: number;
+    secret?: string;
+    onMessage: (msg: InboundMessage) => Promise<void>;
+}
+declare class WebhookServer {
+    private server;
+    private readonly port;
+    private readonly secret;
+    private readonly onMessage;
+    constructor(opts: WebhookServerOpts);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+}
+
+/**
+ * HMAC signature verification for webhook payloads.
+ * Story 4.7
+ */
+/**
+ * Verify that the HMAC-SHA256 signature of body matches the provided signature.
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param body      - The raw request body string
+ * @param secret    - The shared HMAC secret
+ * @param signature - The signature to verify (hex string, possibly prefixed with "sha256=")
+ */
+declare function verifyHmac(body: string, secret: string, signature: string): boolean;
+
+/**
+ * Webhook channel configuration types.
+ * Story 4.7
+ */
+interface WebhookConfig {
+    callbackUrl?: string;
+    secret?: string;
+    port?: number;
+}
+
+export { WebhookAdapter, type WebhookConfig, WebhookServer, type WebhookServerOpts, createWebhookAdapter as default, verifyHmac };

package/dist/channels/webhook/index.js

@@ -0,0 +1,178 @@
+// src/channels/webhook/server.ts
+import { createServer } from "http";
+
+// src/channels/webhook/hmac.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function verifyHmac(body, secret, signature) {
+  const expected = createHmac("sha256", secret).update(body, "utf8").digest("hex");
+  const provided = signature.startsWith("sha256=") ? signature.slice(7) : signature;
+  if (expected.length !== provided.length) return false;
+  try {
+    return timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(provided, "hex"));
+  } catch {
+    return false;
+  }
+}
+
+// src/channels/webhook/server.ts
+var WebhookServer = class {
+  server = null;
+  port;
+  secret;
+  onMessage;
+  constructor(opts) {
+    this.port = opts.port ?? 3200;
+    this.secret = opts.secret;
+    this.onMessage = opts.onMessage;
+  }
+  start() {
+    return new Promise((resolve) => {
+      this.server = createServer((req, res) => {
+        void this.handleRequest(req, res);
+      });
+      this.server.listen(this.port, () => resolve());
+    });
+  }
+  stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        resolve();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  async handleRequest(req, res) {
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    if (method !== "POST" || url !== "/webhook/inbound") {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    let body = "";
+    for await (const chunk of req) {
+      body += chunk;
+    }
+    if (this.secret) {
+      const sig = req.headers["x-webhook-signature"];
+      if (!sig || !verifyHmac(body, this.secret, sig)) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid signature" }));
+        return;
+      }
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON" }));
+      return;
+    }
+    const msg = {
+      id: parsed["id"] ?? `webhook-${Date.now()}`,
+      channel: "webhook",
+      from: parsed["from"] ?? "unknown",
+      body: parsed["text"] ?? "",
+      threadId: parsed["threadId"],
+      receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      raw: parsed
+    };
+    try {
+      await this.onMessage(msg);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  }
+};
+
+// src/channels/webhook/adapter.ts
+var WebhookAdapter = class {
+  id = "webhook";
+  meta = {
+    displayName: "Webhook",
+    homepage: "https://example.com"
+  };
+  capabilities = {
+    chatTypes: ["direct"],
+    threads: false,
+    reactions: false,
+    editing: false,
+    media: false,
+    polls: false,
+    maxTextLength: 65535,
+    formattingMode: "plain"
+  };
+  onMessage;
+  connected = false;
+  config = null;
+  webhookServer = null;
+  async connect(config) {
+    this.config = config;
+    this.connected = true;
+    if (this.config.port) {
+      this.webhookServer = new WebhookServer({
+        port: this.config.port,
+        secret: this.config.secret,
+        onMessage: async (msg) => {
+          if (this.onMessage) await this.onMessage(msg);
+        }
+      });
+      await this.webhookServer.start();
+    }
+  }
+  async disconnect() {
+    if (this.webhookServer) {
+      await this.webhookServer.stop();
+      this.webhookServer = null;
+    }
+    this.connected = false;
+    this.config = null;
+  }
+  async healthCheck() {
+    return { ok: this.connected };
+  }
+  async send(target, payload) {
+    if (!this.connected) {
+      return { success: false, error: "Not connected" };
+    }
+    const callbackUrl = this.config?.callbackUrl;
+    if (!callbackUrl) {
+      return { success: true };
+    }
+    try {
+      const body = JSON.stringify({
+        to: target.peerId,
+        threadId: target.threadId,
+        text: payload.text
+      });
+      const response = await fetch(callbackUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body
+      });
+      if (response.ok) {
+        return { success: true };
+      }
+      return { success: false, error: `HTTP ${response.status}` };
+    } catch (err) {
+      return { success: false, error: String(err) };
+    }
+  }
+};
+function createWebhookAdapter() {
+  return new WebhookAdapter();
+}
+export {
+  WebhookAdapter,
+  WebhookServer,
+  createWebhookAdapter as default,
+  verifyHmac
+};

package/dist/chunk-DLJKZD3Q.js

@@ -0,0 +1,22 @@
+// src/channels/discord/inbound.ts
+function parseDiscordEvent(event) {
+  const id = event.id ?? `discord-${Date.now()}`;
+  const channel = event.channel_id ?? "unknown";
+  const from = event.author?.id ?? "unknown";
+  const body = event.content ?? "";
+  const replyToId = event.message_reference?.message_id;
+  const receivedAt = event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id,
+    channel,
+    from,
+    body,
+    replyToId,
+    receivedAt,
+    raw: event
+  };
+}
+
+export {
+  parseDiscordEvent
+};

package/dist/chunk-QLA6YOFN.js

@@ -0,0 +1,22 @@
+// src/channels/slack/inbound.ts
+function parseSlackEvent(event) {
+  const id = event.client_msg_id ?? event.ts ?? event.event_ts ?? `slack-${Date.now()}`;
+  const channel = event.channel ?? "unknown";
+  const from = event.user ?? "unknown";
+  const body = event.text ?? "";
+  const threadId = event.thread_ts !== void 0 ? event.thread_ts : void 0;
+  const receivedAt = event.ts ? new Date(parseFloat(event.ts) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id,
+    channel,
+    from,
+    body,
+    threadId,
+    receivedAt,
+    raw: event
+  };
+}
+
+export {
+  parseSlackEvent
+};

package/dist/inbound-AFOHYNUY.js

@@ -0,0 +1,6 @@
+import {
+  parseSlackEvent
+} from "./chunk-QLA6YOFN.js";
+export {
+  parseSlackEvent
+};

package/dist/inbound-SNEMBLGA.js

@@ -0,0 +1,6 @@
+import {
+  parseDiscordEvent
+} from "./chunk-DLJKZD3Q.js";
+export {
+  parseDiscordEvent
+};