opencode-mem-agents 0.3.1 → 0.3.2

package/dist/index.js

@@ -21,6 +21,7 @@
  *                                                  └── SQLite + FTS5
  */
 import { tool } from "@opencode-ai/plugin";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 const z = tool.schema;
@@ -29,14 +30,28 @@ const __dirname = dirname(__filename);
 // ---------------------------------------------------------------------------
 // Configuration
 // ---------------------------------------------------------------------------
-const WORKER_PORT = parseInt(process.env.OPENCODE_MEM_PORT ?? "37778", 10);
+const WORKER_PORT = parsePort(process.env.OPENCODE_MEM_PORT, 37778);
 const WORKER_HOST = process.env.OPENCODE_MEM_HOST ?? "127.0.0.1";
 const WORKER_BASE = `http://${WORKER_HOST}:${WORKER_PORT}`;
+const WORKER_API_TOKEN = process.env.OPENCODE_MEM_API_TOKEN ?? "";
 const HEALTH_TIMEOUT_MS = 2000;
 const STARTUP_TIMEOUT_MS = 15000;
+const WORKER_REQUEST_TIMEOUT_MS = 5000;
 const FLUSH_INTERVAL_MS = 10_000;
 const MAX_BUFFER_SIZE = 20;
 const CONTEXT_CACHE_TTL_MS = 60_000;
+const MAX_CONTEXT_CACHE_ENTRIES = 40;
+const MAX_FLUSH_CONCURRENCY = 8;
+function parsePort(rawValue, fallback) {
+    if (!rawValue)
+        return fallback;
+    const parsed = parseInt(rawValue, 10);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    if (parsed < 1 || parsed > 65535)
+        return fallback;
+    return parsed;
+}
 const TOOL_SIGNALS = {
     // HIGH — mutations and explicit saves (sent immediately)
     write: "high",
@@ -105,12 +120,15 @@ async function isWorkerHealthy() {
     }
 }
 const DATA_DIR = process.env.OPENCODE_MEM_DATA_DIR ?? `${process.env.HOME}/.opencode-mem`;
+const PENDING_QUEUE_FILE = join(DATA_DIR, `pending-observations-${process.pid}.json`);
+const PENDING_QUEUE_FILE_PATTERN = /^pending-observations(?:-\d+)?\.json$/;
+if (!existsSync(DATA_DIR))
+    mkdirSync(DATA_DIR, { recursive: true });
 async function startWorker() {
     if (await isWorkerHealthy())
         return true;
     const workerScript = join(__dirname, "worker.js");
     const { spawn } = await import("child_process");
-    const { existsSync } = await import("fs");
     if (!existsSync(workerScript)) {
         console.error(`[opencode-mem] Worker script not found: ${workerScript}`);
         return false;
@@ -146,44 +164,216 @@ async function workerGet(path, params) {
                 url.searchParams.set(k, v);
         }
     }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5000);
     try {
-        const res = await fetch(url.toString(), { signal: controller.signal });
+        const res = await fetchWithTimeout(url.toString(), {
+            headers: workerHeaders(),
+        });
         if (!res.ok)
-            return JSON.stringify({ error: `HTTP ${res.status}` });
+            return await toErrorPayload(res);
         return await res.text();
     }
