@p4r4d0xb0x/opencode-provider-logger 0.1.0 → 1.0.0

package/dist/adapters/claude-code/hook.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/adapters/claude-code/hook.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// ---------------------------------------------------------------------------
+// Claude Code hook script — receives JSON on stdin, logs to JSONL
+// Usage: Set as a "command" hook in ~/.claude/settings.json
+// ---------------------------------------------------------------------------
+import { LocalWriter } from "../../core/logger.js";
+import { R2Uploader } from "../../core/uploader.js";
+import { defaultConfig } from "../../core/types.js";
+import { transformClaudeEvent } from "./transform.js";
+const UPLOAD_ON_EVENTS = new Set(["SessionEnd", "Stop", "StopFailure"]);
+async function main() {
+    // Read JSON from stdin
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw)
+        return;
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        process.stderr.write(`provider-logger: invalid JSON on stdin\n`);
+        return;
+    }
+    const config = defaultConfig("claude-code");
+    const writer = new LocalWriter(config);
+    const entry = transformClaudeEvent(input);
+    // Append to session-scoped JSONL file
+    await writer.append(entry.sessionID, entry);
+    // On session end / stop, trigger upload of pending files
+    if (UPLOAD_ON_EVENTS.has(input.hook_event_name)) {
+        const log = (level, msg, extra) => {
+            if (level === "error" || level === "warn") {
+                process.stderr.write(`provider-logger [${level}]: ${msg}\n`);
+            }
+        };
+        const uploader = new R2Uploader(config, writer, log);
+        await uploader.retryPending().catch(() => { });
+        await uploader.cleanup().catch(() => { });
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`provider-logger: ${err}\n`);
+    process.exit(1);
+});

package/dist/adapters/claude-code/install.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/adapters/claude-code/install.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// ---------------------------------------------------------------------------
+// Generate / merge Claude Code hook configuration into settings.json
+// Usage: node dist/adapters/claude-code/install.js [--global | --project]
+// ---------------------------------------------------------------------------
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Resolve the compiled hook.js path relative to this install script */
+function hookCommand() {
+    const hookPath = join(__dirname, "hook.js");
+    return `node "${hookPath}"`;
+}
+/** All Claude Code hook events we want to capture */
+const ALL_EVENTS = [
+    "SessionStart",
+    "SessionEnd",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PermissionRequest",
+    "PermissionDenied",
+    "SubagentStart",
+    "SubagentStop",
+    "TaskCreated",
+    "TaskCompleted",
+    "Stop",
+    "StopFailure",
+    "InstructionsLoaded",
+    "ConfigChange",
+    "CwdChanged",
+    "FileChanged",
+    "WorktreeCreate",
+    "WorktreeRemove",
+    "PreCompact",
+    "PostCompact",
+    "Notification",
+    "Elicitation",
+    "ElicitationResult",
+    "TeammateIdle",
+];
+function generateHooksConfig() {
+    const cmd = hookCommand();
+    const hooks = {};
+    for (const event of ALL_EVENTS) {
+        hooks[event] = [
+            {
+                matcher: "",
+                hooks: [
+                    {
+                        type: "command",
+                        command: cmd,
+                        timeout: 10,
+                        async: true,
+                    },
+                ],
+            },
+        ];
+    }
+    return hooks;
+}
+async function install(mode) {
+    const home = process.env.HOME ?? require("node:os").homedir();
+    const settingsPath = mode === "global"
+        ? join(home, ".claude", "settings.json")
+        : join(process.cwd(), ".claude", "settings.json");
+    // Read existing settings or start fresh
+    let settings = {};
+    try {
+        const raw = await readFile(settingsPath, "utf-8");
+        settings = JSON.parse(raw);
+    }
+    catch {
+        // file doesn't exist yet
+    }
+    // Merge hooks
+    const existingHooks = (settings.hooks ?? {});
+    const newHooks = generateHooksConfig();
+    for (const [event, matchers] of Object.entries(newHooks)) {
+        if (!existingHooks[event]) {
+            existingHooks[event] = matchers;
+        }
+        else {
+            // Check if provider-logger hook already exists
+            const cmd = hookCommand();
+            const alreadyInstalled = existingHooks[event].some((m) => m?.hooks?.some((h) => h?.command?.includes(cmd)));
+            if (!alreadyInstalled) {
+                existingHooks[event].push(...matchers);
+            }
+        }
+    }
+    settings.hooks = existingHooks;
+    await mkdir(dirname(settingsPath), { recursive: true });
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    console.log(`✓ Provider logger hooks installed → ${settingsPath}`);
+    console.log(`  Events: ${ALL_EVENTS.length}`);
+    console.log(`  Mode: async (non-blocking)`);
+}
+// CLI
+const mode = process.argv.includes("--project") ? "project" : "global";
+install(mode).catch((err) => {
+    console.error(`Install failed: ${err}`);
+    process.exit(1);
+});

