owpenwork 0.1.1

package/.env.example

@@ -0,0 +1,27 @@
+OPENCODE_URL=http://127.0.0.1:4096
+OPENCODE_DIRECTORY=
+OPENCODE_SERVER_USERNAME=
+OPENCODE_SERVER_PASSWORD=
+
+TELEGRAM_BOT_TOKEN=
+TELEGRAM_ENABLED=true
+
+OWPENBOT_DATA_DIR=~/.owpenbot
+OWPENBOT_DB_PATH=~/.owpenbot/owpenbot.db
+OWPENBOT_CONFIG_PATH=~/.owpenbot/owpenbot.json
+OWPENBOT_HEALTH_PORT=3005
+
+WHATSAPP_ACCOUNT_ID=default
+WHATSAPP_AUTH_DIR=
+WHATSAPP_ENABLED=true
+WHATSAPP_DM_POLICY=
+WHATSAPP_SELF_CHAT=false
+
+ALLOW_FROM=
+ALLOW_FROM_TELEGRAM=
+ALLOW_FROM_WHATSAPP=
+TOOL_UPDATES_ENABLED=false
+GROUPS_ENABLED=false
+TOOL_OUTPUT_LIMIT=1200
+PERMISSION_MODE=allow
+LOG_LEVEL=info

package/README.md

