opencode-router 0.11.77 → 0.11.79

package/dist/config.js

@@ -0,0 +1,195 @@
+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 parseModel(value) {
+    if (!value?.trim())
+        return undefined;
+    const parts = value.trim().split("/");
+    if (parts.length < 2)
+        return undefined;
+    const providerID = parts[0];
+    const modelID = parts.slice(1).join("/");
+    if (!providerID || !modelID)
+        return undefined;
+    return { providerID, modelID };
+}
+function expandHome(value) {
+    if (!value.startsWith("~/"))
+        return value;
+    return path.join(os.homedir(), value.slice(2));
+}
+function resolveConfigPath(dataDir, env) {
+    const override = env.OPENCODE_ROUTER_CONFIG_PATH?.trim();
+    if (override)
+        return expandHome(override);
+    return path.join(dataDir, "opencode-router.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 normalizeId(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "";
+    const safe = trimmed.replace(/[^a-zA-Z0-9_.-]+/g, "-");
+    return safe.replace(/^-+|-+$/g, "").slice(0, 48) || "default";
+}
+function coerceTelegramBots(file) {
+    const telegram = file.channels?.telegram;
+    const bots = Array.isArray(telegram?.bots) ? telegram.bots : [];
+    const normalized = [];
+    for (const entry of bots) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const token = typeof record.token === "string" ? record.token.trim() : "";
+        if (!token)
+            continue;
+        const id = normalizeId(typeof record.id === "string" ? record.id : "default");
+        const directory = typeof record.directory === "string" ? record.directory.trim() : "";
+        normalized.push({
+            id,
+            token,
+            enabled: record.enabled === undefined ? true : record.enabled === true,
+            ...(directory ? { directory } : {}),
+        });
+    }
+    if (normalized.length)
+        return normalized;
+    // Legacy single-bot migration (in-memory).
+    const legacyToken = typeof telegram?.token === "string" ? String(telegram.token).trim() : "";
+    if (legacyToken) {
+        return [{ id: "default", token: legacyToken, enabled: true }];
+    }
+    return [];
+}
+function coerceSlackApps(file) {
+    const slack = file.channels?.slack;
+    const apps = Array.isArray(slack?.apps) ? slack.apps : [];
+    const normalized = [];
+    for (const entry of apps) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const botToken = typeof record.botToken === "string" ? record.botToken.trim() : "";
+        const appToken = typeof record.appToken === "string" ? record.appToken.trim() : "";
+        if (!botToken || !appToken)
+            continue;
+        const id = normalizeId(typeof record.id === "string" ? record.id : "default");
+        const directory = typeof record.directory === "string" ? record.directory.trim() : "";
+        normalized.push({
+            id,
+            botToken,
+            appToken,
+            enabled: record.enabled === undefined ? true : record.enabled === true,
+            ...(directory ? { directory } : {}),
+        });
+    }
+    if (normalized.length)
+        return normalized;
+    // Legacy single-app migration (in-memory).
+    const legacyBot = typeof slack?.botToken === "string" ? String(slack.botToken).trim() : "";
+    const legacyApp = typeof slack?.appToken === "string" ? String(slack.appToken).trim() : "";
+    if (legacyBot && legacyApp) {
+        return [{ id: "default", botToken: legacyBot, appToken: legacyApp, enabled: true }];
+    }
+    return [];
+}
+export function loadConfig(env = process.env, options = {}) {
+    const requireOpencode = options.requireOpencode ?? false;
+    const defaultDataDir = path.join(os.homedir(), ".openwork", "opencode-router");
+    const dataDir = expandHome(env.OPENCODE_ROUTER_DATA_DIR ?? defaultDataDir);
+    const dbPath = expandHome(env.OPENCODE_ROUTER_DB_PATH ?? path.join(dataDir, "opencode-router.db"));
+    const logFile = expandHome(env.OPENCODE_ROUTER_LOG_FILE ?? path.join(dataDir, "logs", "opencode-router.log"));
+    const configPath = resolveConfigPath(dataDir, env);
+    let { config: configFile } = readConfigFile(configPath);
+    const opencodeDirectory = env.OPENCODE_DIRECTORY?.trim() || configFile.opencodeDirectory || "";
+    if (!opencodeDirectory && requireOpencode) {
+        throw new Error("OPENCODE_DIRECTORY is required");
+    }
+    const resolvedDirectory = opencodeDirectory || process.cwd();
+    const toolOutputLimit = parseInteger(env.TOOL_OUTPUT_LIMIT) ?? 1200;
+    const permissionMode = env.PERMISSION_MODE?.toLowerCase() === "deny" ? "deny" : "allow";
+    // Identities are loaded from config. Env vars are still supported as a convenience
+    // for single-identity setups.
+    const telegramBots = coerceTelegramBots(configFile);
+    const slackApps = coerceSlackApps(configFile);
+    const envTelegram = env.TELEGRAM_BOT_TOKEN?.trim() ?? "";
+    if (envTelegram && !telegramBots.some((bot) => bot.token === envTelegram)) {
+        telegramBots.unshift({ id: "env", token: envTelegram, enabled: true });
+    }
+    const envSlackBot = env.SLACK_BOT_TOKEN?.trim() ?? "";
+    const envSlackApp = env.SLACK_APP_TOKEN?.trim() ?? "";
+    if (envSlackBot && envSlackApp && !slackApps.some((app) => app.botToken === envSlackBot && app.appToken === envSlackApp)) {
+        slackApps.unshift({ id: "env", botToken: envSlackBot, appToken: envSlackApp, enabled: true });
+    }
+    const healthPort = parseInteger(env.OPENCODE_ROUTER_HEALTH_PORT) ??
+        // Convenience alias (common on PaaS / local experiments)
+        parseInteger(env.PORT) ??
+        3005;
+    const model = parseModel(env.OPENCODE_ROUTER_MODEL);
+    const telegramEnabledDefault = configFile.channels?.telegram?.enabled ?? true;
+    const slackEnabledDefault = configFile.channels?.slack?.enabled ?? true;
+    return {
+        configPath,
+        configFile,
+        opencodeUrl: env.OPENCODE_URL?.trim() || configFile.opencodeUrl || "http://127.0.0.1:4096",
+        opencodeDirectory: resolvedDirectory,
+        opencodeUsername: env.OPENCODE_SERVER_USERNAME?.trim() || undefined,
+        opencodePassword: env.OPENCODE_SERVER_PASSWORD?.trim() || undefined,
+        model,
+        telegramBots: telegramBots.map((bot) => ({ ...bot, enabled: bot.enabled !== false && parseBoolean(env.TELEGRAM_ENABLED, telegramEnabledDefault) })),
+        slackApps: slackApps.map((app) => ({
+            ...app,
+            enabled: app.enabled !== false && parseBoolean(env.SLACK_ENABLED, slackEnabledDefault),
+        })),
+        dataDir,
+        dbPath,
+        logFile,
+        toolUpdatesEnabled: parseBoolean(env.TOOL_UPDATES_ENABLED, false),
+        groupsEnabled: parseBoolean(env.GROUPS_ENABLED, configFile.groupsEnabled ?? false),
+        permissionMode,
+        toolOutputLimit,
+        healthPort,
+        logLevel: env.LOG_LEVEL?.trim() || "info",
+    };
+}

