opencode-claw 0.1.0

package/dist/channels/telegram.js

@@ -0,0 +1,79 @@
+import { Bot } from "grammy";
+import { createReconnector } from "../utils/reconnect.js";
+export function createTelegramAdapter(config, logger) {
+    const bot = new Bot(config.botToken);
+    let state = "disconnected";
+    let handler;
+    const reconnector = createReconnector({
+        name: "telegram",
+        logger,
+        connect: async () => {
+            state = "connecting";
+            bot.start({
+                onStart: () => {
+                    state = "connected";
+                    reconnector.reset();
+                    logger.info("telegram: bot connected");
+                },
+            });
+        },
+    });
+    bot.on("message:text", async (ctx) => {
+        if (!handler)
+            return;
+        if (!ctx.from)
+            return;
+        const peerId = String(ctx.from.id);
+        if (config.allowlist.length > 0 && !config.allowlist.includes(peerId)) {
+            if (config.rejectionBehavior === "reject") {
+                await ctx.reply("This assistant is private.");
+            }
+            logger.debug("telegram: message dropped (not in allowlist)", { peerId });
+            return;
+        }
+        const msg = {
+            channel: "telegram",
+            peerId,
+            peerName: ctx.from.first_name,
+            groupId: ctx.chat.type !== "private" ? String(ctx.chat.id) : undefined,
+            threadId: ctx.message.message_thread_id ? String(ctx.message.message_thread_id) : undefined,
+            text: ctx.message.text ?? "",
+            raw: ctx.message,
+        };
+        await handler(msg);
+    });
+    bot.catch((err) => {
+        logger.error("telegram: bot error", { error: err.message });
+        state = "error";
+        reconnector.attempt();
+    });
+    return {
+        id: "telegram",
+        name: "Telegram",
+        async start(h) {
+            handler = h;
+            state = "connecting";
+            logger.info("telegram: starting bot (polling mode)");
+            bot.start({
+                onStart: () => {
+                    state = "connected";
+                    logger.info("telegram: bot connected");
+                },
+            });
+        },
+        async stop() {
+            reconnector.stop();
+            state = "disconnected";
+            await bot.stop();
+            logger.info("telegram: bot stopped");
+        },
+        async send(peerId, message) {
+            await bot.api.sendMessage(Number(peerId), message.text, {
+                reply_parameters: message.replyToId ? { message_id: Number(message.replyToId) } : undefined,
+            });
+        },
+        status() {
+            return state;
+        },
+    };
+}

package/dist/channels/types.d.ts

@@ -0,0 +1,27 @@
+export type ChannelId = "slack" | "telegram" | "whatsapp";
+export type ChannelStatus = "connected" | "disconnected" | "connecting" | "error";
+export type InboundMessage = {
+    channel: ChannelId;
+    peerId: string;
+    peerName?: string;
+    groupId?: string;
+    threadId?: string;
+    text: string;
+    mediaUrl?: string;
+    replyToId?: string;
+    raw: unknown;
+};
+export type OutboundMessage = {
+    text: string;
+    threadId?: string;
+    replyToId?: string;
+};
+export type InboundMessageHandler = (msg: InboundMessage) => Promise<void>;
+export type ChannelAdapter = {
+    readonly id: ChannelId;
+    readonly name: string;
+    start(handler: InboundMessageHandler): Promise<void>;
+    stop(): Promise<void>;
+    send(peerId: string, message: OutboundMessage): Promise<void>;
+    status(): ChannelStatus;
+};

package/dist/channels/types.js

@@ -0,0 +1 @@
+export {};

package/dist/channels/whatsapp.d.ts

@@ -0,0 +1,4 @@
+import type { WhatsAppConfig } from "../config/types.js";
+import type { Logger } from "../utils/logger.js";
+import type { ChannelAdapter } from "./types.js";
+export declare function createWhatsAppAdapter(config: WhatsAppConfig, logger: Logger): ChannelAdapter;

package/dist/channels/whatsapp.js

