opencode-gateway 0.2.3 → 0.2.5

package/dist/config/gateway.js

@@ -1,148 +0,0 @@
-import { existsSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { parseGatewayLogLevel } from "../host/logger";
-import { parseCronConfig } from "./cron";
-import { parseMemoryConfig } from "./memory";
-import { defaultGatewayStateDbPath, resolveGatewayConfigPath, resolveGatewayWorkspacePath } from "./paths";
-import { parseTelegramConfig } from "./telegram";
-export async function loadGatewayConfig(env = process.env) {
-    const configPath = resolveGatewayConfigPath(env);
-    const workspaceDirPath = resolveGatewayWorkspacePath(configPath);
-    const rawConfig = await readGatewayConfigFile(configPath);
-    const stateDbValue = rawConfig?.gateway?.state_db;
-    if (stateDbValue !== undefined && typeof stateDbValue !== "string") {
-        throw new Error("gateway.state_db must be a string when present");
-    }
-    const stateDbPath = resolveStateDbPath(stateDbValue, configPath, env);
-    return {
-        configPath,
-        stateDbPath,
-        mediaRootPath: resolveMediaRootPath(stateDbPath),
-        workspaceDirPath,
-        logLevel: parseGatewayLogLevel(rawConfig?.gateway?.log_level, "gateway.log_level"),
-        hasLegacyGatewayTimezone: rawConfig?.gateway?.timezone !== undefined,
-        legacyGatewayTimezone: readLegacyGatewayTimezone(rawConfig?.gateway?.timezone),
-        mailbox: parseMailboxConfig(rawConfig?.gateway?.mailbox),
-        memory: await parseMemoryConfig(rawConfig?.memory, workspaceDirPath),
-        cron: parseCronConfig(rawConfig?.cron),
-        telegram: parseTelegramConfig(rawConfig?.channels?.telegram, env),
-    };
-}
-function parseMailboxConfig(value) {
-    const table = readMailboxTable(value);
-    return {
-        batchReplies: readBoolean(table.batch_replies, "gateway.mailbox.batch_replies", false),
-        batchWindowMs: readBatchWindowMs(table.batch_window_ms),
-        routes: readMailboxRoutes(table.routes),
-    };
-}
-async function readGatewayConfigFile(path) {
-    if (!existsSync(path)) {
-        return null;
-    }
-    const source = await Bun.file(path).text();
-    const parsed = Bun.TOML.parse(source);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error(`gateway config must decode to a table: ${path}`);
-    }
-    return parsed;
-}
-function resolveStateDbPath(stateDb, configPath, env) {
-    if (!stateDb || stateDb.trim().length === 0) {
-        return defaultStateDbPath(env);
-    }
-    if (isAbsolute(stateDb)) {
-        return stateDb;
-    }
-    return resolve(dirname(configPath), stateDb);
-}
-function readMailboxTable(value) {
-    if (value === undefined) {
-        return {};
-    }
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("gateway.mailbox must be a table when present");
-    }
-    return value;
-}
-function readBoolean(value, field, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value !== "boolean") {
-        throw new Error(`${field} must be a boolean when present`);
-    }
-    return value;
-}
-function readBatchWindowMs(value) {
-    if (value === undefined) {
-        return 1_500;
-    }
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-        throw new Error("gateway.mailbox.batch_window_ms must be an integer when present");
-    }
-    if (value < 0 || value > 60_000) {
-        throw new Error("gateway.mailbox.batch_window_ms must be between 0 and 60000");
-    }
-    return value;
-}
-function readMailboxRoutes(value) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error("gateway.mailbox.routes must be an array when present");
-    }
-    const routes = value.map((entry, index) => readMailboxRoute(entry, index));
-    const seen = new Set();
-    for (const route of routes) {
-        const key = `${route.channel}:${route.target}:${route.topic ?? ""}`;
-        if (seen.has(key)) {
-            throw new Error(`gateway.mailbox.routes contains a duplicate match for ${key}`);
-        }
-        seen.add(key);
-    }
-    return routes;
-}
-function readMailboxRoute(value, index) {
-    const field = `gateway.mailbox.routes[${index}]`;
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error(`${field} must be a table`);
-    }
-    const route = value;
-    return {
-        channel: readRequiredString(route.channel, `${field}.channel`),
-        target: readRequiredString(route.target, `${field}.target`),
-        topic: readOptionalString(route.topic, `${field}.topic`),
-        mailboxKey: readRequiredString(route.mailbox_key, `${field}.mailbox_key`),
-    };
-}
-function readRequiredString(value, field) {
-    if (typeof value !== "string") {
-        throw new Error(`${field} must be a string`);
-    }
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}
-function readOptionalString(value, field) {
-    if (value === undefined) {
-        return null;
-    }
-    return readRequiredString(value, field);
-}
-function readLegacyGatewayTimezone(value) {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}
-function defaultStateDbPath(env) {
-    return defaultGatewayStateDbPath(env);
-}
-function resolveMediaRootPath(stateDbPath) {
-    return join(dirname(stateDbPath), "media");
-}

