opencode-mem-agents 0.3.1 → 0.3.2

package/dist/worker/http.js

@@ -0,0 +1,130 @@
+import { ZodError } from "zod";
+export class InputValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InputValidationError";
+    }
+}
+export async function readBody(req, maxBytes) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buf.byteLength;
+        if (total > maxBytes) {
+            throw new InputValidationError("payload too large");
+        }
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+export function parseSchema(schema, value) {
+    try {
+        return schema.parse(value);
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            const issue = error.issues[0];
+            const where = issue?.path?.length ? issue.path.join(".") : "request";
+            const reason = issue?.message ?? "invalid input";
+            throw new InputValidationError(`${where}: ${reason}`);
+        }
+        throw error;
+    }
+}
+function withTraceId(ctx, body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        return {
+            traceId: ctx.traceId,
+            data: body,
+        };
+    }
+    const record = body;
+    if ("traceId" in record)
+        return body;
+    return {
+        traceId: ctx.traceId,
+        ...record,
+    };
+}
+export function sendJson(ctx, res, status, data, traceLog) {
+    const payload = withTraceId(ctx, data);
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    res.end(JSON.stringify(payload));
+    traceLog(ctx, "out", status, payload, Date.now() - ctx.startedAt);
+}
+export function sendText(ctx, res, status, data, traceLog) {
+    res.writeHead(status, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    res.end(data);
+    traceLog(ctx, "out", status, { textPreview: data.slice(0, 500), textLength: data.length }, Date.now() - ctx.startedAt);
+}
+export function sendHtml(ctx, res, status, html, traceLog) {
+    res.writeHead(status, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    res.end(html);
+    traceLog(ctx, "out", status, { html: "dashboard", length: html.length }, Date.now() - ctx.startedAt);
+}
+export function sendError(ctx, res, status, code, message, traceLog, details) {
+    const body = {
+        error: {
+            code,
+            message,
+        },
+    };
+    if (details !== undefined) {
+        body.error = {
+            ...body.error,
+            details,
+        };
+    }
+    sendJson(ctx, res, status, body, traceLog);
+}
+export function applyCors(req, res, corsOrigin) {
+    const requestOrigin = typeof req.headers.origin === "string" ? req.headers.origin : "";
+    let allowedOrigin = "";
+    if (corsOrigin) {
+        if (requestOrigin === corsOrigin) {
+            allowedOrigin = corsOrigin;
+        }
+    }
+    else if (requestOrigin) {
+        if (/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/i.test(requestOrigin)) {
+            allowedOrigin = requestOrigin;
+        }
+    }
+    if (allowedOrigin) {
+        res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
+    }
+    res.setHeader("Vary", "Origin");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (requestOrigin && !allowedOrigin) {
+        return false;
+    }
+    return true;
+}
+export function requiresAuth(path, apiToken) {
+    if (!apiToken)
+        return false;
+    if (!path.startsWith("/api"))
+        return false;
+    if (path === "/api/health" || path === "/api/readiness")
+        return false;
+    return true;
+}
+export function isAuthorized(req, apiToken) {
+    if (!apiToken)
+        return true;
+    const authHeader = typeof req.headers.authorization === "string" ? req.headers.authorization : "";
+    if (!authHeader.startsWith("Bearer "))
+        return false;
+    return authHeader.slice("Bearer ".length) === apiToken;
+}

package/dist/worker/repository.d.ts

@@ -0,0 +1,61 @@
+import type { ActivityParams, ContextSessionParams, MemorySaveBody, SearchParams, TimelineParams, ToolResultBody, TracesParams } from "../contracts.js";
+export interface WorkerTraceEvent {
+    id: number;
+    trace_id: string;
+    direction: string;
+    method: string;
+    path: string;
+    status: number;
+    payload: unknown;
+    duration_ms: number;
+    created_at_epoch: number;
+}
+export interface SearchResult {
+    observations: any[];
+    totalResults: number;
+}
+export interface TimelineResult {
+    anchorId: number;
+    observations: any[];
+    depthBefore: number;
+    depthAfter: number;
+}
+export interface SaveResult {
+    id: number;
+    status: "saved" | "captured" | "duplicate";
+}
+export declare class WorkerRepository {
+    private readonly db;
+    private readonly traceRetentionMs;
+    private readonly traceMaxPayloadChars;
+    private readonly insertObs;
+    private readonly insertObsIgnoreCapture;
+    private readonly getObsByCaptureKey;
+    private readonly getObsByIds;
+    private readonly getObsByIdInProject;
+    private readonly getLatestObsInProject;
+    private readonly findTimelineAnchorByQuery;
+    private readonly getTimelineBeforeRows;
+    private readonly getTimelineAfterRows;
+    private readonly insertIoEvent;
+    private readonly deleteStaleIoEvents;
+    private readonly getRecentTraceEvents;
+    private readonly getTraceEventsByTraceId;
+    private traceWritesSincePrune;
+    constructor(dbPath: string, traceRetentionDays?: number, traceMaxPayloadChars?: number);
+    close(): void;
+    logTrace(traceId: string, direction: "in" | "out" | "error", method: string, path: string, status: number, payload: unknown, durationMs?: number): void;
+    search(input: SearchParams): SearchResult;
+    timeline(input: TimelineParams): TimelineResult;
+    getByIds(ids: number[], project?: string): any[];
+    saveMemory(input: MemorySaveBody): SaveResult;
+    saveToolResult(input: ToolResultBody): SaveResult;
+    getContextRows(input: ContextSessionParams): any[];
+    getActivityRows(input: ActivityParams): any[];
+    getTraces(input: TracesParams): WorkerTraceEvent[];
+    private initializeSchema;
+    private ensureColumn;
+    private resolveTimelineAnchor;
+    private pruneStaleTraces;
+    private rebuildFtsIfOutOfSync;
+}