@codemem/opencode-plugin 0.41.0 → 0.42.0

package/.opencode/plugins/codemem.js

@@ -16,7 +16,7 @@ import {
 
 const TRUTHY_VALUES = ["1", "true", "yes"];
 const DISABLED_VALUES = ["0", "false", "off"];
-const PINNED_BACKEND_VERSION = "0.41.0";
+const PINNED_BACKEND_VERSION = "0.42.0";
 const COMPAT_CHECK_DELAY_MS = 1500;
 const COMPAT_CHECK_CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_UPDATE_STATUS_BYTES = 16 * 1024;
@@ -623,6 +623,31 @@ const parsePackMetrics = (stdout) => {
   }
 };
 
+const buildViewerIdentityTarget = (env = process.env, cwd = process.cwd()) => {
+  const normalizeIdentityPath = (value) => {
+    const trimmed = String(value || "").trim();
+    if (!trimmed) return null;
+    const expanded = trimmed.startsWith("~/")
+      ? join(env.HOME?.trim() || homedir(), trimmed.slice(2))
+      : trimmed;
+    return resolve(cwd, expanded);
+  };
+  return {
+    device_id: env.CODEMEM_DEVICE_ID?.trim() || null,
+    actor_id_present: Object.hasOwn(env, "CODEMEM_ACTOR_ID"),
+    actor_id: env.CODEMEM_ACTOR_ID?.trim() || null,
+    config_path: normalizeIdentityPath(env.CODEMEM_CONFIG),
+    runtime_root: normalizeIdentityPath(env.CODEMEM_RUNTIME_ROOT),
+    workspace_id: env.CODEMEM_WORKSPACE_ID?.trim() || null,
+    home_dir: normalizeIdentityPath(env.HOME || homedir()),
+    pack_compression: env.CODEMEM_PACK_COMPRESSION?.trim() || null,
+    embedding_disabled: ["1", "true", "yes"].includes(
+      String(env.CODEMEM_EMBEDDING_DISABLED || "").toLowerCase(),
+    ),
+    embedding_model: env.CODEMEM_EMBEDDING_MODEL || "Xenova/bge-small-en-v1.5",
+  };
+};
+
 const parsePackOutput = (result) => {
   const succeeded = result?.exitCode === 0;
   let payload = null;
@@ -709,8 +734,67 @@ const isViewerContractUnsupportedPayload = (payload) =>
 const isViewerInvalidRequestPayload = (payload) =>
   isRecord(payload)
   && isRecord(payload.error)
-  && payload.error.code === "invalid_request"
-  && typeof payload.error.message === "string";
+  && payload.error.code === "invalid_request";
+
+// Dependency-free port of @codemem/core prompt-transport semantics. Keep the
+// range and classifier parity pinned by the plugin injection tests.
+const PROMPT_TRANSPORT_PROTOCOL_RANGE = Object.freeze({
+  minSupportedProtocolVersion: 1,
+  protocolVersion: 1,
+});
+
+const normalizePromptTransportProtocolRange = (
+  protocolVersion,
+  minSupportedProtocolVersion = undefined,
+) => {
+  if (!Number.isSafeInteger(protocolVersion) || protocolVersion < 1) return null;
+  const minimum = minSupportedProtocolVersion === undefined
+    ? protocolVersion
+    : minSupportedProtocolVersion;
+  if (!Number.isSafeInteger(minimum) || minimum < 1 || minimum > protocolVersion) return null;
+  return { minSupportedProtocolVersion: minimum, protocolVersion };
+};
+
+const arePromptTransportProtocolRangesCompatible = (left, right) =>
+  left.minSupportedProtocolVersion <= right.protocolVersion
+  && right.minSupportedProtocolVersion <= left.protocolVersion;
+
+const classifyPromptTransportFailure = ({ kind, compatibleProfile = false }) => {
+  if (kind === "database_mismatch" || kind === "runtime_identity_mismatch") {
+    return "local_fallback";
+  }
+  if (kind === "invalid_request") {
+    return compatibleProfile ? "terminal" : "fallback";
+  }
+  if (kind === "policy_failure" || kind === "authorization_failure") {
+    return "terminal";
+  }
+  if (kind === "viewer_contract_unsupported") {
+    return compatibleProfile ? "terminal" : "fallback";
+  }
+  return "fallback";
+};
+
+const isViewerPolicyOrAuthFailurePayload = (payload) => {
+  const code = isRecord(payload) && isRecord(payload.error)
+    ? payload.error.code
+    : isRecord(payload)
+    ? payload.error
+    : null;
+  return typeof code === "string" && [
+    "authorization_failed",
+    "forbidden",
+    "policy_denied",
+    "policy_disabled",
+    "unauthorized",
+  ].includes(code);
+};
+
+const viewerFailureClassification = (cause, disposition) => ({
+  cause,
+  disposition,
+  retryable: disposition !== "terminal",
+});
 
 const classifyViewerHttpFailure = ({
   operation,
@@ -718,31 +802,60 @@ const classifyViewerHttpFailure = ({
   error = null,
   malformed = false,
   body = null,
+  compatibleProfile = false,
 }) => {
   if (malformed) {
-    return { cause: `${operation} returned malformed success`, retryable: true };
+    return viewerFailureClassification(
+      `${operation} returned malformed success`,
+      classifyPromptTransportFailure({ kind: "malformed_response" }),
+    );
   }
-  if (
-    isViewerDbMismatchPayload(body)
-    || isViewerIdentityMismatchPayload(body)
-    || isViewerContractUnsupportedPayload(body)
-  ) {
-    return { cause: `${operation} viewer profile mismatch`, retryable: true };
+  if (isViewerDbMismatchPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} viewer database mismatch`,
+      classifyPromptTransportFailure({ kind: "database_mismatch" }),
+    );
+  }
+  if (isViewerIdentityMismatchPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} viewer runtime identity mismatch`,
+      classifyPromptTransportFailure({ kind: "runtime_identity_mismatch" }),
+    );
+  }
+  if (isViewerContractUnsupportedPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} viewer contract unsupported`,
+      classifyPromptTransportFailure({
+        kind: "viewer_contract_unsupported",
+        compatibleProfile,
+      }),
+    );
   }
   if (operation === "prompt-pack-ledger" && isValidLedgerFailureHttpPayload(body)) {
-    return { cause: `${operation} request rejected (${status})`, retryable: false };
+    return viewerFailureClassification(`${operation} request rejected (${status})`, "terminal");
   }
-  if (isViewerInvalidRequestPayload(body) && !operation.endsWith(" profile")) {
-    return { cause: `${operation} request rejected (${status})`, retryable: false };
+  if (status === 401 || status === 403 || isViewerPolicyOrAuthFailurePayload(body)) {
+    return viewerFailureClassification(
+      `${operation} policy or authorization failure (${status})`,
+      classifyPromptTransportFailure({
+        kind: status === 401 || status === 403 ? "authorization_failure" : "policy_failure",
+      }),
+    );
+  }
+  if (isViewerInvalidRequestPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} request rejected (${status})`,
+      classifyPromptTransportFailure({ kind: "invalid_request", compatibleProfile }),
+    );
   }
   if (status === 404 || status === 405) {
-    return { cause: `${operation} endpoint unavailable (${status})`, retryable: true };
+    return viewerFailureClassification(`${operation} endpoint unavailable (${status})`, "fallback");
   }
   if (Number.isInteger(status) && status >= 500) {
-    return { cause: `${operation} server failure (${status})`, retryable: true };
+    return viewerFailureClassification(`${operation} server failure (${status})`, "fallback");
   }
   if (Number.isInteger(status)) {
-    return { cause: `${operation} unexpected response (${status})`, retryable: true };
+    return viewerFailureClassification(`${operation} unexpected response (${status})`, "fallback");
   }
   const diagnostic = [
     error?.name,
@@ -752,10 +865,10 @@ const classifyViewerHttpFailure = ({
     error,
   ].filter(Boolean).join(" ");
   const timedOut = /AbortError|TimeoutError|timeout|timed out|ETIMEDOUT/i.test(diagnostic);
-  return {
-    cause: timedOut ? `${operation} request timeout` : `${operation} connection failed`,
-    retryable: true,
-  };
+  return viewerFailureClassification(
+    timedOut ? `${operation} request timeout` : `${operation} connection failed`,
+    "fallback",
+  );
 };
 
 const buildPackHttpBody = ({
@@ -1675,28 +1788,7 @@ export const CodememPlugin = async ({
     cwd,
     expandedViewerDbPath || join(homedir(), ".codemem", "mem.sqlite"),
   );
-  const normalizeIdentityPath = (value) => {
-    const trimmed = String(value || "").trim();
-    if (!trimmed) return null;
-    const expanded = trimmed.startsWith("~/")
-      ? join(process.env.HOME?.trim() || homedir(), trimmed.slice(2))
-      : trimmed;
-    return resolve(cwd, expanded);
-  };
-  const promptPackIdentityTarget = {
-    device_id: process.env.CODEMEM_DEVICE_ID?.trim() || null,
-    actor_id_present: Object.hasOwn(process.env, "CODEMEM_ACTOR_ID"),
-    actor_id: process.env.CODEMEM_ACTOR_ID?.trim() || null,
-    config_path: normalizeIdentityPath(process.env.CODEMEM_CONFIG),
-    runtime_root: normalizeIdentityPath(process.env.CODEMEM_RUNTIME_ROOT),
-    workspace_id: process.env.CODEMEM_WORKSPACE_ID?.trim() || null,
-    home_dir: normalizeIdentityPath(process.env.HOME || homedir()),
-    pack_compression: process.env.CODEMEM_PACK_COMPRESSION?.trim() || null,
-    embedding_disabled: ["1", "true", "yes"].includes(
-      String(process.env.CODEMEM_EMBEDDING_DISABLED || "").toLowerCase(),
-    ),
-    embedding_model: process.env.CODEMEM_EMBEDDING_MODEL || "Xenova/bge-small-en-v1.5",
-  };
+  const promptPackIdentityTarget = buildViewerIdentityTarget(process.env, cwd);
   const viewerConfigPath = process.env.CODEMEM_CONFIG || "";
   // A malformed value (e.g. "abc", "", "-1") falls back to the 20s default
   // instead of NaN, which would silently disable the timeout. An explicit "0"
@@ -1921,10 +2013,27 @@ export const CodememPlugin = async ({
       const postResp = await fetch(rawEventsUrl, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
+        body: JSON.stringify({
+          ...body,
+          db_path: promptPackDbPath,
+          identity_target: promptPackIdentityTarget,
+        }),
       });
       if (!postResp.ok) {
-        throw new Error(`raw-events post failed (${postResp.status})`);
+        let responseBody = null;
+        if (postResp.status === 409) {
+          try {
+            responseBody = await postResp.json();
+          } catch {
+            // Generic failure handling below remains the safe fallback.
+          }
+        }
+        const targetMismatch = isViewerDbMismatchPayload(responseBody)
+          || isViewerIdentityMismatchPayload(responseBody)
+          || isViewerContractUnsupportedPayload(responseBody);
+        const postError = new Error(`raw-events post failed (${postResp.status})`);
+        postError.viewerTargetMismatch = targetMismatch;
+        throw postError;
       }
       streamUnavailableUntil = 0;
       streamErrorNoted = false;
@@ -1947,6 +2056,7 @@ export const CodememPlugin = async ({
             type,
             viewerHost,
             viewerPort,
+            viewerTargetMismatch: err?.viewerTargetMismatch === true,
             error: String(err),
           },
         });
@@ -2386,19 +2496,19 @@ export const CodememPlugin = async ({
     if (!viewerEnabled) {
       return {
         ok: false,
-        classification: {
-          cause: `${operation} viewer transport disabled`,
-          retryable: true,
-        },
+        classification: viewerFailureClassification(
+          `${operation} viewer transport disabled`,
+          "fallback",
+        ),
       };
     }
     if (Date.now() < promptPackTransportUnavailableUntil) {
       return {
         ok: false,
-        classification: {
-          cause: `${operation} viewer transport in backoff`,
-          retryable: true,
-        },
+        classification: viewerFailureClassification(
+          `${operation} viewer transport in backoff`,
+          "fallback",
+        ),
       };
     }
 
@@ -2426,20 +2536,49 @@ export const CodememPlugin = async ({
         }
         return { ok: false, classification };
       }
-      if (
-        !isRecord(profileBody)
-        || profileBody.service !== "codemem-viewer"
-        || profileBody.protocol_version !== 1
-        || profileBody.db_path !== promptPackDbPath
-        || canonicalJson(profileBody.identity_target) !== canonicalJson(promptPackIdentityTarget)
+      const viewerProtocolRange = isRecord(profileBody)
+        ? normalizePromptTransportProtocolRange(
+            profileBody.protocol_version,
+            profileBody.min_supported_protocol_version,
+          )
+        : null;
+      let profileFailure = null;
+      if (!isRecord(profileBody) || profileBody.service !== "codemem-viewer") {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer profile malformed`,
+          classifyPromptTransportFailure({ kind: "profile_malformed" }),
+        );
+      } else if (!viewerProtocolRange) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer protocol range malformed`,
+          classifyPromptTransportFailure({ kind: "profile_malformed" }),
+        );
+      } else if (!arePromptTransportProtocolRangesCompatible(
+        PROMPT_TRANSPORT_PROTOCOL_RANGE,
+        viewerProtocolRange,
+      )) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer protocol range unsupported`,
+          classifyPromptTransportFailure({ kind: "protocol_range_mismatch" }),
+        );
+      } else if (profileBody.db_path !== promptPackDbPath) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer database mismatch`,
+          classifyPromptTransportFailure({ kind: "database_mismatch" }),
+        );
+      } else if (
+        canonicalJson(profileBody.identity_target) !== canonicalJson(promptPackIdentityTarget)
       ) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer runtime identity mismatch`,
+          classifyPromptTransportFailure({ kind: "runtime_identity_mismatch" }),
+        );
+      }
+      if (profileFailure) {
         promptPackTransportUnavailableUntil = Date.now() + Math.max(1000, rawEventsBackoffMs);
         return {
           ok: false,
-          classification: {
-            cause: `${operation} viewer profile handshake mismatch`,
-            retryable: true,
-          },
+          classification: profileFailure,
         };
       }
       response = await fetch(url, {
@@ -2467,6 +2606,7 @@ export const CodememPlugin = async ({
         operation,
         status: response.status,
         body,
+        compatibleProfile: true,
       });
       if (classification.retryable) {
         promptPackTransportUnavailableUntil =
@@ -3894,12 +4034,17 @@ export const __testUtils = {
   redactPackCommand,
   rejectsInternalLedgerFlag,
   classifyFallbackCommandResult,
+  PROMPT_TRANSPORT_PROTOCOL_RANGE,
+  normalizePromptTransportProtocolRange,
+  arePromptTransportProtocolRangesCompatible,
+  classifyPromptTransportFailure,
   classifyViewerHttpFailure,
   isValidPackHttpPayload,
   isValidLedgerHttpPayload,
   buildPackHttpBody,
   parsePackText,
   parsePackMetrics,
+  buildViewerIdentityTarget,
   resolveInjectSurface,
   applyInjectedContextToOutput,
   applyInjectedContextToMessages,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemem/opencode-plugin",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "CodeMem plugin for OpenCode",
   "type": "module",
   "main": "./index.js",
@@ -18,7 +18,7 @@
     ".opencode/lib/"
   ],
   "dependencies": {
-    "@opencode-ai/plugin": "1.18.16"
+    "@opencode-ai/plugin": "1.18.18"
   },
   "repository": {
     "type": "git",