opencode-claw 0.1.0

package/dist/config/schema.d.ts

@@ -0,0 +1,482 @@
+import { z } from "zod";
+export declare const configSchema: z.ZodObject<{
+    opencode: z.ZodDefault<z.ZodObject<{
+        configPath: z.ZodOptional<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+        directory: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        port: number;
+        directory?: string | undefined;
+        configPath?: string | undefined;
+    }, {
+        directory?: string | undefined;
+        configPath?: string | undefined;
+        port?: number | undefined;
+    }>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        backend: z.ZodDefault<z.ZodEnum<["txt", "openviking"]>>;
+        txt: z.ZodDefault<z.ZodObject<{
+            directory: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            directory: string;
+        }, {
+            directory?: string | undefined;
+        }>>;
+        openviking: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<["http", "subprocess"]>>;
+            url: z.ZodDefault<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            embedding: z.ZodOptional<z.ZodEnum<["openai", "volcengine"]>>;
+            fallback: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "http" | "subprocess";
+            url: string;
+            fallback: boolean;
+            path?: string | undefined;
+            embedding?: "openai" | "volcengine" | undefined;
+        }, {
+            path?: string | undefined;
+            mode?: "http" | "subprocess" | undefined;
+            url?: string | undefined;
+            embedding?: "openai" | "volcengine" | undefined;
+            fallback?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        txt: {
+            directory: string;
+        };
+        backend: "txt" | "openviking";
+        openviking?: {
+            mode: "http" | "subprocess";
+            url: string;
+            fallback: boolean;
+            path?: string | undefined;
+            embedding?: "openai" | "volcengine" | undefined;
+        } | undefined;
+    }, {
+        txt?: {
+            directory?: string | undefined;
+        } | undefined;
+        openviking?: {
+            path?: string | undefined;
+            mode?: "http" | "subprocess" | undefined;
+            url?: string | undefined;
+            embedding?: "openai" | "volcengine" | undefined;
+            fallback?: boolean | undefined;
+        } | undefined;
+        backend?: "txt" | "openviking" | undefined;
+    }>>;
+    channels: z.ZodObject<{
+        telegram: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            botToken: z.ZodString;
+            allowlist: z.ZodArray<z.ZodString, "many">;
+            mode: z.ZodDefault<z.ZodEnum<["polling", "webhook"]>>;
+            webhookUrl: z.ZodOptional<z.ZodString>;
+            rejectionBehavior: z.ZodDefault<z.ZodEnum<["ignore", "reject"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            botToken: string;
+            allowlist: string[];
+            mode: "polling" | "webhook";
+            rejectionBehavior: "ignore" | "reject";
+            webhookUrl?: string | undefined;
+        }, {
+            enabled: boolean;
+            botToken: string;
+            allowlist: string[];
+            mode?: "polling" | "webhook" | undefined;
+            webhookUrl?: string | undefined;
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+        }>>;
+        slack: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            botToken: z.ZodString;
+            appToken: z.ZodString;
+            allowlist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            mode: z.ZodDefault<z.ZodEnum<["socket", "http"]>>;
+            signingSecret: z.ZodOptional<z.ZodString>;
+            rejectionBehavior: z.ZodDefault<z.ZodEnum<["ignore", "reject"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            botToken: string;
+            mode: "socket" | "http";
+            rejectionBehavior: "ignore" | "reject";
+            appToken: string;
+            allowlist?: string[] | undefined;
+            signingSecret?: string | undefined;
+        }, {
+            enabled: boolean;
+            botToken: string;
+            appToken: string;
+            allowlist?: string[] | undefined;
+            mode?: "socket" | "http" | undefined;
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+            signingSecret?: string | undefined;
+        }>>;
+        whatsapp: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            allowlist: z.ZodArray<z.ZodString, "many">;
+            authDir: z.ZodDefault<z.ZodString>;
+            debounceMs: z.ZodDefault<z.ZodNumber>;
+            rejectionBehavior: z.ZodDefault<z.ZodEnum<["ignore", "reject"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            allowlist: string[];
+            rejectionBehavior: "ignore" | "reject";
+            authDir: string;
+            debounceMs: number;
+        }, {
+            enabled: boolean;
+            allowlist: string[];
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+            authDir?: string | undefined;
+            debounceMs?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        slack?: {
+            enabled: boolean;
+            botToken: string;
+            mode: "socket" | "http";
+            rejectionBehavior: "ignore" | "reject";
+            appToken: string;
+            allowlist?: string[] | undefined;
+            signingSecret?: string | undefined;
+        } | undefined;
+        telegram?: {
+            enabled: boolean;
+            botToken: string;
+            allowlist: string[];
+            mode: "polling" | "webhook";
+            rejectionBehavior: "ignore" | "reject";
+            webhookUrl?: string | undefined;
+        } | undefined;
+        whatsapp?: {
+            enabled: boolean;
+            allowlist: string[];
+            rejectionBehavior: "ignore" | "reject";
+            authDir: string;
+            debounceMs: number;
+        } | undefined;
+    }, {
+        slack?: {
+            enabled: boolean;
+            botToken: string;
+            appToken: string;
+            allowlist?: string[] | undefined;
+            mode?: "socket" | "http" | undefined;
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+            signingSecret?: string | undefined;
+        } | undefined;
+        telegram?: {
+            enabled: boolean;
+            botToken: string;
+            allowlist: string[];
+            mode?: "polling" | "webhook" | undefined;
+            webhookUrl?: string | undefined;
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+        } | undefined;
+        whatsapp?: {
+            enabled: boolean;
+            allowlist: string[];
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+            authDir?: string | undefined;
+            debounceMs?: number | undefined;
+        } | undefined;
+    }>;
+    cron: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        defaultTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        jobs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            schedule: z.ZodString;
+            description: z.ZodString;
+            prompt: z.ZodString;
+            reportTo: z.ZodOptional<z.ZodObject<{
+                channel: z.ZodEnum<["slack", "telegram", "whatsapp"]>;
+                peerId: z.ZodString;
+                threadId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            }, {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            }>>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            id: string;
+            schedule: string;
+            description: string;
+            prompt: string;
+            timeoutMs: number;
+            reportTo?: {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            } | undefined;
+        }, {
+            id: string;
+            schedule: string;
+            description: string;
+            prompt: string;
+            enabled?: boolean | undefined;
+            reportTo?: {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            } | undefined;
+            timeoutMs?: number | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        defaultTimeoutMs: number;
+        jobs: {
+            enabled: boolean;
+            id: string;
+            schedule: string;
+            description: string;
+            prompt: string;
+            timeoutMs: number;
+            reportTo?: {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            } | undefined;
+        }[];
+    }, {
+        enabled?: boolean | undefined;
+        defaultTimeoutMs?: number | undefined;
+        jobs?: {
+            id: string;
+            schedule: string;
+            description: string;
+            prompt: string;
+            enabled?: boolean | undefined;
+            reportTo?: {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            } | undefined;
+            timeoutMs?: number | undefined;
+        }[] | undefined;
+    }>>;
+    sessions: z.ZodDefault<z.ZodObject<{
+        titleTemplate: z.ZodDefault<z.ZodString>;
+        persistPath: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        titleTemplate: string;
+        persistPath: string;
+    }, {
+        titleTemplate?: string | undefined;
+        persistPath?: string | undefined;
+    }>>;
+    outbox: z.ZodDefault<z.ZodObject<{
+        directory: z.ZodDefault<z.ZodString>;
+        pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        directory: string;
+        pollIntervalMs: number;
+        maxAttempts: number;
+    }, {
+        directory?: string | undefined;
+        pollIntervalMs?: number | undefined;
+        maxAttempts?: number | undefined;
+    }>>;
+    log: z.ZodDefault<z.ZodObject<{
+        level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+        file: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        level: "debug" | "info" | "warn" | "error";
+        file?: string | undefined;
+    }, {
+        level?: "debug" | "info" | "warn" | "error" | undefined;
+        file?: string | undefined;
+    }>>;
+    health: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        port: number;
+    }, {
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+    }>>;
+    router: z.ZodDefault<z.ZodObject<{
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeoutMs: number;
+    }, {
+        timeoutMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    opencode: {
+        port: number;
+        directory?: string | undefined;
+        configPath?: string | undefined;
+    };
+    memory: {
+        txt: {
+            directory: string;
+        };
+        backend: "txt" | "openviking";
+        openviking?: {
+            mode: "http" | "subprocess";
+            url: string;
+            fallback: boolean;
+            path?: string | undefined;
+            embedding?: "openai" | "volcengine" | undefined;
+        } | undefined;
+    };
+    channels: {
+        slack?: {
+            enabled: boolean;
+            botToken: string;
+            mode: "socket" | "http";
+            rejectionBehavior: "ignore" | "reject";
+            appToken: string;
+            allowlist?: string[] | undefined;
+            signingSecret?: string | undefined;
+        } | undefined;
+        telegram?: {
+            enabled: boolean;
+            botToken: string;
+            allowlist: string[];
+            mode: "polling" | "webhook";
+            rejectionBehavior: "ignore" | "reject";
+            webhookUrl?: string | undefined;
+        } | undefined;
+        whatsapp?: {
+            enabled: boolean;
+            allowlist: string[];
+            rejectionBehavior: "ignore" | "reject";
+            authDir: string;
+            debounceMs: number;
+        } | undefined;
+    };
+    sessions: {
+        titleTemplate: string;
+        persistPath: string;
+    };
+    outbox: {
+        directory: string;
+        pollIntervalMs: number;
+        maxAttempts: number;
+    };
+    log: {
+        level: "debug" | "info" | "warn" | "error";
+        file?: string | undefined;
+    };
+    router: {
+        timeoutMs: number;
+    };
+    cron?: {
+        enabled: boolean;
+        defaultTimeoutMs: number;
+        jobs: {
+            enabled: boolean;
+            id: string;
+            schedule: string;
+            description: string;
+            prompt: string;
+            timeoutMs: number;
+            reportTo?: {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            } | undefined;
+        }[];
+    } | undefined;
+    health?: {
+        enabled: boolean;
+        port: number;
+    } | undefined;
+}, {
+    channels: {
+        slack?: {
+            enabled: boolean;
+            botToken: string;
+            appToken: string;
+            allowlist?: string[] | undefined;
+            mode?: "socket" | "http" | undefined;
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+            signingSecret?: string | undefined;
+        } | undefined;
+        telegram?: {
+            enabled: boolean;
+            botToken: string;
+            allowlist: string[];
+            mode?: "polling" | "webhook" | undefined;
+            webhookUrl?: string | undefined;
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+        } | undefined;
+        whatsapp?: {
+            enabled: boolean;
+            allowlist: string[];
+            rejectionBehavior?: "ignore" | "reject" | undefined;
+            authDir?: string | undefined;
+            debounceMs?: number | undefined;
+        } | undefined;
+    };
+    opencode?: {
+        directory?: string | undefined;
+        configPath?: string | undefined;
+        port?: number | undefined;
+    } | undefined;
+    memory?: {
+        txt?: {
+            directory?: string | undefined;
+        } | undefined;
+        openviking?: {
+            path?: string | undefined;
+            mode?: "http" | "subprocess" | undefined;
+            url?: string | undefined;
+            embedding?: "openai" | "volcengine" | undefined;
+            fallback?: boolean | undefined;
+        } | undefined;
+        backend?: "txt" | "openviking" | undefined;
+    } | undefined;
+    cron?: {
+        enabled?: boolean | undefined;
+        defaultTimeoutMs?: number | undefined;
+        jobs?: {
+            id: string;
+            schedule: string;
+            description: string;
+            prompt: string;
+            enabled?: boolean | undefined;
+            reportTo?: {
+                channel: "slack" | "telegram" | "whatsapp";
+                peerId: string;
+                threadId?: string | undefined;
+            } | undefined;
+            timeoutMs?: number | undefined;
+        }[] | undefined;
+    } | undefined;
+    sessions?: {
+        titleTemplate?: string | undefined;
+        persistPath?: string | undefined;
+    } | undefined;
+    outbox?: {
+        directory?: string | undefined;
+        pollIntervalMs?: number | undefined;
+        maxAttempts?: number | undefined;
+    } | undefined;
+    log?: {
+        level?: "debug" | "info" | "warn" | "error" | undefined;
+        file?: string | undefined;
+    } | undefined;
+    health?: {
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+    } | undefined;
+    router?: {
+        timeoutMs?: number | undefined;
+    } | undefined;
+}>;

