@p4r4d0xb0x/opencode-provider-logger 1.2.0 → 2.0.0

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

@@ -1,6 +1,14 @@
-import type { Hooks } from "@opencode-ai/plugin";
-import type { SessionBuffer, PluginConfig } from "@p4r4d0xb0x/provider-logger-core";
+import type { Plugin } from "@opencode-ai/plugin";
+import type { PluginConfig, SessionBuffer } from "@p4r4d0xb0x/provider-logger-core";
+interface Disposable {
+    dispose(): Promise<void>;
+}
+interface HookRuntime {
+    registrations: Disposable[];
+    eventLoop: Promise<void>;
+}
 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 declare function sanitizeForLog(value: unknown, seen?: WeakSet<object>): unknown;
+export declare function registerHooks(context: Plugin.Context, signal: AbortSignal, buffer: SessionBuffer, config: PluginConfig, flush: FlushFn, log?: LogFn): Promise<HookRuntime>;
 export {};

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

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

package/dist/index.js

@@ -1,3 +1,7 @@
+// src/adapters/opencode/index.ts
+import { basename } from "node:path";
+import { Plugin } from "@opencode-ai/plugin";
+
 // ../provider-logger-core/dist/types.js
 import { join } from "node:path";
 import { readFileSync, writeFileSync } from "node:fs";
@@ -256,157 +260,206 @@ function makeEntry(platform, sessionID, category, hookName, input, output, meta)
 }
 
 // src/adapters/opencode/hooks.ts
-var LOG_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "message.updated",
-  "session.idle",
-  "session.status",
-  "session.created",
-  "session.compacted"
-]);
-var 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",
+var HOOK_CATEGORIES = {
+  "session.prompt": "prompt.user",
+  "session.context": "prompt.system",
+  "session.model.request": "prompt.params",
   "tool.execute.before": "tool.pre",
   "tool.execute.after": "tool.post",
   event: "raw"
 };
-var EVENT_TYPE_CATEGORY_MAP = {
-  "message.updated": "message.updated",
-  "session.idle": "session.idle",
-  "session.status": "session.status",
+var EVENT_CATEGORIES = {
   "session.created": "session.created",
-  "session.compacted": "session.compact"
+  "session.status": "session.status",
+  "session.idle": "session.idle",
+  "session.step.ended": "message.assistant",
+  "session.compaction.ended": "session.compact"
 };
-function createHooks(buffer, config, flush, log) {
-  const safeRecord = (sessionID, hook, input, output, categoryOverride) => {
+var SENSITIVE_KEY = /authorization|api[-_]?key|token|secret|cookie|credential/i;
+function sanitizeForLog(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Request) {
+    return {
+      method: value.method,
+      url: value.url,
+      headers: sanitizeForLog(Object.fromEntries(value.headers), seen)
+    };
+  }
+  if (value instanceof Response) {
+    return {
+      status: value.status,
+      statusText: value.statusText,
+      headers: sanitizeForLog(Object.fromEntries(value.headers), seen)
+    };
+  }
+  if (value instanceof Error) return { name: value.name, message: value.message };
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((item) => sanitizeForLog(item, seen));
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [
+      key,
+      SENSITIVE_KEY.test(key) ? "[REDACTED]" : sanitizeForLog(item, seen)
+    ])
+  );
+}
+function makeRecorder(buffer, config, flush, log) {
+  return (sessionID, hook, input, output, category = HOOK_CATEGORIES[hook]) => {
     try {
-      const category = categoryOverride ?? HOOK_CATEGORY_MAP[hook];
       const entry = makeEntry(
         "opencode",
         sessionID,
         category,
         hook,
-        input,
-        output
+        sanitizeForLog(input),
+        sanitizeForLog(output)
       );
       buffer.append(entry);
       if (buffer.sizeOf(sessionID) >= config.flushThresholdBytes) {
-        flush(sessionID).catch(() => {
-        });
+        void flush(sessionID);
       }
-    } catch (err) {
-      log?.("error", `Hook record failed [${hook}]`, { error: String(err) });
+    } catch (error) {
+      log?.("error", `Hook record failed [${hook}]`, { error: String(error) });
     }
   };
-  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) });
-      }
+}
+function sessionIDFromEvent(event) {
+  if (!event.data || typeof event.data !== "object") return void 0;
+  const sessionID = event.data.sessionID;
+  return typeof sessionID === "string" ? sessionID : void 0;
+}
+async function consumeEvents(context, signal, record, flush, log) {
+  try {
+    for await (const event of context.event.subscribe({ signal })) {
+      const category = EVENT_CATEGORIES[event.type];
+      if (!category) continue;
+      const sessionID = sessionIDFromEvent(event);
+      if (!sessionID) continue;
+      record(sessionID, "event", { type: event.type }, event.data, category);
+      if (event.type === "session.idle") await flush(sessionID);
     }
+  } catch (error) {
+    if (!signal.aborted) log?.("error", "Event subscription failed", { error: String(error) });
+  }
+}
+async function registerHooks(context, signal, buffer, config, flush, log) {
+  const record = makeRecorder(buffer, config, flush, log);
+  const registrations = [];
+  try {
+    registrations.push(await context.session.hook("prompt", (event) => {
+      record(event.sessionID, "session.prompt", event, event.prompt);
+    }));
+    registrations.push(await context.session.hook("context", (event) => {
+      record(event.sessionID, "session.context", {
+        sessionID: event.sessionID,
+        agent: event.agent,
+        model: event.model
+      }, event);
+    }));
+    registrations.push(await context.session.hook("model.request", (event) => {
+      record(event.sessionID, "session.model.request", {
+        sessionID: event.sessionID,
+        agent: event.agent,
+        model: event.model
+      }, { baseURL: event.baseURL, headers: event.headers });
+    }));
+    registrations.push(await context.tool.hook("execute.before", (event) => {
+      record(event.sessionID, "tool.execute.before", event, event.input);
+    }));
+    registrations.push(await context.tool.hook("execute.after", (event) => {
+      const category = event.status === "error" ? "tool.error" : "tool.post";
+      record(event.sessionID, "tool.execute.after", event, event, category);
+    }));
+  } catch (error) {
+    await Promise.allSettled(registrations.map((registration) => registration.dispose()));
+    throw error;
+  }
+  return {
+    registrations,
+    eventLoop: consumeEvents(context, signal, record, flush, log)
   };
 }
 
 // src/adapters/opencode/index.ts
