@p4r4d0xb0x/opencode-provider-logger 1.0.1 → 1.1.1

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

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

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

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

@@ -1,48 +0,0 @@
-#!/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

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

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

@@ -1,118 +0,0 @@
-#!/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

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

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

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

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

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

@@ -1,45 +0,0 @@
-/** 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/core/buffer.d.ts

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

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

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

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

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

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

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