package/dist/adapters/claude-code/transform.d.ts

@@ -0,0 +1,26 @@
+import type { ProviderLogEntry } from "../../core/types.js";
+/** Common fields present in every Claude Code hook stdin payload */
+export interface ClaudeHookInput {
+    session_id: string;
+    hook_event_name: string;
+    transcript_path?: string | null;
+    cwd?: string;
+    permission_mode?: string;
+    source?: string;
+    model?: string;
+    agent_id?: string;
+    agent_type?: string;
+    prompt?: string;
+    turn_id?: string;
+    stop_hook_active?: boolean;
+    last_assistant_message?: string | null;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_use_id?: string;
+    tool_response?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Transform a Claude Code hook stdin payload into a ProviderLogEntry.
+ */
+export declare function transformClaudeEvent(input: ClaudeHookInput): ProviderLogEntry;

package/dist/adapters/claude-code/transform.js

@@ -0,0 +1,66 @@
+import { makeEntry } from "../../core/entry.js";
+// ---------------------------------------------------------------------------
+// Claude Code hook event → normalised category mapping
+// ---------------------------------------------------------------------------
+const HOOK_CATEGORY_MAP = {
+    // Session lifecycle
+    SessionStart: "session.start",
+    SessionEnd: "session.end",
+    PreCompact: "session.compact",
+    PostCompact: "session.compact",
+    // Prompt / message
+    UserPromptSubmit: "prompt.user",
+    InstructionsLoaded: "instructions.loaded",
+    Stop: "message.assistant",
+    StopFailure: "message.assistant",
+    // Tool execution
+    PreToolUse: "tool.pre",
+    PostToolUse: "tool.post",
+    PostToolUseFailure: "tool.error",
+    // Permission
+    PermissionRequest: "permission.request",
+    PermissionDenied: "permission.denied",
+    // Subagent / task
+    SubagentStart: "subagent.start",
+    SubagentStop: "subagent.stop",
+    TaskCreated: "task.created",
+    TaskCompleted: "task.completed",
+    // Environment
+    ConfigChange: "config.change",
+    CwdChanged: "cwd.change",
+    FileChanged: "file.change",
+    WorktreeCreate: "file.change",
+    WorktreeRemove: "file.change",
+    // Misc
+    Notification: "notification",
+    Elicitation: "elicitation",
+    ElicitationResult: "elicitation.result",
+    TeammateIdle: "session.idle",
+};
+/**
+ * Transform a Claude Code hook stdin payload into a ProviderLogEntry.
+ */
+export function transformClaudeEvent(input) {
+    const hookName = input.hook_event_name;
+    const category = HOOK_CATEGORY_MAP[hookName] ?? "raw";
+    const sessionID = input.session_id ?? "unknown";
+    // Build output based on event type
+    let output = null;
+    if (hookName === "PostToolUse" || hookName === "PostToolUseFailure") {
+        output = input.tool_response ?? null;
+    }
+    else if (hookName === "Stop" || hookName === "StopFailure") {
+        output = input.last_assistant_message ?? null;
+    }
+    return makeEntry("claude-code", sessionID, category, hookName, input, output, {
+        model: input.model ?? undefined,
+        toolName: input.tool_name ?? undefined,
+        turnID: input.turn_id ?? undefined,
+        agentID: input.agent_id ?? undefined,
+        agentType: input.agent_type ?? undefined,
+        transcriptPath: input.transcript_path ?? undefined,
+        cwd: input.cwd ?? undefined,
+        userID: process.env.USER ?? process.env.USERNAME ?? undefined,
+        permissionMode: input.permission_mode ?? undefined,
+    });
+}

package/dist/adapters/codex-cli/hook.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/adapters/codex-cli/hook.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// ---------------------------------------------------------------------------
+// Codex CLI hook script — receives JSON on stdin, logs to JSONL
+// Usage: Set as a "command" hook in ~/.codex/hooks.json
+// ---------------------------------------------------------------------------
+import { LocalWriter } from "../../core/logger.js";
+import { R2Uploader } from "../../core/uploader.js";
+import { defaultConfig } from "../../core/types.js";
+import { transformCodexEvent } from "./transform.js";
+const UPLOAD_ON_EVENTS = new Set(["Stop"]);
+async function main() {
+    // Read JSON from stdin
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw)
+        return;
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        process.stderr.write(`provider-logger: invalid JSON on stdin\n`);
+        return;
+    }
+    const config = defaultConfig("codex-cli");
+    const writer = new LocalWriter(config);
+    const entry = transformCodexEvent(input);
+    // Append to session-scoped JSONL file
+    await writer.append(entry.sessionID, entry);
+    // On stop, trigger upload of pending files
+    if (UPLOAD_ON_EVENTS.has(input.hook_event_name)) {
+        const log = (level, msg, extra) => {
+            if (level === "error" || level === "warn") {
+                process.stderr.write(`provider-logger [${level}]: ${msg}\n`);
+            }
+        };
+        const uploader = new R2Uploader(config, writer, log);
+        await uploader.retryPending().catch(() => { });
+        await uploader.cleanup().catch(() => { });
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`provider-logger: ${err}\n`);
+    process.exit(1);
+});

