@openviking/opencode-plugin 0.2.4 → 2026.9.9-1

package/lib/shared/workspace-peer.mjs

@@ -1,16 +1,134 @@
 // GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * Which peer a workspace writes its memories under.
+ *
+ * The peer used to be the working directory with every non-alphanumeric byte
+ * turned into a dash, which made the identity an accident of where the
+ * repository happened to sit: a clone on another machine, a rename, a worktree
+ * or simply `cd examples/` each minted a separate, empty namespace. The default
+ * is now git's own idea of the repository, so one project keeps one memory
+ * wherever it is checked out.
+ *
+ * `peer.source` decides the rule. Presets cover the three answers most people
+ * want; a template — or a list of templates tried in order — covers the rest.
+ * The old behaviour is still one word away, byte for byte.
+ */
+
+import { legacySanitize, resolveWorkspaceIdentity, sanitizePeerId } from "./workspace-identity.mjs";
+
+/**
+ * `git` is the default, and it resolves only inside a repository: the remote
+ * first, because that is the one name every clone agrees on, then the
+ * repository root for a repo that has none. Anywhere else it resolves to
+ * nothing and no peer is sent — a scratch folder or an app's per-task
+ * directory would otherwise mint a fresh, empty namespace each time, so those
+ * memories go to the user-level space instead. Naming such a directory is what
+ * `peer.id` is for, and deriving one from a bare path is what `cwd` is for;
+ * both are opt-in.
+ *
+ * No preset adds a prefix. A path-derived id starts with `-` on POSIX, so it
+ * cannot collide with a remote-derived one; anyone who wants a prefix writes
+ * their own template.
+ */
+export const PEER_SOURCE_PRESETS = {
+  git: ["{git_remote}", "{git_root}"],
+  cwd: ["{cwd}"],
+  none: [],
+};
+
+export const DEFAULT_PEER_SOURCE = "git";
+
+const VARIABLE_RE = /\{([a-z_]+)\}/g;
+
 export function deriveWorkspacePeerId(cwd) {
-  return String(cwd || "").replace(/[^A-Za-z0-9]/g, "-");
+  return legacySanitize(cwd);
 }
 
