@openviking/opencode-plugin 0.1.6 → 0.2.0

package/lib/shared/setup-wizard.mjs

@@ -0,0 +1,111 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * Interactive ovcli.conf setup wizard shared by the OpenViking memory plugins.
+ *
+ * Lets a pure-marketplace install (no installer script) configure the server
+ * URL and API key that both the lifecycle hooks and the stdio MCP proxy read:
+ *
+ *   node <plugin>/scripts/setup.mjs
+ *
+ * Conventions: show current values, keep existing secrets on empty input,
+ * merge-write (never drop unknown fields), back up the previous file, 0600.
+ */
+
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { dirname } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { loadCredentialFiles } from "./credentials.mjs";
+
+const CLOUD_URL = "https://api.vikingdb.cn-beijing.volces.com/openviking";
+const LOCAL_URL = "http://127.0.0.1:1933";
+
+function maskSecret(value) {
+  const s = String(value || "");
+  if (!s) return "(not set)";
+  if (s.length <= 8) return "****";
+  return `${s.slice(0, 4)}…${s.slice(-4)} (${s.length} chars)`;
+}
+
+function readJsonSafe(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export async function runSetupWizard({
+  input = process.stdin,
+  output = process.stdout,
+  env = process.env,
+} = {}) {
+  const { cliPath } = loadCredentialFiles(env);
+  const current = readJsonSafe(cliPath);
+  const rl = createInterface({ input, output });
+  const say = (line = "") => output.write(`${line}\n`);
+
+  try {
+    say("OpenViking memory plugin setup");
+    say(`Config file: ${cliPath}`);
+    say("");
+    say("Current values:");
+    say(`  url:     ${current.url || "(not set)"}`);
+    say(`  api_key: ${maskSecret(current.api_key)}`);
+    if (current.account) say(`  account: ${current.account}`);
+    if (current.user) say(`  user:    ${current.user}`);
+    say("");
+
+    const defaultUrl = current.url || LOCAL_URL;
+    say("Where do you connect to OpenViking?");
+    say(`  1) Self-hosted / local        [${LOCAL_URL}]`);
+    say(`  2) Volcengine OpenViking Cloud [${CLOUD_URL}]`);
+    say(`  3) Custom URL / keep current   [${defaultUrl}]`);
+    const mode = (await rl.question("Choice [1/2/3, default 3]: ")).trim();
+    let url = defaultUrl;
+    if (mode === "1") {
+      url = LOCAL_URL;
+    } else if (mode === "2") {
+      url = CLOUD_URL;
+    } else {
+      const answer = (await rl.question(`Server URL [${defaultUrl}]: `)).trim();
+      if (answer) url = answer;
+    }
+
+    const keyPrompt = current.api_key
+      ? `API key [enter = keep ${maskSecret(current.api_key)}, '-' = clear]: `
+      : "API key (leave empty for unauthenticated local mode): ";
+    const keyAnswer = await rl.question(keyPrompt);
+    let apiKey = current.api_key || "";
+    if (keyAnswer === "-") apiKey = "";
+    else if (keyAnswer.trim()) apiKey = keyAnswer.trim();
+    else if (!current.api_key) apiKey = "";
+
+    const next = { ...current, url, api_key: apiKey };
+
+    say("");
+    say("Changes:");
+    say(`  url:     ${current.url || "(not set)"} -> ${next.url}`);
+    say(`  api_key: ${maskSecret(current.api_key)} -> ${maskSecret(next.api_key)}`);
+    const confirm = (await rl.question("Write config? [Y/n] ")).trim().toLowerCase();
+    if (confirm === "n" || confirm === "no") {
+      say("Aborted; nothing written.");
+      return { written: false, path: cliPath };
+    }
+
+    mkdirSync(dirname(cliPath), { recursive: true });
+    if (existsSync(cliPath)) {
+      copyFileSync(cliPath, `${cliPath}.bak.${Date.now()}`);
+    }
+    writeFileSync(cliPath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    try {
+      chmodSync(cliPath, 0o600);
+    } catch {
+      /* best effort on platforms without chmod semantics */
+    }
+    say(`Written: ${cliPath}`);
+    say("The stdio MCP proxy and hooks pick this up on the next harness start.");
+    return { written: true, path: cliPath };
+  } finally {
+    rl.close();
+  }
+}

package/lib/shared/uri-guard.mjs

@@ -0,0 +1,56 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+const DEFAULT_URI_KEYS = [
+  "filePath",
+  "file_path",
+  "filepath",
+  "path",
+  "uri",
+  "target_uri",
+  "targetUri",
+  "pattern",
+];
+
+export function normalizeToolName(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+export function findVikingUri(args = {}, keys = DEFAULT_URI_KEYS) {
+  if (!args || typeof args !== "object") return null;
+  for (const key of keys) {
+    const uri = findVikingUriInValue(args[key]);
+    if (uri) return uri;
+  }
+  return findVikingUriInValue(args);
+}
+
+export function findVikingUriInValue(value) {
+  if (typeof value === "string") {
+    const match = value.match(/\bviking:\/\/[^\s"'`<>)]*/i);
+    return match?.[0] || null;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const uri = findVikingUriInValue(item);
+      if (uri) return uri;
+    }
+    return null;
+  }
+  if (value && typeof value === "object") {
+    for (const item of Object.values(value)) {
+      const uri = findVikingUriInValue(item);
+      if (uri) return uri;
+    }
+  }
+  return null;
+}
+
+export function buildGuardMessage(uri, hint = {}) {
+  const tool = hint.tool || "the OpenViking MCP tools";
+  const example = typeof hint.example === "function" ? hint.example(uri) : hint.example;
+  const lines = [
+    "viking:// URIs are OpenViking virtual paths, not local filesystem paths.",
+    `Use ${tool} instead.`,
+  ];
+  if (example) lines.push(`Example: ${example}`);
+  return lines.join("\n");
+}

package/lib/utils.mjs

@@ -1,123 +1,8 @@
 import fs from "fs"
 import path from "path"
-import { homedir } from "os"
-
-export const DEFAULT_CONFIG = {
-  endpoint: "http://localhost:1933",
-  apiKey: "",
-  account: "",
-  user: "",
-  peerId: "",
-  enabled: true,
-  timeoutMs: 30000,
-  runtime: {
-    dataDir: "",
-  },
-  repoContext: {
-    enabled: true,
-    cacheTtlMs: 60000,
-  },
-  autoRecall: {
-    enabled: true,
-    limit: 6,
-    scoreThreshold: 0.15,
-    maxContentChars: 500,
-    preferAbstract: true,
-    tokenBudget: 2000,
-  },
-}
 
 let logFilePath = null
 
-function cloneDefaultConfig() {
-  return JSON.parse(JSON.stringify(DEFAULT_CONFIG))
-}
-
-function mergeConfig(fileConfig = {}) {
-  const config = cloneDefaultConfig()
-  for (const key of ["endpoint", "apiKey", "account", "user", "peerId", "enabled", "timeoutMs"]) {
-    if (fileConfig[key] !== undefined) config[key] = fileConfig[key]
-  }
-  config.runtime = {
-    ...DEFAULT_CONFIG.runtime,
-    dataDir: fileConfig.runtime?.dataDir ?? DEFAULT_CONFIG.runtime.dataDir,
-  }
-  config.repoContext = { ...DEFAULT_CONFIG.repoContext, ...(fileConfig.repoContext ?? {}) }
-  config.autoRecall = { ...DEFAULT_CONFIG.autoRecall, ...(fileConfig.autoRecall ?? {}) }
-
-  if (process.env.OPENVIKING_API_KEY) {
-    config.apiKey = process.env.OPENVIKING_API_KEY
-  }
-  if (process.env.OPENVIKING_ACCOUNT) {
-    config.account = process.env.OPENVIKING_ACCOUNT
-  }
-  if (process.env.OPENVIKING_USER) {
-    config.user = process.env.OPENVIKING_USER
-  }
-  if (process.env.OPENVIKING_PEER_ID) {
-    config.peerId = process.env.OPENVIKING_PEER_ID
-  }
-
-  config.timeoutMs = normalizeNumber(config.timeoutMs, DEFAULT_CONFIG.timeoutMs, 1000, 300000)
-  config.repoContext.cacheTtlMs = normalizeNumber(
-    config.repoContext.cacheTtlMs,
-    DEFAULT_CONFIG.repoContext.cacheTtlMs,
-    1000,
-    60 * 60 * 1000,
-  )
-  clampRecallConfig(config.autoRecall)
-  return config
-}
-
-function normalizeNumber(value, fallback, min, max) {
-  const next = Number(value)
-  if (!Number.isFinite(next)) return fallback
-  return Math.max(min, Math.min(max, next))
-}
-
-function clampRecallConfig(recall) {
-  recall.limit = Math.max(1, Math.min(50, Math.round(Number(recall.limit) || 6)))
-  recall.scoreThreshold = Math.max(0, Math.min(1, Number(recall.scoreThreshold) || 0))
-  recall.maxContentChars = Math.max(100, Math.min(5000, Math.round(Number(recall.maxContentChars) || 500)))
-  recall.tokenBudget = Math.max(100, Math.min(10000, Math.round(Number(recall.tokenBudget) || 2000)))
-}
-
-export function loadConfig(pluginRoot, projectDirectory) {
-  for (const configPath of getConfigPaths(pluginRoot, projectDirectory)) {
-    try {
-      if (fs.existsSync(configPath)) {
-        const fileConfig = JSON.parse(fs.readFileSync(configPath, "utf8"))
-        return mergeConfig(fileConfig)
-      }
-    } catch (error) {
-      console.warn(`Failed to load OpenViking config from ${configPath}:`, error)
-    }
-  }
-  return mergeConfig()
-}
-
-function getConfigPaths(pluginRoot, projectDirectory) {
-  const paths = []
-  if (process.env.OPENVIKING_PLUGIN_CONFIG) paths.push(expandHome(process.env.OPENVIKING_PLUGIN_CONFIG))
-  if (projectDirectory) paths.push(path.join(projectDirectory, ".opencode", "openviking-config.json"))
-  paths.push(path.join(homedir(), ".config", "opencode", "openviking-config.json"))
-  paths.push(path.join(pluginRoot, "openviking-config.json"))
-  return paths
-}
-
-export function resolveDataDir(pluginRoot, config) {
-  const configured = config.runtime?.dataDir
-  if (configured) return expandHome(configured)
-  return path.join(homedir(), ".config", "opencode", "openviking")
-}
-
-function expandHome(value) {
-  if (!value || typeof value !== "string") return value
-  if (value === "~") return homedir()
-  if (value.startsWith("~/") || value.startsWith("~\\")) return path.join(homedir(), value.slice(2))
-  return value
-}
-
 export function initLogger(dataDir) {
   fs.mkdirSync(dataDir, { recursive: true })
   logFilePath = path.join(dataDir, "openviking-memory.log")
@@ -183,6 +68,38 @@ export function effectivePeerId(config) {
   return String(config.peerId || "").trim() || null
 }
 
+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) : {}
+    if (!response.ok || payload?.status === "error") {
+      return {
+        ok: false,
+        status: response.status,
+        error: payload?.error || payload?.message || { message: `HTTP ${response.status}` },
+      }
+    }
+    return { ok: true, status: response.status, result: payload?.result ?? payload }
+  } catch (error) {
+    return { ok: false, status: 0, error: { message: error?.message ?? String(error) } }
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
 export async function makeRequest(config, options) {
   const url = `${normalizeEndpoint(config.endpoint)}${options.endpoint}`
   const headers = makeAuthHeaders(
@@ -291,7 +208,7 @@ export async function makeMultipartRequest(config, options) {
 
 function makeAuthHeaders(config, headers = {}, actorPeerId = "") {
   const result = { ...headers }
-  if (config.apiKey) result["X-API-Key"] = config.apiKey
+  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()

package/lib/viking-uri-guard.mjs

@@ -1,17 +1,18 @@
 import { log } from "./utils.mjs"
+import { buildGuardMessage, findVikingUri, normalizeToolName } from "./shared/uri-guard.mjs"
 
 const FILESYSTEM_TOOL_HINTS = {
   read: {
-    replacement: "memread",
-    example: (uri) => `memread(uri="${uri}", level="auto")`,
+    tool: "openviking_read",
+    example: (uri) => `openviking_read(uri="${uri}")`,
   },
   glob: {
-    replacement: "membrowse",
-    example: (uri) => `membrowse(uri="${uri}", view="list", recursive=true)`,
+    tool: "openviking_glob",
+    example: (uri) => `openviking_glob(uri="${uri}", pattern="**/*")`,
   },
   grep: {
-    replacement: "memsearch",
-    example: (uri, args) => `memsearch(query="${String(args.pattern ?? "").replaceAll('"', '\\"')}", target_uri="${uri}")`,
+    tool: "openviking_search",
+    example: (uri, args = {}) => `openviking_search(query="${String(args.pattern ?? "").replaceAll('"', '\\"')}", target_uri="${uri}")`,
   },
 }
 
@@ -29,24 +30,8 @@ export function createVikingUriGuard() {
       tool: toolName,
       uri,
     })
-    throw new Error(
-      [
-        "viking:// URIs are OpenViking virtual paths, not local filesystem paths.",
-        `Use ${hint.replacement} instead.`,
-        `Example: ${hint.example(uri, args)}`,
-      ].join("\n"),
-    )
+    throw new Error(buildGuardMessage(uri, { ...hint, example: hint.example(uri, args) }))
   }
 }
 
-export function findVikingUri(args = {}) {
-  for (const key of ["filePath", "path", "uri"]) {
-    const value = args[key]
-    if (typeof value === "string" && value.startsWith("viking://")) return value
-  }
-  return null
-}
-
-function normalizeToolName(value) {
-  return String(value || "").trim().toLowerCase()
-}
+export { findVikingUri, normalizeToolName }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -10,22 +10,23 @@
     "tui"
   ],
   "exports": {
-    ".": "./index.mjs"
+    ".": "./index.mjs",
+    "./servers/mcp-proxy.mjs": "./servers/mcp-proxy.mjs"
   },
   "files": [
     "index.mjs",
     "lib/",
+    "servers/",
+    "scripts/",
     "README.md",
     "INSTALL.md",
     "INSTALL-ZH.md"
   ],
   "scripts": {
-    "check": "node --check index.mjs && node --check lib/runtime.mjs && node --check lib/repo-context.mjs && node --check lib/memory-session.mjs && node --check lib/memadd-local.mjs && node --check lib/memory-tools.mjs && node --check lib/code-tools.mjs && node --check lib/memory-recall.mjs && node --check lib/viking-uri-guard.mjs && node --check lib/utils.mjs && node --check tests/*.test.mjs",
-    "test": "node --test tests/*.test.mjs"
-  },
-  "dependencies": {
-    "@opencode-ai/plugin": "^1.14.37"
+    "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"
   },
+  "dependencies": {},
   "publishConfig": {
     "access": "public"
   },

package/scripts/setup.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runSetupWizard } from "../lib/shared/setup-wizard.mjs"
+
+runSetupWizard().catch((err) => {
+  process.stderr.write(`${err?.stack || err}\n`)
+  process.exit(1)
+})

package/servers/mcp-proxy.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+/**
+ * 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
+ * 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 { fileURLToPath } from "node:url"
+import { loadConfig } from "../lib/config.mjs"
+import { createLogger } from "../lib/shared/debug-log.mjs"
+import { createOpenVikingMcpProxy } from "../lib/shared/mcp-proxy-core.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 mcpUrl = cfg.mcpUrl || `${trimSlash(cfg.endpoint)}/mcp`
+  return {
+    mcpUrl,
+    apiKey: cfg.apiKey || "",
+    account: cfg.account || "",
+    user: cfg.user || "",
+    peerId: cfg.peerId || "",
+    timeoutMs: Math.max(1000, Number(cfg.timeoutMs) || DEFAULT_TIMEOUT_MS),
+    debug: cfg.debug === true,
+    debugLogPath: cfg.debugLogPath,
+    credentialSource: cfg.credentialSource || "auto",
+    credentialPath: cfg.credentialPath || cfg.configPath || "",
+    watchedPaths: uniq([
+      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])) {
+  createOpenVikingMcpProxy({ readConfig: readProxyConfig, loggerFactory: createLogger }).start()
+}

package/servers/mcp-proxy.test.mjs

@@ -0,0 +1,100 @@
+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",
+      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")
+    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)
+  })
+})