@sagentlab/navarch-runtime 0.1.118 → 0.1.121

package/README.md

@@ -815,6 +815,21 @@ to OpenCode's remote-server config with OAuth disabled and environment-backed
 headers. Missing accounting fields stay absent rather than becoming a
 fabricated zero.
 
+Host OpenCode sessions preserve operator provider definitions from
+`$XDG_CONFIG_HOME/opencode/opencode.json(c)` (default
+`~/.config/opencode/opencode.json(c)`), then `OPENCODE_CONFIG`, configs in
+`OPENCODE_CONFIG_DIR`, and finally `OPENCODE_CONFIG_CONTENT`. JSONC comments
+and trailing commas are supported. Nested provider settings merge in that
+order; later arrays replace earlier arrays. Legacy `provider` entries work
+with V1 and V2; native `providers` entries are included for V2. Custom model
+IDs, metadata, and variants are preserved, so a pin such as
+`--model magpie/openrouter/deepseek/deepseek-v4.1-flash-1017` works without
+duplicating the provider configuration. API keys and header values become
+child environment references, and file references resolve relative to their
+original config file. Provider settings are the only imported configuration:
+Navarch still generates the session's MCP and permissions and disables
+project config discovery. Docker sessions do not import host providers.
+
 OpenCode also runs with `--print-logs --log-level ERROR` by default (see its
 [CLI flags](https://opencode.ai/docs/cli/#global-flags)), so provider errors
 that are missing from assistant messages still reach the runtime. A rate or

package/bin/worktree-guard-hook.cjs

@@ -214,6 +214,73 @@ function isInsideOpeningQuote(command, start) {
   return beforeQuote === undefined || /[\s=(<>;|&]/.test(beforeQuote);
 }
 
+/**
+ * Returns [open, close, segmentStart] for the quoted word containing `index`,
+ * or null when it sits outside quotes or the quote state cannot be trusted.
+ * `segmentStart` follows the last unquoted, unescaped `;`, `|`, `&` or newline
+ * before the word, so a separator inside quotes never starts a segment. Only
+ * plain single and double quotes are tracked. Constructs that nest or hide
+ * quotes (backticks, `$(`, `$'`, heredocs, shell comments) make the scan bail
+ * out, so a misread quote never exempts a token.
+ */
+function quotedSpanAt(command, index) {
+  let quote = "";
+  let open = -1;
+  let segmentStart = 0;
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i];
+    if (quote === "'") {
+      if (ch === "'") {
+        if (index > open && index < i) return [open, i, segmentStart];
+        quote = "";
+      }
+      continue;
+    }
+    if (ch === "`" || (ch === "$" && (command[i + 1] === "(" || command[i + 1] === "'"))) return null;
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (quote === '"') {
+      if (ch === '"') {
+        if (index > open && index < i) return [open, i, segmentStart];
+        quote = "";
+      }
+      continue;
+    }
+    if (/[;|&\n]/.test(ch)) segmentStart = i + 1;
+    if (ch === "<" && command[i + 1] === "<") return null;
+    if (ch === "#" && (i === 0 || /[\s;|&(]/.test(command[i - 1]))) return null;
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      open = i;
+    }
+  }
+  return null;
+}
+
+/**
+ * True for the jq alternative operator (`//`, `//=`) used as its own word inside
+ * a quoted jq program: `jq '.a // "x"' f.json`, `gh ... --jq '(.x) // "none"'`.
+ * Narrow on purpose. The token must be whitespace-delimited, sit inside a
+ * plain-quoted word in a shell segment whose command word is `jq`, or is `gh`
+ * with the word given to `--jq`/`-q`. Unquoted tokens (`find // -x`),
+ * quoted bare roots (`ls "//"`) and `//` in other quoted text stay screened.
+ */
+function isJqAlternativeOperator(command, start, token) {
+  if (token !== "//" && token !== "//=") return false;
+  const next = command[start + token.length];
+  if (!/\s/.test(command[start - 1] ?? "") || next === undefined || !/\s/.test(next)) return false;
+  const span = quotedSpanAt(command, start);
+  if (!span) return false;
+  const segment = command.slice(span[2], span[0]);
+  const commandWord = /^\s*\(?\s*(?:[A-Za-z_]\w*=\S*\s+)*/;
+  if (new RegExp(commandWord.source + "jq\\s").test(segment)) return true;
+  return (
+    new RegExp(commandWord.source + "gh\\s").test(segment) && /\s(?:--jq|-q)(?:=|\s+)$/.test(segment)
+  );
+}
+
 /**
  * True when a "/"-leading token is comment or markup text rather than a path:
  * a closing tag (`</p>`), a block-comment opener (`/**`, `/*`), or a line
@@ -222,12 +289,16 @@ function isInsideOpeningQuote(command, start) {
  * checked, `/*` and `//` only count at a comment position (line start, right
  * after an opening quote, or after `;`) so `rm -rf /*`, `find // -name x`
  * and `rm -rf "" /*` stay blocked, and a block comment needs a closing
- * `*` + `/` later in the text.
+ * `*` + `/` later in the text. The jq alternative operator inside a quoted jq
+ * program is exempt under the separate, narrower rule in
+ * isJqAlternativeOperator.
  */
 function isCommentOrMarkupToken(command, start, token) {
   const end = start + token.length;
   const next = command[end];
 
+  if (isJqAlternativeOperator(command, start, token)) return true;
+
   if (command[start - 1] === "<" && next === ">" && /^\/[A-Za-z][\w:.-]*$/.test(token)) {
     return !fs.existsSync(token);
   }

package/dist/adapters/opencode-providers.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOpenCodeProviders = loadOpenCodeProviders;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const jsonc_parser_1 = require("jsonc-parser");
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function merge(base, override) {
+    return Object.fromEntries([...new Set([...Object.keys(base), ...Object.keys(override)])].map((key) => {
+        const previous = base[key];
+        const next = override[key];
+        if (!Object.hasOwn(override, key))
+            return [key, previous];
+        return [key, isObject(previous) && isObject(next) ? merge(previous, next) : next];
+    }));
+}
+/** Import operator providers only, before the adapter replaces OpenCode's paths.
+ * OpenCode V2 accepts legacy `provider` entries alongside native `providers`;
+ * let its own compatibility loader handle model capabilities and variants.
+ * Never discover repository config or import its plugins, MCP, or permissions.
+ */
+async function loadOpenCodeProviders(env, generation) {
+    const setting = (name) => env[name] ?? process.env[name];
+    const home = setting("HOME") || node_os_1.default.homedir();
+    const expand = (file) => file.startsWith("~/") ? node_path_1.default.join(home, file.slice(2)) : file;
+    const globalDir = node_path_1.default.join(setting("XDG_CONFIG_HOME") || node_path_1.default.join(home, ".config"), "opencode");
+    let result = {};
+    let secretIndex = 0;
+    // Resolve file references against their original config, then keep credentials
+    // out of both the generated file and OPENCODE_CONFIG_CONTENT. Existing env
+    // references remain references and are resolved by the OpenCode child.
+    async function prepare(value, directory, sensitive = false) {
+        if (Array.isArray(value))
+            return Promise.all(value.map((item) => prepare(item, directory, sensitive)));
+        if (isObject(value)) {
+            return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, item]) => [
+                key, await prepare(item, directory, sensitive || /^(?:api[_-]?key|token|password|secret|headers)$/i.test(key)),
+            ])));
+        }
+        if (typeof value !== "string")
+            return value;
+        const fromFile = /\{file:[^}]+\}/.test(value);
+        if (!fromFile && (!sensitive || !value || /^\{env:[^}]+\}$/.test(value)))
+            return value;
+        // Mixed strings such as "Bearer {env:TOKEN}" need expansion before moving
+        // the whole header into another env var; substitutions are not recursive.
+        let resolved = value.replace(/\{env:([^}]+)\}/g, (_match, name) => setting(name) ?? "");
+        for (const match of value.matchAll(/\{file:([^}]+)\}/g)) {
+            const file = node_path_1.default.resolve(directory, expand(match[1]));
+            const contents = (await node_fs_1.promises.readFile(file, "utf8")).trim();
+            resolved = resolved.replace(match[0], () => contents);
+        }
+        let name;
+        do {
+            name = `NAVARCH_OPENCODE_PROVIDER_${secretIndex++}`;
+        } while (setting(name) !== undefined);
+        env[name] = resolved;
+        return `{env:${name}}`;
+    }
+    async function include(text, source, directory) {
+        const errors = [];
+        const config = (0, jsonc_parser_1.parse)(text, errors, { allowTrailingComma: true });
+        if (errors.length || !isObject(config)) {
+            // Parser diagnostics can contain literal credentials; report only source.
+            throw new Error(`Invalid OpenCode JSON/JSONC configuration in ${source}.`);
+        }
+        const picked = {};
+        for (const key of generation === 1 ? ["provider"] : ["provider", "providers"]) {
+            if (config[key] === undefined)
+                continue;
+            if (!isObject(config[key]))
+                throw new Error(`OpenCode ${key} must be an object in ${source}.`);
+            picked[key] = await prepare(config[key], directory);
+        }
+        result = merge(result, picked);
+    }
+    async function file(filePath, optional) {
+        const absolute = node_path_1.default.resolve(expand(filePath));
+        let text;
+        try {
+            text = await node_fs_1.promises.readFile(absolute, "utf8");
+        }
+        catch (error) {
+            if (optional && error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        await include(text, absolute, node_path_1.default.dirname(absolute));
+    }
+    for (const name of ["opencode.json", "opencode.jsonc"])
+        await file(node_path_1.default.join(globalDir, name), true);
+    const explicit = setting("OPENCODE_CONFIG");
+    if (explicit)
+        await file(explicit, false);
+    const directory = setting("OPENCODE_CONFIG_DIR");
+    if (directory) {
+        for (const name of ["opencode.json", "opencode.jsonc"])
+            await file(node_path_1.default.join(expand(directory), name), true);
+    }
+    const inline = setting("OPENCODE_CONFIG_CONTENT");
+    if (inline)
+        await include(inline, "OPENCODE_CONFIG_CONTENT", process.cwd());
+    return result;
+}

package/dist/adapters/opencode.cjs

@@ -12,12 +12,20 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const config_cjs_1 = require("../config.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const opencode_providers_cjs_1 = require("./opencode-providers.cjs");
 /**
- * Headless OpenCode adapter, fixture-pinned to the OpenCode JSON/config
- * contract shared by V1 and V2 (verified against 2.0.6):
+ * Headless OpenCode adapter, fixture-pinned to the OpenCode JSON event
+ * contract shared by V1 and V2 (verified against 1.19.1, 2.0.6 and 2.0.17):
  *
  *   opencode run --format json [--model provider/model[#variant]]  < prompt
  *
+ * V1 (still npm's `latest`) differs in two ways the adapter must follow: its
+ * config takes V1 `permission` rules and flat `mcp` entries, and it rejects
+ * V2's `permissions`/`mcp.servers` outright ("V2 permissions are not
+ * supported by OpenCode V1"); and it takes the reasoning variant as
+ * `--variant`, reporting `model#variant` as an unknown model. A `--version`
+ * probe picks the dialect per session, defaulting to V2.
+ *
  * The prompt goes in on stdin, which `opencode run` reads as the message when
  * none is given (verified against 2.0.17). Linux rejects any single argv
  * string over 128 KiB (`spawn E2BIG`), and an argv prompt also let an
@@ -27,8 +35,9 @@ const kill_agent_cjs_1 = require("../kill-agent.cjs");
  * so each Navarch session gets an isolated XDG/config directory, disables
  * project discovery, and supplies its complete policy as both a private file
  * and the highest-precedence inline config. Provider credentials remain in
- * OpenCode's data store or the child environment; only MCP env references are
- * written to disk.
+ * OpenCode's data store or the child environment. Operator provider definitions
+ * are copied without importing unrelated global config; credential and MCP
+ * values use env references in the generated file.
  */
 async function runOpenCodeAdapter(options) {
     if (options.opencodeHostGuard && !options.dockerExec) {
@@ -45,16 +54,20 @@ async function runOpenCodeAdapter(options) {
     // supervisor's PWD in the inherited environment (often the home directory).
     if (!options.dockerExec && options.cwd)
         env.PWD = node_path_1.default.resolve(options.cwd);
-    await prepareOpenCodeConfig(options.mcpConfigPath, env, Boolean(options.dockerExec));
+    const probe = (probeArgs) => {
+        const probeOptions = { ...options, env, timeoutMs: 10_000, onProcessStarted: undefined };
+        return options.dockerExec ? runViaDocker(probeOptions, probeArgs) : runOnHost(probeOptions, probeArgs);
+    };
+    // Neither generation loads config for --version, so the probe runs before
+    // the config is written in the matching dialect.
+    const generation = openCodeGeneration(await probe(["--version"]));
+    await prepareOpenCodeConfig(options.mcpConfigPath, env, Boolean(options.dockerExec), generation);
     // V2's default background service owns its own cwd, environment and MCP
     // configuration. A client process's isolated config does not isolate that
     // service. Probe help without starting a turn, so older in-process CLIs
     // remain supported and upgrades are detected on the next session.
     const runOptions = { ...options, env };
-    const probeOptions = { ...runOptions, timeoutMs: 10_000, onProcessStarted: undefined };
-    const help = options.dockerExec
-        ? await runViaDocker(probeOptions, ["run", "--help"])
-        : await runOnHost(probeOptions, ["run", "--help"]);
+    const help = await probe(["run", "--help"]);
     if (help.exitCode !== 0 || help.timedOut || help.killedByLeaseLoss) {
         return { ...help, stderr: `OpenCode CLI capability check failed. ${help.stderr}` };
     }
@@ -76,10 +89,18 @@ async function runOpenCodeAdapter(options) {
     if (options.model && options.model !== "default" && !hasArg(options.extraArgs, "--model", "-m")) {
         // OpenCode V2 folds the reasoning variant into the model reference
         // (`provider/model#variant`) and hard-fails on a variant the model does
-        // not advertise. The claim route clamps the effort to the model's
-        // advertised variants, so a present value is always valid; absent means
-        // use the model's own default.
-        args.push("--model", options.reasoningEffort ? `${options.model}#${options.reasoningEffort}` : options.model);
+        // not advertise; V1 takes it as `--variant`. The claim route clamps the
+        // effort to the model's advertised variants, so a present value is
+        // always valid; absent means use the model's own default.
+        if (generation === 1) {
+            args.push("--model", options.model);
+            if (options.reasoningEffort && !hasArg(options.extraArgs, "--variant")) {
+                args.push("--variant", options.reasoningEffort);
+            }
+        }
+        else {
+            args.push("--model", options.reasoningEffort ? `${options.model}#${options.reasoningEffort}` : options.model);
+        }
     }
     const run = (runArgs) => runOptions.dockerExec
         ? runViaDocker(runOptions, runArgs, options.prompt)
@@ -110,10 +131,20 @@ function isLogLevelRejection(stderr) {
 function resetOpenCodeLogLevelCache() {
     openCodeLogLevels.clear();
 }
+/**
+ * V1 prints a bare `1.19.1`, V2 `opencode v2.0.17`. Anything unrecognized
+ * keeps the V2 dialect the adapter has always written.
+ */
+function openCodeGeneration(version) {
+    if (version.exitCode !== 0)
+        return 2;
+    const major = version.stdout.match(/^\s*(?:opencode\s+)?v?(\d+)\.\d+\.\d+/i)?.[1];
+    return major !== undefined && Number(major) < 2 ? 1 : 2;
+}
 function hasArg(args, ...flags) {
     return args.some((arg) => flags.some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
 }
-async function prepareOpenCodeConfig(mcpConfigPath, env, inDocker) {
+async function prepareOpenCodeConfig(mcpConfigPath, env, inDocker, generation) {
     if (!mcpConfigPath) {
         throw new Error("OpenCode requires a per-session MCP config path for isolated execution.");
     }
@@ -143,28 +174,51 @@ async function prepareOpenCodeConfig(mcpConfigPath, env, inDocker) {
         mcp[name] = {
             type: "remote",
             url,
-            disabled: false,
+            ...(generation === 1 ? { enabled: true } : { disabled: false }),
             oauth: false,
             ...(Object.keys(headers).length > 0 ? { headers } : {}),
         };
     }
-    const config = {
-        $schema: "https://opencode.ai/config.json",
-        update: "disable",
-        share: "disabled",
-        plugins: [],
-        mcp: { servers: mcp },
-        permissions: [
-            { action: "*", resource: "*", effect: "allow" },
-            { action: "external_directory", resource: "*", effect: "deny" },
-            ...(await openCodeManagedDirectories(env, inDocker)).map((resource) => ({
-                action: "external_directory",
-                resource,
-                effect: "allow",
-            })),
-            { action: "question", resource: "*", effect: "deny" },
-        ],
-    };
+    const managedDirectories = await openCodeManagedDirectories(env, inDocker);
+    // Host provider endpoints and credentials belong to the operator's host.
+    // Docker continues to use its own provider setup, never the host's files.
+    const providers = inDocker ? {} : await (0, opencode_providers_cjs_1.loadOpenCodeProviders)(env, generation);
+    // Same policy in both dialects; in each the last matching rule wins.
+    const config = generation === 1
+        ? {
+            $schema: "https://opencode.ai/config.json",
+            ...providers,
+            autoupdate: false,
+            share: "disabled",
+            plugin: [],
+            mcp,
+            permission: {
+                "*": "allow",
+                external_directory: {
+                    "*": "deny",
+                    ...Object.fromEntries(managedDirectories.map((resource) => [resource, "allow"])),
+                },
+                question: "deny",
+            },
+        }
+        : {
+            $schema: "https://opencode.ai/config.json",
+            ...providers,
+            update: "disable",
+            share: "disabled",
+            plugins: [],
+            mcp: { servers: mcp },
+            permissions: [
+                { action: "*", resource: "*", effect: "allow" },
+                { action: "external_directory", resource: "*", effect: "deny" },
+                ...managedDirectories.map((resource) => ({
+                    action: "external_directory",
+                    resource,
+                    effect: "allow",
+                })),
+                { action: "question", resource: "*", effect: "deny" },
+            ],
+        };
     const configPath = `${mcpConfigPath}.opencode.json`;
     const configDir = `${mcpConfigPath}.opencode-config`;
     const xdgConfigHome = `${mcpConfigPath}.opencode-xdg`;

package/node_modules/jsonc-parser/CHANGELOG.md

@@ -0,0 +1,76 @@
+3.3.0 2022-06-24
+=================
+- `JSONVisitor.onObjectBegin` and `JSONVisitor.onArrayBegin` can now return `false` to instruct the visitor that no children should be visited.
+
+
+3.2.0 2022-08-30
+=================
+- update the version of the bundled Javascript files to `es2020`.
+- include all `const enum` values in the bundled JavaScript files (`ScanError`, `SyntaxKind`, `ParseErrorCode`).
+
+3.1.0 2022-07-07
+==================
+  * added new API `FormattingOptions.keepLines` : It leaves the initial line positions in the formatting.
+
+3.0.0 2020-11-13
+==================
+  * fixed API spec for `parseTree`. Can return `undefine` for empty input.
+  * added new API `FormattingOptions.insertFinalNewline`.
+
+
+2.3.0 2020-07-03
+==================
+  * new API `ModificationOptions.isArrayInsertion`: If `JSONPath` refers to an index of an array and `isArrayInsertion` is `true`, then `modify` will insert a new item at that location instead of overwriting its contents.
+  * `ModificationOptions.formattingOptions` is now optional. If not set, newly inserted content will not be formatted.
+
+
+2.2.0 2019-10-25
+==================
+  * added `ParseOptions.allowEmptyContent`. Default is `false`.
+  * new API `getNodeType`: Returns the type of a value returned by parse.
+  * `parse`: Fix issue with empty property name
+
+2.1.0 2019-03-29
+==================
+ * `JSONScanner` and `JSONVisitor` return lineNumber / character.
+
+2.0.0 2018-04-12
+==================
+  * renamed `Node.columnOffset` to `Node.colonOffset`
+  * new API `getNodePath`: Gets the JSON path of the given JSON DOM node
+  * new API `findNodeAtOffset`: Finds the most inner node at the given offset. If `includeRightBound` is set, also finds nodes that end at the given offset.
+
+1.0.3 2018-03-07
+==================
+  * provide ems modules
+
+1.0.2 2018-03-05
+==================
+  * added the `visit.onComment` API, reported when comments are allowed.
+  * added the `ParseErrorCode.InvalidCommentToken` enum value, reported when comments are disallowed.
+
+1.0.1
+==================
+  * added the `format` API: computes edits to format a JSON document.
+  * added the `modify` API: computes edits to insert, remove or replace a property or value in a JSON document.
+  * added the `allyEdits` API: applies edits to a document
+
+1.0.0
+==================
+ * remove nls dependency (remove `getParseErrorMessage`)
+
+0.4.2 / 2017-05-05
+==================
+ * added `ParseError.offset` & `ParseError.length`
+
+0.4.1 / 2017-04-02
+==================
+ * added `ParseOptions.allowTrailingComma`
+
+0.4.0 / 2017-02-23
+==================
+  * fix for `getLocation`. Now `getLocation` inside an object will always return a property from inside that property. Can be empty string if the object has no properties or if the offset is before a actual property  `{ "a": { | }} will return location ['a', ' ']`
+
+0.3.0 / 2017-01-17
+==================
+  * Updating to typescript 2.0

package/node_modules/jsonc-parser/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.