-export function resolveEffectivePeerId({ cfg = {}, cwd = "" } = {}) {
+/**
+ * Normalize `peer.source` — a preset name, a template, or a list — to templates.
+ *
+ * A bare string with no `{` is a misspelled preset, not a template: `Git` or
+ * `gti` would otherwise become a peer literally named `Git`, quietly stranding
+ * the workspace's memories in a namespace nobody meant to create. Such a value
+ * warns and falls back to the default chain. An array is left alone — writing a
+ * list is explicit enough to mean the constant it contains.
+ */
+export function peerSourceTemplates(source, onWarn = null) {
+  if (Array.isArray(source)) return source.map(String).filter(Boolean);
+  const raw = String(source ?? "").trim();
+  if (!raw) return PEER_SOURCE_PRESETS[DEFAULT_PEER_SOURCE];
+  if (Object.hasOwn(PEER_SOURCE_PRESETS, raw)) return PEER_SOURCE_PRESETS[raw];
+  if (raw.includes("{")) return [raw];
+
+  const message = `OpenViking: ignored peer.source ${JSON.stringify(raw)}: it is neither a preset `
+    + `(${Object.keys(PEER_SOURCE_PRESETS).join(", ")}) nor a template such as "team-{dir}". `
+    + `Falling back to ${DEFAULT_PEER_SOURCE}.`;
+  if (typeof onWarn === "function") onWarn(message);
+  else process.stderr.write(`${message}\n`);
+  return PEER_SOURCE_PRESETS[DEFAULT_PEER_SOURCE];
+}
+
+/**
+ * Substitute one template, or return "" when any variable it names is empty.
+ *
+ * All-or-nothing on purpose: a half-resolved template like `git-` would be a
+ * silently shared identity, so an empty variable falls through to the next
+ * template instead.
+ */
+export function renderPeerTemplate(template, vars) {
+  const text = String(template || "");
+  if (!text) return "";
+  let empty = false;
+  const rendered = text.replace(VARIABLE_RE, (match, name) => {
+    if (!Object.hasOwn(vars, name)) {
+      empty = true;
+      return "";
+    }
+    const value = String(vars[name] ?? "");
+    if (!value) empty = true;
+    return value;
+  });
+  return empty ? "" : rendered;
+}
+
+/**
+ * The peer this process should send, and where it came from.
+ *
+ * `source` keeps its three values — call sites compare it against the literal
+ * `"workspace"` to decide whether a session pin may be reused — while `origin`
+ * names the template that actually produced the id, and `legacyPeerId` carries
+ * the pre-git id whenever it differs, so recall can still reach memories
+ * written under it.
+ */
+export function resolveEffectivePeerId({ cfg = {}, cwd = "", identity = null, env = process.env, onWarn = null } = {}) {
   const explicit = String(cfg.peerId || "").trim();
-  if (explicit) return { peerId: explicit, source: "explicit" };
+  if (explicit) return { peerId: explicit, source: "explicit", origin: "explicit", legacyPeerId: "" };
 
-  if (cfg.workspacePeer !== false) {
-    const peerId = deriveWorkspacePeerId(cwd);
-    if (peerId) return { peerId, source: "workspace" };
-  }
+  // `OPENVIKING_WORKSPACE_PEER=0` predates `peer.source` and still means "none".
+  if (cfg.workspacePeer === false) return { peerId: "", source: "none", origin: "disabled", legacyPeerId: "" };
+
+  const templates = peerSourceTemplates(cfg.peerSource, onWarn);
+  if (!templates.length) return { peerId: "", source: "none", origin: "none", legacyPeerId: "" };
 
-  return { peerId: "", source: "none" };
+  // `harness` is composed here rather than in the identity, whose result is
+  // cached on disk under a cwd-only key — two harnesses in one directory would
+  // otherwise read each other's peer back out of that cache.
+  const vars = {
+    ...((identity || resolveWorkspaceIdentity({ cwd, env })).vars || {}),
+    harness: sanitizePeerId(cfg.harness || cfg.clientId || ""),
+  };
+  const legacyPeerId = deriveWorkspacePeerId(cwd);
+  for (const template of templates) {
+    const peerId = renderPeerTemplate(template, vars);
+    if (!peerId) continue;
+    return {
+      peerId,
+      source: "workspace",
+      origin: template,
+      legacyPeerId: peerId === legacyPeerId ? "" : legacyPeerId,
+    };
+  }
+  // No peer, but the pre-git id is still what earlier sessions in this
+  // directory wrote under, so recall keeps reaching it.
+  return { peerId: "", source: "none", origin: "unresolved", legacyPeerId };
 }

package/lib/utils.mjs

@@ -68,6 +68,10 @@ 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
+}
+
 export async function fetchJSON(config, endpoint, init = {}, options = {}) {
   const url = `${normalizeEndpoint(config.endpoint)}${endpoint}`
   const headers = makeAuthHeaders(
@@ -85,14 +89,16 @@ export async function fetchJSON(config, endpoint, init = {}, options = {}) {
     })
     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 }
+    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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "0.2.4",
+  "version": "2026.9.9-1",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -43,5 +43,6 @@
     "rag",
     "code-search"
   ],
-  "license": "Apache-2.0"
+  "license": "Apache-2.0",
+  "openvikingSourceCommit": "708dba60bd2484a9ecb69da27383b5203d8daee2"
 }

package/servers/mcp-proxy.mjs