package/dist/db.js

@@ -0,0 +1,196 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Database } from "bun:sqlite";
+export class BridgeStore {
+    dbPath;
+    db;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+        this.ensureDir();
+        this.db = new Database(dbPath, { create: true });
+        this.db.exec("PRAGMA journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        channel TEXT NOT NULL,
+        identity_id TEXT NOT NULL,
+        peer_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        directory TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (channel, identity_id, 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 bindings (
+        channel TEXT NOT NULL,
+        identity_id TEXT NOT NULL,
+        peer_id TEXT NOT NULL,
+        directory TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (channel, identity_id, peer_id)
+      );
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+        this.migrate();
+    }
+    migrate() {
+        // Sessions: migrate from legacy (channel, peer_id) PK to identity-scoped PK.
+        const sessionColumns = this.db
+            .prepare("PRAGMA table_info(sessions)")
+            .all();
+        const hasSessionIdentity = sessionColumns.some((column) => column.name === "identity_id");
+        if (!hasSessionIdentity) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS sessions_v2 (
+          channel TEXT NOT NULL,
+          identity_id TEXT NOT NULL,
+          peer_id TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          directory TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (channel, identity_id, peer_id)
+        );
+      `);
+            // Copy existing rows, defaulting identity_id to "default".
+            this.db.exec(`
+        INSERT OR IGNORE INTO sessions_v2 (channel, identity_id, peer_id, session_id, directory, created_at, updated_at)
+        SELECT channel, 'default', peer_id, session_id, NULL, created_at, updated_at FROM sessions;
+      `);
+            this.db.exec("DROP TABLE sessions");
+            this.db.exec("ALTER TABLE sessions_v2 RENAME TO sessions");
+        }
+        // Bindings: migrate from legacy (channel, peer_id) PK to identity-scoped PK.
+        const bindingColumns = this.db
+            .prepare("PRAGMA table_info(bindings)")
+            .all();
+        const hasBindingIdentity = bindingColumns.some((column) => column.name === "identity_id");
+        if (!hasBindingIdentity) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS bindings_v2 (
+          channel TEXT NOT NULL,
+          identity_id TEXT NOT NULL,
+          peer_id TEXT NOT NULL,
+          directory TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (channel, identity_id, peer_id)
+        );
+      `);
+            this.db.exec(`
+        INSERT OR IGNORE INTO bindings_v2 (channel, identity_id, peer_id, directory, created_at, updated_at)
+        SELECT channel, 'default', peer_id, directory, created_at, updated_at FROM bindings;
+      `);
+            this.db.exec("DROP TABLE bindings");
+            this.db.exec("ALTER TABLE bindings_v2 RENAME TO bindings");
+        }
+        // Cleanup: WhatsApp pairing table is no longer used.
+        try {
+            this.db.exec("DROP TABLE IF EXISTS pairing_requests");
+        }
+        catch {
+            // ignore
+        }
+    }
+    ensureDir() {
+        const dir = path.dirname(this.dbPath);
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    getSession(channel, identityId, peerId) {
+        const stmt = this.db.prepare("SELECT channel, identity_id, peer_id, session_id, directory, created_at, updated_at FROM sessions WHERE channel = ? AND identity_id = ? AND peer_id = ?");
+        const row = stmt.get(channel, identityId, peerId);
+        return row ?? null;
+    }
+    upsertSession(channel, identityId, peerId, sessionId, directory) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`INSERT INTO sessions (channel, identity_id, peer_id, session_id, directory, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(channel, identity_id, peer_id) DO UPDATE SET session_id = excluded.session_id, directory = excluded.directory, updated_at = excluded.updated_at`);
+        stmt.run(channel, identityId, peerId, sessionId, directory ?? null, now, now);
+    }
+    deleteSession(channel, identityId, peerId) {
+        const stmt = this.db.prepare("DELETE FROM sessions WHERE channel = ? AND identity_id = ? AND peer_id = ?");
+        const result = stmt.run(channel, identityId, peerId);
+        return result.changes > 0;
+    }
+    getBinding(channel, identityId, peerId) {
+        const stmt = this.db.prepare("SELECT channel, identity_id, peer_id, directory, created_at, updated_at FROM bindings WHERE channel = ? AND identity_id = ? AND peer_id = ?");
+        const row = stmt.get(channel, identityId, peerId);
+        return row ?? null;
+    }
+    upsertBinding(channel, identityId, peerId, directory) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`INSERT INTO bindings (channel, identity_id, peer_id, directory, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(channel, identity_id, peer_id) DO UPDATE SET directory = excluded.directory, updated_at = excluded.updated_at`);
+        stmt.run(channel, identityId, peerId, directory, now, now);
+    }
+    deleteBinding(channel, identityId, peerId) {
+        const stmt = this.db.prepare("DELETE FROM bindings WHERE channel = ? AND identity_id = ? AND peer_id = ?");
+        const result = stmt.run(channel, identityId, peerId);
+        return result.changes > 0;
+    }
+    listBindings(filters = {}) {
+        const where = [];
+        const args = [];
+        if (filters.channel) {
+            where.push("channel = ?");
+            args.push(filters.channel);
+        }
+        if (filters.identityId) {
+            where.push("identity_id = ?");
+            args.push(filters.identityId);
+        }
+        if (filters.directory) {
+            where.push("directory = ?");
+            args.push(filters.directory);
+        }
+        const clause = where.length ? ` WHERE ${where.join(" AND ")}` : "";
+        const stmt = this.db.prepare(`SELECT channel, identity_id, peer_id, directory, created_at, updated_at FROM bindings${clause} ORDER BY updated_at DESC`);
+        return stmt.all(...args);
+    }
+    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(() => {
+            for (const peer of peers) {
+                insert.run(channel, peer, now);
+            }
+        });
+        transaction();
+    }
+    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;
+}