@codemem/opencode-plugin 0.46.0 → 0.46.2

package/.opencode/lib/raw-event-delivery.js

@@ -1,8 +1,11 @@
+import { appendFile, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
+import { join } from "node:path";
 import {
   DEFAULT_DRAIN_LIMIT,
   DEFAULT_MAX_ENTRIES,
   loadRawEventSpoolEntries,
+  RAW_EVENT_SPOOL_CONFLICT_CODE,
   RAW_EVENT_SPOOL_FULL_CODE,
   removeRawEventSpoolEntry,
   resolveSpoolDirectory,
@@ -95,6 +98,24 @@ const warnSpoolPersistenceFailure = async (state, sessionID, reason) => {
   await bestEffortNotify(state, { message: `codemem: ${message}`, variant: "error" });
 };
 
+const SPOOL_STAGES = new Set(["directory", "existing_entry", "capacity", "temporary_write", "publish", "directory_sync"]);
+const SPOOL_ERRNOS = new Set(["EACCES", "EPERM", "ENOSPC", "EROFS", "ENOTDIR", "EEXIST", "EIO", "EINVAL", "EMFILE", "ENFILE"]);
+
+const spoolFailureDiagnostic = (error) => {
+  const stage = SPOOL_STAGES.has(error?.spoolStage) ? error.spoolStage : "unknown";
+  let code = "other";
+  if (error?.code === RAW_EVENT_SPOOL_CONFLICT_CODE) code = "conflict";
+  else if (error?.code === RAW_EVENT_SPOOL_FULL_CODE) code = "full";
+  else if (SPOOL_ERRNOS.has(error?.code)) code = error.code;
+  return `raw_events.spool.failure stage=${stage} code=${code} category=persistence`;
+};
+
+const persistSafeSpoolDiagnostic = async (state, line) => {
+  const directory = join(state.options.spoolHome, ".codemem");
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  await appendFile(join(directory, "plugin.log"), `${new Date().toISOString()} ${line}\n`, { mode: 0o600 });
+};
+
 const persistForRetry = async (state, { body, serialized, payload, sessionID }) => {
   try {
     await writeRawEventSpoolEntry({
@@ -109,6 +130,14 @@ const persistForRetry = async (state, { body, serialized, payload, sessionID })
   } catch (error) {
     const reason = error?.code === RAW_EVENT_SPOOL_FULL_CODE ? "spool_full" : "write_failed";
     await state.options.logLine(`raw_events.spool.${reason} category=persistence`);
+    const diagnostic = spoolFailureDiagnostic(error);
+    try {
+      await persistSafeSpoolDiagnostic(state, diagnostic);
+    } catch {
+      // The same disk/permission failure can block the local log. Keep the
+      // category visible in the host's stderr without exposing event content.
+      console.error(`codemem: ${diagnostic}`);
+    }
     await warnSpoolPersistenceFailure(state, sessionID, reason);
     return false;
   }

package/.opencode/lib/raw-event-spool.js

@@ -11,10 +11,12 @@ import {
 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 
 const DEFAULT_DRAIN_LIMIT = 20;
 const DEFAULT_MAX_ENTRIES = 2000;
 const RAW_EVENT_SPOOL_FULL_CODE = "raw_event_spool_full";
+const RAW_EVENT_SPOOL_CONFLICT_CODE = "raw_event_spool_conflict";
 const SPOOL_DIRECTORY_NAME = "opencode-raw-event-spool";
 const spoolWritesInFlight = new Map();
 
@@ -36,6 +38,28 @@ const requireEventId = (envelope) => {
   return eventId;
 };
 
+/** Delivery timestamps can change when the same host event is captured again. */
+const sameEventApartFromDeliveryTime = (existingBytes, incomingBytes) => {
+  if (existingBytes === incomingBytes) return true;
+  try {
+    const existing = JSON.parse(existingBytes);
+    const incoming = JSON.parse(incomingBytes);
+    if (!existing || typeof existing !== "object" || Array.isArray(existing)) return false;
+    if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return false;
+    const withoutDeliveryTime = ({ ts_wall_ms: _wall, ts_mono_ms: _mono, ...event }) => event;
+    return isDeepStrictEqual(withoutDeliveryTime(existing), withoutDeliveryTime(incoming));
+  } catch {
+    // Malformed retained data is not proof that the new event is already durable.
+    return false;
+  }
+};
+
+const conflictingEntry = () => {
+  const error = new Error("raw event spool entry conflicts with existing event_id");
+  error.code = RAW_EVENT_SPOOL_CONFLICT_CODE;
+  return error;
+};
+
 const ensurePrivateDirectory = async (directory) => {
   const firstCreated = await mkdir(directory, { recursive: true, mode: 0o700 });
   await chmod(directory, 0o700);
@@ -75,6 +99,61 @@ const syncDirectory = async (path) => {
   }
 };
 
+const atSpoolStage = async (stage, action) => {
+  try {
+    return await action();
+  } catch (error) {
+    if (error && typeof error === "object") error.spoolStage = stage;
+    throw error;
+  }
+};
+
+const readExistingEntry = async (directory, destination, bytes, eventId) => {
+  try {
+    return await atSpoolStage("existing_entry", async () => {
+      const existing = await readFile(destination, "utf8");
+      if (!sameEventApartFromDeliveryTime(existing, bytes)) throw conflictingEntry();
+      await chmod(destination, 0o600);
+      await syncDirectory(directory);
+      return { eventId, serialized: existing };
+    });
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+    return null;
+  }
+};
+
+const requireSpoolCapacity = async (directory, maxEntries) =>
+  atSpoolStage("capacity", async () => {
+    const directoryEntries = await readdir(directory, { withFileTypes: true });
+    const entryCount = directoryEntries.filter(
+      (entry) => entry.isFile() && entry.name.endsWith(".json"),
+    ).length;
+    if (entryCount < maxEntries) return;
+    const error = new Error("raw event spool is full");
+    error.code = RAW_EVENT_SPOOL_FULL_CODE;
+    throw error;
+  });
+
+const publishSpoolEntry = async (temporary, destination, bytes) => {
+  try {
+    await atSpoolStage("temporary_write", () => writeDurableFile(temporary, bytes));
+    await atSpoolStage("publish", async () => {
+      try {
+        await link(temporary, destination);
+      } catch (error) {
+        if (error?.code !== "EEXIST") throw error;
+        const existing = await readFile(destination, "utf8");
+        if (!sameEventApartFromDeliveryTime(existing, bytes)) throw conflictingEntry();
+        await chmod(destination, 0o600);
+      }
+      await chmod(destination, 0o600);
+    });
+  } finally {
+    await rm(temporary, { force: true }).catch(() => {});
+  }
+};
+
 const writeRawEventSpoolEntryUnlocked = async ({
   envelope,
   serialized,
@@ -93,50 +172,12 @@ const writeRawEventSpoolEntryUnlocked = async ({
     `.${spoolFilename(eventId)}.${process.pid}.${randomUUID()}.tmp`,
   );
 
-  await ensurePrivateDirectory(directory);
-  try {
-    const existing = await readFile(destination, "utf8");
-    if (existing !== bytes) {
-      throw new Error("raw event spool entry conflicts with existing event_id");
-    }
-    await chmod(destination, 0o600);
-    await syncDirectory(directory);
-    return { eventId, serialized: existing };
-  } catch (error) {
-    if (error?.code !== "ENOENT") {
-      throw error;
-    }
-  }
-
-  const directoryEntries = await readdir(directory, { withFileTypes: true });
-  const entryCount = directoryEntries.filter(
-    (entry) => entry.isFile() && entry.name.endsWith(".json"),
-  ).length;
-  if (entryCount >= normalizedMaxEntries) {
-    const error = new Error("raw event spool is full");
-    error.code = RAW_EVENT_SPOOL_FULL_CODE;
-    throw error;
-  }
-
-  try {
-    await writeDurableFile(temporary, bytes);
-    try {
-      await link(temporary, destination);
-    } catch (error) {
-      if (error?.code !== "EEXIST") {
-        throw error;
-      }
-      const existing = await readFile(destination, "utf8");
-      if (existing !== bytes) {
-        throw new Error("raw event spool entry conflicts with existing event_id");
-      }
-      await chmod(destination, 0o600);
-    }
-    await chmod(destination, 0o600);
-  } finally {
-    await rm(temporary, { force: true }).catch(() => {});
-  }
-  await syncDirectory(directory);
+  await atSpoolStage("directory", () => ensurePrivateDirectory(directory));
+  const existing = await readExistingEntry(directory, destination, bytes, eventId);
+  if (existing) return existing;
+  await requireSpoolCapacity(directory, normalizedMaxEntries);
+  await publishSpoolEntry(temporary, destination, bytes);
+  await atSpoolStage("directory_sync", () => syncDirectory(directory));
 
   return { eventId, serialized: bytes };
 };
@@ -225,6 +266,7 @@ export {
   DEFAULT_DRAIN_LIMIT,
   DEFAULT_MAX_ENTRIES,
   loadRawEventSpoolEntries,
+  RAW_EVENT_SPOOL_CONFLICT_CODE,
   RAW_EVENT_SPOOL_FULL_CODE,
   removeRawEventSpoolEntry,
   resolveSpoolDirectory,

package/.opencode/lib/runtime.js

@@ -30,7 +30,7 @@ import {
 
 const TRUTHY_VALUES = ["1", "true", "yes"];
 const DISABLED_VALUES = ["0", "false", "off"];
-const PINNED_BACKEND_VERSION = "0.46.0";
+const PINNED_BACKEND_VERSION = "0.46.2";
 const COMPAT_CHECK_DELAY_MS = 1500;
 const COMPAT_CHECK_CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_UPDATE_STATUS_BYTES = 16 * 1024;
@@ -1948,6 +1948,7 @@ const buildRawEventEnvelope = ({
   nowMono,
   nextEventId,
   captureContext,
+  hostGeneration,
 }) => ({
   session_stream_id: sessionID,
   session_id: sessionID,
@@ -1960,6 +1961,7 @@ const buildRawEventEnvelope = ({
   cwd,
   project,
   started_at: startedAt,
+  ...(hostGeneration === "v2" ? { host_generation: "v2" } : {}),
   ...(captureContext ? { capture_context: captureContext } : {}),
 });
 
@@ -2169,7 +2171,7 @@ const buildRunnerArgs = ({ runner, runnerFrom, runnerFromExplicit }) => {
   return runnerFromExplicit ? [runnerFrom] : [];
 };
 
-export const createCodememRuntime = async ({ location, host }) => {
+export const createCodememRuntime = async ({ location, host, hostGeneration = null }) => {
   const { project, directory, worktree } = location;
   const hostLog = typeof host?.log === "function" ? host.log : async () => {};
   const hostNotify = typeof host?.notify === "function" ? host.notify : null;
@@ -2803,7 +2805,7 @@ export const createCodememRuntime = async ({ location, host }) => {
 
   rawEventDelivery = createRawEventDelivery({
     backoffMs: rawEventsBackoffMs,
-    buildEnvelope: buildRawEventEnvelope,
+    buildEnvelope: (input) => buildRawEventEnvelope({ ...input, hostGeneration }),
     classifyViewerFailure: classifyRawEventViewerFailure,
     cwd,
     discardResponseBody,

package/index.js

@@ -2,12 +2,15 @@ import {
 	CodememPlugin,
 	OpencodeMemPlugin,
 } from "./.opencode/plugins/codemem.js";
-import { setupOpenCodeV2 } from "./.opencode/lib/opencode-v2-adapter.js";
+import { createOpenCodeV2Adapter } from "./.opencode/lib/opencode-v2-adapter.js";
+import { createCodememRuntime } from "./.opencode/lib/runtime.js";
 
 const CodememDualPlugin = {
 	id: "codemem",
 	server: CodememPlugin,
-	setup: setupOpenCodeV2,
+	setup: createOpenCodeV2Adapter({
+		createRuntime: (options) => createCodememRuntime({ ...options, hostGeneration: "v2" }),
+	}),
 };
 
 export default CodememDualPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemem/opencode-plugin",
-  "version": "0.46.0",
+  "version": "0.46.2",
   "description": "CodeMem plugin for OpenCode",
   "type": "module",
   "main": "./index.js",