@@ -0,0 +1,108 @@
+# Owpenbot
+
+Simple WhatsApp bridge for a running OpenCode server. Telegram support exists but is not yet E2E tested.
+
+## Install + Run (WhatsApp)
+
+One-command install (recommended):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/different-ai/openwork/dev/packages/owpenbot/install.sh | bash
+```
+
+Then follow the printed next steps (run `owpenbot setup`, link WhatsApp, start the bridge).
+
+1) One-command setup (installs deps, builds, creates `.env` if missing):
+
+```bash
+pnpm -C packages/owpenbot setup
+```
+
+2) (Optional) Fill in `packages/owpenbot/.env` (see `.env.example`).
+
+Required:
+- `OPENCODE_URL`
+- `OPENCODE_DIRECTORY`
+- `WHATSAPP_AUTH_DIR`
+
+Recommended:
+- `OPENCODE_SERVER_USERNAME`
+- `OPENCODE_SERVER_PASSWORD`
+
+3) Run setup (writes `~/.owpenbot/owpenbot.json`):
+
+```bash
+owpenbot setup
+```
+
+4) Link WhatsApp (QR):
+
+```bash
+owpenbot whatsapp login
+```
+
+5) Start the bridge:
+
+```bash
+owpenbot start
+```
+
+Owpenbot keeps the WhatsApp session alive once connected.
+
+6) Pair a user with the bot (only if DM policy is pairing):
+
+- Run `owpenbot pairing list` to view pending codes.
+- Approve a code: `owpenbot pairing approve <code>`.
+- The user can then message again to receive OpenCode replies.
+
+## Usage Flows
+
+### One-person flow (personal testing)
+
+Use your own WhatsApp account as the bot and test from a second number you control.
+
+1) Run `owpenbot setup` and choose “personal number.”
+2) Run `owpenbot whatsapp login` to scan the QR.
+3) Message yourself or from a second number; your number is already allowlisted.
+
+Note: WhatsApp’s “message yourself” thread is not reliable for bot testing.
+
+### Two-person flow (dedicated bot)
+
+Use a separate WhatsApp number as the bot account so it stays independent from your personal chat history.
+
+1) Create a new WhatsApp account for the dedicated number.
+2) Run `owpenbot setup` and choose “dedicated number.”
+3) Run `owpenbot whatsapp login` to scan the QR.
+4) If DM policy is pairing, approve codes with `owpenbot pairing approve <code>`.
+
+## Telegram (Untested)
+
+Telegram support is wired but not E2E tested yet. To try it:
+- Set `TELEGRAM_BOT_TOKEN`.
+- Optionally set `TELEGRAM_ENABLED=true`.
+
+## Commands
+
+```bash
+owpenbot setup
+owpenbot whatsapp login
+owpenbot start
+owpenbot pairing list
+owpenbot pairing approve <code>
+owpenbot status
+```
+
+## Defaults
+
+- SQLite at `~/.owpenbot/owpenbot.db` unless overridden.
+- Config stored at `~/.owpenbot/owpenbot.json` (created by `owpenbot setup`).
+- DM policy defaults to `pairing` unless changed in setup.
+- Group chats are disabled unless `GROUPS_ENABLED=true`.
+
+## Tests
+
+```bash
+pnpm -C packages/owpenbot test:unit
+pnpm -C packages/owpenbot test:smoke
+```

package/dist/bridge.js

@@ -0,0 +1,260 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { normalizeWhatsAppId } from "./config.js";
+import { BridgeStore } from "./db.js";
+import { normalizeEvent } from "./events.js";
+import { startHealthServer } from "./health.js";
+import { buildPermissionRules, createClient } from "./opencode.js";
+import { chunkText, formatInputSummary, truncateText } from "./text.js";
+import { createTelegramAdapter } from "./telegram.js";
+import { createWhatsAppAdapter } from "./whatsapp.js";
+const TOOL_LABELS = {
+    bash: "bash",
+    read: "read",
+    write: "write",
+    edit: "edit",
+    patch: "patch",
+    multiedit: "edit",
+    grep: "grep",
+    glob: "glob",
+    task: "agent",
+    webfetch: "webfetch",
+};
+export async function startBridge(config, logger) {
+    const client = createClient(config);
+    const store = new BridgeStore(config.dbPath);
+    store.seedAllowlist("telegram", config.allowlist.telegram);
+    store.seedAllowlist("whatsapp", [...config.whatsappAllowFrom].filter((entry) => entry !== "*"));
+    store.prunePairingRequests();
+    const adapters = new Map();
+    if (config.telegramEnabled && config.telegramToken) {
+        adapters.set("telegram", createTelegramAdapter(config, logger, handleInbound));
+    }
+    else {
+        logger.info("telegram adapter disabled");
+    }
+    if (config.whatsappEnabled) {
+        adapters.set("whatsapp", createWhatsAppAdapter(config, logger, handleInbound, { printQr: true }));
+    }
+    else {
+        logger.info("whatsapp adapter disabled");
+    }
+    const sessionQueue = new Map();
+    const activeRuns = new Map();
+    let opencodeHealthy = false;
+    let opencodeVersion;
+    async function refreshHealth() {
+        try {
+            const health = await client.global.health();
+            opencodeHealthy = Boolean(health.healthy);
+            opencodeVersion = health.version;
+        }
+        catch (error) {
+            logger.warn({ error }, "failed to reach opencode health");
+            opencodeHealthy = false;
+        }
+    }
+    await refreshHealth();
+    const healthTimer = setInterval(refreshHealth, 30_000);
+    let stopHealthServer = null;
+    if (config.healthPort) {
+        stopHealthServer = startHealthServer(config.healthPort, () => ({
+            ok: opencodeHealthy,
+            opencode: {
+                url: config.opencodeUrl,
+                healthy: opencodeHealthy,
+                version: opencodeVersion,
+            },
+            channels: {
+                telegram: adapters.has("telegram"),
+                whatsapp: adapters.has("whatsapp"),
+            },
+        }), logger);
+    }
+    const eventAbort = new AbortController();
+    void (async () => {
+        const subscription = await client.event.subscribe(undefined, { signal: eventAbort.signal });
+        for await (const raw of subscription.stream) {
+            const event = normalizeEvent(raw);
+            if (!event)
+                continue;
+            if (event.type === "message.part.updated") {
+                const part = event.properties?.part;
+                if (!part?.sessionID)
+                    continue;
+                const run = activeRuns.get(part.sessionID);
+                if (!run || !run.toolUpdatesEnabled)
+                    continue;
+                if (part.type !== "tool")
+                    continue;
+                const callId = part.callID;
+                if (!callId)
+                    continue;
+                const state = part.state;
+                const status = state?.status ?? "unknown";
+                if (run.seenToolStates.get(callId) === status)
+                    continue;
+                run.seenToolStates.set(callId, status);
+                const label = TOOL_LABELS[part.tool] ?? part.tool;
+                const title = state.title || truncateText(formatInputSummary(state.input ?? {}), 120) || "running";
+                let message = `[tool] ${label} ${status}: ${title}`;
+                if (status === "completed" && state.output) {
+                    const output = truncateText(state.output.trim(), config.toolOutputLimit);
+                    if (output)
+                        message += `\n${output}`;
+                }
+                await sendText(run.channel, run.peerId, message);
+            }
+            if (event.type === "permission.asked") {
+                const permission = event.properties;
+                if (!permission?.id || !permission.sessionID)
+                    continue;
+                const response = config.permissionMode === "deny" ? "reject" : "always";
+                await client.permission.respond({
+                    sessionID: permission.sessionID,
+                    permissionID: permission.id,
+                    response,
+                });
+                if (response === "reject") {
+                    const run = activeRuns.get(permission.sessionID);
+                    if (run) {
+                        await sendText(run.channel, run.peerId, "Permission denied. Update configuration to allow tools.");
+                    }
+                }
+            }
+        }
+    })().catch((error) => {
+        logger.error({ error }, "event stream closed");
+    });
+    async function sendText(channel, peerId, text) {
+        const adapter = adapters.get(channel);
+        if (!adapter)
+            return;
+        const chunks = chunkText(text, adapter.maxTextLength);
+        for (const chunk of chunks) {
+            logger.info({ channel, peerId, length: chunk.length }, "sending message");
+            await adapter.sendText(peerId, chunk);
+        }
+    }
+    async function handleInbound(message) {
+        const adapter = adapters.get(message.channel);
+        if (!adapter)
+            return;
+        let inbound = message;
+        logger.info({ channel: inbound.channel, peerId: inbound.peerId, length: inbound.text.length }, "received message");
+        const peerKey = inbound.channel === "whatsapp" ? normalizeWhatsAppId(inbound.peerId) : inbound.peerId;
+        if (inbound.channel === "whatsapp") {
+            if (config.whatsappDmPolicy === "disabled") {
+                return;
+            }
+            const allowAll = config.whatsappDmPolicy === "open" || config.whatsappAllowFrom.has("*");
+            const isSelf = Boolean(inbound.fromMe && config.whatsappSelfChatMode);
+            const allowed = allowAll || isSelf || store.isAllowed("whatsapp", peerKey);
+            if (!allowed) {
+                if (config.whatsappDmPolicy === "allowlist") {
+                    await sendText(inbound.channel, inbound.peerId, "Access denied. Ask the owner to allowlist your number.");
+                    return;
+                }
+                store.prunePairingRequests();
+                const active = store.getPairingRequest("whatsapp", peerKey);
+                const pending = store.listPairingRequests("whatsapp");
+                if (!active && pending.length >= 3) {
+                    await sendText(inbound.channel, inbound.peerId, "Pairing queue full. Ask the owner to approve pending requests.");
+                    return;
+                }
+                const code = active?.code ?? String(Math.floor(100000 + Math.random() * 900000));
+                if (!active) {
+                    store.createPairingRequest("whatsapp", peerKey, code, 60 * 60_000);
+                }
+                await sendText(inbound.channel, inbound.peerId, `Pairing required. Ask the owner to approve code: ${code}`);
+                return;
+            }
+        }
+        else if (config.allowlist[inbound.channel].size > 0) {
+            if (!store.isAllowed(inbound.channel, peerKey)) {
+                await sendText(inbound.channel, inbound.peerId, "Access denied.");
+                return;
+            }
+        }
+        const session = store.getSession(inbound.channel, peerKey);
+        const sessionID = session?.session_id ?? (await createSession({ ...inbound, peerId: peerKey }));
+        enqueue(sessionID, async () => {
+            const runState = {
+                sessionID,
+                channel: inbound.channel,
+                peerId: inbound.peerId,
+                toolUpdatesEnabled: config.toolUpdatesEnabled,
+                seenToolStates: new Map(),
+            };
+            activeRuns.set(sessionID, runState);
+            try {
+                const response = await client.session.prompt({
+                    sessionID,
+                    parts: [{ type: "text", text: inbound.text }],
+                });
+                const parts = response.parts ?? [];
+                const reply = parts
+                    .filter((part) => part.type === "text" && !part.ignored)
+                    .map((part) => part.text ?? "")
+                    .join("\n")
+                    .trim();
+                if (reply) {
+                    await sendText(inbound.channel, inbound.peerId, reply);
+                }
+                else {
+                    await sendText(inbound.channel, inbound.peerId, "No response generated. Try again.");
+                }
+            }
+            catch (error) {
+                logger.error({ error }, "prompt failed");
+                await sendText(inbound.channel, inbound.peerId, "Error: failed to reach OpenCode.");
+            }
+            finally {
+                activeRuns.delete(sessionID);
+            }
+        });
+    }
+    async function createSession(message) {
+        const title = `owpenbot ${message.channel} ${message.peerId}`;
+        const session = await client.session.create({
+            title,
+            permission: buildPermissionRules(config.permissionMode),
+        });
+        const sessionID = session.id;
+        if (!sessionID)
+            throw new Error("Failed to create session");
+        store.upsertSession(message.channel, message.peerId, sessionID);
+        logger.info({ sessionID, channel: message.channel, peerId: message.peerId }, "session created");
+        return sessionID;
+    }
+    function enqueue(sessionID, task) {
+        const previous = sessionQueue.get(sessionID) ?? Promise.resolve();
+        const next = previous
+            .then(task)
+            .catch((error) => {
+            logger.error({ error }, "session task failed");
+        })
+            .finally(() => {
+            if (sessionQueue.get(sessionID) === next) {
+                sessionQueue.delete(sessionID);
+            }
+        });
+        sessionQueue.set(sessionID, next);
+    }
+    for (const adapter of adapters.values()) {
+        await adapter.start();
+    }
+    logger.info({ channels: Array.from(adapters.keys()) }, "bridge started");
+    return {
+        async stop() {
+            eventAbort.abort();
+            clearInterval(healthTimer);
+            if (stopHealthServer)
+                stopHealthServer();
+            for (const adapter of adapters.values()) {
+                await adapter.stop();
+            }
+            store.close();
+            await delay(50);
+        },
+    };
+}

package/dist/cli.js

@@ -0,0 +1,252 @@
+import fs from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { Command } from "commander";
+import { startBridge } from "./bridge.js";
+import { loadConfig, normalizeWhatsAppId, readConfigFile, writeConfigFile, } from "./config.js";
+import { BridgeStore } from "./db.js";
+import { createLogger } from "./logger.js";
+import { loginWhatsApp, unpairWhatsApp } from "./whatsapp.js";
+const program = new Command();
+program
+    .name("owpenbot")
+    .description("OpenCode WhatsApp + Telegram bridge")
+    .argument("[path]");
+const runStart = async (pathOverride) => {
+    if (pathOverride?.trim()) {
+        process.env.OPENCODE_DIRECTORY = pathOverride.trim();
+    }
+    const config = loadConfig();
+    const logger = createLogger(config.logLevel);
+    if (!process.env.OPENCODE_DIRECTORY) {
+        process.env.OPENCODE_DIRECTORY = config.opencodeDirectory;
+    }
+    const bridge = await startBridge(config, logger);
+    logger.info("Commands: owpenbot whatsapp login, owpenbot pairing list, owpenbot status");
+    const shutdown = async () => {
+        logger.info("shutting down");
+        await bridge.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+};
+program
+    .command("start")
+    .description("Start the bridge")
+    .action(() => runStart());
+program.action((pathArg) => {
+    if (process.argv.includes("--help") || process.argv.includes("-h")) {
+        program.outputHelp();
+        return;
+    }
+    return runStart(pathArg);
+});
+program
+    .command("setup")
+    .description("Create or update owpenbot.json for WhatsApp")
+    .option("--non-interactive", "Write defaults without prompts", false)
+    .action(async (opts) => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const { config: existing } = readConfigFile(config.configPath);
+    const next = existing ?? { version: 1 };
+    if (opts.nonInteractive) {
+        next.version = 1;
+        next.channels = next.channels ?? {};
+        next.channels.whatsapp = {
+            dmPolicy: "pairing",
+            allowFrom: [],
+            selfChatMode: false,
+            accounts: {
+                [config.whatsappAccountId]: {
+                    authDir: config.whatsappAuthDir,
+                },
+            },
+        };
+        writeConfigFile(config.configPath, next);
+        console.log(`Wrote ${config.configPath}`);
+        return;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const phoneMode = await rl.question("WhatsApp setup: (1) Personal number (2) Dedicated number [1]: ");
+    const mode = phoneMode.trim() === "2" ? "dedicated" : "personal";
+    let dmPolicy = "pairing";
+    let allowFrom = [];
+    let selfChatMode = false;
+    if (mode === "personal") {
+        let normalized = "";
+        while (!normalized) {
+            const number = await rl.question("Your WhatsApp number (E.164, e.g. +15551234567): ");
+            const candidate = normalizeWhatsAppId(number);
+            if (!/^\+\d+$/.test(candidate)) {
+                console.log("Invalid number. Try again.");
+                continue;
+            }
+            normalized = candidate;
+        }
+        allowFrom = [normalized];
+        dmPolicy = "allowlist";
+        selfChatMode = true;
+    }
+    else {
+        const policyInput = await rl.question("DM policy: (1) Pairing (2) Allowlist (3) Open (4) Disabled [1]: ");
+        const policyChoice = policyInput.trim();
+        if (policyChoice === "2")
+            dmPolicy = "allowlist";
+        else if (policyChoice === "3")
+            dmPolicy = "open";
+        else if (policyChoice === "4")
+            dmPolicy = "disabled";
+        else
+            dmPolicy = "pairing";
+        const listInput = await rl.question("Allowlist numbers (comma-separated, optional): ");
+        if (listInput.trim()) {
+            allowFrom = listInput
+                .split(",")
+                .map((item) => normalizeWhatsAppId(item))
+                .filter(Boolean);
+        }
+        if (dmPolicy === "open") {
+            allowFrom = allowFrom.length ? allowFrom : ["*"];
+        }
+    }
+    rl.close();
+    next.version = 1;
+    next.channels = next.channels ?? {};
+    next.channels.whatsapp = {
+        dmPolicy,
+        allowFrom,
+        selfChatMode,
+        accounts: {
+            [config.whatsappAccountId]: {
+                authDir: config.whatsappAuthDir,
+            },
+        },
+    };
+    writeConfigFile(config.configPath, next);
+    console.log(`Wrote ${config.configPath}`);
+});
+program
+    .command("pairing-code")
+    .description("List pending pairing codes")
+    .action(() => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const store = new BridgeStore(config.dbPath);
+    store.prunePairingRequests();
+    const requests = store.listPairingRequests("whatsapp");
+    if (!requests.length) {
+        console.log("No pending pairing requests.");
+    }
+    else {
+        for (const request of requests) {
+            console.log(`${request.code} ${request.peer_id}`);
+        }
+    }
+    store.close();
+});
+const whatsapp = program.command("whatsapp").description("WhatsApp helpers");
+whatsapp
+    .command("login")
+    .description("Login to WhatsApp via QR code")
+    .action(async () => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const logger = createLogger(config.logLevel);
+    await loginWhatsApp(config, logger);
+});
+whatsapp
+    .command("logout")
+    .description("Logout of WhatsApp and clear auth state")
+    .action(() => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const logger = createLogger(config.logLevel);
+    unpairWhatsApp(config, logger);
+});
+program
+    .command("qr")
+    .description("Print a WhatsApp QR code to pair")
+    .action(async () => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const logger = createLogger(config.logLevel);
+    await loginWhatsApp(config, logger);
+});
+program
+    .command("unpair")
+    .description("Clear WhatsApp pairing data")
+    .action(() => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const logger = createLogger(config.logLevel);
+    unpairWhatsApp(config, logger);
+});
+const pairing = program.command("pairing").description("Pairing requests");
+pairing
+    .command("list")
+    .description("List pending pairing requests")
+    .action(() => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const store = new BridgeStore(config.dbPath);
+    store.prunePairingRequests();
+    const requests = store.listPairingRequests("whatsapp");
+    if (!requests.length) {
+        console.log("No pending pairing requests.");
+    }
+    else {
+        for (const request of requests) {
+            console.log(`${request.code} ${request.peer_id}`);
+        }
+    }
+    store.close();
+});
+pairing
+    .command("approve")
+    .argument("<code>")
+    .description("Approve a pairing request")
+    .action((code) => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const store = new BridgeStore(config.dbPath);
+    const request = store.approvePairingRequest("whatsapp", code.trim());
+    if (!request) {
+        console.log("Pairing code not found or expired.");
+        store.close();
+        return;
+    }
+    store.allowPeer("whatsapp", request.peer_id);
+    store.close();
+    console.log(`Approved ${request.peer_id}`);
+});
+pairing
+    .command("deny")
+    .argument("<code>")
+    .description("Deny a pairing request")
+    .action((code) => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const store = new BridgeStore(config.dbPath);
+    const ok = store.denyPairingRequest("whatsapp", code.trim());
+    store.close();
+    console.log(ok ? "Removed pairing request." : "Pairing code not found.");
+});
+program
+    .command("status")
+    .description("Show WhatsApp and OpenCode status")
+    .action(async () => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const authPath = `${config.whatsappAuthDir}/creds.json`;
+    const linked = fs.existsSync(authPath);
+    console.log(`Config: ${config.configPath}`);
+    console.log(`WhatsApp linked: ${linked ? "yes" : "no"}`);
+    console.log(`Auth dir: ${config.whatsappAuthDir}`);
+    console.log(`OpenCode URL: ${config.opencodeUrl}`);
+});
+program
+    .command("doctor")
+    .description("Diagnose common issues")
+    .action(async () => {
+    const config = loadConfig(process.env, { requireOpencode: false });
+    const authPath = `${config.whatsappAuthDir}/creds.json`;
+    if (!fs.existsSync(authPath)) {
+        console.log("WhatsApp not linked. Run: owpenbot whatsapp login");
+    }
+    else {
+        console.log("WhatsApp linked.");
+    }
+    console.log("If replies fail, ensure OpenCode server is running at OPENCODE_URL.");
+});
+await program.parseAsync(process.argv);