@p4r4d0xb0x/opencode-provider-logger 0.1.0

package/dist/buffer.d.ts

@@ -0,0 +1,13 @@
+import type { LogEntry } from "./types.js";
+/** Rough byte estimate without JSON.stringify overhead */
+export declare function estimateEntrySize(entry: LogEntry): number;
+export declare class SessionBuffer {
+    private buffers;
+    private sizes;
+    append(entry: LogEntry): void;
+    sizeOf(sessionID: string): number;
+    flush(sessionID: string): LogEntry[];
+    flushAll(): Map<string, LogEntry[]>;
+    has(sessionID: string): boolean;
+    sessionIDs(): string[];
+}

package/dist/buffer.js

@@ -0,0 +1,45 @@
+/** Rough byte estimate without JSON.stringify overhead */
+export function estimateEntrySize(entry) {
+    // Fixed overhead: id(36) + timestamp(24) + timestampNanos(19) + hook(~30) + JSON structure(~80)
+    const FIXED = 190;
+    const dataStr = typeof entry.data.input === "string" ? entry.data.input.length : 200;
+    const dataOut = typeof entry.data.output === "string" ? entry.data.output.length : 200;
+    return FIXED + entry.sessionID.length + dataStr + dataOut;
+}
+export class SessionBuffer {
+    buffers = new Map();
+    sizes = new Map();
+    append(entry) {
+        const { sessionID } = entry;
+        if (!this.buffers.has(sessionID)) {
+            this.buffers.set(sessionID, []);
+            this.sizes.set(sessionID, 0);
+        }
+        this.buffers.get(sessionID).push(entry);
+        // Approximate size: avoid double JSON.stringify (once here, once on write)
+        const approx = estimateEntrySize(entry);
+        this.sizes.set(sessionID, (this.sizes.get(sessionID) ?? 0) + approx);
+    }
+    sizeOf(sessionID) {
+        return this.sizes.get(sessionID) ?? 0;
+    }
+    flush(sessionID) {
+        const entries = this.buffers.get(sessionID) ?? [];
+        this.buffers.delete(sessionID);
+        this.sizes.delete(sessionID);
+        return entries;
+    }
+    flushAll() {
+        const all = new Map(this.buffers);
+        this.buffers.clear();
+        this.sizes.clear();
+        return all;
+    }
+    has(sessionID) {
+        const buf = this.buffers.get(sessionID);
+        return buf !== undefined && buf.length > 0;
+    }
+    sessionIDs() {
+        return [...this.buffers.keys()];
+    }
+}

package/dist/hooks.d.ts

@@ -0,0 +1,7 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { SessionBuffer } from "./buffer.js";
+import type { PluginConfig } from "./types.js";
+type FlushFn = (sessionID: string) => Promise<void>;
+type LogFn = (level: "error" | "warn", message: string, extra?: Record<string, unknown>) => void;
+export declare function createHooks(buffer: SessionBuffer, config: PluginConfig, flush: FlushFn, log?: LogFn): Hooks;
+export {};

package/dist/hooks.js