-import { basename } from "node:path";
-var 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 }
-    });
+function createLogger() {
+  return (level, message, extra) => {
+    const detail = extra ? ` ${JSON.stringify(extra)}` : "";
+    const line = `[provider-logger] ${message}${detail}`;
+    if (level === "error") console.error(line);
+    else if (level === "warn") console.warn(line);
+    else if (level === "debug") console.debug(line);
+    else console.info(line);
   };
-  const uploader = new WorkerUploader(config, writer, log);
-  uploader.retryPending().catch((err) => {
-    log("warn", "Failed to retry pending uploads", { error: String(err) });
-  });
-  uploader.cleanup().catch((err) => {
-    log("warn", "Failed to cleanup old files", { error: String(err) });
+}
+async function persistEntries(sessionID, entries, writer, uploader) {
+  if (entries.length === 0) return;
+  const filepath = await writer.write(sessionID, entries);
+  if (!filepath) return;
+  await uploader.upload({
+    path: filepath,
+    sessionID,
+    tsNanos: basename(filepath, ".jsonl")
   });
-  const flush = async (sessionID) => {
+}
+function makeFlush(buffer, writer, uploader, log) {
+  return 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)
-      });
-    }
-  };
-  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 persistEntries(sessionID, buffer.flush(sessionID), writer, uploader);
+    } catch (error) {
+      log("error", `Flush failed for session ${sessionID}`, { error: String(error) });
     }
-    await Promise.allSettled(writes);
   };
-  process.on("beforeExit", () => {
-    flushAll().catch(() => {
+}
+async function flushAll(buffer, writer, uploader, log) {
+  const writes = Array.from(
+    buffer.flushAll(),
+    ([sessionID, entries]) => persistEntries(sessionID, entries, writer, uploader).catch((error) => {
+      log("error", `Shutdown flush failed for ${sessionID}`, { error: String(error) });
+    })
+  );
+  await Promise.allSettled(writes);
+}
+var providerLogger = Plugin.define({
+  id: "opencode-provider-logger",
+  async setup(context) {
+    const config = defaultConfig("opencode");
+    const buffer = new SessionBuffer();
+    const writer = new LocalWriter(config);
+    const log = createLogger();
+    const uploader = new WorkerUploader(config, writer, log);
+    const flush = makeFlush(buffer, writer, uploader, log);
+    void uploader.retryPending().catch((error) => {
+      log("warn", "Failed to retry pending uploads", { error: String(error) });
     });
-  });
-  log("info", "Provider logger initialized");
-  return createHooks(buffer, config, flush, log);
-};
+    void uploader.cleanup().catch((error) => {
+      log("warn", "Failed to cleanup old files", { error: String(error) });
+    });
+    const abortController = new AbortController();
+    const runtime = await registerHooks(
+      context,
+      abortController.signal,
+      buffer,
+      config,
+      flush,
+      log
+    );
+    const flushOnBeforeExit = () => {
+      void flushAll(buffer, writer, uploader, log);
+    };
+    process.on("beforeExit", flushOnBeforeExit);
+    log("info", "Provider logger initialized");
+    return async () => {
+      process.off("beforeExit", flushOnBeforeExit);
+      abortController.abort();
+      await Promise.allSettled([
+        ...runtime.registrations.map((registration) => registration.dispose()),
+        runtime.eventLoop
+      ]);
+      await flushAll(buffer, writer, uploader, log);
+    };
+  }
+});
 var opencode_default = providerLogger;
 export {
   opencode_default as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p4r4d0xb0x/opencode-provider-logger",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Provider logger plugin for OpenCode",
   "type": "module",
   "main": "dist/index.js",
@@ -13,16 +13,15 @@
   },
   "files": ["dist"],
   "scripts": {
-    "build": "tsc --emitDeclarationOnly && esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@opencode-ai/plugin --external:@opencode-ai/sdk",
-    "test": "bun test",
+    "build": "tsc --emitDeclarationOnly && esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@opencode-ai/plugin",
+    "test": "node --test 'test/*.test.mjs'",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.3.0"
+    "@opencode-ai/plugin": "0.0.0-beta-18992"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "1.3.0",
-    "@opencode-ai/sdk": "1.3.0",
+    "@opencode-ai/plugin": "0.0.0-beta-18992",
     "@p4r4d0xb0x/provider-logger-core": "*",
     "@types/bun": "^1.3.11",
     "@types/node": "^25.5.0",