@rynfar/meridian 1.63.0 → 1.65.0

package/dist/cli-n8t34zmq.js

@@ -0,0 +1,939 @@
+import {
+  __commonJS,
+  __esm,
+  __require,
+  __toESM
+} from "./cli-p9swy5t3.js";
+
+// node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function checkPathExt(path, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i = 0;i < pathext.length; i++) {
+      var p = pathext[i].toLowerCase();
+      if (p && path.substr(-p.length).toLowerCase() === p) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat, path, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile()) {
+      return false;
+    }
+    return checkPathExt(path, options);
+  }
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), path, options);
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), options);
+  }
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
+  }
+  function checkMode(stat, options) {
+    var mod = stat.mode;
+    var uid = stat.uid;
+    var gid = stat.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+    var u = parseInt("100", 8);
+    var g = parseInt("010", 8);
+    var o = parseInt("001", 8);
+    var ug = u | g;
+    var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var core;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core = require_windows();
+  } else {
+    core = require_mode();
+  }
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve, reject) {
+        isexe(path, options || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve(is);
+          }
+        });
+      });
+    }
+    core(path, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path, options) {
+    try {
+      return core.sync(path, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS((exports, module) => {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path = __require("path");
+  var COLON = isWindows ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, opt) => {
+    const colon = opt.colon || COLON;
+    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd, opt, cb) => {
+    if (typeof opt === "function") {
+      cb = opt;
+      opt = {};
+    }
+    if (!opt)
+      opt = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    const step = (i) => new Promise((resolve, reject) => {
+      if (i === pathEnv.length)
+        return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve(subStep(p, i, 0));
+    });
+    const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+      if (ii === pathExt.length)
+        return resolve(step(i + 1));
+      const ext = pathExt[ii];
+      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p + ext);
+          else
+            return resolve(p + ext);
+        }
+        return resolve(subStep(p, i, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd, opt) => {
+    opt = opt || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (let i = 0;i < pathEnv.length; i++) {
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j = 0;j < pathExt.length; j++) {
+        const cur = p + pathExt[j];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module) => {
+  var pathKey = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform = options.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module) => {
+  var path = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path.delimiter : undefined
+      });
+    } catch (e) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS((exports, module) => {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS((exports, module) => {
+  module.exports = /^#!(.*)/;
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module) => {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string = "") => {
+    const match = string.match(shebangRegex);
+    if (!match) {
+      return null;
+    }
+    const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path.split("/").pop();
+    if (binary === "env") {
+      return argument;
+    }
+    return argument ? `${binary} ${argument}` : binary;
+  };
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs.openSync(command, "r");
+      fs.readSync(fd, buffer, 0, size, 0);
+      fs.closeSync(fd);
+    } catch (e) {}
+    return shebangCommand(buffer.toString());
+  }
+  module.exports = readShebang;
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var path = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape = require_escape();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path.normalize(parsed.command);
+      parsed.command = escape.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse;
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module) => {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        const err = verifyENOENT(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module) => {
+  var cp = __require("child_process");
+  var parse = require_parse();
+  var enoent = require_enoent();
+  function spawn(command, args, options) {
+    const parsed = parse(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options) {
+    const parsed = parse(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn;
+  module.exports.spawn = spawn;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse;
+  module.exports._enoent = enoent;
+});
+
+// src/proxy/priorityAttestation.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+function configDirectory() {
+  return process.env.MERIDIAN_CONFIG_DIR ?? join(homedir(), ".config", "meridian");
+}
+function priorityAttestationKeyPath() {
+  return join(configDirectory(), PRIORITY_ATTESTATION_KEY_FILE);
+}
+function decodeCanonicalBase64Url(raw) {
+  if (!/^[A-Za-z0-9_-]+$/.test(raw))
+    return;
+  const decoded = Buffer.from(raw, "base64url");
+  return decoded.toString("base64url") === raw ? decoded : undefined;
+}
+function decodePriorityAttestationKey(raw) {
+  if (raw === undefined)
+    return;
+  const decoded = decodeCanonicalBase64Url(raw.trim());
+  return decoded?.length === 32 ? decoded : undefined;
+}
+function loadPriorityAttestationKey() {
+  const fromEnv = process.env[PRIORITY_ATTESTATION_KEY_ENV];
+  if (fromEnv !== undefined)
+    return decodePriorityAttestationKey(fromEnv);
+  try {
+    return decodePriorityAttestationKey(readFileSync(priorityAttestationKeyPath(), "utf8"));
+  } catch {
+    return;
+  }
+}
+function readRequiredFileKey(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    throw new InvalidPriorityAttestationKeyError(path);
+  }
+  const key = decodePriorityAttestationKey(raw);
+  if (!key)
+    throw new InvalidPriorityAttestationKeyError(path);
+  return key;
+}
+function ensurePriorityAttestationKey() {
+  const fromEnv = process.env[PRIORITY_ATTESTATION_KEY_ENV];
+  if (fromEnv !== undefined) {
+    const key2 = decodePriorityAttestationKey(fromEnv);
+    if (!key2)
+      throw new InvalidPriorityAttestationKeyError(PRIORITY_ATTESTATION_KEY_ENV);
+    return { key: key2 };
+  }
+  const path = priorityAttestationKeyPath();
+  try {
+    const key2 = readRequiredFileKey(path);
+    if (platform() !== "win32")
+      chmodSync(path, 384);
+    return { key: key2, path };
+  } catch (error) {
+    if (!(error instanceof InvalidPriorityAttestationKeyError))
+      throw error;
+    try {
+      readFileSync(path);
+      throw error;
+    } catch (readError) {
+      if (readError === error)
+        throw error;
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const encoded = randomBytes(32).toString("base64url");
+  try {
+    writeFileSync(path, `${encoded}
+`, { encoding: "utf8", flag: "wx", mode: 384 });
+  } catch (error) {
+    const code = typeof error === "object" && error !== null ? Reflect.get(error, "code") : undefined;
+    if (code !== "EEXIST")
+      throw error;
+  }
+  const key = readRequiredFileKey(path);
+  if (platform() !== "win32")
+    chmodSync(path, 384);
+  return { key, path };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeAgentId(value) {
+  return value.length >= 1 && value.length <= 64 && value.trim() === value && /^[\x20-\x7E]+$/.test(value);
+}
+function parseCanonicalPayload(raw) {
+  if (Buffer.byteLength(raw) > MAX_PAYLOAD_BYTES)
+    return;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (!isRecord(value))
+    return;
+  if (Object.keys(value).join(",") !== "v,g,s,a,t,iat")
+    return;
+  if (value.v !== 1)
+    return;
+  if (value.g !== "oc1" && value.g !== "oc2b18314")
+    return;
+  if (typeof value.s !== "string" || !SAFE_ID_PATTERN.test(value.s))
+    return;
+  if (typeof value.a !== "string" || !isSafeAgentId(value.a))
+    return;
+  if (typeof value.t !== "string" || !TURN_DIGEST_PATTERN.test(value.t))
+    return;
+  if (typeof value.iat !== "number" || !Number.isSafeInteger(value.iat) || value.iat < 0)
+    return;
+  const canonical = JSON.stringify({
+    v: 1,
+    g: value.g,
+    s: value.s,
+    a: value.a,
+    t: value.t,
+    iat: value.iat
+  });
+  if (canonical !== raw)
+    return;
+  return {
+    generation: value.g,
+    sessionId: value.s,
+    agentId: value.a,
+    turnId: value.t,
+    issuedAt: value.iat
+  };
+}
+function verifyPriorityAttestation(token, key = loadPriorityAttestationKey() ?? Buffer.alloc(0), nowSeconds = Math.floor(Date.now() / 1000)) {
+  if (!token || key.length !== 32 || Buffer.byteLength(token) > MAX_HEADER_BYTES)
+    return;
+  const match = TOKEN_PATTERN.exec(token);
+  if (!match?.[1] || !match[2])
+    return;
+  const payloadBytes = decodeCanonicalBase64Url(match[1]);
+  const suppliedMac = decodeCanonicalBase64Url(match[2]);
+  if (!payloadBytes || !suppliedMac || suppliedMac.length !== 32)
+    return;
+  const payloadRaw = payloadBytes.toString("utf8");
+  if (Buffer.from(payloadRaw, "utf8").compare(payloadBytes) !== 0)
+    return;
+  const payload = parseCanonicalPayload(payloadRaw);
+  if (!payload)
+    return;
+  if (payload.issuedAt < nowSeconds - MAX_PAST_AGE_SECONDS)
+    return;
+  if (payload.issuedAt > nowSeconds + MAX_FUTURE_SKEW_SECONDS)
+    return;
+  const expectedMac = createHmac("sha256", key).update(MAC_DOMAIN).update(payloadRaw).digest();
+  if (!timingSafeEqual(expectedMac, suppliedMac))
+    return;
+  return payload;
+}
+var PRIORITY_ATTESTATION_HEADER = "x-meridian-opencode-turn", PRIORITY_ATTESTATION_KEY_ENV = "MERIDIAN_OPENCODE_ATTESTATION_KEY", PRIORITY_ATTESTATION_KEY_FILE = "opencode-turn.key", TOKEN_PATTERN, MAC_DOMAIN = "meridian.opencode.turn.v1\x00", MAX_HEADER_BYTES = 768, MAX_PAYLOAD_BYTES = 384, MAX_PAST_AGE_SECONDS = 120, MAX_FUTURE_SKEW_SECONDS = 30, SAFE_ID_PATTERN, TURN_DIGEST_PATTERN, InvalidPriorityAttestationKeyError;
+var init_priorityAttestation = __esm(() => {
+  TOKEN_PATTERN = /^v1\.([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]{43})$/;
+  SAFE_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+  TURN_DIGEST_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+  InvalidPriorityAttestationKeyError = class InvalidPriorityAttestationKeyError extends Error {
+    keyPath;
+    constructor(keyPath) {
+      super(`OpenCode routing attestation key is invalid at ${keyPath}`);
+      this.keyPath = keyPath;
+      this.name = "InvalidPriorityAttestationKeyError";
+    }
+  };
+});
+
+// src/proxy/setup.ts
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2, platform as platform2 } from "os";
+import { basename, dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { applyEdits, modify, parse as parseJsonc } from "jsonc-parser";
+
+// src/utils/lruMap.ts
+class LRUMap {
+  maxSize;
+  onEvict;
+  map = new Map;
+  constructor(maxSize, onEvict) {
+    this.maxSize = maxSize;
+    this.onEvict = onEvict;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value === undefined)
+      return;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.maxSize) {
+      this.evictOldest();
+    }
+    this.map.set(key, value);
+    return this;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+  forEach(callbackfn) {
+    this.map.forEach((value, key) => callbackfn(value, key, this));
+  }
+  [Symbol.iterator]() {
+    return this.map[Symbol.iterator]();
+  }
+  evictOldest() {
+    const oldestKey = this.map.keys().next().value;
+    if (oldestKey === undefined)
+      return;
+    const oldestValue = this.map.get(oldestKey);
+    if (oldestValue === undefined)
+      return;
+    this.map.delete(oldestKey);
+    this.onEvict?.(oldestKey, oldestValue);
+  }
+}
+
+// src/proxy/setup.ts
+init_priorityAttestation();
+
+class UnparseableConfigError extends Error {
+  configPath;
+  constructor(configPath) {
+    super(`Could not parse ${configPath} — it may contain a syntax error.`);
+    this.configPath = configPath;
+    this.name = "UnparseableConfigError";
+  }
+}
+
+class MissingV2PluginError extends Error {
+  expectedPath;
+  constructor(expectedPath) {
+    super(`OpenCode V2 plugin bundle not found at ${expectedPath}`);
+    this.expectedPath = expectedPath;
+    this.name = "MissingV2PluginError";
+  }
+}
+
+class DuplicateMeridianConfigError extends Error {
+  configPath;
+  siblingPath;
+  constructor(configPath, siblingPath) {
+    super(`A Meridian entry in ${siblingPath} conflicts with setup target ${configPath}`);
+    this.configPath = configPath;
+    this.siblingPath = siblingPath;
+    this.name = "DuplicateMeridianConfigError";
+  }
+}
+function parseOpencodeConfig(text) {
+  const errors = [];
+  const parsed = parseJsonc(text, errors, { allowTrailingComma: true });
+  if (errors.length > 0 || parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  return parsed;
+}
+function opencodeConfigDirectory() {
+  if (process.env.OPENCODE_CONFIG_DIR)
+    return process.env.OPENCODE_CONFIG_DIR;
+  if (process.env.XDG_CONFIG_HOME)
+    return join2(process.env.XDG_CONFIG_HOME, "opencode");
+  if (platform2() === "win32" && process.env.APPDATA)
+    return join2(process.env.APPDATA, "opencode");
+  return join2(homedir2(), ".config", "opencode");
+}
+function findOpencodeConfigPath() {
+  const dir = opencodeConfigDirectory();
+  const jsonPath = join2(dir, "opencode.json");
+  const jsoncPath = join2(dir, "opencode.jsonc");
+  return !existsSync(jsonPath) && existsSync(jsoncPath) ? jsoncPath : jsonPath;
+}
+function siblingOpencodeConfigPath(configPath) {
+  const name = basename(configPath);
+  if (name === "opencode.json")
+    return join2(dirname2(configPath), "opencode.jsonc");
+  if (name === "opencode.jsonc")
+    return join2(dirname2(configPath), "opencode.json");
+  return;
+}
+function findPluginPath(fromUrl) {
+  const dir = dirname2(fileURLToPath(fromUrl));
+  return join2(dir, "..", "plugin", "meridian.ts");
+}
+var SUPPORTED_OPENCODE_V2_VERSION = "0.0.0-beta-18314";
+function findV2PluginPath(fromUrl) {
+  const entryPath = fileURLToPath(fromUrl);
+  const dir = dirname2(entryPath);
+  if (entryPath.endsWith(".ts")) {
+    const sourcePlugin = join2(dir, "..", "plugin", "meridian-v2.ts");
+    if (existsSync(sourcePlugin))
+      return sourcePlugin;
+    throw new MissingV2PluginError(sourcePlugin);
+  }
+  const bundledPlugin = join2(dir, "meridian-v2.js");
+  if (existsSync(bundledPlugin))
+    return bundledPlugin;
+  throw new MissingV2PluginError(bundledPlugin);
+}
+function classifyOpenCodeVersion(output) {
+  const match = output.trim().match(/^(?:opencode2?\s+)?v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/i);
+  const version = match?.[1];
+  if (!version)
+    return;
+  const major = Number(version.split(".", 1)[0]);
+  return {
+    generation: major === 1 ? "v1" : "v2",
+    version
+  };
+}
+function detectOpenCodeGeneration(commands = process.env.OPENCODE_BIN ? [process.env.OPENCODE_BIN] : ["opencode", "opencode2"], probe = (command) => {
+  const result = import_cross_spawn.default.sync(command, ["--version"], {
+    encoding: "utf8",
+    timeout: 3000,
+    windowsHide: true
+  });
+  if (result.error || result.status !== 0)
+    return;
+  return String(result.stdout ?? "");
+}) {
+  for (const command of commands) {
+    const output = probe(command);
+    if (!output)
+      continue;
+    const detected = classifyOpenCodeVersion(output);
+    if (detected)
+      return { ...detected, command };
+  }
+  return { generation: "v1" };
+}
+function pluginPathForGeneration(fromUrl, generation) {
+  return generation === "v2" ? findV2PluginPath(fromUrl) : findPluginPath(fromUrl);
+}
+var STALE_PATTERNS = [
+  "opencode-claude-max-proxy",
+  "claude-max-headers",
+  "meridian-agent-mode"
+];
+function pluginEntryPackage(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+    return;
+  const packageName = Reflect.get(entry, "package");
+  return typeof packageName === "string" ? packageName : undefined;
+}
+function isMeridianEntry(entry) {
+  const packageName = pluginEntryPackage(entry);
+  if (!packageName)
+    return false;
+  return STALE_PATTERNS.some((pattern) => packageName.includes(pattern)) || packageName.includes("meridian.ts") || packageName.includes("meridian-v2.") || packageName.includes("@rynfar/meridian");
+}
+function checkPluginConfigured(configPath, expectedPluginPath) {
+  const selectedPath = configPath ?? findOpencodeConfigPath();
+  const siblingPath = configPath ? undefined : siblingOpencodeConfigPath(selectedPath);
+  const paths = siblingPath ? [selectedPath, siblingPath] : [selectedPath];
+  return paths.some((path) => {
+    if (!existsSync(path))
+      return false;
+    const config = parseOpencodeConfig(readFileSync2(path, "utf-8"));
+    if (config === null)
+      return false;
+    const plugins = [
+      ...Array.isArray(config.plugin) ? config.plugin : [],
+      ...Array.isArray(config.plugins) ? config.plugins : []
+    ];
+    if (expectedPluginPath)
+      return plugins.some((entry) => pluginEntryPackage(entry) === expectedPluginPath);
+    return plugins.some(isMeridianEntry);
+  });
+}
+var pluginlessWarned = new LRUMap(256);
+function clearPluginlessWarnings() {
+  pluginlessWarned.clear();
+}
+function notePluginlessOpenCodeRequest(input) {
+  if (!input.userAgent?.toLowerCase().startsWith("opencode/"))
+    return;
+  if (input.agentModeHeader)
+    return;
+  const key = input.sessionId || "(keyless)";
+  if (pluginlessWarned.get(key))
+    return;
+  pluginlessWarned.set(key, true);
+  const shortId = input.sessionId ? `${input.sessionId.slice(0, 12)}…` : "(no session header)";
+  return `OpenCode request without the Meridian plugin's agent headers (session ${shortId}). ` + `OpenCode runs its internal title/summary agents under your session id, so Meridian ` + `cannot tell them apart from your conversation: the first turn of each session can fail ` + `with a 400 or replay against a cold cache. Fix: meridian setup (or update the plugin).`;
+}
+function runSetup(pluginPath, configPath, generation = "v1") {
+  const path = configPath ?? findOpencodeConfigPath();
+  const dir = dirname2(path);
+  const targetField = generation === "v2" ? "plugins" : "plugin";
+  const otherField = generation === "v2" ? "plugin" : "plugins";
+  const siblingPath = siblingOpencodeConfigPath(path);
+  if (siblingPath && existsSync(siblingPath)) {
+    const siblingConfig = parseOpencodeConfig(readFileSync2(siblingPath, "utf-8"));
+    if (siblingConfig === null)
+      throw new UnparseableConfigError(siblingPath);
+    const siblingPlugins = [
+      ...Array.isArray(siblingConfig.plugin) ? siblingConfig.plugin : [],
+      ...Array.isArray(siblingConfig.plugins) ? siblingConfig.plugins : []
+    ];
+    if (siblingPlugins.some(isMeridianEntry)) {
+      throw new DuplicateMeridianConfigError(path, siblingPath);
+    }
+  }
+  if (!existsSync(path)) {
+    ensurePriorityAttestationKey();
+    if (!existsSync(dir))
+      mkdirSync2(dir, { recursive: true });
+    writeFileSync2(path, `${JSON.stringify({ [targetField]: [pluginPath] }, null, 2)}
+`, "utf-8");
+    return { configPath: path, pluginPath, alreadyConfigured: false, removedStale: [], created: true };
+  }
+  const text = readFileSync2(path, "utf-8");
+  const config = parseOpencodeConfig(text);
+  if (config === null) {
+    throw new UnparseableConfigError(path);
+  }
+  const entries = (field) => Array.isArray(config[field]) ? config[field] : [];
+  const targetEntries = entries(targetField);
+  const otherEntries = entries(otherField);
+  const targetMeridian = targetEntries.filter(isMeridianEntry);
+  const otherMeridian = otherEntries.filter(isMeridianEntry);
+  const targetExact = targetMeridian.filter((entry) => pluginEntryPackage(entry) === pluginPath);
+  const removedStale = [...targetMeridian, ...otherMeridian].flatMap((entry) => {
+    const packageName = pluginEntryPackage(entry);
+    return packageName ? [packageName] : [];
+  });
+  const alreadyConfigured = targetMeridian.length === 1 && targetExact.length === 1 && otherMeridian.length === 0;
+  const targetPlugin = targetExact.length === 1 && targetMeridian.length === 1 ? targetExact[0] : pluginPath;
+  const targetPlugins = [
+    ...targetEntries.filter((entry) => !isMeridianEntry(entry)),
+    targetPlugin
+  ];
+  const otherPlugins = otherEntries.filter((entry) => !isMeridianEntry(entry));
+  let updated = text;
+  const formattingOptions = { insertSpaces: true, tabSize: 2 };
+  updated = applyEdits(updated, modify(updated, [targetField], targetPlugins, { formattingOptions }));
+  if (Array.isArray(config[otherField]) && otherMeridian.length > 0) {
+    updated = applyEdits(updated, modify(updated, [otherField], otherPlugins, { formattingOptions }));
+  }
+  ensurePriorityAttestationKey();
+  writeFileSync2(path, updated, "utf-8");
+  return { configPath: path, pluginPath, alreadyConfigured, removedStale, created: false };
+}
+
+export { LRUMap, PRIORITY_ATTESTATION_HEADER, verifyPriorityAttestation, init_priorityAttestation, UnparseableConfigError, MissingV2PluginError, DuplicateMeridianConfigError, findOpencodeConfigPath, findPluginPath, SUPPORTED_OPENCODE_V2_VERSION, findV2PluginPath, classifyOpenCodeVersion, detectOpenCodeGeneration, pluginPathForGeneration, checkPluginConfigured, clearPluginlessWarnings, notePluginlessOpenCodeRequest, runSetup };