botinabox 0.2.0 → 0.2.1

package/dist/channels/discord/index.js

@@ -0,0 +1,98 @@
+import {
+  parseDiscordEvent
+} from "../../chunk-DLJKZD3Q.js";
+
+// src/channels/discord/outbound.ts
+var DISCORD_MAX_LENGTH = 2e3;
+function chunkForDiscord(text) {
+  if (text.length <= DISCORD_MAX_LENGTH) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > DISCORD_MAX_LENGTH) {
+    const slice = remaining.slice(0, DISCORD_MAX_LENGTH);
+    const lastSpace = slice.lastIndexOf(" ");
+    if (lastSpace > 0) {
+      chunks.push(remaining.slice(0, lastSpace));
+      remaining = remaining.slice(lastSpace + 1);
+    } else {
+      chunks.push(remaining.slice(0, DISCORD_MAX_LENGTH));
+      remaining = remaining.slice(DISCORD_MAX_LENGTH);
+    }
+  }
+  if (remaining.length > 0) chunks.push(remaining);
+  return chunks;
+}
+function formatForDiscord(text) {
+  return text;
+}
+
+// src/channels/discord/adapter.ts
+var DiscordAdapter = class {
+  id = "discord";
+  meta = {
+    displayName: "Discord",
+    icon: "https://discord.com/favicon.ico",
+    homepage: "https://discord.com"
+  };
+  capabilities = {
+    chatTypes: ["direct", "group", "channel"],
+    threads: true,
+    reactions: true,
+    editing: true,
+    media: true,
+    polls: false,
+    maxTextLength: 2e3,
+    formattingMode: "markdown"
+  };
+  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 = formatForDiscord(payload.text);
+    if (this.client) {
+      try {
+        const result = await this.client.sendMessage(target.peerId, text);
+        return { success: true, messageId: result.id };
+      } 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 { parseDiscordEvent: parseDiscordEvent2 } = await import("../../inbound-SNEMBLGA.js");
+      const msg = parseDiscordEvent2(event);
+      await this.onMessage(msg);
+    }
+  }
+};
+function createDiscordAdapter(client) {
+  return new DiscordAdapter(client);
+}
+export {
+  DiscordAdapter,
+  chunkForDiscord,
+  createDiscordAdapter as default,
+  formatForDiscord,
+  parseDiscordEvent
+};

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.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
+};