package/dist/config/memory.js

@@ -1,105 +0,0 @@
-import { stat } from "node:fs/promises";
-import { resolve } from "node:path";
-export async function parseMemoryConfig(value, workspaceDirPath) {
-    const table = readMemoryTable(value);
-    const entries = await readMemoryEntries(table.entries, workspaceDirPath);
-    return { entries };
-}
-function readMemoryTable(value) {
-    if (value === undefined) {
-        return {};
-    }
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("memory must be a table when present");
-    }
-    return value;
-}
-async function readMemoryEntries(value, workspaceDirPath) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error("memory.entries must be an array when present");
-    }
-    return await Promise.all(value.map((entry, index) => readMemoryEntry(entry, index, workspaceDirPath)));
-}
-async function readMemoryEntry(value, index, workspaceDirPath) {
-    const field = `memory.entries[${index}]`;
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error(`${field} must be a table`);
-    }
-    const entry = value;
-    const displayPath = readRequiredString(entry.path, `${field}.path`);
-    const description = readRequiredString(entry.description, `${field}.description`);
-    const resolvedPath = resolve(workspaceDirPath, displayPath);
-    const metadata = await statPath(resolvedPath, `${field}.path`);
-    if (metadata.isFile()) {
-        ensureDirectoryOnlyFieldIsAbsent(entry.inject_markdown_contents, `${field}.inject_markdown_contents`);
-        ensureDirectoryOnlyFieldIsAbsent(entry.globs, `${field}.globs`);
-        return {
-            kind: "file",
-            path: resolvedPath,
-            displayPath,
-            description,
-            injectContent: readBoolean(entry.inject_content, `${field}.inject_content`, false),
-        };
-    }
-    if (metadata.isDirectory()) {
-        ensureFileOnlyFieldIsAbsent(entry.inject_content, `${field}.inject_content`);
-        return {
-            kind: "directory",
-            path: resolvedPath,
-            displayPath,
-            description,
-            injectMarkdownContents: readBoolean(entry.inject_markdown_contents, `${field}.inject_markdown_contents`, false),
-            globs: readGlobList(entry.globs, `${field}.globs`),
-        };
-    }
-    throw new Error(`${field}.path must point to a regular file or directory`);
-}
-async function statPath(path, field) {
-    try {
-        return await stat(path);
-    }
-    catch (error) {
-        throw new Error(`${field} does not exist: ${path}`, { cause: error });
-    }
-}
-function ensureDirectoryOnlyFieldIsAbsent(value, field) {
-    if (value !== undefined) {
-        throw new Error(`${field} is only valid for directory entries`);
-    }
-}
-function ensureFileOnlyFieldIsAbsent(value, field) {
-    if (value !== undefined) {
-        throw new Error(`${field} is only valid for file entries`);
-    }
-}
-function readBoolean(value, field, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value !== "boolean") {
-        throw new Error(`${field} must be a boolean when present`);
-    }
-    return value;
-}
-function readGlobList(value, field) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array when present`);
-    }
-    return value.map((entry, index) => readRequiredString(entry, `${field}[${index}]`));
-}
-function readRequiredString(value, field) {
-    if (typeof value !== "string") {
-        throw new Error(`${field} must be a string`);
-    }
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}

package/dist/config/paths.js

@@ -1,39 +0,0 @@
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-export const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
-export const OPENCODE_CONFIG_FILE = "opencode.json";
-export const OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
-export const OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
-export const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
-export function resolveGatewayConfigPath(env) {
-    const explicit = env.OPENCODE_GATEWAY_CONFIG;
-    if (explicit && explicit.trim().length > 0) {
-        return resolve(explicit);
-    }
-    return join(resolveOpencodeConfigDir(env), GATEWAY_CONFIG_FILE);
-}
-export function resolveOpencodeConfigDir(env) {
-    const explicit = env.OPENCODE_CONFIG_DIR;
-    if (explicit && explicit.trim().length > 0) {
-        return resolve(explicit);
-    }
-    return defaultOpencodeConfigDir(env);
-}
-export function resolveManagedOpencodeConfigDir(env) {
-    return join(resolveConfigHome(env), "opencode-gateway", "opencode");
-}
-export function resolveGatewayWorkspacePath(configPath) {
-    return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
-}
-export function defaultGatewayStateDbPath(env) {
-    return join(resolveDataHome(env), "opencode-gateway", "state.db");
-}
-export function resolveConfigHome(env) {
-    return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-}
-export function resolveDataHome(env) {
-    return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-}
-function defaultOpencodeConfigDir(env) {
-    return join(resolveConfigHome(env), "opencode");
-}

package/dist/config/telegram.js

@@ -1,91 +0,0 @@
-export function parseTelegramConfig(value, env) {
-    const table = readTelegramTable(value);
-    const enabled = readBoolean(table.enabled, "channels.telegram.enabled", false);
-    if (!enabled) {
-        return { enabled: false };
-    }
-    const botTokenEnv = readString(table.bot_token_env, "channels.telegram.bot_token_env", "TELEGRAM_BOT_TOKEN");
-    const pollTimeoutSeconds = readPollTimeoutSeconds(table.poll_timeout_seconds);
-    const allowedChats = readIdentifierList(table.allowed_chats, "channels.telegram.allowed_chats");
-    const allowedUsers = readIdentifierList(table.allowed_users, "channels.telegram.allowed_users");
-    const botToken = env[botTokenEnv]?.trim();
-    if (!botToken) {
-        throw new Error(`Telegram is enabled but ${botTokenEnv} is not set`);
-    }
-    if (allowedChats.length === 0 && allowedUsers.length === 0) {
-        throw new Error("Telegram is enabled but no allowlist entries were configured");
-    }
-    return {
-        enabled: true,
-        botToken,
-        botTokenEnv,
-        pollTimeoutSeconds,
-        allowedChats,
-        allowedUsers,
-    };
-}
-function readTelegramTable(value) {
-    if (value === undefined) {
-        return {};
-    }
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("channels.telegram must be a table when present");
-    }
-    return value;
-}
-function readBoolean(value, field, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value !== "boolean") {
-        throw new Error(`${field} must be a boolean when present`);
-    }
-    return value;
-}
-function readString(value, field, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value !== "string") {
-        throw new Error(`${field} must be a string when present`);
-    }
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}
-function readPollTimeoutSeconds(value) {
-    if (value === undefined) {
-        return 25;
-    }
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-        throw new Error("channels.telegram.poll_timeout_seconds must be an integer when present");
-    }
-    if (value < 1 || value > 50) {
-        throw new Error("channels.telegram.poll_timeout_seconds must be between 1 and 50");
-    }
-    return value;
-}
-function readIdentifierList(value, field) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array when present`);
-    }
-    return value.map((entry) => normalizeIdentifier(entry, field));
-}
-function normalizeIdentifier(value, field) {
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed.length === 0) {
-            throw new Error(`${field} entries must not be empty`);
-        }
-        return trimmed;
-    }
-    if (typeof value === "number" && Number.isSafeInteger(value)) {
-        return String(value);
-    }
-    throw new Error(`${field} entries must be strings or safe integers`);
-}