package/dist/adapters/codex-cli/install.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/adapters/codex-cli/install.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// ---------------------------------------------------------------------------
+// Generate / merge Codex CLI hook configuration into hooks.json
+// Usage: node dist/adapters/codex-cli/install.js [--global | --project]
+// ---------------------------------------------------------------------------
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Resolve the compiled hook.js path relative to this install script */
+function hookCommand() {
+    const hookPath = join(__dirname, "hook.js");
+    return `node "${hookPath}"`;
+}
+function generateHooksConfig() {
+    const cmd = hookCommand();
+    return {
+        SessionStart: [
+            {
+                matcher: "startup|resume",
+                hooks: [
+                    {
+                        type: "command",
+                        command: cmd,
+                        timeout: 10,
+                    },
+                ],
+            },
+        ],
+        PreToolUse: [
+            {
+                matcher: ".*",
+                hooks: [
+                    {
+                        type: "command",
+                        command: cmd,
+                        timeout: 10,
+                    },
+                ],
+            },
+        ],
+        PostToolUse: [
+            {
+                matcher: ".*",
+                hooks: [
+                    {
+                        type: "command",
+                        command: cmd,
+                        timeout: 10,
+                    },
+                ],
+            },
+        ],
+        UserPromptSubmit: [
+            {
+                hooks: [
+                    {
+                        type: "command",
+                        command: cmd,
+                        timeout: 10,
+                    },
+                ],
+            },
+        ],
+        Stop: [
+            {
+                hooks: [
+                    {
+                        type: "command",
+                        command: cmd,
+                        timeout: 30,
+                    },
+                ],
+            },
+        ],
+    };
+}
+async function install(mode) {
+    const home = process.env.HOME ?? require("node:os").homedir();
+    const hooksPath = mode === "global"
+        ? join(home, ".codex", "hooks.json")
+        : join(process.cwd(), ".codex", "hooks.json");
+    // Read existing hooks or start fresh
+    let existing = {};
+    try {
+        const raw = await readFile(hooksPath, "utf-8");
+        existing = JSON.parse(raw);
+    }
+    catch {
+        // file doesn't exist yet
+    }
+    const existingHooks = (existing.hooks ?? {});
+    const newHooks = generateHooksConfig();
+    for (const [event, matchers] of Object.entries(newHooks)) {
+        if (!existingHooks[event]) {
+            existingHooks[event] = matchers;
+        }
+        else {
+            const cmd = hookCommand();
+            const alreadyInstalled = existingHooks[event].some((m) => m?.hooks?.some((h) => h?.command?.includes(cmd)));
+            if (!alreadyInstalled) {
+                existingHooks[event].push(...matchers);
+            }
+        }
+    }
+    existing.hooks = existingHooks;
+    await mkdir(dirname(hooksPath), { recursive: true });
+    await writeFile(hooksPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+    console.log(`✓ Provider logger hooks installed → ${hooksPath}`);
+    console.log(`  Events: SessionStart, PreToolUse, PostToolUse, UserPromptSubmit, Stop`);
+    console.log(`  Note: Codex hooks require [features] codex_hooks = true in config.toml`);
+}
+// CLI
+const mode = process.argv.includes("--project") ? "project" : "global";
+install(mode).catch((err) => {
+    console.error(`Install failed: ${err}`);
+    process.exit(1);
+});

package/dist/adapters/codex-cli/transform.d.ts

@@ -0,0 +1,26 @@
+import type { ProviderLogEntry } from "../../core/types.js";
+/** Common fields present in every Codex CLI hook stdin payload */
+export interface CodexHookInput {
+    session_id: string;
+    hook_event_name: string;
+    transcript_path?: string | null;
+    cwd?: string;
+    model?: string;
+    source?: string;
+    turn_id?: string;
+    tool_name?: string;
+    tool_use_id?: string;
+    tool_input?: {
+        command?: string;
+        [key: string]: unknown;
+    };
+    tool_response?: unknown;
+    prompt?: string;
+    stop_hook_active?: boolean;
+    last_assistant_message?: string | null;
+    [key: string]: unknown;
+}
+/**
+ * Transform a Codex CLI hook stdin payload into a ProviderLogEntry.
+ */
+export declare function transformCodexEvent(input: CodexHookInput): ProviderLogEntry;

package/dist/adapters/codex-cli/transform.js

@@ -0,0 +1,35 @@
+import { makeEntry } from "../../core/entry.js";
+// ---------------------------------------------------------------------------
+// Codex CLI hook event → normalised category mapping
+// ---------------------------------------------------------------------------
+const HOOK_CATEGORY_MAP = {
+    SessionStart: "session.start",
+    PreToolUse: "tool.pre",
+    PostToolUse: "tool.post",
+    UserPromptSubmit: "prompt.user",
+    Stop: "message.assistant",
+};
+/**
+ * Transform a Codex CLI hook stdin payload into a ProviderLogEntry.
+ */
+export function transformCodexEvent(input) {
+    const hookName = input.hook_event_name;
+    const category = HOOK_CATEGORY_MAP[hookName] ?? "raw";
+    const sessionID = input.session_id ?? "unknown";
+    // Build output based on event type
+    let output = null;
+    if (hookName === "PostToolUse") {
+        output = input.tool_response ?? null;
+    }
+    else if (hookName === "Stop") {
+        output = input.last_assistant_message ?? null;
+    }
+    return makeEntry("codex-cli", sessionID, category, hookName, input, output, {
+        model: input.model ?? undefined,
+        toolName: input.tool_name ?? undefined,
+        turnID: input.turn_id ?? undefined,
+        transcriptPath: input.transcript_path ?? undefined,
+        cwd: input.cwd ?? undefined,
+        userID: process.env.USER ?? process.env.USERNAME ?? undefined,
+    });
+}

package/dist/adapters/opencode/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { SessionBuffer, PluginConfig } from "@p4r4d0xb0x/provider-logger-core";
+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/adapters/opencode/hooks.js

@@ -0,0 +1,87 @@
+import { makeEntry } from "@p4r4d0xb0x/provider-logger-core";
+/** OpenCode event types worth logging */
+const LOG_EVENT_TYPES = new Set([
+    "message.updated",
+    "session.idle",
+    "session.status",
+    "session.created",
+    "session.compacted",
+]);
+/** Map OpenCode hook names to normalised event categories */
+const HOOK_CATEGORY_MAP = {
+    "chat.message": "message.updated",
+    "chat.params": "prompt.params",
+    "experimental.chat.system.transform": "prompt.system",
+    "experimental.chat.messages.transform": "prompt.system",
+    "experimental.text.complete": "message.assistant",
+    "tool.execute.before": "tool.pre",
+    "tool.execute.after": "tool.post",
+    event: "raw",
+};
+/** Map OpenCode event types to normalised categories */
+const EVENT_TYPE_CATEGORY_MAP = {
+    "message.updated": "message.updated",
+    "session.idle": "session.idle",
+    "session.status": "session.status",
+    "session.created": "session.created",
+    "session.compacted": "session.compact",
+};
+export function createHooks(buffer, config, flush, log) {
+    const safeRecord = (sessionID, hook, input, output, categoryOverride) => {
+        try {
+            const category = categoryOverride ?? HOOK_CATEGORY_MAP[hook];
+            const entry = makeEntry("opencode", sessionID, category, hook, input, output);
+            buffer.append(entry);
+            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) => {
+            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 {
+                const ev = event;
+                if (!LOG_EVENT_TYPES.has(ev.type))
+                    return;
+                const sessionID = ev.properties?.sessionID ?? ev.properties?.info?.sessionID;
+                if (!sessionID)
+                    return;
+                const category = EVENT_TYPE_CATEGORY_MAP[ev.type] ?? "raw";
+                safeRecord(sessionID, "event", { type: ev.type }, ev.properties, category);
+                if (ev.type === "session.idle") {
+                    await flush(sessionID);
+                }
+            }
+            catch (err) {
+                log?.("error", "Event hook failed", { error: String(err) });
+            }
+        },
+    };
+}

package/dist/adapters/opencode/index.d.ts

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

package/dist/adapters/opencode/index.js

@@ -0,0 +1,63 @@
+import { SessionBuffer, LocalWriter, WorkerUploader, defaultConfig, } from "@p4r4d0xb0x/provider-logger-core";
+import { createHooks } from "./hooks.js";
+import { basename } from "node:path";
+const providerLogger = async ({ client }) => {
+    const config = defaultConfig("opencode");
+    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 WorkerUploader(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/core/buffer.d.ts

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

package/dist/core/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) + hookName(~30)
+    //   + platform(~12) + category(~20) + JSON structure(~100)
+    const FIXED = 240;
+    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);
+        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/core/entry.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderLogEntry, Platform, EventCategory } from "./types.js";
+/**
+ * Create a ProviderLogEntry with auto-generated id, timestamp, and nanos.
+ */
+export declare function makeEntry(platform: Platform, sessionID: string, category: EventCategory, hookName: string, input: unknown, output: unknown, meta?: ProviderLogEntry["meta"]): ProviderLogEntry;