@@ -13,56 +13,32 @@ import { join, 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 { createOpenVikingMcpProxy } from "../lib/shared/mcp-proxy-core.mjs"
-import { resolveEffectivePeerId } from "../lib/shared/workspace-peer.mjs"
 
 export { createOpenVikingMcpProxy } from "../lib/shared/mcp-proxy-core.mjs"
 
-const DEFAULT_TIMEOUT_MS = 15000
-
-function trimSlash(value) {
-  return String(value || "").replace(/\/+$/, "")
-}
-
-function normalizePath(value) {
-  const raw = String(value || "").trim()
-  if (!raw) return ""
-  if (raw === "~") return homedir()
-  if (raw.startsWith("~/")) return resolvePath(join(homedir(), raw.slice(2)))
-  return resolvePath(raw)
-}
-
-function uniq(values) {
-  return [...new Set(values.filter(Boolean))]
-}
-
 function readProxyConfig() {
   const cfg = loadConfig(resolvePath(fileURLToPath(import.meta.url), "..", ".."))
-  const effectivePeer = resolveEffectivePeerId({ cfg, cwd: process.cwd() })
-  const mcpUrl = cfg.mcpUrl || `${trimSlash(cfg.endpoint)}/mcp`
-  return {
-    mcpUrl,
-    apiKey: cfg.apiKey || "",
-    account: cfg.account || "",
-    user: cfg.user || "",
-    peerId: effectivePeer.peerId,
-    userAgent: cfg.userAgent || "",
-    timeoutMs: Math.max(1000, Number(cfg.timeoutMs) || DEFAULT_TIMEOUT_MS),
-    debug: cfg.debug === true,
+  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 || "auto",
-    credentialPath: cfg.credentialPath || cfg.configPath || "",
-    watchedPaths: uniq([
+    credentialSource: cfg.credentialSource,
+    credentialPath: cfg.credentialPath || cfg.configPath,
+    watchedPaths: [
       cfg.credentialPath,
       cfg.configPath,
-      normalizePath(process.env.OPENVIKING_CLI_CONFIG_FILE),
-      normalizePath(process.env.OPENVIKING_CONFIG_FILE),
-      normalizePath(process.env.OPENVIKING_PLUGIN_CONFIG),
-      join(homedir(), ".openviking", "ovcli.conf"),
-      join(homedir(), ".openviking", "ov.conf"),
       join(homedir(), ".config", "opencode", "openviking-config.json"),
-    ]),
-  }
+    ],
+  })
 }
 
 if (process.argv[1] && fileURLToPath(import.meta.url) === resolvePath(process.argv[1])) {

package/lib/shared/async-writer.mjs

@@ -1,78 +0,0 @@
-// 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/plugin-config.mjs

@@ -1,90 +0,0 @@
-// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
-/**
- * Per-harness plugin settings from ovcli.conf.
- *
- * ovcli.conf carried connection fields only, so every harness had to keep its
- * tuning knobs in ov.conf's harness section — a server-side file that a
- * client-side plugin has no business editing. The `plugin` section fixes that:
- * shared keys apply to every harness that reads them, and a per-harness object
- * overrides them.
- *
- *   {
- *     "url": "...", "api_key": "...",
- *     "plugin": {
- *       "recallQueryExpansion": "off",
- *       "recallCompress": "auto"
- *     }
- *   }
- *
- * Resolution stays env → ovcli.conf plugin.<harness> → ovcli.conf plugin →
- * ov.conf harness section (legacy) → defaults.
- *
- * Consumers: Claude Code and Codex only. The other harnesses ship this module
- * through `sync.mjs` but still read their knobs from the environment, so a
- * `plugin` entry named after them is inert. `HARNESS_KEYS` lists what a harness
- * loader actually consumes today — add a key here as its loader starts calling
- * `loadPluginSettings`, not before, so the section never promises a knob that
- * silently does nothing.
- */
-
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve as resolvePath } from "node:path";
-
-const DEFAULT_OVCLI_CONF_PATH = join(homedir(), ".openviking", "ovcli.conf");
-
-export const HARNESS_KEYS = {
-  claudeCode: "claude_code",
-  codex: "codex",
-};
-
-function tryLoadJson(path) {
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Merge the shared plugin section with the harness-specific override.
- * Returns a flat settings object; unknown keys pass through untouched so a
- * harness can add its own knobs without touching this module.
- */
-export function loadPluginSettings(harness, env = process.env) {
-  const path = resolvePath(
-    (env.OPENVIKING_CLI_CONFIG_FILE || DEFAULT_OVCLI_CONF_PATH).replace(/^~/, homedir()),
-  );
-  const file = tryLoadJson(path);
-  const plugin = file && typeof file.plugin === "object" && file.plugin ? file.plugin : {};
-
-  const shared = {};
-  for (const [key, value] of Object.entries(plugin)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) continue;
-    shared[key] = value;
-  }
-  const scoped = harness && plugin[harness] && typeof plugin[harness] === "object"
-    ? plugin[harness]
-    : {};
-
-  return { ...shared, ...scoped };
-}
-
-const REWRITE_MODES = new Set(["off", "client", "server", "auto"]);
-
-/**
- * Normalize the tri-state rewrite knob.
- *
- * off    — never compress
- * client — always compress locally through the host CLI
- * server — always ask the server for a digest
- * auto   — prefer local (cost lands on the user's own subscription), fall back
- *          to the server when no healthy host CLI is available
- */
-export function normalizeRewriteMode(value, fallback = "off") {
-  const raw = String(value ?? "").trim().toLowerCase();
-  if (REWRITE_MODES.has(raw)) return raw;
-  if (raw === "1" || raw === "true" || raw === "yes") return "auto";
-  if (raw === "0" || raw === "false" || raw === "no") return "off";
-  return fallback;
-}