-    finally {
-        clearTimeout(timeout);
+    catch (error) {
+        return JSON.stringify({
+            error: `network_error:${error instanceof Error ? error.message : "request_failed"}`,
+        });
     }
 }
 async function workerPost(path, body) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5000);
     try {
-        const res = await fetch(`${WORKER_BASE}${path}`, {
+        const res = await fetchWithTimeout(`${WORKER_BASE}${path}`, {
             method: "POST",
-            headers: { "Content-Type": "application/json" },
+            headers: workerHeaders("application/json"),
             body: JSON.stringify(body),
-            signal: controller.signal,
         });
         if (!res.ok)
-            return JSON.stringify({ error: `HTTP ${res.status}` });
+            return await toErrorPayload(res);
         return await res.text();
     }
+    catch (error) {
+        return JSON.stringify({
+            error: `network_error:${error instanceof Error ? error.message : "request_failed"}`,
+        });
+    }
+}
+async function fetchWithTimeout(url, init, timeoutMs = WORKER_REQUEST_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
     finally {
         clearTimeout(timeout);
     }
 }
+async function toErrorPayload(res) {
+    const text = await res.text();
+    try {
+        const parsed = JSON.parse(text);
+        return JSON.stringify({
+            error: `HTTP ${res.status}`,
+            body: parsed,
+        });
+    }
+    catch {
+        return JSON.stringify({
+            error: `HTTP ${res.status}`,
+            body: text.slice(0, 1000),
+        });
+    }
+}
+function workerHeaders(contentType) {
+    const headers = {};
+    if (contentType)
+        headers["Content-Type"] = contentType;
+    if (WORKER_API_TOKEN)
+        headers["Authorization"] = `Bearer ${WORKER_API_TOKEN}`;
+    return headers;
+}
+function buildToolResultPayload(obs) {
+    return {
+        sessionId: obs.sessionId,
+        tool: obs.tool,
+        callId: obs.callId,
+        args: obs.args,
+        output: obs.output,
+        title: obs.title,
+        files_modified: obs.files_modified ?? [],
+        metadata: {
+            signal: obs.signal,
+            agent: obs.agent,
+            timestamp: obs.timestamp,
+        },
+    };
+}
+async function postToolResult(obs) {
+    try {
+        const response = await fetchWithTimeout(`${WORKER_BASE}/api/session/tool-result`, {
+            method: "POST",
+            headers: workerHeaders("application/json"),
+            body: JSON.stringify(buildToolResultPayload(obs)),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function buildContextCacheKey(sessionId, agent) {
+    return [
+        sessionId,
+        agent.workflowId || "default-workflow",
+        agent.agentName || "default-agent",
+        agent.phase || "default-phase",
+    ].join("|");
+}
+function pruneContextCache(cache) {
+    if (cache.size <= MAX_CONTEXT_CACHE_ENTRIES)
+        return;
+    const sorted = Array.from(cache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const overflow = cache.size - MAX_CONTEXT_CACHE_ENTRIES;
+    for (let i = 0; i < overflow; i += 1) {
+        const [key] = sorted[i];
+        cache.delete(key);
+    }
+}
+function formatRoleResults(raw, maxItems, maxItemLength) {
+    try {
+        const parsed = JSON.parse(raw);
+        const observations = Array.isArray(parsed.observations) ? parsed.observations : [];
+        if (observations.length === 0)
+            return "";
+        const lines = ["## Role-Relevant Observations"];
+        for (const row of observations.slice(0, maxItems)) {
+            const id = typeof row.id === "number" ? row.id : 0;
+            const type = typeof row.type === "string" ? row.type : "observation";
+            const titleValue = typeof row.title === "string" ? row.title : "";
+            const textValue = typeof row.text === "string" ? row.text : "";
+            const content = (titleValue || textValue || "(empty)").slice(0, maxItemLength);
+            lines.push(`- #${id} [${type}] ${content}`);
+        }
+        return lines.join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+function isBufferedObservation(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const row = value;
+    return (typeof row.sessionId === "string" &&
+        typeof row.tool === "string" &&
+        typeof row.callId === "string" &&
+        typeof row.output === "string" &&
+        typeof row.signal === "string" &&
+        typeof row.timestamp === "number" &&
+        typeof row.agent === "object" &&
+        row.agent !== null);
+}
 function createObservationBuffer() {
-    const pending = [];
+    const pending = loadPendingFromDisk();
     let timer = null;
     let flushing = false;
     let flushFailures = 0;
     const MAX_FLUSH_FAILURES = 3;
     const CIRCUIT_RESET_MS = 30_000;
     let circuitOpenAt = 0;
+    const MAX_RETRY_QUEUE_SIZE = 2000;
+    function pendingKey(obs) {
+        return `${obs.sessionId}|${obs.callId}|${obs.tool}|${obs.timestamp}`;
+    }
+    function loadPendingFromDisk() {
+        try {
+            const entries = existsSync(DATA_DIR) ? readdirSync(DATA_DIR) : [];
+            const queueFiles = entries.filter((name) => PENDING_QUEUE_FILE_PATTERN.test(name));
+            if (queueFiles.length === 0)
+                return [];
+            const merged = new Map();
+            for (const fileName of queueFiles) {
+                const path = join(DATA_DIR, fileName);
+                try {
+                    const raw = readFileSync(path, "utf-8");
+                    const parsed = JSON.parse(raw);
+                    if (!Array.isArray(parsed))
+                        continue;
+                    for (const row of parsed) {
+                        if (!isBufferedObservation(row))
+                            continue;
+                        merged.set(pendingKey(row), row);
+                    }
+                }
+                catch {
+                    // best effort read
+                }
+            }
+            return Array.from(merged.values());
+        }
+        catch {
+            return [];
+        }
+    }
+    function persistPendingToDisk() {
+        try {
+            if (pending.length > 1) {
+                const deduped = new Map();
+                for (const row of pending) {
+                    deduped.set(pendingKey(row), row);
+                }
+                pending.splice(0, pending.length, ...Array.from(deduped.values()));
+            }
+            if (pending.length === 0) {
+                if (existsSync(PENDING_QUEUE_FILE))
+                    unlinkSync(PENDING_QUEUE_FILE);
+                return;
+            }
+            const tempPath = `${PENDING_QUEUE_FILE}.tmp`;
+            writeFileSync(tempPath, JSON.stringify(pending), "utf-8");
+            renameSync(tempPath, PENDING_QUEUE_FILE);
+        }
+        catch {
+            // best effort durability
+        }
+    }
     async function flush() {
         if (flushing || pending.length === 0)
             return;
@@ -196,26 +386,21 @@ function createObservationBuffer() {
         flushing = true;
         const batch = pending.splice(0);
         try {
-            const results = await Promise.allSettled(batch.map((obs) => fetch(`${WORKER_BASE}/api/session/tool-result`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    sessionId: obs.sessionId,
-                    tool: obs.tool,
-                    callId: obs.callId,
-                    args: obs.args,
-                    output: obs.output,
-                    title: obs.title,
-                    files_modified: obs.files_modified ?? [],
-                    metadata: {
-                        signal: obs.signal,
-                        agent: obs.agent,
-                        timestamp: obs.timestamp,
-                    },
-                }),
-            })));
-            const failures = results.filter((r) => r.status === "rejected").length;
-            if (failures > 0) {
+            const failed = [];
+            for (let i = 0; i < batch.length; i += MAX_FLUSH_CONCURRENCY) {
+                const slice = batch.slice(i, i + MAX_FLUSH_CONCURRENCY);
+                const results = await Promise.all(slice.map(async (obs) => ({ ok: await postToolResult(obs), obs })));
+                for (const result of results) {
+                    if (!result.ok) {
+                        failed.push(result.obs);
+                    }
+                }
+            }
+            if (failed.length > 0) {
+                pending.unshift(...failed);
+                if (pending.length > MAX_RETRY_QUEUE_SIZE) {
+                    pending.splice(MAX_RETRY_QUEUE_SIZE);
+                }
                 flushFailures++;
                 if (flushFailures >= MAX_FLUSH_FAILURES) {
                     circuitOpenAt = Date.now();
@@ -225,9 +410,9 @@ function createObservationBuffer() {
             else {
                 flushFailures = 0;
             }
-            // Don't re-queue batch — accept data loss over unbounded growth
         }
         finally {
+            persistPendingToDisk();
             flushing = false;
         }
     }
@@ -235,35 +420,23 @@ function createObservationBuffer() {
         if (timer)
             return;
         timer = setInterval(() => flush().catch(() => { }), FLUSH_INTERVAL_MS);
+        if (pending.length > 0) {
+            flush().catch(() => { });
+        }
     }
     function add(obs) {
         pending.push(obs);
+        if (pending.length > MAX_RETRY_QUEUE_SIZE) {
+            pending.splice(0, pending.length - MAX_RETRY_QUEUE_SIZE);
+        }
+        persistPendingToDisk();
         if (pending.length >= MAX_BUFFER_SIZE)
             flush().catch(() => { });
     }
     async function sendImmediate(obs) {
-        try {
-            await fetch(`${WORKER_BASE}/api/session/tool-result`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    sessionId: obs.sessionId,
-                    tool: obs.tool,
-                    callId: obs.callId,
-                    args: obs.args,
-                    output: obs.output,
-                    title: obs.title,
-                    files_modified: obs.files_modified ?? [],
-                    metadata: {
-                        signal: obs.signal,
-                        agent: obs.agent,
-                        timestamp: obs.timestamp,
-                    },
-                }),
-            });
-        }
-        catch {
-            // Worker unavailable
+        const ok = await postToolResult(obs);
+        if (!ok) {
+            add(obs);
         }
     }
     return { start, add, flush, sendImmediate };
@@ -278,7 +451,7 @@ const plugin = async (_input) => {
     }
     const observationBuffer = createObservationBuffer();
     observationBuffer.start();
-    let contextCache = null;
+    const contextCache = new Map();
     return {
         // ------------------------------------------------------------------
         // Tools
@@ -294,6 +467,18 @@ const plugin = async (_input) => {
                         .string()
                         .optional()
                         .describe("Filter by type: decision, bugfix, feature, refactor, discovery, change"),
+                    signal: z
+                        .enum(["high", "medium", "low"])
+                        .optional()
+                        .describe("Filter by signal level"),
+                    offset: z
+                        .number()
+                        .optional()
+                        .describe("Pagination offset"),
+                    orderBy: z
+                        .enum(["created_desc", "created_asc", "id_desc", "id_asc"])
+                        .optional()
+                        .describe("Sort order"),
                     dateStart: z.string().optional().describe("ISO date start filter"),
                     dateEnd: z.string().optional().describe("ISO date end filter"),
                     since_id: z
@@ -311,6 +496,9 @@ const plugin = async (_input) => {
                         limit: String(args.limit ?? 20),
                         project: args.project ?? "",
                         type: args.type ?? "",
+                        signal: args.signal ?? "",
+                        offset: args.offset !== undefined ? String(args.offset) : "",
+                        orderBy: args.orderBy ?? "",
                         dateStart: args.dateStart ?? "",
                         dateEnd: args.dateEnd ?? "",
                         since_id: args.since_id !== undefined ? String(args.since_id) : "",
@@ -338,6 +526,10 @@ const plugin = async (_input) => {
                         .optional()
                         .describe("Records after anchor (default 3)"),
                     project: z.string().optional().describe("Filter by project"),
+                    format: z
+                        .enum(["text", "json"])
+                        .optional()
+                        .describe("Response format (default text)"),
                 },
                 async execute(args) {
                     return await workerGet("/api/timeline", {
@@ -346,6 +538,7 @@ const plugin = async (_input) => {
                         depth_before: String(args.depth_before ?? 3),
                         depth_after: String(args.depth_after ?? 3),
                         project: args.project ?? "",
+                        format: args.format ?? "",
                     });
                 },
             }),
@@ -415,6 +608,7 @@ const plugin = async (_input) => {
                     const project = wfId || ctx.directory.split("/").pop() || "opencode-mem";
                     return await workerGet("/api/activity", {
                         project,
+                        role: args.role ?? agentCtx.agentName ?? "default",
                     });
                 },
             }),
@@ -536,22 +730,23 @@ const plugin = async (_input) => {
         // ------------------------------------------------------------------
         "experimental.chat.system.transform": async (hookInput, hookOutput) => {
             if (!(await isWorkerHealthy())) {
-                contextCache = null;
+                contextCache.clear();
                 return;
             }
             const MAX_CONTEXT_BYTES = 4096;
             const MAX_CONTEXT_ITEMS = 10;
             const MAX_ITEM_LENGTH = 300;
-            const now = Date.now();
-            if (contextCache &&
-                now - contextCache.timestamp < CONTEXT_CACHE_TTL_MS) {
-                if (contextCache.content.length > 100) {
-                    hookOutput.system.push(contextCache.content);
-                }
-                return;
-            }
             try {
                 const agentCtx = getAgentContext();
+                const now = Date.now();
+                const cacheKey = buildContextCacheKey(hookInput.sessionID ?? "default", agentCtx);
+                const cached = contextCache.get(cacheKey);
+                if (cached && now - cached.timestamp < CONTEXT_CACHE_TTL_MS) {
+                    if (cached.content.trim().length > 0) {
+                        hookOutput.system.push(cached.content);
+                    }
+                    return;
+                }
                 const roleQuery = getRoleQuery(agentCtx.agentName);
                 const blocks = [];
                 const [roleResults, sessionContext] = await Promise.all([
@@ -562,6 +757,7 @@ const plugin = async (_input) => {
                     }).catch(() => ""),
                     workerGet("/api/context/session", {
                         sessionId: hookInput.sessionID ?? "default",
+                        project: agentCtx.workflowId || "",
                         limit: String(MAX_CONTEXT_ITEMS),
                     }).catch(() => ""),
                 ]);
@@ -569,17 +765,21 @@ const plugin = async (_input) => {
                     blocks.push(`[Memory] Workflow: ${agentCtx.workflowId} | Agent: ${agentCtx.agentName}` +
                         (agentCtx.phase ? ` | Phase: ${agentCtx.phase}` : ""));
                 }
-                if (roleResults && roleResults.length > 50)
-                    blocks.push(roleResults);
-                if (sessionContext && sessionContext.length > 100)
+                if (roleResults && roleResults.length > 50) {
+                    const formattedRoleResults = formatRoleResults(roleResults, MAX_CONTEXT_ITEMS, MAX_ITEM_LENGTH);
+                    if (formattedRoleResults)
+                        blocks.push(formattedRoleResults);
+                }
+                if (sessionContext && sessionContext.length > 40)
                     blocks.push(sessionContext);
                 let content = blocks.join("\n\n");
                 // Enforce hard cap on injected context size
                 if (content.length > MAX_CONTEXT_BYTES) {
                     content = content.substring(0, MAX_CONTEXT_BYTES) + "\n[...truncated]";
                 }
-                contextCache = { content, timestamp: now };
-                if (content.length > 100)
+                contextCache.set(cacheKey, { content, timestamp: now });
+                pruneContextCache(contextCache);
+                if (content.trim().length > 0)
                     hookOutput.system.push(content);
             }
             catch {

package/dist/worker/config.d.ts

@@ -0,0 +1,14 @@
+export interface WorkerConfig {
+    port: number;
+    host: string;
+    dataDir: string;
+    dbPath: string;
+    pidFile: string;
+    maxBodyBytes: number;
+    apiToken: string;
+    corsOrigin: string;
+    traceRetentionDays: number;
+    traceMaxPayloadChars: number;
+}
+export declare const WORKER_VERSION = "0.3.1";
+export declare function readWorkerConfig(): WorkerConfig;

package/dist/worker/config.js

@@ -0,0 +1,44 @@
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+export const WORKER_VERSION = "0.3.1";
+export function readWorkerConfig() {
+    const port = parsePort(process.env.OPENCODE_MEM_PORT, 37778);
+    const host = process.env.OPENCODE_MEM_HOST ?? "127.0.0.1";
+    const dataDir = process.env.OPENCODE_MEM_DATA_DIR ?? join(homedir(), ".opencode-mem");
+    const traceRetentionDays = clampInt(process.env.OPENCODE_MEM_TRACE_RETENTION_DAYS, 1, 365, 7);
+    const traceMaxPayloadChars = clampInt(process.env.OPENCODE_MEM_TRACE_MAX_PAYLOAD_CHARS, 512, 200_000, 4_000);
+    if (!existsSync(dataDir)) {
+        mkdirSync(dataDir, { recursive: true });
+    }
+    return {
+        port,
+        host,
+        dataDir,
+        dbPath: join(dataDir, "opencode-mem.db"),
+        pidFile: join(dataDir, "worker.pid"),
+        maxBodyBytes: 64 * 1024,
+        apiToken: process.env.OPENCODE_MEM_API_TOKEN ?? "",
+        corsOrigin: (process.env.OPENCODE_MEM_CORS_ORIGIN ?? "").trim(),
+        traceRetentionDays,
+        traceMaxPayloadChars,
+    };
+}
+function clampInt(rawValue, min, max, fallback) {
+    if (!rawValue)
+        return fallback;
+    const parsed = parseInt(rawValue, 10);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.min(max, Math.max(min, parsed));
+}
+function parsePort(rawValue, fallback) {
+    if (!rawValue)
+        return fallback;
+    const parsed = parseInt(rawValue, 10);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    if (parsed < 1 || parsed > 65535)
+        return fallback;
+    return parsed;
+}

package/dist/worker/http.d.ts

@@ -0,0 +1,23 @@
+import type http from "http";
+export interface RequestContext {
+    traceId: string;
+    method: string;
+    path: string;
+    startedAt: number;
+}
+export type TraceDirection = "in" | "out" | "error";
+export type TraceLogger = (ctx: RequestContext, direction: TraceDirection, status: number, payload: unknown, durationMs?: number) => void;
+export declare class InputValidationError extends Error {
+    constructor(message: string);
+}
+export declare function readBody(req: http.IncomingMessage, maxBytes: number): Promise<string>;
+export declare function parseSchema<T>(schema: {
+    parse: (value: unknown) => T;
+}, value: unknown): T;
+export declare function sendJson(ctx: RequestContext, res: http.ServerResponse, status: number, data: unknown, traceLog: TraceLogger): void;
+export declare function sendText(ctx: RequestContext, res: http.ServerResponse, status: number, data: string, traceLog: TraceLogger): void;
+export declare function sendHtml(ctx: RequestContext, res: http.ServerResponse, status: number, html: string, traceLog: TraceLogger): void;
+export declare function sendError(ctx: RequestContext, res: http.ServerResponse, status: number, code: string, message: string, traceLog: TraceLogger, details?: unknown): void;
+export declare function applyCors(req: http.IncomingMessage, res: http.ServerResponse, corsOrigin: string): boolean;
+export declare function requiresAuth(path: string, apiToken: string): boolean;
+export declare function isAuthorized(req: http.IncomingMessage, apiToken: string): boolean;