@openviking/opencode-plugin 2026.9.10 → 2026.9.21-1

package/lib/shared/workspace-registry.mjs

@@ -0,0 +1,87 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * The per-machine workspace registry, `~/.openviking/workspaces/`.
+ *
+ * One file per workspace rather than one file listing them all: hooks are many
+ * short-lived processes, and a shared JSON file loses writes whenever any two
+ * of them touch unrelated workspaces at once.
+ *
+ * The plugins only read this layer; nothing writes it today. A user who wants
+ * an entry creates the file by hand, and it then outranks both workspace files
+ * — so it is where they keep the last word over any repository they clone.
+ */
+
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+
+import { readWorkspaceFile } from "./workspace-config.mjs";
+
+export function registryDir(env = process.env) {
+  const home = String(env.OPENVIKING_HOME || "").trim();
+  const base = home ? home.replace(/^~(?=$|\/)/, homedir()) : join(homedir(), ".openviking");
+  return join(base, "workspaces");
+}
+
+/**
+ * A readable name plus a hash, keyed on the workspace's identity rather than
+ * its path wherever git supplies one.
+ *
+ * Two linked worktrees of one repository are one workspace — the same peer and
+ * the same settings — and keying on the checkout path would silently split
+ * them in two. Outside a repository there is no
+ * identity but the path, so two `~/src/api` clones still get separate entries.
+ */
+export function slotName(root, identity = null) {
+  const path = String(root || "");
+  const key = identity ? identityKey(identity) : "path";
+  const source = key === "path" ? path : key;
+  const label = key.startsWith("remote:") ? key.split("/").pop() : basename(path);
+  const readable = String(label || "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  const digest = createHash("sha256").update(source).digest("hex").slice(0, 12);
+  return `${readable ? `${readable}-` : ""}${digest}.json`;
+}
+
+export function entryPath(root, env = process.env, identity = null) {
+  return join(registryDir(env), slotName(root, identity));
+}
+
+/**
+ * The identity a stored entry is checked against. Path alone is not enough:
+ * a directory can be deleted and a different repository cloned in its place,
+ * and inheriting the old entry's peer would silently cross two projects.
+ */
+export function identityKey(identity) {
+  // The normalized remote, so re-spelling origin (ssh ↔ https, or rotating an
+  // embedded token) is not mistaken for a different repository.
+  const remote = String(identity?.remote || "").trim();
+  if (remote) return `remote:${remote}`;
+  if (identity?.isGit) return `git:${identity.gitCommonDir || ""}`;
+  return "path";
+}
+
+/**
+ * Read this workspace's entry, or null.
+ *
+ * A stored entry whose identity contradicts the current one is treated as a
+ * miss — negative evidence. Nothing is inherited from it.
+ */
+export function readEntry(root, { identity = null, env = process.env } = {}) {
+  const path = entryPath(root, env, identity);
+  const file = readWorkspaceFile(path, { layer: "registry" });
+  if (!file.data) return { path, entry: null, warnings: file.warnings, conflict: false };
+
+  const entry = file.data;
+  const warnings = [...file.warnings];
+  if (identity) {
+    const expected = identityKey(identity);
+    const stored = String(entry.identity || "");
+    if (stored && stored !== expected) {
+      warnings.push(
+        `${path} was recorded for a different repository (${stored}); starting a fresh entry for ${expected}`,
+      );
+      return { path, entry: null, warnings, conflict: true };
+    }
+  }
+  return { path, entry, warnings, conflict: false };
+}

package/lib/utils.mjs

@@ -1,6 +1,8 @@
 import fs from "fs"
 import path from "path"
 
+import { createOvHttp } from "./shared/ov-http.mjs"
+
 let logFilePath = null
 
 export function initLogger(dataDir) {
@@ -68,167 +70,49 @@ export function effectivePeerId(config) {
   return String(config.effectivePeer?.peerId || config.peerId || "").trim() || null
 }
 
-function responseTraceId(payload) {
-  return payload?.result?.trace_id || payload?.error?.trace_id || payload?.trace_id || undefined
+// The config travels with every call here, so the client is built per call —
+// a closure next to a network round-trip costs nothing.
+function ovHttp(config) {
+  return createOvHttp(
+    { ...config, baseUrl: normalizeEndpoint(config.endpoint) },
+    { defaultTimeoutMs: config.timeoutMs },
+  )
 }
 
 export async function fetchJSON(config, endpoint, init = {}, options = {}) {
-  const url = `${normalizeEndpoint(config.endpoint)}${endpoint}`
-  const headers = makeAuthHeaders(
-    config,
-    { "Content-Type": "application/json", ...(init.headers ?? {}) },
-    options.actorPeerId,
-  )
-  const controller = new AbortController()
-  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? config.timeoutMs)
-  try {
-    const response = await fetch(url, {
-      ...init,
-      headers,
-      signal: controller.signal,
-    })
-    const text = await response.text()
-    const payload = text ? parseJsonOrText(text) : {}
-    const traceId = responseTraceId(payload)
-    if (!response.ok || payload?.status === "error") {
-      return {
-        ok: false,
-        status: response.status,
-        error: payload?.error || payload?.message || { message: `HTTP ${response.status}` },
-        traceId,
-      }
-    }
-    return { ok: true, status: response.status, result: payload?.result ?? payload, traceId }
-  } catch (error) {
-    return { ok: false, status: 0, error: { message: error?.message ?? String(error) } }
-  } finally {
-    clearTimeout(timeout)
-  }
+  return ovHttp(config)(endpoint, init, options)
 }
 
+/**
+ * `fetchJSON` for the callers that would rather catch than branch: it resolves
+ * to the unwrapped result and turns every failure into an Error whose message
+ * is what the user can act on.
+ */
 export async function makeRequest(config, options) {
-  const url = `${normalizeEndpoint(config.endpoint)}${options.endpoint}`
-  const headers = makeAuthHeaders(
-    config,
-    { "Content-Type": "application/json", ...(options.headers ?? {}) },
-    options.actorPeerId,
-  )
-
-  const controller = new AbortController()
-  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? config.timeoutMs)
-  let onAbort = null
-
-  if (options.abortSignal) {
-    if (options.abortSignal.aborted) controller.abort()
-    onAbort = () => controller.abort()
-    options.abortSignal.addEventListener("abort", onAbort, { once: true })
-  }
-
-  try {
-    const response = await fetch(url, {
-      method: options.method,
-      headers,
-      body: options.body === undefined ? undefined : JSON.stringify(options.body),
-      signal: controller.signal,
-    })
-
-    const text = await response.text()
-    const payload = text ? parseJsonOrText(text) : {}
-
-    if (!response.ok) {
-      const rawError = typeof payload === "object" ? payload.error ?? payload.message : payload
-      const errorMessage = typeof rawError === "string" ? rawError : JSON.stringify(rawError)
-      if (response.status === 401 || response.status === 403) {
-        throw new Error("Authentication failed. Please check apiKey/account/user in openviking-config.json or OPENVIKING_* environment variables.")
-      }
-      throw new Error(`Request failed (${response.status}): ${errorMessage}`)
-    }
-
-    return payload
-  } catch (error) {
-    if (error?.name === "AbortError") {
-      throw new Error(`Request timeout after ${options.timeoutMs ?? config.timeoutMs}ms`)
-    }
-    if (error?.message?.includes("fetch failed") || error?.code === "ECONNREFUSED") {
-      throw new Error(`OpenViking service unavailable at ${config.endpoint}. Start it with: openviking-server --config ~/.openviking/ov.conf`)
-    }
-    throw error
-  } finally {
-    clearTimeout(timeout)
-    if (options.abortSignal && onAbort) {
-      options.abortSignal.removeEventListener("abort", onAbort)
-    }
-  }
-}
-
-export async function makeMultipartRequest(config, options) {
-  const url = `${normalizeEndpoint(config.endpoint)}${options.endpoint}`
-  const headers = makeAuthHeaders(config, options.headers ?? {}, options.actorPeerId)
-
-  const controller = new AbortController()
-  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? config.timeoutMs)
-  let onAbort = null
-
-  if (options.abortSignal) {
-    if (options.abortSignal.aborted) controller.abort()
-    onAbort = () => controller.abort()
-    options.abortSignal.addEventListener("abort", onAbort, { once: true })
-  }
-
-  try {
-    const response = await fetch(url, {
-      method: options.method,
-      headers,
-      body: options.body,
-      signal: controller.signal,
-    })
-
-    const text = await response.text()
-    const payload = text ? parseJsonOrText(text) : {}
-
-    if (!response.ok) {
-      const rawError = typeof payload === "object" ? payload.error ?? payload.message : payload
-      const errorMessage = typeof rawError === "string" ? rawError : JSON.stringify(rawError)
-      if (response.status === 401 || response.status === 403) {
-        throw new Error("Authentication failed. Please check apiKey/account/user in openviking-config.json or OPENVIKING_* environment variables.")
-      }
-      throw new Error(`Request failed (${response.status}): ${errorMessage}`)
+  const timeoutMs = options.timeoutMs ?? config.timeoutMs
+  const response = await fetchJSON(config, options.endpoint, {
+    method: options.method,
+    headers: options.headers,
+    body: options.body === undefined ? undefined : JSON.stringify(options.body),
+  }, { timeoutMs, actorPeerId: options.actorPeerId })
+  if (response.ok) return response.result
+
+  const message = getResponseErrorMessage(response.error)
+  // Status 0 is the transport: nothing answered, so the message is ours, not
+  // the server's, and it says what the user has to go fix.
+  if (response.status === 0) {
+    if (response.error?.aborted) {
+      throw new Error(`Request timeout after ${timeoutMs}ms`)
     }
-
-    return payload
-  } catch (error) {
-    if (error?.name === "AbortError") {
-      throw new Error(`Request timeout after ${options.timeoutMs ?? config.timeoutMs}ms`)
-    }
-    if (error?.message?.includes("fetch failed") || error?.code === "ECONNREFUSED") {
+    if (message.includes("fetch failed") || message.includes("ECONNREFUSED")) {
       throw new Error(`OpenViking service unavailable at ${config.endpoint}. Start it with: openviking-server --config ~/.openviking/ov.conf`)
     }
-    throw error
-  } finally {
-    clearTimeout(timeout)
-    if (options.abortSignal && onAbort) {
-      options.abortSignal.removeEventListener("abort", onAbort)
-    }
+    throw new Error(message)
   }
-}
-
-function makeAuthHeaders(config, headers = {}, actorPeerId = "") {
-  const result = { ...headers }
-  if (config.apiKey) result["Authorization"] = `Bearer ${config.apiKey}`
-  if (config.account) result["X-OpenViking-Account"] = config.account
-  if (config.user) result["X-OpenViking-User"] = config.user
-  const peerId = String(actorPeerId || "").trim()
-  if (peerId) result["X-OpenViking-Actor-Peer"] = peerId
-  if (config.userAgent) result["User-Agent"] = config.userAgent
-  return result
-}
-
-function parseJsonOrText(text) {
-  try {
-    return JSON.parse(text)
-  } catch {
-    return text
+  if (response.status === 401 || response.status === 403) {
+    throw new Error("Authentication failed. Check api_key/account/user in ~/.openviking/ovcli.conf, or the OPENVIKING_* environment variables.")
   }
+  throw new Error(`Request failed (${response.status}): ${message}`)
 }
 
 export function getResponseErrorMessage(error) {
@@ -236,30 +120,3 @@ export function getResponseErrorMessage(error) {
   if (typeof error === "string") return error
   return error.message || error.code || "Unknown OpenViking error"
 }
-
-export function unwrapResponse(response) {
-  if (!response || typeof response !== "object") {
-    throw new Error("OpenViking returned an invalid response")
-  }
-  if (response.status && response.status !== "ok") {
-    throw new Error(getResponseErrorMessage(response.error))
-  }
-  return response.result
-}
-
-export function validateVikingUri(uri, toolName = "tool") {
-  if (typeof uri !== "string" || !uri.startsWith("viking://")) {
-    log("ERROR", toolName, "Invalid Viking URI", { uri })
-    return 'Error: Invalid URI format. Must start with "viking://".'
-  }
-  return null
-}
-
-export function ensureRemoteUrl(value) {
-  try {
-    const url = new URL(value)
-    return url.protocol === "http:" || url.protocol === "https:"
-  } catch {
-    return false
-  }
-}

package/lib/viking-uri-guard.mjs

@@ -1,5 +1,5 @@
 import { log } from "./utils.mjs"
-import { buildGuardMessage, findVikingUri, normalizeToolName } from "./shared/uri-guard.mjs"
+import { evaluateUriGuard, evaluateUriNotice, findVikingUri, normalizeToolName } from "./shared/uri-guard.mjs"
 
 const FILESYSTEM_TOOL_HINTS = {
   read: {
@@ -14,23 +14,38 @@ const FILESYSTEM_TOOL_HINTS = {
     tool: "openviking_search",
     example: (uri, args = {}) => `openviking_search(query="${String(args.pattern ?? "").replaceAll('"', '\\"')}", target_uri="${uri}")`,
   },
+  bash: {
+    tool: "openviking_read or openviking_search",
+    example: (uri) => `openviking_read(uris=["${uri}"])`,
+  },
 }
 
 export function createVikingUriGuard() {
   return async (input, output) => {
     const toolName = normalizeToolName(input?.tool ?? input?.name)
-    const hint = FILESYSTEM_TOOL_HINTS[toolName]
-    if (!hint) return
-
     const args = output?.args ?? input?.args ?? {}
-    const uri = findVikingUri(args)
-    if (!uri) return
+    const decision = evaluateUriGuard(toolName, args, { hints: FILESYSTEM_TOOL_HINTS })
+    if (!decision) return
 
     log("INFO", "viking-uri-guard", "Blocked filesystem tool for viking URI", {
       tool: toolName,
-      uri,
+      uri: decision.uri,
+    })
+    throw new Error(decision.reason)
+  }
+}
+
+export function createVikingUriNotice() {
+  return async (input, output) => {
+    const toolName = normalizeToolName(input?.tool ?? input?.name)
+    const notice = evaluateUriNotice(toolName, input?.args ?? {}, { hints: FILESYSTEM_TOOL_HINTS })
+    if (!notice || !output) return
+
+    log("INFO", "viking-uri-guard", "Attached viking URI notice to shell tool output", {
+      tool: toolName,
+      uri: notice.uri,
     })
-    throw new Error(buildGuardMessage(uri, { ...hint, example: hint.example(uri, args) }))
+    output.output = output.output ? `${output.output}\n\n${notice.reason}` : notice.reason
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "2026.9.10",
+  "version": "2026.9.21-1",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -23,8 +23,9 @@
     "INSTALL-ZH.md"
   ],
   "scripts": {
+    "prepack": "node ../memory-plugin-shared/sync.mjs",
     "check": "node --check index.mjs && node --check lib/config.mjs && node --check lib/mcp-config.mjs && node --check lib/runtime.mjs && node --check lib/repo-context.mjs && node --check lib/memory-session.mjs && node --check lib/memory-recall.mjs && node --check lib/session-inject.mjs && node --check lib/viking-uri-guard.mjs && node --check lib/utils.mjs && node --check lib/shared/*.mjs && node --check servers/mcp-proxy.mjs && node --check scripts/setup.mjs && node --check tests/*.test.mjs",
-    "test": "node --test tests/*.test.mjs servers/*.test.mjs"
+    "test": "node --test tests/*.test.mjs"
   },
   "dependencies": {},
   "publishConfig": {
@@ -44,5 +45,5 @@
     "code-search"
   ],
   "license": "Apache-2.0",
-  "openvikingSourceCommit": "3841e6f2992bc2299142f5ec50143e6b30e55ac0"
+  "openvikingSourceCommit": "9b0ce3dea5d8874fc373dbf40d8314945dc10234"
 }

package/servers/mcp-proxy.mjs

@@ -3,42 +3,22 @@
 /**
  * stdio -> streamable-HTTP MCP proxy for the OpenViking OpenCode plugin.
  *
- * OpenCode starts this process as a local MCP server. The proxy reads the same
- * OpenViking credential sources as the lifecycle hooks, forwards JSON-RPC
+ * OpenCode starts this process as a local MCP server. The proxy resolves its
+ * connection through the plugin's own `loadConfig()`, forwards JSON-RPC
  * requests to the server's /mcp endpoint, and keeps stdout protocol-clean.
  */
 
-import { homedir } from "node:os"
-import { join, resolve as resolvePath } from "node:path"
+import { resolve as resolvePath } from "node:path"
 import { fileURLToPath } from "node:url"
 import { loadConfig } from "../lib/config.mjs"
 import { createLogger } from "../lib/shared/debug-log.mjs"
-import { buildMcpProxyConfig, resolveMcpActorPeerId } from "../lib/shared/mcp-proxy-config.mjs"
+import { toMcpProxyConfig } from "../lib/shared/mcp-proxy-config.mjs"
 import { createOpenVikingMcpProxy } from "../lib/shared/mcp-proxy-core.mjs"
 
-export { createOpenVikingMcpProxy } from "../lib/shared/mcp-proxy-core.mjs"
+const PLUGIN_ROOT = resolvePath(fileURLToPath(import.meta.url), "..", "..")
 
-function readProxyConfig() {
-  const cfg = loadConfig(resolvePath(fileURLToPath(import.meta.url), "..", ".."))
-  return buildMcpProxyConfig({
-    baseUrl: cfg.endpoint,
-    mcpUrl: cfg.mcpUrl,
-    apiKey: cfg.apiKey,
-    account: cfg.account,
-    user: cfg.user,
-    peerId: resolveMcpActorPeerId(cfg),
-    userAgent: cfg.userAgent,
-    timeoutMs: cfg.timeoutMs,
-    debug: cfg.debug,
-    debugLogPath: cfg.debugLogPath,
-    credentialSource: cfg.credentialSource,
-    credentialPath: cfg.credentialPath || cfg.configPath,
-    watchedPaths: [
-      cfg.credentialPath,
-      cfg.configPath,
-      join(homedir(), ".config", "opencode", "openviking-config.json"),
-    ],
-  })
+export function readProxyConfig(env = process.env) {
+  return toMcpProxyConfig(loadConfig(PLUGIN_ROOT, undefined, { env }), { env })
 }
 
 if (process.argv[1] && fileURLToPath(import.meta.url) === resolvePath(process.argv[1])) {

package/servers/mcp-proxy.test.mjs

@@ -1,102 +0,0 @@
-import test from "node:test"
-import assert from "node:assert/strict"
-import { createServer } from "node:http"
-import { Writable } from "node:stream"
-import { createOpenVikingMcpProxy } from "./mcp-proxy.mjs"
-
-function jsonRpc(id, result = {}) {
-  return { jsonrpc: "2.0", id, result }
-}
-
-function sseMessage(obj) {
-  return `event: message\r\ndata: ${JSON.stringify(obj)}\r\n\r\n`
-}
-
-async function readBody(req) {
-  const chunks = []
-  for await (const chunk of req) chunks.push(chunk)
-  return Buffer.concat(chunks).toString("utf-8")
-}
-
-async function withServer(handler, fn) {
-  const requests = []
-  const server = createServer(async (req, res) => {
-    const body = await readBody(req)
-    const entry = {
-      method: req.method,
-      url: req.url,
-      headers: req.headers,
-      body: body ? JSON.parse(body) : null,
-    }
-    requests.push(entry)
-    await handler(req, res, entry)
-  })
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve))
-  try {
-    const { port } = server.address()
-    return await fn({ url: `http://127.0.0.1:${port}/mcp`, requests })
-  } finally {
-    await new Promise((resolve) => server.close(resolve))
-  }
-}
-
-function makeProxy(url) {
-  const out = []
-  const stdout = new Writable({
-    write(chunk, _encoding, callback) {
-      out.push(chunk.toString("utf-8"))
-      callback()
-    },
-  })
-  const proxy = createOpenVikingMcpProxy({
-    stdout,
-    readConfig: () => ({
-      mcpUrl: url,
-      apiKey: "test-key",
-      account: "acct",
-      user: "user",
-      peerId: "peer",
-      userAgent: "openviking-memory-opencode/9.9.9",
-      timeoutMs: 5000,
-      debug: false,
-      debugLogPath: "",
-      credentialSource: "test",
-      credentialPath: "",
-      watchedPaths: [],
-    }),
-    loggerFactory: () => ({ log() {}, logError() {} }),
-  })
-  return {
-    proxy,
-    async messages() {
-      await new Promise((resolve) => setImmediate(resolve))
-      return out.join("").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line))
-    },
-  }
-}
-
-test("OpenCode MCP proxy forwards initialize with auth and identity headers", async () => {
-  await withServer((_req, res, entry) => {
-    assert.equal(entry.method, "POST")
-    assert.equal(entry.headers.authorization, "Bearer test-key")
-    assert.equal(entry.headers["x-openviking-account"], "acct")
-    assert.equal(entry.headers["x-openviking-user"], "user")
-    assert.equal(entry.headers["x-openviking-actor-peer"], "peer")
-    assert.equal(entry.headers["user-agent"], "openviking-memory-opencode/9.9.9")
-    res.writeHead(200, {
-      "content-type": "text/event-stream",
-      "mcp-session-id": "sid-oc",
-    })
-    res.end(sseMessage(jsonRpc(1, { protocolVersion: "2025-06-18" })))
-  }, async ({ url, requests }) => {
-    const { proxy, messages } = makeProxy(url)
-    await proxy.handleMessage({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "initialize",
-      params: { protocolVersion: "2025-06-18" },
-    })
-    assert.deepEqual(await messages(), [jsonRpc(1, { protocolVersion: "2025-06-18" })])
-    assert.equal(requests.length, 1)
-  })
-})