package/dist/core/entry.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+/**
+ * Create a ProviderLogEntry with auto-generated id, timestamp, and nanos.
+ */
+export function makeEntry(platform, sessionID, category, hookName, input, output, meta) {
+    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,
+        platform,
+        category,
+        hookName,
+        data: { input, output },
+        ...(meta ? { meta } : {}),
+    };
+}

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export type { ProviderLogEntry, Platform, EventCategory, OpenCodeHookName, PluginConfig, } from "./types.js";
+export { defaultConfig, DEFAULT_CONFIG, LOG_EVENT_TYPES } from "./types.js";
+export { SessionBuffer, estimateEntrySize } from "./buffer.js";
+export { LocalWriter, makeTimestampNanos, _resetCounter } from "./logger.js";
+export type { PendingFile } from "./logger.js";
+export { R2Uploader } from "./uploader.js";
+export type { LogFn } from "./uploader.js";
+export { makeEntry } from "./entry.js";

package/dist/core/index.js

@@ -0,0 +1,5 @@
+export { defaultConfig, DEFAULT_CONFIG, LOG_EVENT_TYPES } from "./types.js";
+export { SessionBuffer, estimateEntrySize } from "./buffer.js";
+export { LocalWriter, makeTimestampNanos, _resetCounter } from "./logger.js";
+export { R2Uploader } from "./uploader.js";
+export { makeEntry } from "./entry.js";

