owpenwork 0.1.1

package/dist/config.js

@@ -0,0 +1,169 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const packageDir = path.resolve(moduleDir, "..");
+dotenv.config({ path: path.join(packageDir, ".env") });
+dotenv.config();
+function parseBoolean(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function parseInteger(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseList(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function expandHome(value) {
+    if (!value.startsWith("~/"))
+        return value;
+    return path.join(os.homedir(), value.slice(2));
+}
+export function normalizeWhatsAppId(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return trimmed;
+    if (trimmed.endsWith("@g.us"))
+        return trimmed;
+    const base = trimmed.replace(/@s\.whatsapp\.net$/i, "");
+    if (base.startsWith("+"))
+        return base;
+    if (/^\d+$/.test(base))
+        return `+${base}`;
+    return base;
+}
+function normalizeWhatsAppAllowFrom(list) {
+    const set = new Set();
+    for (const entry of list) {
+        const trimmed = entry.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed === "*") {
+            set.add("*");
+            continue;
+        }
+        set.add(normalizeWhatsAppId(trimmed));
+    }
+    return set;
+}
+function normalizeDmPolicy(value) {
+    if (value === "allowlist" || value === "open" || value === "disabled" || value === "pairing") {
+        return value;
+    }
+    return "pairing";
+}
+function resolveConfigPath(dataDir, env) {
+    const override = env.OWPENBOT_CONFIG_PATH?.trim();
+    if (override)
+        return expandHome(override);
+    return path.join(dataDir, "owpenbot.json");
+}
+export function readConfigFile(configPath) {
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return { exists: true, config: parsed };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { exists: false, config: { version: 1 } };
+        }
+        throw error;
+    }
+}
+export function writeConfigFile(configPath, config) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function parseAllowlist(env) {
+    const allowlist = {
+        telegram: new Set(),
+        whatsapp: new Set(),
+    };
+    const shared = parseList(env.ALLOW_FROM);
+    for (const entry of shared) {
+        if (entry.includes(":")) {
+            const [channel, peer] = entry.split(":");
+            const normalized = channel.trim().toLowerCase();
+            if (normalized === "telegram" || normalized === "whatsapp") {
+                if (peer?.trim()) {
+                    allowlist[normalized].add(peer.trim());
+                }
+            }
+        }
+        else {
+            allowlist.telegram.add(entry);
+            allowlist.whatsapp.add(entry);
+        }
+    }
+    for (const entry of parseList(env.ALLOW_FROM_TELEGRAM)) {
+        allowlist.telegram.add(entry);
+    }
+    for (const entry of parseList(env.ALLOW_FROM_WHATSAPP)) {
+        allowlist.whatsapp.add(entry);
+    }
+    return allowlist;
+}
+export function loadConfig(env = process.env, options = {}) {
+    const requireOpencode = options.requireOpencode ?? false;
+    const opencodeDirectory = env.OPENCODE_DIRECTORY?.trim() ?? "";
+    if (!opencodeDirectory && requireOpencode) {
+        throw new Error("OPENCODE_DIRECTORY is required");
+    }
+    const resolvedDirectory = opencodeDirectory || process.cwd();
+    const dataDir = expandHome(env.OWPENBOT_DATA_DIR ?? "~/.owpenbot");
+    const dbPath = expandHome(env.OWPENBOT_DB_PATH ?? path.join(dataDir, "owpenbot.db"));
+    const configPath = resolveConfigPath(dataDir, env);
+    const { config: configFile } = readConfigFile(configPath);
+    const whatsappFile = configFile.channels?.whatsapp ?? {};
+    const whatsappAccountId = env.WHATSAPP_ACCOUNT_ID?.trim() || "default";
+    const accountAuthDir = whatsappFile.accounts?.[whatsappAccountId]?.authDir;
+    const whatsappAuthDir = expandHome(env.WHATSAPP_AUTH_DIR ??
+        accountAuthDir ??
+        path.join(dataDir, "credentials", "whatsapp", whatsappAccountId));
+    const dmPolicy = normalizeDmPolicy(env.WHATSAPP_DM_POLICY?.trim().toLowerCase() ?? whatsappFile.dmPolicy);
+    const selfChatMode = parseBoolean(env.WHATSAPP_SELF_CHAT, whatsappFile.selfChatMode ?? false);
+    const envAllowlist = parseAllowlist(env);
+    const fileAllowFrom = normalizeWhatsAppAllowFrom(whatsappFile.allowFrom ?? []);
+    const envAllowFrom = normalizeWhatsAppAllowFrom(envAllowlist.whatsapp.size ? [...envAllowlist.whatsapp] : []);
+    const whatsappAllowFrom = new Set([...fileAllowFrom, ...envAllowFrom]);
+    const toolOutputLimit = parseInteger(env.TOOL_OUTPUT_LIMIT) ?? 1200;
+    const permissionMode = env.PERMISSION_MODE?.toLowerCase() === "deny" ? "deny" : "allow";
+    return {
+        configPath,
+        configFile,
+        opencodeUrl: env.OPENCODE_URL?.trim() ?? "http://127.0.0.1:4096",
+        opencodeDirectory: resolvedDirectory,
+        opencodeUsername: env.OPENCODE_SERVER_USERNAME?.trim() || undefined,
+        opencodePassword: env.OPENCODE_SERVER_PASSWORD?.trim() || undefined,
+        telegramToken: env.TELEGRAM_BOT_TOKEN?.trim() || undefined,
+        telegramEnabled: parseBoolean(env.TELEGRAM_ENABLED, Boolean(env.TELEGRAM_BOT_TOKEN?.trim())),
+        whatsappAuthDir,
+        whatsappAccountId,
+        whatsappDmPolicy: dmPolicy,
+        whatsappAllowFrom,
+        whatsappSelfChatMode: selfChatMode,
+        whatsappEnabled: parseBoolean(env.WHATSAPP_ENABLED, true),
+        dataDir,
+        dbPath,
+        allowlist: envAllowlist,
+        toolUpdatesEnabled: parseBoolean(env.TOOL_UPDATES_ENABLED, false),
+        groupsEnabled: parseBoolean(env.GROUPS_ENABLED, false),
+        permissionMode,
+        toolOutputLimit,
+        healthPort: parseInteger(env.OWPENBOT_HEALTH_PORT),
+        logLevel: env.LOG_LEVEL?.trim() || "info",
+    };
+}

