@p4r4d0xb0x/opencode-provider-logger 1.0.1 → 1.1.1

package/dist/core/logger.js

@@ -1,107 +0,0 @@
-import { mkdir, writeFile, appendFile, 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);
-    }
-    /** Write a batch of entries to a new JSONL file (used by buffered mode) */
-    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;
-    }
-    /** Append a single entry to a session-scoped JSONL file (used by hook scripts) */
-    async append(sessionID, entry) {
-        const dir = this.sessionDir(sessionID);
-        await mkdir(dir, { recursive: true });
-        // Use a stable filename per session so repeated hook calls append to one file
-        const filepath = join(dir, `${sessionID}.jsonl`);
-        await appendFile(filepath, JSON.stringify(entry) + "\n", "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;
-export 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/core/types.d.ts

@@ -1,42 +0,0 @@
-/** Supported platforms */
-export type Platform = "opencode" | "claude-code" | "codex-cli";
-/** Normalised event categories across all platforms */
-export type EventCategory = "session.start" | "session.end" | "session.idle" | "session.compact" | "session.status" | "session.created" | "prompt.user" | "prompt.system" | "prompt.params" | "message.assistant" | "message.updated" | "tool.pre" | "tool.post" | "tool.error" | "permission.request" | "permission.denied" | "subagent.start" | "subagent.stop" | "task.created" | "task.completed" | "config.change" | "file.change" | "cwd.change" | "instructions.loaded" | "notification" | "elicitation" | "elicitation.result" | "raw";
-/** A single log entry — the universal record written to JSONL */
-export interface ProviderLogEntry {
-    id: string;
-    timestamp: string;
-    timestampNanos: string;
-    sessionID: string;
-    platform: Platform;
-    category: EventCategory;
-    /** Original platform-specific hook/event name (for debugging) */
-    hookName: string;
-    data: {
-        input: unknown;
-        output: unknown;
-    };
-    meta?: {
-        model?: string;
-        toolName?: string;
-        turnID?: string;
-        agentID?: string;
-        agentType?: string;
-        transcriptPath?: string;
-        cwd?: string;
-        userID?: string;
-        permissionMode?: string;
-    };
-}
-export type OpenCodeHookName = "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 function defaultConfig(platform: Platform): PluginConfig;
-/** @deprecated Use defaultConfig("opencode") instead */
-export declare const DEFAULT_CONFIG: PluginConfig;
-/** OpenCode event types worth logging */
-export declare const LOG_EVENT_TYPES: Set<string>;

package/dist/core/types.js

@@ -1,27 +0,0 @@
-// ---------------------------------------------------------------------------
-// Platform-neutral provider log types
-// ---------------------------------------------------------------------------
-export function defaultConfig(platform) {
-    const home = process.env.HOME ?? require("node:os").homedir();
-    const dirMap = {
-        opencode: `${home}/.cache/opencode/provider-logs`,
-        "claude-code": `${home}/.cache/claude-code/provider-logs`,
-        "codex-cli": `${home}/.cache/codex-cli/provider-logs`,
-    };
-    return {
-        localDir: dirMap[platform],
-        r2Remote: "paradox:ailog",
-        retentionDays: 7,
-        flushThresholdBytes: 10 * 1024 * 1024, // 10 MB
-    };
-}
-/** @deprecated Use defaultConfig("opencode") instead */
-export const DEFAULT_CONFIG = defaultConfig("opencode");
-/** OpenCode event types worth logging */
-export const LOG_EVENT_TYPES = new Set([
-    "message.updated",
-    "session.idle",
-    "session.status",
-    "session.created",
-    "session.compacted",
-]);

package/dist/core/uploader.d.ts

@@ -1,12 +0,0 @@
-import type { PluginConfig } from "./types.js";
-import type { LocalWriter, PendingFile } from "./logger.js";
-export 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>;
-}

package/dist/core/uploader.js

@@ -1,45 +0,0 @@
-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/dist/hooks.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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/logger.d.ts

@@ -1,17 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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();
-    }
-}