package/dist/config/schema.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+const telegramSchema = z.object({
+    enabled: z.boolean(),
+    botToken: z.string().min(1),
+    allowlist: z.array(z.string()),
+    mode: z.enum(["polling", "webhook"]).default("polling"),
+    webhookUrl: z.string().url().optional(),
+    rejectionBehavior: z.enum(["ignore", "reject"]).default("ignore"),
+});
+const slackSchema = z.object({
+    enabled: z.boolean(),
+    botToken: z.string().min(1),
+    appToken: z.string().min(1),
+    allowlist: z.array(z.string()).optional(),
+    mode: z.enum(["socket", "http"]).default("socket"),
+    signingSecret: z.string().optional(),
+    rejectionBehavior: z.enum(["ignore", "reject"]).default("ignore"),
+});
+const whatsappSchema = z.object({
+    enabled: z.boolean(),
+    allowlist: z.array(z.string()),
+    authDir: z.string().default("./data/whatsapp/auth"),
+    debounceMs: z.number().int().min(0).default(1000),
+    rejectionBehavior: z.enum(["ignore", "reject"]).default("ignore"),
+});
+const memorySchema = z.object({
+    backend: z.enum(["txt", "openviking"]).default("txt"),
+    txt: z
+        .object({
+        directory: z.string().default("./data/memory"),
+    })
+        .default({}),
+    openviking: z
+        .object({
+        mode: z.enum(["http", "subprocess"]).default("http"),
+        url: z.string().url().default("http://localhost:8100"),
+        path: z.string().optional(),
+        embedding: z.enum(["openai", "volcengine"]).optional(),
+        fallback: z.boolean().default(true),
+    })
+        .optional(),
+});
+const cronJobSchema = z.object({
+    id: z.string().min(1),
+    schedule: z.string().min(1),
+    description: z.string(),
+    prompt: z.string().min(1),
+    reportTo: z
+        .object({
+        channel: z.enum(["slack", "telegram", "whatsapp"]),
+        peerId: z.string().min(1),
+        threadId: z.string().optional(),
+    })
+        .optional(),
+    enabled: z.boolean().default(true),
+    timeoutMs: z.number().int().min(1000).default(300_000),
+});
+const cronSchema = z.object({
+    enabled: z.boolean().default(true),
+    defaultTimeoutMs: z.number().int().min(1000).default(300_000),
+    jobs: z.array(cronJobSchema).default([]),
+});
+export const configSchema = z.object({
+    opencode: z
+        .object({
+        configPath: z.string().optional(),
+        port: z.number().int().min(0).default(0),
+        directory: z.string().optional(),
+    })
+        .default({}),
+    memory: memorySchema.default({ backend: "txt" }),
+    channels: z.object({
+        telegram: telegramSchema.optional(),
+        slack: slackSchema.optional(),
+        whatsapp: whatsappSchema.optional(),
+    }),
+    cron: cronSchema.optional(),
+    sessions: z
+        .object({
+        titleTemplate: z.string().default("{{channel}}:{{peerId}}"),
+        persistPath: z.string().default("./data/sessions.json"),
+    })
+        .default({}),
+    outbox: z
+        .object({
+        directory: z.string().default("./data/outbox"),
+        pollIntervalMs: z.number().int().min(100).default(500),
+        maxAttempts: z.number().int().min(1).default(3),
+    })
+        .default({}),
+    log: z
+        .object({
+        level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+        file: z.string().optional(),
+    })
+        .default({}),
+    health: z
+        .object({
+        enabled: z.boolean().default(false),
+        port: z.number().int().min(1).default(9090),
+    })
+        .optional(),
+    router: z
+        .object({
+        timeoutMs: z.number().int().min(1000).default(300_000),
+    })
+        .default({}),
+});