@@ -0,0 +1,136 @@
+import { DisconnectReason, makeWASocket, useMultiFileAuthState, } from "@whiskeysockets/baileys";
+export function createWhatsAppAdapter(config, logger) {
+    let state = "disconnected";
+    let handler;
+    let sock;
+    // Debounce map: peerId -> pending messages
+    const pending = new Map();
+    function extractPeerId(jid) {
+        if (!jid)
+            return "";
+        return jid.split("@")[0] ?? "";
+    }
+    function flush(peerId) {
+        const item = pending.get(peerId);
+        if (!item || !handler)
+            return;
+        pending.delete(peerId);
+        const combined = item.texts.join("\n");
+        if (!combined.trim())
+            return;
+        const msg = {
+            channel: "whatsapp",
+            peerId: item.peerId,
+            text: combined,
+            raw: {},
+        };
+        handler(msg).catch((err) => {
+            logger.error("whatsapp: handler error", {
+                peerId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        });
+    }
+    function debounce(peerId, text) {
+        const existing = pending.get(peerId);
+        if (existing) {
+            clearTimeout(existing.timer);
+            existing.texts.push(text);
+            existing.timer = setTimeout(() => flush(peerId), config.debounceMs);
+        }
+        else {
+            const timer = setTimeout(() => flush(peerId), config.debounceMs);
+            pending.set(peerId, { peerId, texts: [text], timer });
+        }
+    }
+    async function connect() {
+        const { state: authState, saveCreds } = await useMultiFileAuthState(config.authDir);
+        sock = makeWASocket({
+            auth: authState,
+            printQRInTerminal: true,
+        });
+        sock.ev.on("creds.update", saveCreds);
+        sock.ev.on("connection.update", (update) => {
+            const { connection, lastDisconnect } = update;
+            if (connection === "close") {
+                const code = lastDisconnect?.error?.output?.statusCode;
+                if (code !== DisconnectReason.loggedOut) {
+                    logger.warn("whatsapp: connection closed, reconnecting", {
+                        code,
+                    });
+                    state = "connecting";
+                    connect();
+                }
+                else {
+                    logger.error("whatsapp: logged out, not reconnecting");
+                    state = "disconnected";
+                }
+            }
+            if (connection === "open") {
+                state = "connected";
+                logger.info("whatsapp: connected");
+            }
+        });
+        sock.ev.on("messages.upsert", (upsert) => {
+            if (upsert.type !== "notify")
+                return;
+            for (const msg of upsert.messages) {
+                if (msg.key.fromMe)
+                    continue;
+                const jid = msg.key.remoteJid;
+                const peerId = extractPeerId(jid);
+                if (!peerId)
+                    continue;
+                // Allowlist check
+                if (config.allowlist.length > 0 && !config.allowlist.includes(peerId)) {
+                    if (config.rejectionBehavior === "reject" && sock && jid) {
+                        sock
+                            .sendMessage(jid, {
+                            text: "This assistant is private.",
+                        })
+                            .catch(() => { });
+                    }
+                    logger.debug("whatsapp: message dropped (not in allowlist)", { peerId });
+                    continue;
+                }
+                const text = msg.message?.conversation ?? msg.message?.extendedTextMessage?.text ?? "";
+                if (!text)
+                    continue;
+                // Debounce rapid messages from same peer
+                debounce(peerId, text);
+            }
+        });
+    }
+    return {
+        id: "whatsapp",
+        name: "WhatsApp",
+        async start(h) {
+            handler = h;
+            state = "connecting";
+            logger.info("whatsapp: connecting...");
+            await connect();
+        },
+        async stop() {
+            // Flush all pending debounced messages
+            for (const [peerId] of pending) {
+                flush(peerId);
+            }
+            pending.clear();
+            if (sock) {
+                sock.end(undefined);
+                sock = undefined;
+            }
+            state = "disconnected";
+            logger.info("whatsapp: disconnected");
+        },
+        async send(peerId, message) {
+            if (!sock)
+                throw new Error("WhatsApp socket not connected");
+            const jid = `${peerId}@s.whatsapp.net`;
+            await sock.sendMessage(jid, { text: message.text });
+        },
+        status() {
+            return state;
+        },
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from "./index.js";
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/compat.d.ts

@@ -0,0 +1,12 @@
+export declare function readTextFile(path: string): Promise<string>;
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function readJsonFile<T>(path: string): Promise<T>;
+export declare function writeTextFile(path: string, content: string): Promise<void>;
+export declare function createFileWriter(path: string): {
+    write(data: string): void;
+    flush(): void;
+};
+export declare function createHttpServer(port: number, handler: (req: Request) => Promise<Response>): {
+    start(): void;
+    stop(): void;
+};

package/dist/compat.js

@@ -0,0 +1,63 @@
+import { createWriteStream } from "node:fs";
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+export async function readTextFile(path) {
+    return readFile(path, "utf-8");
+}
+export async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readJsonFile(path) {
+    const text = await readFile(path, "utf-8");
+    return JSON.parse(text);
+}
+export async function writeTextFile(path, content) {
+    await writeFile(path, content, "utf-8");
+}
+export function createFileWriter(path) {
+    const stream = createWriteStream(path, { flags: "a", encoding: "utf-8" });
+    return {
+        write(data) {
+            stream.write(data);
+        },
+        flush() { },
+    };
+}
+export function createHttpServer(port, handler) {
+    let srv = null;
+    return {
+        start() {
+            srv = createServer((nodeReq, nodeRes) => {
+                const host = nodeReq.headers.host ?? "localhost";
+                const url = `http://${host}${nodeReq.url ?? "/"}`;
+                const request = new Request(url, {
+                    method: nodeReq.method ?? "GET",
+                    headers: nodeReq.headers,
+                });
+                handler(request)
+                    .then(async (response) => {
+                    const body = await response.text();
+                    nodeRes.writeHead(response.status, Object.fromEntries(response.headers));
+                    nodeRes.end(body);
+                })
+                    .catch(() => {
+                    nodeRes.writeHead(500);
+                    nodeRes.end("Internal Server Error");
+                });
+            });
+            srv.listen(port);
+        },
+        stop() {
+            if (srv) {
+                srv.close();
+                srv = null;
+            }
+        },
+    };
+}

package/dist/config/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from "./types.js";
+export declare function loadConfig(): Promise<Config>;

package/dist/config/loader.js

@@ -0,0 +1,57 @@
+import { fileExists, readJsonFile } from "../compat.js";
+import { configSchema } from "./schema.js";
+function expand(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_, name) => {
+        const env = process.env[name];
+        if (env === undefined)
+            throw new Error(`Environment variable "${name}" is not set`);
+        return env;
+    });
+}
+function expandDeep(obj) {
+    if (typeof obj === "string")
+        return expand(obj);
+    if (Array.isArray(obj))
+        return obj.map(expandDeep);
+    if (obj !== null && typeof obj === "object") {
+        const result = {};
+        for (const [key, val] of Object.entries(obj)) {
+            result[key] = expandDeep(val);
+        }
+        return result;
+    }
+    return obj;
+}
+const searchPaths = [
+    process.env.OPENCODE_CLAW_CONFIG,
+    "./opencode-claw.json",
+    `${process.env.HOME}/.config/opencode-claw/config.json`,
+].filter(Boolean);
+export async function loadConfig() {
+    let raw = null;
+    let found = "";
+    for (const p of searchPaths) {
+        if (await fileExists(p)) {
+            raw = await readJsonFile(p);
+            found = p;
+            break;
+        }
+    }
+    if (!raw) {
+        throw new Error([
+            "No config file found. Searched:",
+            ...searchPaths.map((p) => `  - ${p}`),
+            "",
+            "Copy opencode-claw.example.json to opencode-claw.json and fill in your values.",
+        ].join("\n"));
+    }
+    const expanded = expandDeep(raw);
+    const result = configSchema.safeParse(expanded);
+    if (!result.success) {
+        const errors = result.error.issues
+            .map((i) => `  - ${i.path.join(".")}: ${i.message}`)
+            .join("\n");
+        throw new Error(`Config validation failed (${found}):\n${errors}`);
+    }
+    return result.data;
+}