@openviking/opencode-plugin 0.2.1 → 0.2.3

package/lib/memory-session.mjs

@@ -12,6 +12,9 @@ import {
   enqueue,
   replayPending,
 } from "./shared/pending-queue.mjs"
+import {
+  sendSessionMessages,
+} from "./shared/batch-send.mjs"
 import {
   log,
   effectivePeerId,
@@ -358,7 +361,7 @@ export function createMemorySessionManager({ config, pluginRoot }) {
   }
 
   async function flushPendingMessages(opencodeSessionId, state) {
-    let added = 0
+    const toSend = []
     for (const [messageId, message] of state.messages.entries()) {
       if (message.captured) continue
       const body = buildCapturePayload(message)
@@ -366,40 +369,45 @@ export function createMemorySessionManager({ config, pluginRoot }) {
         message.captured = true
         continue
       }
-      const ok = await addMessageToSession(state.ovSessionId, body)
-      if (!ok) break
-      message.captured = true
-      added += 1
-    }
-    if (added > 0) {
-      state.lastActivityAt = Date.now()
-      debouncedSaveState()
+      toSend.push({ messageId, message, body })
     }
-    return added
-  }
+    if (toSend.length === 0) return 0
 
-  async function addMessageToSession(ovSessionId, body) {
+    let added = 0
     const health = await fetchJSON(config, "/health", {}, { timeoutMs: 5000 })
     if (!health.ok) {
-      await enqueue("addMessage", ovSessionId, body)
-      return true
+      for (const item of toSend) {
+        const queued = await enqueue("addMessage", state.ovSessionId, item.body)
+        if (!queued.ok) break
+        item.message.captured = true
+        added += 1
+      }
+    } else {
+      const res = await sendSessionMessages(
+        (endpoint, init = {}, options = {}) => fetchJSON(config, endpoint, init, { timeoutMs: 10000, ...options }),
+        state.ovSessionId,
+        toSend.map((item) => item.body),
+        { enqueueOnRetryable: true },
+      )
+      added = res.sent + res.queued
+      for (const item of toSend.slice(0, added)) {
+        item.message.captured = true
+      }
+      if (res.failed > 0 || res.enqueueFailed > 0) {
+        log("ERROR", "message", "Failed to add message to OpenViking session", {
+          openviking_session: state.ovSessionId,
+          status: res.lastError?.status,
+          error: res.lastError,
+          failed: res.failed,
+          enqueueFailed: res.enqueueFailed,
+        })
+      }
     }
-    const res = await fetchJSON(config, `/api/v1/sessions/${encodeURIComponent(ovSessionId)}/messages`, {
-      method: "POST",
-      body: JSON.stringify(body),
-    }, { timeoutMs: 10000 })
-    if (res.ok) return true
-    if (isRetryableFailure(res)) {
-      const queued = await enqueue("addMessage", ovSessionId, body)
-      return Boolean(queued.ok)
+    if (added > 0) {
+      state.lastActivityAt = Date.now()
+      debouncedSaveState()
     }
-    log("ERROR", "message", "Failed to add message to OpenViking session", {
-      openviking_session: ovSessionId,
-      role: body.role,
-      status: res.status,
-      error: res.error,
-    })
-    return false
+    return added
   }
 
   async function maybeCommitByThreshold(state) {

package/lib/shared/async-writer.mjs

@@ -0,0 +1,78 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * Async write-path helper for hook-based memory plugins.
+ *
+ * When `cfg.writePathAsync` is true and we're not already the worker, we:
+ *   1. Drain the parent's stdin (the hook payload)
+ *   2. Emit the harness-specific approve/no-op response on stdout immediately
+ *   3. Spawn a detached clone of ourselves with env OV_HOOK_WORKER=1
+ *   4. Feed the drained payload to the worker's stdin, unref, and exit
+ *
+ * The worker re-enters the same script, maybeDetach returns false (because
+ * OV_HOOK_WORKER=1), and the hook's normal synchronous code path reads its
+ * own stdin and runs the OV HTTP work with nobody waiting.
+ *
+ * Call this BEFORE the hook reads stdin itself. When it returns true, the
+ * caller must `return` out of main() immediately.
+ */
+
+import { spawn } from "node:child_process";
+
+const WORKER_ENV = "OV_HOOK_WORKER";
+
+export async function maybeDetach(cfg, { approve }) {
+  if (!cfg.writePathAsync) return false;
+  if (process.env[WORKER_ENV] === "1") return false;
+
+  // Drain parent stdin so we can forward to the worker.
+  let raw;
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    raw = Buffer.concat(chunks);
+  } catch {
+    // stdin read failed - let the synchronous path handle it.
+    return false;
+  }
+
+  let child;
+  try {
+    child = spawn(process.execPath, [process.argv[1]], {
+      detached: true,
+      stdio: ["pipe", "ignore", "ignore"],
+      env: { ...process.env, [WORKER_ENV]: "1" },
+    });
+  } catch {
+    // spawn failed - fall through to sync mode, but we've already drained
+    // stdin so hand the payload back via env var path below.
+    process.env.OPENVIKING_HOOK_STDIN_CACHE = raw.toString();
+    return false;
+  }
+
+  // Approve first, then write to the detached child. Ordering matters for
+  // harnesses that read stdout before waiting for the hook process to exit.
+  approve();
+
+  try {
+    child.stdin.write(raw);
+    child.stdin.end();
+  } catch { /* worker may have already exited; nothing useful to recover */ }
+  child.unref();
+  return true;
+}
+
+/**
+ * Fallback stdin reader used when the async path drained stdin but spawn
+ * failed; hooks should call this instead of reading stdin directly when
+ * possible so the sync fallback still works after a failed detach.
+ */
+export async function readHookStdin() {
+  if (process.env.OPENVIKING_HOOK_STDIN_CACHE) {
+    const cached = process.env.OPENVIKING_HOOK_STDIN_CACHE;
+    delete process.env.OPENVIKING_HOOK_STDIN_CACHE;
+    return cached;
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString();
+}

package/lib/shared/batch-send.mjs

@@ -0,0 +1,122 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+import { enqueue } from "./pending-queue.mjs";
+
+export const BATCH_LIMIT = 100;
+
+export function isRetryableSendFailure(res) {
+  if (!res || res.ok) return false;
+  const status = Number(res.status || 0);
+  return !status || status === 408 || status === 429 || status >= 500;
+}
+
+function makeResult() {
+  return {
+    sent: 0,
+    queued: 0,
+    enqueueFailed: 0,
+    failed: 0,
+    retryable: false,
+    usedBatch: true,
+    lastError: null,
+  };
+}
+
+async function enqueueRemainder(sessionId, payloads, startIndex, result, retryable, lastError) {
+  result.retryable = retryable;
+  result.lastError = lastError ?? null;
+
+  if (!retryable) {
+    result.failed += Math.max(0, payloads.length - startIndex);
+    return result;
+  }
+
+  const baseCreatedAt = Date.now();
+  for (let i = startIndex; i < payloads.length; i++) {
+    const queued = await enqueue("addMessage", sessionId, payloads[i], {
+      createdAt: baseCreatedAt + (i - startIndex),
+    });
+    if (!queued.ok) {
+      // Stop at the first enqueue failure so queued entries stay a contiguous
+      // prefix: consumers mark the first sent+queued payloads as captured, so
+      // skipping a payload here and queueing a later one would silently drop it.
+      result.enqueueFailed += payloads.length - i;
+      return result;
+    }
+    result.queued++;
+  }
+  return result;
+}
+
+async function sendSerial(fetchJSON, sessionId, payloads, startIndex, opts, result) {
+  result.usedBatch = false;
+  const encodedSid = encodeURIComponent(sessionId);
+  for (let i = startIndex; i < payloads.length; i++) {
+    const res = await fetchJSON(`/api/v1/sessions/${encodedSid}/messages`, {
+      method: "POST",
+      body: JSON.stringify(payloads[i]),
+    });
+    if (res?.ok) {
+      result.sent++;
+      await opts.onSent?.(1);
+      continue;
+    }
+
+    const retryable = isRetryableSendFailure(res);
+    if (opts.enqueueOnRetryable) {
+      return enqueueRemainder(sessionId, payloads, i, result, retryable, res?.error ?? res);
+    }
+    result.retryable = retryable;
+    result.lastError = res?.error ?? res ?? null;
+    result.failed += payloads.length - i;
+    return result;
+  }
+  return result;
+}
+
+/**
+ * Send add-message payloads in server-sized batches with serial fallback.
+ *
+ * @param {Function} fetchJSON - (path, init) => { ok, status, result?, error? }
+ * @param {string} sessionId - OpenViking session id
+ * @param {Array<object>} payloads - sanitized add-message request bodies
+ * @param {object} opts
+ * @param {boolean} opts.enqueueOnRetryable - enqueue unsent payloads after a retryable failure
+ * @param {Function} opts.onSent - called with the number of messages durably sent after each success
+ * @returns {Promise<{sent:number,queued:number,enqueueFailed:number,failed:number,retryable:boolean,usedBatch:boolean,lastError:any}>}
+ */
+export async function sendSessionMessages(fetchJSON, sessionId, payloads, opts = {}) {
+  const result = makeResult();
+  const messages = Array.isArray(payloads) ? payloads : [];
+  if (messages.length === 0) return result;
+
+  const encodedSid = encodeURIComponent(sessionId);
+  for (let start = 0; start < messages.length; start += BATCH_LIMIT) {
+    const chunk = messages.slice(start, start + BATCH_LIMIT);
+    const res = await fetchJSON(`/api/v1/sessions/${encodedSid}/messages/batch`, {
+      method: "POST",
+      body: JSON.stringify({ messages: chunk }),
+    });
+
+    if (res?.ok) {
+      result.sent += chunk.length;
+      await opts.onSent?.(chunk.length);
+      continue;
+    }
+
+    const status = Number(res?.status || 0);
+    if (status === 404 || status === 405) {
+      return sendSerial(fetchJSON, sessionId, messages, start, opts, result);
+    }
+
+    const retryable = isRetryableSendFailure(res);
+    if (opts.enqueueOnRetryable) {
+      return enqueueRemainder(sessionId, messages, start, result, retryable, res?.error ?? res);
+    }
+    result.retryable = retryable;
+    result.lastError = res?.error ?? res ?? null;
+    result.failed += messages.length - start;
+    return result;
+  }
+
+  return result;
+}

package/lib/shared/mcp-proxy-core.mjs

@@ -201,11 +201,14 @@ export function createOpenVikingMcpProxy({
     return true;
   }
 
-  function headersForRequest(includeSession = true, message = null) {
+  function headersForRequest(includeSession = true) {
     const headers = {
       "Content-Type": "application/json",
       "Accept": "application/json, text/event-stream",
-      "MCP-Protocol-Version": message?.params?.protocolVersion || protocolVersion,
+      // Always the proxy's current version (default, then server-negotiated) —
+      // never the client's un-negotiated ask, which strict upstreams reject
+      // with HTTP 400 before initialize negotiation can run.
+      "MCP-Protocol-Version": protocolVersion,
     };
     if (includeSession && sessionId) headers["Mcp-Session-Id"] = sessionId;
     if (proxyConfig.apiKey) headers.Authorization = `Bearer ${proxyConfig.apiKey}`;
@@ -265,7 +268,7 @@ export function createOpenVikingMcpProxy({
     try {
       const res = await fetchImpl(proxyConfig.mcpUrl, {
         method: "POST",
-        headers: headersForRequest(includeSession, message),
+        headers: headersForRequest(includeSession),
         body: JSON.stringify(message),
         signal: controller.signal,
       });
@@ -273,6 +276,10 @@ export function createOpenVikingMcpProxy({
       const messages = parseHttpBody(res.headers.get("content-type"), text);
       const nextSessionId = res.headers.get("mcp-session-id");
       if (nextSessionId) sessionId = nextSessionId;
+      if (message?.method === "initialize" && res.ok) {
+        const negotiated = messages.find((m) => typeof m?.result?.protocolVersion === "string")?.result.protocolVersion;
+        if (negotiated) protocolVersion = negotiated;
+      }
       if (!res.ok) {
         throw new HttpStatusError(res.status, res.statusText, text, messages);
       }
@@ -366,7 +373,7 @@ export function createOpenVikingMcpProxy({
     const expectsResponse = isRequest(message);
     if (message.method === "initialize") {
       initializeRequest = cloneMessage(message);
-      protocolVersion = message.params?.protocolVersion || protocolVersion || DEFAULT_PROTOCOL_VERSION;
+      protocolVersion = DEFAULT_PROTOCOL_VERSION;
       sessionId = "";
     }
     if (message.method === "notifications/initialized") {

package/lib/shared/pending-queue.mjs

@@ -182,10 +182,12 @@ async function recoverStaleProcessing(dir) {
  * @param {string} type - "addMessage" or "commitSession"
  * @param {string} sessionId - OV session ID
  * @param {object} payload - the data that failed to send
+ * @param {object} options
+ * @param {number} options.createdAt - optional queue timestamp override
  */
-export async function enqueue(type, sessionId, payload) {
+export async function enqueue(type, sessionId, payload, options = {}) {
   const dir = getPendingDir();
-  const now = Date.now();
+  const now = Number.isFinite(options.createdAt) ? options.createdAt : Date.now();
   const dedupKey = makeDedupKey(type, sessionId, payload);
   const filename = pendingFilename(dedupKey, 0);
   const entry = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",