package/dist/db.js

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+export class BridgeStore {
+    dbPath;
+    db;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+        this.ensureDir();
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        channel TEXT NOT NULL,
+        peer_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (channel, peer_id)
+      );
+      CREATE TABLE IF NOT EXISTS allowlist (
+        channel TEXT NOT NULL,
+        peer_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (channel, peer_id)
+      );
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS pairing_requests (
+        channel TEXT NOT NULL,
+        peer_id TEXT NOT NULL,
+        code TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        PRIMARY KEY (channel, peer_id)
+      );
+    `);
+    }
+    ensureDir() {
+        const dir = path.dirname(this.dbPath);
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    getSession(channel, peerId) {
+        const stmt = this.db.prepare("SELECT channel, peer_id, session_id, created_at, updated_at FROM sessions WHERE channel = ? AND peer_id = ?");
+        const row = stmt.get(channel, peerId);
+        return row ?? null;
+    }
+    upsertSession(channel, peerId, sessionId) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`INSERT INTO sessions (channel, peer_id, session_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(channel, peer_id) DO UPDATE SET session_id = excluded.session_id, updated_at = excluded.updated_at`);
+        stmt.run(channel, peerId, sessionId, now, now);
+    }
+    isAllowed(channel, peerId) {
+        const stmt = this.db.prepare("SELECT channel, peer_id, created_at FROM allowlist WHERE channel = ? AND peer_id = ?");
+        return Boolean(stmt.get(channel, peerId));
+    }
+    allowPeer(channel, peerId) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`INSERT INTO allowlist (channel, peer_id, created_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(channel, peer_id) DO UPDATE SET created_at = excluded.created_at`);
+        stmt.run(channel, peerId, now);
+    }
+    seedAllowlist(channel, peers) {
+        const insert = this.db.prepare(`INSERT INTO allowlist (channel, peer_id, created_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(channel, peer_id) DO NOTHING`);
+        const now = Date.now();
+        const transaction = this.db.transaction((items) => {
+            for (const peer of items) {
+                insert.run(channel, peer, now);
+            }
+        });
+        transaction(peers);
+    }
+    listPairingRequests(channel) {
+        const now = Date.now();
+        const stmt = channel
+            ? this.db.prepare("SELECT channel, peer_id, code, created_at, expires_at FROM pairing_requests WHERE channel = ? AND expires_at > ? ORDER BY created_at ASC")
+            : this.db.prepare("SELECT channel, peer_id, code, created_at, expires_at FROM pairing_requests WHERE expires_at > ? ORDER BY created_at ASC");
+        const rows = (channel ? stmt.all(channel, now) : stmt.all(now));
+        return rows;
+    }
+    getPairingRequest(channel, peerId) {
+        const now = Date.now();
+        const stmt = this.db.prepare("SELECT channel, peer_id, code, created_at, expires_at FROM pairing_requests WHERE channel = ? AND peer_id = ? AND expires_at > ?");
+        const row = stmt.get(channel, peerId, now);
+        return row ?? null;
+    }
+    createPairingRequest(channel, peerId, code, ttlMs) {
+        const now = Date.now();
+        const expiresAt = now + ttlMs;
+        const stmt = this.db.prepare(`INSERT INTO pairing_requests (channel, peer_id, code, created_at, expires_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(channel, peer_id) DO UPDATE SET code = excluded.code, created_at = excluded.created_at, expires_at = excluded.expires_at`);
+        stmt.run(channel, peerId, code, now, expiresAt);
+    }
+    approvePairingRequest(channel, code) {
+        const now = Date.now();
+        const select = this.db.prepare("SELECT channel, peer_id, code, created_at, expires_at FROM pairing_requests WHERE channel = ? AND code = ? AND expires_at > ?");
+        const row = select.get(channel, code, now);
+        if (!row)
+            return null;
+        const del = this.db.prepare("DELETE FROM pairing_requests WHERE channel = ? AND peer_id = ?");
+        del.run(channel, row.peer_id);
+        return row;
+    }
+    denyPairingRequest(channel, code) {
+        const stmt = this.db.prepare("DELETE FROM pairing_requests WHERE channel = ? AND code = ?");
+        const result = stmt.run(channel, code);
+        return result.changes > 0;
+    }
+    prunePairingRequests() {
+        const now = Date.now();
+        const stmt = this.db.prepare("DELETE FROM pairing_requests WHERE expires_at <= ?");
+        stmt.run(now);
+    }
+    getSetting(key) {
+        const stmt = this.db.prepare("SELECT value FROM settings WHERE key = ?");
+        const row = stmt.get(key);
+        return row?.value ?? null;
+    }
+    setSetting(key, value) {
+        const stmt = this.db.prepare("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+        stmt.run(key, value);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/events.js

@@ -0,0 +1,11 @@
+export function normalizeEvent(raw) {
+    if (!raw)
+        return null;
+    if (typeof raw.type === "string") {
+        return { type: raw.type, properties: raw.properties };
+    }
+    if (raw.payload && typeof raw.payload.type === "string") {
+        return { type: raw.payload.type, properties: raw.payload.properties };
+    }
+    return null;
+}

package/dist/health.js

@@ -0,0 +1,21 @@
+import http from "node:http";
+export function startHealthServer(port, getStatus, logger) {
+    const server = http.createServer((req, res) => {
+        if (!req.url || req.url === "/health") {
+            const snapshot = getStatus();
+            res.writeHead(snapshot.ok ? 200 : 503, {
+                "Content-Type": "application/json",
+            });
+            res.end(JSON.stringify(snapshot));
+            return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Not found" }));
+    });
+    server.listen(port, "0.0.0.0", () => {
+        logger.info({ port }, "health server listening");
+    });
+    return () => {
+        server.close();
+    };
+}

package/dist/logger.js

@@ -0,0 +1,7 @@
+import pino from "pino";
+export function createLogger(level) {
+    return pino({
+        level,
+        base: undefined,
+    });
+}

package/dist/opencode.js

@@ -0,0 +1,34 @@
+import { Buffer } from "node:buffer";
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
+export function createClient(config) {
+    const headers = {};
+    if (config.opencodeUsername && config.opencodePassword) {
+        const token = Buffer.from(`${config.opencodeUsername}:${config.opencodePassword}`).toString("base64");
+        headers.Authorization = `Basic ${token}`;
+    }
+    return createOpencodeClient({
+        baseUrl: config.opencodeUrl,
+        directory: config.opencodeDirectory,
+        headers: Object.keys(headers).length ? headers : undefined,
+        responseStyle: "data",
+        throwOnError: true,
+    });
+}
+export function buildPermissionRules(mode) {
+    if (mode === "deny") {
+        return [
+            {
+                permission: "*",
+                pattern: "*",
+                action: "deny",
+            },
+        ];
+    }
+    return [
+        {
+            permission: "*",
+            pattern: "*",
+            action: "allow",
+        },
+    ];
+}

package/dist/telegram.js

@@ -0,0 +1,45 @@
+import { Bot } from "grammy";
+const MAX_TEXT_LENGTH = 4096;
+export function createTelegramAdapter(config, logger, onMessage) {
+    if (!config.telegramToken) {
+        throw new Error("TELEGRAM_BOT_TOKEN is required for Telegram adapter");
+    }
+    const bot = new Bot(config.telegramToken);
+    bot.catch((err) => {
+        logger.error({ error: err.error }, "telegram bot error");
+    });
+    bot.on("message", async (ctx) => {
+        const msg = ctx.message;
+        if (!msg?.chat)
+            return;
+        const chatType = msg.chat.type;
+        const isGroup = chatType === "group" || chatType === "supergroup" || chatType === "channel";
+        if (isGroup && !config.groupsEnabled) {
+            return;
+        }
+        const text = msg.text ?? msg.caption ?? "";
+        if (!text.trim())
+            return;
+        await onMessage({
+            channel: "telegram",
+            peerId: String(msg.chat.id),
+            text,
+            raw: msg,
+        });
+    });
+    return {
+        name: "telegram",
+        maxTextLength: MAX_TEXT_LENGTH,
+        async start() {
+            await bot.start();
+            logger.info("telegram adapter started");
+        },
+        async stop() {
+            bot.stop();
+            logger.info("telegram adapter stopped");
+        },
+        async sendText(peerId, text) {
+            await bot.api.sendMessage(Number(peerId), text);
+        },
+    };
+}

package/dist/text.js

@@ -0,0 +1,41 @@
+export function chunkText(input, limit) {
+    if (input.length <= limit)
+        return [input];
+    const chunks = [];
+    let current = "";
+    for (const line of input.split(/\n/)) {
+        if ((current + line).length + 1 > limit) {
+            if (current)
+                chunks.push(current.trimEnd());
+            current = "";
+        }
+        if (line.length > limit) {
+            for (let i = 0; i < line.length; i += limit) {
+                const slice = line.slice(i, i + limit);
+                if (slice.length)
+                    chunks.push(slice);
+            }
+            continue;
+        }
+        current += current ? `\n${line}` : line;
+    }
+    if (current.trim().length)
+        chunks.push(current.trimEnd());
+    return chunks.length ? chunks : [input];
+}
+export function truncateText(text, limit) {
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, Math.max(0, limit - 1))}…`;
+}
+export function formatInputSummary(input) {
+    const entries = Object.entries(input);
+    if (!entries.length)
+        return "";
+    try {
+        return JSON.stringify(input);
+    }
+    catch {
+        return entries.map(([key, value]) => `${key}=${String(value)}`).join(", ");
+    }
+}

package/dist/whatsapp.js

@@ -0,0 +1,166 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DisconnectReason, fetchLatestBaileysVersion, isJidGroup, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState, } from "@whiskeysockets/baileys";
+import qrcode from "qrcode-terminal";
+const MAX_TEXT_LENGTH = 3800;
+function extractText(message) {
+    const content = message.message;
+    if (!content)
+        return "";
+    return (content.conversation ||
+        content.extendedTextMessage?.text ||
+        content.imageMessage?.caption ||
+        content.videoMessage?.caption ||
+        content.documentMessage?.caption ||
+        "");
+}
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function createWhatsAppAdapter(config, logger, onMessage, opts = {}) {
+    let socket = null;
+    let stopped = false;
+    const log = logger.child({ channel: "whatsapp" });
+    const authDir = path.resolve(config.whatsappAuthDir);
+    ensureDir(authDir);
+    async function connect() {
+        const { state, saveCreds } = await useMultiFileAuthState(authDir);
+        const { version } = await fetchLatestBaileysVersion();
+        const sock = makeWASocket({
+            auth: {
+                creds: state.creds,
+                keys: makeCacheableSignalKeyStore(state.keys, log),
+            },
+            version,
+            logger: log,
+            printQRInTerminal: false,
+            syncFullHistory: false,
+            markOnlineOnConnect: false,
+            browser: ["owpenbot", "cli", "0.1.0"],
+        });
+        sock.ev.on("creds.update", saveCreds);
+        sock.ev.on("connection.update", (update) => {
+            if (update.qr && opts.printQr) {
+                qrcode.generate(update.qr, { small: true });
+                log.info("scan the QR code to connect WhatsApp");
+            }
+            if (update.connection === "open") {
+                log.info("whatsapp connected");
+            }
+            if (update.connection === "close") {
+                const lastDisconnect = update.lastDisconnect;
+                const statusCode = lastDisconnect?.error?.output?.statusCode;
+                const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+                if (shouldReconnect && !stopped) {
+                    log.warn("whatsapp connection closed, reconnecting");
+                    void connect();
+                }
+                else if (!shouldReconnect) {
+                    log.warn("whatsapp logged out, run 'owpenbot whatsapp login'");
+                }
+            }
+        });
+        sock.ev.on("messages.upsert", async ({ messages }) => {
+            for (const msg of messages) {
+                if (!msg.message)
+                    continue;
+                const fromMe = Boolean(msg.key.fromMe);
+                if (fromMe && !config.whatsappSelfChatMode)
+                    continue;
+                const peerId = msg.key.remoteJid;
+                if (!peerId)
+                    continue;
+                if (isJidGroup(peerId) && !config.groupsEnabled) {
+                    continue;
+                }
+                const text = extractText(msg);
+                if (!text.trim())
+                    continue;
+                await onMessage({
+                    channel: "whatsapp",
+                    peerId,
+                    text,
+                    raw: msg,
+                    fromMe,
+                });
+            }
+        });
+        socket = sock;
+    }
+    return {
+        name: "whatsapp",
+        maxTextLength: MAX_TEXT_LENGTH,
+        async start() {
+            await connect();
+        },
+        async stop() {
+            stopped = true;
+            if (socket) {
+                socket.end(undefined);
+                socket = null;
+            }
+        },
+        async sendText(peerId, text) {
+            if (!socket)
+                throw new Error("WhatsApp socket not initialized");
+            await socket.sendMessage(peerId, { text });
+        },
+    };
+}
+export async function loginWhatsApp(config, logger) {
+    const authDir = path.resolve(config.whatsappAuthDir);
+    ensureDir(authDir);
+    const log = logger.child({ channel: "whatsapp" });
+    const { state, saveCreds } = await useMultiFileAuthState(authDir);
+    const { version } = await fetchLatestBaileysVersion();
+    await new Promise((resolve) => {
+        let finished = false;
+        const sock = makeWASocket({
+            auth: {
+                creds: state.creds,
+                keys: makeCacheableSignalKeyStore(state.keys, log),
+            },
+            version,
+            logger: log,
+            printQRInTerminal: false,
+            syncFullHistory: false,
+            markOnlineOnConnect: false,
+            browser: ["owpenbot", "cli", "0.1.0"],
+        });
+        const finish = (reason) => {
+            if (finished)
+                return;
+            finished = true;
+            log.info({ reason }, "whatsapp login finished");
+            sock.end(undefined);
+            resolve();
+        };
+        sock.ev.on("creds.update", async () => {
+            await saveCreds();
+            if (state.creds?.registered) {
+                finish("creds.registered");
+            }
+        });
+        sock.ev.on("connection.update", (update) => {
+            if (update.qr) {
+                qrcode.generate(update.qr, { small: true });
+                log.info("scan the QR code to connect WhatsApp");
+            }
+            if (update.connection === "open") {
+                finish("connection.open");
+            }
+            if (update.connection === "close" && state.creds?.registered) {
+                finish("connection.close.registered");
+            }
+        });
+    });
+}
+export function unpairWhatsApp(config, logger) {
+    const authDir = path.resolve(config.whatsappAuthDir);
+    if (!fs.existsSync(authDir)) {
+        logger.info({ authDir }, "whatsapp auth directory not found");
+        return;
+    }
+    fs.rmSync(authDir, { recursive: true, force: true });
+    logger.info({ authDir }, "whatsapp auth cleared; run owpenbot to re-pair");
+}