package/dist/config/types.d.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import type { configSchema } from "./schema.js";
+export type Config = z.infer<typeof configSchema>;
+export type TelegramConfig = NonNullable<Config["channels"]["telegram"]>;
+export type SlackConfig = NonNullable<Config["channels"]["slack"]>;
+export type WhatsAppConfig = NonNullable<Config["channels"]["whatsapp"]>;
+export type MemoryConfig = Config["memory"];
+export type CronConfig = NonNullable<Config["cron"]>;
+export type CronJobConfig = CronConfig["jobs"][number];
+export type SessionsConfig = Config["sessions"];
+export type OutboxConfig = Config["outbox"];
+export type LogConfig = Config["log"];
+export type HealthConfig = NonNullable<Config["health"]>;
+export type RouterConfig = Config["router"];

package/dist/config/types.js

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

package/dist/cron/scheduler.d.ts

@@ -0,0 +1,16 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { CronConfig } from "../config/types.js";
+import type { OutboxWriter } from "../outbox/writer.js";
+import type { Logger } from "../utils/logger.js";
+type CronSchedulerDeps = {
+    client: OpencodeClient;
+    outbox: OutboxWriter;
+    config: CronConfig;
+    logger: Logger;
+};
+export declare function createCronScheduler(deps: CronSchedulerDeps): {
+    start: () => void;
+    stop: () => void;
+};
+export type CronScheduler = ReturnType<typeof createCronScheduler>;
+export {};