@@ -0,0 +1,72 @@
+import { LOG_EVENT_TYPES } from "./types.js";
+import { randomUUID } from "node:crypto";
+function makeEntry(sessionID, hook, input, output) {
+    const now = Date.now();
+    const micro = Math.floor(Math.random() * 1_000_000);
+    return {
+        id: randomUUID(),
+        timestamp: new Date(now).toISOString(),
+        timestampNanos: `${now}${String(micro).padStart(6, "0")}`,
+        sessionID,
+        hook,
+        data: { input, output },
+    };
+}
+export function createHooks(buffer, config, flush, log) {
+    const safeRecord = (sessionID, hook, input, output) => {
+        try {
+            buffer.append(makeEntry(sessionID, hook, input, output));
+            if (buffer.sizeOf(sessionID) >= config.flushThresholdBytes) {
+                flush(sessionID).catch(() => { });
+            }
+        }
+        catch (err) {
+            log?.("error", `Hook record failed [${hook}]`, { error: String(err) });
+        }
+    };
+    return {
+        "chat.message": async (input, output) => {
+            safeRecord(input.sessionID, "chat.message", input, output);
+        },
+        "chat.params": async (input, output) => {
+            safeRecord(input.sessionID, "chat.params", input, output);
+        },
+        "experimental.chat.system.transform": async (input, output) => {
+            const sessionID = input.sessionID ?? "unknown";
+            safeRecord(sessionID, "experimental.chat.system.transform", input, output);
+        },
+        "experimental.chat.messages.transform": async (input, output) => {
+            // input is {} — extract sessionID from first message
+            const firstMsg = output.messages?.[0]?.info;
+            const sessionID = firstMsg?.sessionID ?? "unknown";
+            safeRecord(sessionID, "experimental.chat.messages.transform", input, output);
+        },
+        "experimental.text.complete": async (input, output) => {
+            safeRecord(input.sessionID, "experimental.text.complete", input, output);
+        },
+        "tool.execute.before": async (input, output) => {
+            safeRecord(input.sessionID, "tool.execute.before", input, output);
+        },
+        "tool.execute.after": async (input, output) => {
+            safeRecord(input.sessionID, "tool.execute.after", input, output);
+        },
+        event: async ({ event }) => {
+            try {
+                // Each Event is { type: string; properties: { sessionID?, ... } }
+                const ev = event;
+                if (!LOG_EVENT_TYPES.has(ev.type))
+                    return;
+                const sessionID = ev.properties?.sessionID ?? ev.properties?.info?.sessionID;
+                if (!sessionID)
+                    return;
+                safeRecord(sessionID, "event", { type: ev.type }, ev.properties);
+                if (ev.type === "session.idle") {
+                    await flush(sessionID);
+                }
+            }
+            catch (err) {
+                log?.("error", "Event hook failed", { error: String(err) });
+            }
+        },
+    };
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,66 @@
+import { SessionBuffer } from "./buffer.js";
+import { LocalWriter } from "./logger.js";
+import { R2Uploader } from "./uploader.js";
+import { createHooks } from "./hooks.js";
+import { DEFAULT_CONFIG } from "./types.js";
+import { basename } from "node:path";
+const providerLogger = async ({ client }) => {
+    const config = { ...DEFAULT_CONFIG };
+    const buffer = new SessionBuffer();
+    const writer = new LocalWriter(config);
+    const log = (level, message, extra) => {
+        client.app.log({
+            body: { service: "provider-logger", level, message, extra },
+        });
+    };
+    const uploader = new R2Uploader(config, writer, log);
+    // Retry any pending uploads from previous sessions
+    uploader.retryPending().catch((err) => {
+        log("warn", "Failed to retry pending uploads", { error: String(err) });
+    });
+    // Cleanup local files older than retention period
+    uploader.cleanup().catch((err) => {
+        log("warn", "Failed to cleanup old files", { error: String(err) });
+    });
+    const flush = async (sessionID) => {
+        if (!buffer.has(sessionID))
+            return;
+        const entries = buffer.flush(sessionID);
+        try {
+            const filepath = await writer.write(sessionID, entries);
+            if (filepath) {
+                const tsNanos = basename(filepath, ".jsonl");
+                await uploader.upload({ path: filepath, sessionID, tsNanos });
+            }
+        }
+        catch (err) {
+            log("error", `Flush failed for session ${sessionID}`, {
+                error: String(err),
+            });
+        }
+    };
+    // Flush remaining buffers on process exit
+    const flushAll = async () => {
+        const all = buffer.flushAll();
+        const writes = [];
+        for (const [sessionID, entries] of all) {
+            if (entries.length === 0)
+                continue;
+            writes.push(writer.write(sessionID, entries).then(async (filepath) => {
+                if (filepath) {
+                    const tsNanos = basename(filepath, ".jsonl");
+                    await uploader.upload({ path: filepath, sessionID, tsNanos });
+                }
+            }).catch((err) => {
+                log("error", `Shutdown flush failed for ${sessionID}`, { error: String(err) });
+            }));
+        }
+        await Promise.allSettled(writes);
+    };
+    process.on("beforeExit", () => {
+        flushAll().catch(() => { });
+    });
+    log("info", "Provider logger initialized");
+    return createHooks(buffer, config, flush, log);
+};
+export default providerLogger;

package/dist/logger.d.ts

@@ -0,0 +1,17 @@
+import type { LogEntry, PluginConfig } from "./types.js";
+export interface PendingFile {
+    path: string;
+    sessionID: string;
+    tsNanos: string;
+}
+export declare class LocalWriter {
+    private config;
+    constructor(config: PluginConfig);
+    private sessionDir;
+    write(sessionID: string, entries: LogEntry[]): Promise<string>;
+    getPending(): Promise<PendingFile[]>;
+    markUploaded(filepath: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+/** @internal — exposed for testing */
+export declare function _resetCounter(): void;

package/dist/logger.js

@@ -0,0 +1,97 @@
+import { mkdir, writeFile, readdir, stat, unlink, rmdir, } from "node:fs/promises";
+import { join } from "node:path";
+export class LocalWriter {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    sessionDir(sessionID) {
+        return join(this.config.localDir, sessionID);
+    }
+    async write(sessionID, entries) {
+        if (entries.length === 0)
+            return "";
+        const dir = this.sessionDir(sessionID);
+        await mkdir(dir, { recursive: true });
+        const tsNanos = makeTimestampNanos();
+        const filepath = join(dir, `${tsNanos}.jsonl`);
+        const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+        await writeFile(filepath, content, "utf-8");
+        return filepath;
+    }
+    async getPending() {
+        const pending = [];
+        try {
+            const sessions = await readdir(this.config.localDir);
+            for (const sessionID of sessions) {
+                const dir = this.sessionDir(sessionID);
+                const s = await stat(dir).catch(() => null);
+                if (!s?.isDirectory())
+                    continue;
+                const files = await readdir(dir);
+                const uploaded = new Set(files.filter((f) => f.endsWith(".uploaded")));
+                for (const file of files) {
+                    if (file.endsWith(".jsonl") &&
+                        !uploaded.has(`${file}.uploaded`)) {
+                        pending.push({
+                            path: join(dir, file),
+                            sessionID,
+                            tsNanos: file.replace(".jsonl", ""),
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // directory may not exist yet
+        }
+        return pending;
+    }
+    async markUploaded(filepath) {
+        await writeFile(`${filepath}.uploaded`, "", "utf-8");
+    }
+    async cleanup() {
+        const cutoff = Date.now() - this.config.retentionDays * 24 * 60 * 60 * 1000;
+        try {
+            const sessions = await readdir(this.config.localDir);
+            for (const sessionID of sessions) {
+                const dir = this.sessionDir(sessionID);
+                const s = await stat(dir).catch(() => null);
+                if (!s?.isDirectory())
+                    continue;
+                const files = await readdir(dir);
+                for (const file of files) {
+                    if (!file.endsWith(".jsonl"))
+                        continue;
+                    const filepath = join(dir, file);
+                    const fstat = await stat(filepath).catch(() => null);
+                    if (!fstat)
+                        continue;
+                    const hasMarker = files.includes(`${file}.uploaded`);
+                    if (hasMarker && fstat.mtimeMs < cutoff) {
+                        await unlink(filepath).catch(() => { });
+                        await unlink(`${filepath}.uploaded`).catch(() => { });
+                    }
+                }
+                // Remove empty session directories
+                const remaining = await readdir(dir).catch(() => ["placeholder"]);
+                if (remaining.length === 0) {
+                    await rmdir(dir).catch(() => { });
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+let _counter = 0;
+function makeTimestampNanos() {
+    const ms = Date.now();
+    const seq = _counter++;
+    return `${ms}${String(seq % 1_000_000).padStart(6, "0")}`;
+}
+/** @internal — exposed for testing */
+export function _resetCounter() {
+    _counter = 0;
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export interface LogEntry {
+    id: string;
+    timestamp: string;
+    timestampNanos: string;
+    sessionID: string;
+    hook: HookName;
+    data: {
+        input: unknown;
+        output: unknown;
+    };
+}
+export type HookName = "chat.message" | "chat.params" | "experimental.chat.system.transform" | "experimental.chat.messages.transform" | "experimental.text.complete" | "tool.execute.before" | "tool.execute.after" | "event";
+export interface PluginConfig {
+    localDir: string;
+    r2Remote: string;
+    retentionDays: number;
+    flushThresholdBytes: number;
+}
+export declare const DEFAULT_CONFIG: PluginConfig;
+/** Event types worth logging for training data */
+export declare const LOG_EVENT_TYPES: Set<string>;

package/dist/types.js

@@ -0,0 +1,14 @@
+export const DEFAULT_CONFIG = {
+    localDir: `${process.env.HOME ?? require("node:os").homedir()}/.cache/opencode/provider-logs`,
+    r2Remote: "paradox:ailog",
+    retentionDays: 7,
+    flushThresholdBytes: 10 * 1024 * 1024, // 10 MB
+};
+/** Event types worth logging for training data */
+export const LOG_EVENT_TYPES = new Set([
+    "message.updated",
+    "session.idle",
+    "session.status",
+    "session.created",
+    "session.compacted",
+]);

package/dist/uploader.d.ts

@@ -0,0 +1,13 @@
+import type { PluginConfig } from "./types.js";
+import type { LocalWriter, PendingFile } from "./logger.js";
+type LogFn = (level: "debug" | "info" | "warn" | "error", message: string, extra?: Record<string, unknown>) => void;
+export declare class R2Uploader {
+    private config;
+    private writer;
+    private log;
+    constructor(config: PluginConfig, writer: LocalWriter, log: LogFn);
+    upload(file: PendingFile): Promise<boolean>;
+    retryPending(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export {};

package/dist/uploader.js

@@ -0,0 +1,45 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export class R2Uploader {
+    config;
+    writer;
+    log;
+    constructor(config, writer, log) {
+        this.config = config;
+        this.writer = writer;
+        this.log = log;
+    }
+    async upload(file) {
+        const remotePath = `${this.config.r2Remote}/${file.sessionID}/${file.tsNanos}.jsonl`;
+        try {
+            await execFileAsync("rclone", [
+                "copyto",
+                file.path,
+                remotePath,
+                "--no-traverse",
+            ]);
+            await this.writer.markUploaded(file.path);
+            this.log("info", `Uploaded → ${remotePath}`);
+            return true;
+        }
+        catch (err) {
+            this.log("warn", `Upload failed: ${file.path}`, {
+                error: String(err),
+            });
+            return false;
+        }
+    }
+    async retryPending() {
+        const pending = await this.writer.getPending();
+        if (pending.length === 0)
+            return;
+        this.log("info", `Retrying ${pending.length} pending upload(s)`);
+        for (const file of pending) {
+            await this.upload(file);
+        }
+    }
+    async cleanup() {
+        await this.writer.cleanup();
+    }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@p4r4d0xb0x/opencode-provider-logger",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that logs all provider requests/responses for model training",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "prepublishOnly": "tsc"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.3.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "1.3.0",
+    "@opencode-ai/sdk": "1.3.0",
+    "@types/bun": "^1.3.11",
+    "@types/node": "^25.5.0",
+    "typescript": "^5.7.0"
+  },
+  "license": "MIT"
+}