opencode-claw 0.1.0

package/dist/cron/scheduler.js

@@ -0,0 +1,113 @@
+import cron from "node-cron";
+function extractText(parts) {
+    return parts
+        .filter((p) => p.type === "text" && typeof p.text === "string")
+        .map((p) => p.text)
+        .join("\n\n");
+}
+export function createCronScheduler(deps) {
+    const jobs = new Map();
+    const running = new Set();
+    async function executeJob(job) {
+        if (running.has(job.id)) {
+            deps.logger.warn(`cron: job "${job.id}" already running, skipping`);
+            return;
+        }
+        running.add(job.id);
+        const title = `cron:${job.id}:${new Date().toISOString()}`;
+        deps.logger.info(`cron: firing job "${job.id}"`, { schedule: job.schedule });
+        try {
+            const session = await deps.client.session.create({
+                body: { title },
+            });
+            if (!session.data)
+                throw new Error("session.create returned no data");
+            const sessionId = session.data.id;
+            deps.logger.debug(`cron: job "${job.id}" session created`, { sessionId });
+            // session.prompt() is synchronous — blocks until the agent finishes.
+            // Wrap with AbortSignal timeout for safety.
+            const timeout = job.timeoutMs ?? deps.config.defaultTimeoutMs;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout);
+            let result;
+            try {
+                result = await deps.client.session.prompt({
+                    path: { id: sessionId },
+                    body: { parts: [{ type: "text", text: job.prompt }] },
+                });
+            }
+            catch (err) {
+                if (controller.signal.aborted) {
+                    deps.logger.warn(`cron: job "${job.id}" timed out after ${timeout}ms`);
+                    return;
+                }
+                throw err;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!result.data) {
+                deps.logger.warn(`cron: job "${job.id}" returned no data`);
+                return;
+            }
+            const text = extractText(result.data.parts);
+            deps.logger.info(`cron: job "${job.id}" completed`, {
+                sessionId,
+                responseLength: text.length,
+            });
+            // Route result to channel if configured
+            if (job.reportTo && text.trim()) {
+                await deps.outbox.enqueue({
+                    channel: job.reportTo.channel,
+                    peerId: job.reportTo.peerId,
+                    text,
+                    threadId: job.reportTo.threadId,
+                });
+                deps.logger.info(`cron: job "${job.id}" result enqueued to ${job.reportTo.channel}:${job.reportTo.peerId}`);
+            }
+        }
+        catch (err) {
+            deps.logger.error(`cron: job "${job.id}" failed`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            running.delete(job.id);
+        }
+    }
+    function start() {
+        if (!deps.config.enabled) {
+            deps.logger.info("cron: disabled by config");
+            return;
+        }
+        for (const job of deps.config.jobs) {
+            if (!job.enabled) {
+                deps.logger.info(`cron: skipping disabled job "${job.id}"`);
+                continue;
+            }
+            if (!cron.validate(job.schedule)) {
+                deps.logger.error(`cron: invalid schedule for job "${job.id}": ${job.schedule}`);
+                continue;
+            }
+            const task = cron.schedule(job.schedule, () => {
+                executeJob(job).catch((err) => {
+                    deps.logger.error(`cron: unhandled error in job "${job.id}"`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            });
+            jobs.set(job.id, { config: job, task });
+            deps.logger.info(`cron: scheduled "${job.id}" (${job.schedule}) — ${job.description}`);
+        }
+        deps.logger.info(`cron: ${jobs.size} job(s) scheduled`);
+    }
+    function stop() {
+        for (const [id, { task }] of jobs) {
+            task.stop();
+            deps.logger.debug(`cron: stopped job "${id}"`);
+        }
+        jobs.clear();
+        deps.logger.info("cron: all jobs stopped");
+    }
+    return { start, stop };
+}

package/dist/exports.d.ts

@@ -0,0 +1,9 @@
+export { main } from "./index.js";
+export type { Config, MemoryConfig, OutboxConfig, LogConfig, HealthConfig, RouterConfig, } from "./config/types.js";
+export type { MemoryBackend, MemoryEntry, MemoryInput, MemorySearchOptions, MemoryStatus, MemoryCategory, } from "./memory/types.js";
+export { createMemoryBackend } from "./memory/factory.js";
+export type { ChannelAdapter, ChannelId, InboundMessage, OutboundMessage, ChannelStatus, } from "./channels/types.js";
+export type { OutboxEntry, OutboxWriter } from "./outbox/writer.js";
+export { createOutboxWriter } from "./outbox/writer.js";
+export type { OutboxDrainer } from "./outbox/drainer.js";
+export { createOutboxDrainer } from "./outbox/drainer.js";

package/dist/exports.js

@@ -0,0 +1,4 @@
+export { main } from "./index.js";
+export { createMemoryBackend } from "./memory/factory.js";
+export { createOutboxWriter } from "./outbox/writer.js";
+export { createOutboxDrainer } from "./outbox/drainer.js";

package/dist/health/server.d.ts

@@ -0,0 +1,17 @@
+import type { ChannelAdapter, ChannelId } from "../channels/types.js";
+import type { OutboxConfig } from "../config/types.js";
+import type { MemoryBackend } from "../memory/types.js";
+import type { Logger } from "../utils/logger.js";
+type HealthDeps = {
+    port: number;
+    adapters: Map<ChannelId, ChannelAdapter>;
+    memory: MemoryBackend;
+    outbox: OutboxConfig;
+    logger: Logger;
+};
+export declare function createHealthServer(deps: HealthDeps): {
+    start: () => void;
+    stop: () => void;
+};
+export type HealthServer = ReturnType<typeof createHealthServer>;
+export {};

package/dist/health/server.js

@@ -0,0 +1,68 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { createHttpServer } from "../compat.js";
+async function countFiles(dir) {
+    try {
+        const entries = await readdir(dir, { recursive: true });
+        return entries.filter((e) => e.endsWith(".json")).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function channelsInfo(adapters) {
+    const result = {};
+    for (const [id, adapter] of adapters) {
+        result[id] = adapter.status();
+    }
+    return result;
+}
+export function createHealthServer(deps) {
+    let srv = null;
+    async function handleRequest(req) {
+        const url = new URL(req.url);
+        const json = (data, status = 200) => new Response(JSON.stringify(data, null, 2), {
+            status,
+            headers: { "content-type": "application/json" },
+        });
+        switch (url.pathname) {
+            case "/health": {
+                const channels = channelsInfo(deps.adapters);
+                const allConnected = Object.values(channels).every((s) => s === "connected");
+                const anyConnected = Object.values(channels).some((s) => s === "connected");
+                const status = allConnected ? "up" : anyConnected ? "degraded" : "down";
+                return json({ status, uptime: process.uptime() });
+            }
+            case "/channels": {
+                return json(channelsInfo(deps.adapters));
+            }
+            case "/memory": {
+                const info = await deps.memory.status();
+                return json(info);
+            }
+            case "/outbox": {
+                const pendingDir = deps.outbox.directory;
+                const deadDir = join(deps.outbox.directory, "dead");
+                const pending = await countFiles(pendingDir);
+                const dead = await countFiles(deadDir);
+                return json({ pending, dead });
+            }
+            default: {
+                return json({ error: "not found" }, 404);
+            }
+        }
+    }
+    function start() {
+        srv = createHttpServer(deps.port, handleRequest);
+        srv.start();
+        deps.logger.info("health: server started", { port: deps.port });
+    }
+    function stop() {
+        if (srv) {
+            srv.stop();
+            srv = null;
+        }
+        deps.logger.info("health: server stopped");
+    }
+    return { start, stop };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,127 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createOpencode } from "@opencode-ai/sdk";
+import { createRouter } from "./channels/router.js";
+import { createSlackAdapter } from "./channels/slack.js";
+import { createTelegramAdapter } from "./channels/telegram.js";
+import { createWhatsAppAdapter } from "./channels/whatsapp.js";
+import { loadConfig } from "./config/loader.js";
+import { createCronScheduler } from "./cron/scheduler.js";
+import { createHealthServer } from "./health/server.js";
+import { createMemoryBackend } from "./memory/factory.js";
+import { createOutboxDrainer } from "./outbox/drainer.js";
+import { createOutboxWriter } from "./outbox/writer.js";
+import { createSessionManager } from "./sessions/manager.js";
+import { loadSessionMap } from "./sessions/persistence.js";
+import { createLogger } from "./utils/logger.js";
+import { onShutdown, setupShutdown } from "./utils/shutdown.js";
+export async function main() {
+    const config = await loadConfig();
+    const logger = createLogger(config.log);
+    logger.info("opencode-claw starting", { version: "0.1.0" });
+    // --- Phase 3: Memory System ---
+    const memory = createMemoryBackend(config.memory);
+    await memory.initialize();
+    logger.info("memory: initialized", { backend: config.memory.backend });
+    onShutdown(async () => {
+        await memory.close();
+    });
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const pluginPath = `file://${resolve(dir, "memory/plugin-entry.js")}`;
+    logger.info("opencode: starting server...", { plugins: [pluginPath] });
+    const { client, server } = await createOpencode({
+        port: config.opencode.port,
+        config: { plugin: [pluginPath] },
+    });
+    logger.info("opencode: server ready");
+    onShutdown(async () => {
+        logger.info("opencode: shutting down server");
+        server.close();
+    });
+    // Load persisted session map
+    const sessionMap = await loadSessionMap(config.sessions, logger);
+    const sessions = createSessionManager(client, config.sessions, sessionMap, logger);
+    onShutdown(async () => {
+        await sessions.persist();
+    });
+    // Setup graceful shutdown
+    setupShutdown(logger);
+    // --- Phase 2: Channel Adapters ---
+    const adapters = new Map();
+    if (config.channels.telegram?.enabled) {
+        const telegram = createTelegramAdapter(config.channels.telegram, logger);
+        adapters.set("telegram", telegram);
+        onShutdown(async () => {
+            await telegram.stop();
+        });
+    }
+    if (config.channels.slack?.enabled) {
+        const slack = createSlackAdapter(config.channels.slack, logger);
+        adapters.set("slack", slack);
+        onShutdown(async () => {
+            await slack.stop();
+        });
+    }
+    if (config.channels.whatsapp?.enabled) {
+        const whatsapp = createWhatsAppAdapter(config.channels.whatsapp, logger);
+        adapters.set("whatsapp", whatsapp);
+        onShutdown(async () => {
+            await whatsapp.stop();
+        });
+    }
+    const router = createRouter({
+        client,
+        sessions,
+        adapters,
+        config,
+        logger,
+        timeoutMs: config.router.timeoutMs,
+    });
+    // Start all adapters with the router handler
+    for (const [id, adapter] of adapters) {
+        logger.info(`channel: starting ${id}`);
+        await adapter.start(router.handler);
+    }
+    // --- Phase 4: Outbox ---
+    const outbox = createOutboxWriter(config.outbox);
+    const drainer = createOutboxDrainer(config.outbox, adapters, logger);
+    drainer.start();
+    onShutdown(() => {
+        drainer.stop();
+    });
+    // --- Phase 5: Cron ---
+    if (config.cron?.enabled) {
+        const scheduler = createCronScheduler({
+            client,
+            outbox,
+            config: config.cron,
+            logger,
+        });
+        scheduler.start();
+        onShutdown(() => {
+            scheduler.stop();
+        });
+    }
+    // --- Phase 7: Health Server ---
+    if (config.health?.enabled) {
+        const health = createHealthServer({
+            port: config.health.port,
+            adapters,
+            memory,
+            outbox: config.outbox,
+            logger,
+        });
+        health.start();
+        onShutdown(() => {
+            health.stop();
+        });
+    }
+    logger.info("opencode-claw ready", {
+        channels: Object.entries(config.channels)
+            .filter(([_, v]) => v?.enabled)
+            .map(([k]) => k),
+        memory: config.memory.backend,
+        cron: config.cron?.enabled ?? false,
+        health: config.health?.enabled ?? false,
+    });
+}

package/dist/memory/factory.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryConfig } from "../config/types.js";
+import type { MemoryBackend } from "./types.js";
+export declare function createMemoryBackend(config: MemoryConfig): MemoryBackend;

package/dist/memory/factory.js

@@ -0,0 +1,14 @@
+import { createOpenVikingBackend } from "./openviking.js";
+import { createTxtMemoryBackend } from "./txt.js";
+export function createMemoryBackend(config) {
+    if (config.backend === "txt") {
+        return createTxtMemoryBackend(config.txt.directory);
+    }
+    if (config.backend === "openviking") {
+        if (!config.openviking) {
+            throw new Error("memory.openviking config required when backend is 'openviking'");
+        }
+        return createOpenVikingBackend(config.openviking, config.txt.directory);
+    }
+    throw new Error(`Unknown memory backend: ${config.backend}`);
+}

package/dist/memory/openviking.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryConfig } from "../config/types.js";
+import type { MemoryBackend } from "./types.js";
+type OpenVikingConfig = NonNullable<MemoryConfig["openviking"]>;
+export declare function createOpenVikingBackend(config: OpenVikingConfig, fallbackDir?: string): MemoryBackend;
+export {};

package/dist/memory/openviking.js

@@ -0,0 +1,138 @@
+const CATEGORY_TO_PATH = {
+    project: "patterns",
+    experience: "cases",
+    preference: "preferences",
+    entity: "entities",
+    event: "events",
+    knowledge: "patterns",
+};
+const PATH_TO_CATEGORY = {
+    patterns: "project",
+    cases: "experience",
+    preferences: "preference",
+    entities: "entity",
+    events: "event",
+};
+function mapCategory(category) {
+    return CATEGORY_TO_PATH[category] ?? "patterns";
+}
+function reverseCategory(path) {
+    for (const [segment, cat] of Object.entries(PATH_TO_CATEGORY)) {
+        if (path.includes(segment))
+            return cat;
+    }
+    return "knowledge";
+}
+async function request(url, method, body, params) {
+    let endpoint = url;
+    if (params) {
+        const qs = new URLSearchParams(params).toString();
+        if (qs)
+            endpoint = `${url}?${qs}`;
+    }
+    const init = {
+        method,
+        headers: { "Content-Type": "application/json" },
+    };
+    if (body !== undefined) {
+        init.body = JSON.stringify(body);
+    }
+    const res = await fetch(endpoint, init);
+    const data = (await res.json());
+    if (data.status === "error") {
+        const msg = data.error?.message ?? "Unknown OpenViking error";
+        throw new Error(`OpenViking: ${data.error?.code ?? "UNKNOWN"} — ${msg}`);
+    }
+    return data.result;
+}
+export function createOpenVikingBackend(config, fallbackDir) {
+    const base = config.url.replace(/\/$/, "");
+    let available = false;
+    let fallback;
+    return {
+        async initialize() {
+            try {
+                await request(`${base}/api/v1/sessions`, "GET");
+                available = true;
+            }
+            catch {
+                if (config.fallback && fallbackDir) {
+                    const { createTxtMemoryBackend } = await import("./txt.js");
+                    fallback = createTxtMemoryBackend(fallbackDir);
+                    await fallback.initialize();
+                    available = false;
+                }
+                else {
+                    throw new Error(`OpenViking unavailable at ${base} and fallback is disabled`);
+                }
+            }
+        },
+        async search(query, options) {
+            if (fallback)
+                return fallback.search(query, options);
+            const result = await request(`${base}/api/v1/search/find`, "POST", {
+                query,
+                limit: options?.limit ?? 10,
+                score_threshold: options?.minRelevance ?? 0.1,
+            });
+            const items = result.items ?? [];
+            return items.map((item) => ({
+                id: item.uri,
+                content: item.content,
+                category: reverseCategory(item.uri),
+                source: "openviking",
+                createdAt: new Date(),
+                relevance: item.score,
+                metadata: item.metadata,
+            }));
+        },
+        async store(entry) {
+            if (fallback)
+                return fallback.store(entry);
+            const session = await request(`${base}/api/v1/sessions`, "POST", {});
+            const sid = session.session_id;
+            const category = mapCategory(entry.category);
+            const tagged = `[${category}] [source:${entry.source}] ${entry.content}`;
+            await request(`${base}/api/v1/sessions/${sid}/messages`, "POST", {
+                role: "user",
+                content: tagged,
+            });
+            await request(`${base}/api/v1/sessions/${sid}/commit`, "POST");
+        },
+        async delete(id) {
+            if (fallback)
+                return fallback.delete(id);
+            if (id.startsWith("viking://")) {
+                await request(`${base}/api/v1/fs`, "DELETE", undefined, {
+                    uri: id,
+                    recursive: "false",
+                });
+            }
+        },
+        async status() {
+            if (fallback) {
+                const s = await fallback.status();
+                return { ...s, backend: "openviking (fallback: txt)" };
+            }
+            try {
+                const sessions = await request(`${base}/api/v1/sessions`, "GET");
+                return {
+                    backend: "openviking",
+                    initialized: true,
+                    entryCount: Array.isArray(sessions) ? sessions.length : 0,
+                };
+            }
+            catch {
+                return {
+                    backend: "openviking",
+                    initialized: available,
+                    entryCount: 0,
+                };
+            }
+        },
+        async close() {
+            if (fallback)
+                await fallback.close();
+        },
+    };
+}

package/dist/memory/plugin-entry.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const memoryPlugin: Plugin;
+export { memoryPlugin };

package/dist/memory/plugin-entry.js

@@ -0,0 +1,11 @@
+import { loadConfig } from "../config/loader.js";
+import { createMemoryBackend } from "./factory.js";
+import { createMemoryPlugin } from "./plugin.js";
+// This file runs inside OpenCode's child process (loaded via `import()`).
+// It reads the same opencode-claw config and creates its own MemoryBackend
+// instance pointing to the same MEMORY.md file on disk.
+const config = await loadConfig();
+const backend = createMemoryBackend(config.memory);
+await backend.initialize();
+const memoryPlugin = createMemoryPlugin(backend);
+export { memoryPlugin };

package/dist/memory/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import type { MemoryBackend, MemoryCategory } from "./types.js";
+declare function createMemoryPlugin(backend: MemoryBackend): Plugin;
+export { createMemoryPlugin };
+export type { MemoryBackend, MemoryCategory };

package/dist/memory/plugin.js

@@ -0,0 +1,63 @@
+import { tool } from "@opencode-ai/plugin";
+const z = tool.schema;
+const CATEGORIES = ["project", "experience", "preference", "entity", "event", "knowledge"];
+function createMemoryPlugin(backend) {
+    return async () => ({
+        tool: {
+            memory_search: tool({
+                description: "Search long-term memory for relevant context about projects, experiences, preferences, or entities",
+                args: {
+                    query: z.string().describe("What to search for"),
+                    category: z
+                        .enum(CATEGORIES)
+                        .optional()
+                        .describe("Filter by category: project, experience, preference, entity, event, knowledge"),
+                    limit: z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(20)
+                        .optional()
+                        .describe("Max results to return (default: 5)"),
+                },
+                execute: async ({ query, category, limit }) => {
+                    const results = await backend.search(query, {
+                        category: category,
+                        limit: limit ?? 5,
+                    });
+                    if (results.length === 0)
+                        return "No relevant memories found.";
+                    return results.map((r) => `[${r.category}] ${r.content}`).join("\n\n---\n\n");
+                },
+            }),
+            memory_store: tool({
+                description: "Store important information in long-term memory for future sessions",
+                args: {
+                    content: z.string().describe("The information to remember"),
+                    category: z
+                        .enum(CATEGORIES)
+                        .describe("Category: project, experience, preference, entity, event, knowledge"),
+                },
+                execute: async ({ content, category }) => {
+                    await backend.store({
+                        content: content,
+                        category: category,
+                        source: "agent",
+                    });
+                    return "Stored in memory.";
+                },
+            }),
+        },
+        "experimental.chat.system.transform": async (_input, output) => {
+            const memories = await backend.search("recent context", {
+                limit: 5,
+                minRelevance: 0.05,
+            });
+            if (memories.length === 0)
+                return;
+            const block = memories.map((m) => `- [${m.category}] ${m.content}`).join("\n");
+            output.system.push(`\n\n## Relevant Context from Memory\n${block}`);
+        },
+    });
+}
+export { createMemoryPlugin };

package/dist/memory/txt.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryBackend } from "./types.js";
+export declare function createTxtMemoryBackend(directory: string): MemoryBackend;