package/dist/core/logger.d.ts

@@ -0,0 +1,21 @@
+import type { ProviderLogEntry, 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 a batch of entries to a new JSONL file (used by buffered mode) */
+    write(sessionID: string, entries: ProviderLogEntry[]): Promise<string>;
+    /** Append a single entry to a session-scoped JSONL file (used by hook scripts) */
+    append(sessionID: string, entry: ProviderLogEntry): Promise<string>;
+    getPending(): Promise<PendingFile[]>;
+    markUploaded(filepath: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export declare function makeTimestampNanos(): string;
+/** @internal — exposed for testing */
+export declare function _resetCounter(): void;

package/dist/core/logger.js

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

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

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

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

@@ -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/dist/index.d.ts

@@ -1,3 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
-declare const providerLogger: Plugin;
-export default providerLogger;
+export { default } from "./adapters/opencode/index.js";
+export type { ProviderLogEntry, Platform, EventCategory, PluginConfig, } from "@p4r4d0xb0x/provider-logger-core";
+export { defaultConfig, SessionBuffer, LocalWriter, WorkerUploader, makeEntry, } from "@p4r4d0xb0x/provider-logger-core";
+export { createHooks as createOpenCodeHooks } from "./adapters/opencode/hooks.js";

package/dist/index.js

@@ -1,66 +1,5 @@
-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;
+// Default export: OpenCode plugin (backward compatible)
+export { default } from "./adapters/opencode/index.js";
+export { defaultConfig, SessionBuffer, LocalWriter, WorkerUploader, makeEntry, } from "@p4r4d0xb0x/provider-logger-core";
+// Re-export OpenCode adapter
+export { createHooks as createOpenCodeHooks } from "./adapters/opencode/hooks.js";

package/package.json

@@ -1,16 +1,25 @@
 {
   "name": "@p4r4d0xb0x/opencode-provider-logger",
-  "version": "0.1.0",
-  "description": "OpenCode plugin that logs all provider requests/responses for model training",
+  "version": "1.0.0",
+  "description": "Provider logger plugin for OpenCode",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "files": ["dist"],
   "scripts": {
     "build": "tsc",
     "test": "bun test",
     "prepublishOnly": "tsc"
   },
+  "dependencies": {
+    "@p4r4d0xb0x/provider-logger-core": "file:../provider-logger-core"
+  },
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.3.0"
   },