Skip to content

A desktop coding agent with free access to frontier models.

TypeScript

chore(engine): bump the bundled opencode engine to 1.18.32

ogsamrat70ae9cba6299
diff --git a/apps/desktop/electron/runtime.test.mjs b/apps/desktop/electron/runtime.test.mjs
index 29cbb1c4..e24221f8 100644
--- a/apps/desktop/electron/runtime.test.mjs
+++ b/apps/desktop/electron/runtime.test.mjs
@@ -87,8 +87,11 @@ describe("bundled OpenCode runtime", () => {
const constants = JSON.parse(await readFile(constantsPath, "utf8"));
// OpenCode #40990 stops old assistant messages with lexicographically
- // later IDs from short-circuiting a newly appended user turn.
- assert.equal(constants.opencodeVersion, "v1.18.18");
+ // later IDs from short-circuiting a newly appended user turn. It shipped
+ // in 1.18.18; the pin has since moved to 1.18.32 (2026-09-21) for the
+ // patch-release fixes on top of it (apply_patch move-path metadata,
+ // config snapshot comparison, provider SDK bumps, session header fixes).
+ assert.equal(constants.opencodeVersion, "v1.18.32");
});
});
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 47a683c5..263c29c0 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -34,7 +34,7 @@
"dependencies": {
"@modelcontextprotocol/client": "^2.0.0",
"@modelcontextprotocol/sdk": "^1.29.0",
- "@opencode-ai/sdk": "^1.18.15",
+ "@opencode-ai/sdk": "^1.18.32",
"@omnirush/browser-logins": "workspace:*",
"@omnirush/browser-tabs": "workspace:*",
"@omnirush/enterprise-mcp-client": "workspace:*",
diff --git a/apps/server/package.json b/apps/server/package.json
index 439e498a..b18d2bea 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -53,7 +53,7 @@
"dependencies": {
"@modelcontextprotocol/client": "^2.0.0",
"@modelcontextprotocol/sdk": "^1.29.0",
- "@opencode-ai/sdk": "^1.18.15",
+ "@opencode-ai/sdk": "^1.18.32",
"@omnirush/enterprise-mcp-client": "workspace:*",
"@omnirush/types": "workspace:*",
"better-sqlite3": "^13.0.2",
diff --git a/apps/server/src/cli.ts b/apps/server/src/cli.ts
index 0c54c44f..430b0a9f 100644
--- a/apps/server/src/cli.ts
+++ b/apps/server/src/cli.ts
@@ -27,6 +27,7 @@ import { keepOmniRushRuntimeConfigFileFresh, writeOmniRushRuntimeConfigFile } fr
import { migrateOmniRushCloudMcpRuntimeConfig } from "./cloud-mcp-health.js";
import { migrateWorkspaceRuntimeConfigToEngineGlobal } from "./runtime-opencode-config-store.js";
import { resolveOpencodeModelsUrl } from "./opencode-models-url.js";
+import { assertOpencodeConfigCompat } from "./opencode-config-compat.js";
import { startWorkerActivityHeartbeat } from "./worker-activity-heartbeat.js";
import pkg from "../package.json" with { type: "json" };
@@ -97,6 +98,15 @@ if (!config.opencodeBaseUrl && process.env.OMNIRUSH_MANAGE_OPENCODE === "1") {
return [...new Set([config.port, ...poolPorts].filter((port) => port > 0))];
},
};
+ // See embedded.ts: a V2 `permissions` key in a user-owned config file is
+ // fatal to the bundled engine; report the file before spawning.
+ await assertOpencodeConfigCompat({
+ workspaceRoots: config.workspaces
+ .filter((entry) => entry.workspaceType !== "remote")
+ .map((entry) => entry.path),
+ env: { ...process.env, ...engineEnv },
+ logger,
+ });
managedOpencode = await createManagedOpencodeServer({
bin: process.env.OMNIRUSH_OPENCODE_BIN,
cwd: managedOpencodeCwd,
diff --git a/apps/server/src/embedded-lifecycle.test.ts b/apps/server/src/embedded-lifecycle.test.ts
index 590acd89..cbcff053 100644
--- a/apps/server/src/embedded-lifecycle.test.ts
+++ b/apps/server/src/embedded-lifecycle.test.ts
@@ -7,6 +7,8 @@ import { describe, expect, spyOn, test } from "bun:test";
import { startEmbeddedServer, type EmbeddedServerHandle, type EmbeddedServerOptions } from "./embedded.js";
import { readEngineRegistry } from "./engine-registry.js";
import * as managedOpencodeModule from "./managed-opencode.js";
+import { OPENCODE_V2_PERMISSIONS_MESSAGE, OpencodeConfigCompatError } from "./opencode-config-compat.js";
+import * as opencodeConfigCompatModule from "./opencode-config-compat.js";
import { writeOmniRushRuntimeConfigFile } from "./omnirush-runtime-config.js";
import { writeGlobalRuntimeOpencodeConfig, writeRuntimeOpencodeConfig } from "./runtime-opencode-config-store.js";
import * as serverModule from "./server.js";
@@ -24,6 +26,7 @@ const ENV_NAMES: string[] = [
"OMNIRUSH_ENCRYPTION_KEY",
"OMNIRUSH_OPENCODE_BASE_URL",
"OMNIRUSH_LIFECYCLE_LOG",
+ "OPENCODE_CONFIG_DIR",
"OPENCODE_MODELS_URL",
];
@@ -398,6 +401,74 @@ describe("embedded server lifecycle", () => {
}
});
+ test.serial("a global OpenCode config with V2 permissions aborts before any engine is spawned", async () => {
+ const fixture = await createFixture();
+ // The engine reads its global config from OPENCODE_CONFIG_DIR when set;
+ // the pre-flight must look at the same directory.
+ const globalDir = join(fixture.root, "opencode-config");
+ const globalFile = join(globalDir, "opencode.json");
+ await mkdir(globalDir, { recursive: true });
+ await writeFile(globalFile, JSON.stringify({ permissions: { bash: "deny" } }), "utf8");
+ process.env.OPENCODE_CONFIG_DIR = globalDir;
+ const managedSpy = spyOn(managedOpencodeModule, "createManagedOpencodeServer");
+
+ try {
+ const options = managedOptions(fixture, "v2-global");
+ await mkdir(options.opencodeCwd ?? "", { recursive: true });
+ let thrown: unknown;
+ try {
+ await startEmbeddedServer(options);
+ } catch (error) {
+ thrown = error;
+ }
+
+ // 1.18.32 would exit at boot with this message buried in stderr; the
+ // pre-flight names the file and the fix without spawning anything.
+ expect(thrown).toBeInstanceOf(OpencodeConfigCompatError);
+ if (!(thrown instanceof OpencodeConfigCompatError)) throw new Error("Expected OpencodeConfigCompatError");
+ expect(thrown.message).toContain(`Configuration is invalid at ${globalFile}`);
+ expect(thrown.message).toContain(OPENCODE_V2_PERMISSIONS_MESSAGE);
+ expect(thrown.findings).toEqual([
+ { scope: "global", file: globalFile, issues: [{ path: ["permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE }] },
+ ]);
+ expect(managedSpy).not.toHaveBeenCalled();
+ expect((await logLines(fixture.logPath)).filter((line) => line === "SIGTERM")).toHaveLength(0);
+ } finally {
+ managedSpy.mockRestore();
+ await fixture.restore();
+ }
+ });
+
+ test.serial("a workspace OpenCode config with V2 permissions is reported but still boots the engine", async () => {
+ const fixture = await createFixture();
+ process.env.OPENCODE_CONFIG_DIR = join(fixture.root, "opencode-config");
+ const workspace = join(fixture.root, "v2-workspace-workspace");
+ const workspaceFile = join(workspace, ".opencode", "opencode.json");
+ await mkdir(join(workspace, ".opencode"), { recursive: true });
+ await writeFile(workspaceFile, JSON.stringify({ agent: { build: { permissions: { bash: "allow" } } } }), "utf8");
+ const originalAssert = opencodeConfigCompatModule.assertOpencodeConfigCompat;
+ const reported: opencodeConfigCompatModule.OpencodeConfigCompatFinding[][] = [];
+ const assertSpy = spyOn(opencodeConfigCompatModule, "assertOpencodeConfigCompat").mockImplementation(async (input) => {
+ const findings = await originalAssert(input);
+ reported.push(findings);
+ return findings;
+ });
+
+ try {
+ const handle = await startManaged(fixture, "v2-workspace");
+
+ // Other workspaces keep working, so the engine must still come up; the
+ // finding is logged and that workspace's routes answer opencode_config_invalid.
+ expect(handle.managedOpencode?.pid).toBeGreaterThan(0);
+ expect(reported).toEqual([[
+ { scope: "workspace", file: workspaceFile, issues: [{ path: ["agent", "build", "permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE }] },
+ ]]);
+ } finally {
+ assertSpy.mockRestore();
+ await fixture.restore();
+ }
+ });
+
test.serial("engine spawn failure after HTTP start releases the server and subscription", async () => {
const fixture = await createFixture();
const spawnError = new Error("forced engine spawn failure");
diff --git a/apps/server/src/embedded.ts b/apps/server/src/embedded.ts
index cec942df..0b1b7676 100644
--- a/apps/server/src/embedded.ts
+++ b/apps/server/src/embedded.ts
@@ -38,6 +38,7 @@ import { keepOmniRushRuntimeConfigFileFresh, writeOmniRushRuntimeConfigFile } fr
import { migrateOmniRushCloudMcpRuntimeConfig } from "./cloud-mcp-health.js";
import { migrateWorkspaceRuntimeConfigToEngineGlobal } from "./runtime-opencode-config-store.js";
import { resolveOpencodeModelsUrl } from "./opencode-models-url.js";
+import { assertOpencodeConfigCompat } from "./opencode-config-compat.js";
import type { ServeResult } from "./serve-node.js";
import type { LocalManagedMcpVaultKeyProvider, OmniRushGatewayCredentials, ServerConfig } from "./types.js";
@@ -251,6 +252,17 @@ export async function startEmbeddedServer(options: EmbeddedServerOptions): Promi
return [...new Set([config.port, ...poolPorts, startupPort].filter((port) => port > 0))];
},
};
+ // The bundled engine (1.18.32+) refuses user-owned config files that
+ // carry a V2 `permissions` key: a global file exits the engine at boot,
+ // a workspace file breaks that workspace's instance. Name the file and
+ // the keys here, before the spawn, instead of surfacing an opaque exit.
+ await duringStartup(() => assertOpencodeConfigCompat({
+ workspaceRoots: config.workspaces
+ .filter((entry) => entry.workspaceType !== "remote")
+ .map((entry) => entry.path),
+ env: { ...process.env, ...engineEnv },
+ logger,
+ }));
managedOpencode = await duringStartup(() => createManagedOpencodeServer({
bin: opencodeBin,
cwd,
diff --git a/apps/server/src/omnirush-agent-prompt.ts b/apps/server/src/omnirush-agent-prompt.ts
index ee3e81d8..7eac086f 100644
--- a/apps/server/src/omnirush-agent-prompt.ts
+++ b/apps/server/src/omnirush-agent-prompt.ts
@@ -41,6 +41,10 @@ Hard rule: never copy private memory into repo files. Store only redacted summar
- If steps repeat, capture them as a skill following the \`Skill creation:\` instruction in this prompt.
- Prefer clear, practical steps over abstract explanations.
+## Editing files
+
+- When apply_patch or edit reports that expected lines were not found, the file changed since you read it (a formatter ran, or an earlier edit was rejected or aborted). Read the file again before retrying; never resend the same patch. Prefer smaller hunks with unambiguous context. On Windows, keep the file's existing line endings.
+
## OmniRush.ai Artifacts
OmniRush.ai can preview, edit, and download standard artifacts when you create or update them in the workspace.
diff --git a/apps/server/src/opencode-config-compat.test.ts b/apps/server/src/opencode-config-compat.test.ts
new file mode 100644
index 00000000..33a0ef44
--- /dev/null
+++ b/apps/server/src/opencode-config-compat.test.ts
@@ -0,0 +1,220 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+ OPENCODE_CONFIG_COMPAT_HINT,
+ OPENCODE_V2_PERMISSIONS_MESSAGE,
+ OpencodeConfigCompatError,
+ assertOpencodeConfigCompat,
+ diagnoseOpencodeConfigCompat,
+ findUnsupportedV2PermissionPaths,
+ formatOpencodeConfigCompatFinding,
+ globalOpencodeConfigFiles,
+ parseOpencodeConfigErrorBody,
+ workspaceOpencodeConfigFiles,
+} from "./opencode-config-compat.js";
+
+const roots: string[] = [];
+
+afterEach(async () => {
+ while (roots.length > 0) await rm(roots.pop()!, { recursive: true, force: true });
+});
+
+async function createRoot(): Promise<string> {
+ const root = await mkdtemp(join(tmpdir(), "omnirush-opencode-config-compat-"));
+ roots.push(root);
+ return root;
+}
+
+async function writeConfig(path: string, content: string | Record<string, unknown>): Promise<void> {
+ await mkdir(join(path, ".."), { recursive: true });
+ await writeFile(path, typeof content === "string" ? content : JSON.stringify(content, null, 2), "utf8");
+}
+
+type Logged = { level: "warn" | "error"; message: string; attributes?: Record<string, unknown> };
+
+function recordingLogger(): { logger: { log: (level: "warn" | "error", message: string, attributes?: Record<string, unknown>) => void }; lines: Logged[] } {
+ const lines: Logged[] = [];
+ return {
+ lines,
+ logger: { log: (level, message, attributes) => { lines.push({ level, message, attributes }); } },
+ };
+}
+
+describe("findUnsupportedV2PermissionPaths", () => {
+ test("mirrors the engine: top-level and agent/agents/mode.<name>.permissions are fatal, permission is fine", () => {
+ expect(findUnsupportedV2PermissionPaths({ permission: { bash: "deny" } })).toEqual([]);
+ expect(findUnsupportedV2PermissionPaths({ permissions: { bash: "deny" } })).toEqual([["permissions"]]);
+ // Presence is what the engine checks; the value does not matter.
+ expect(findUnsupportedV2PermissionPaths({ permissions: null })).toEqual([["permissions"]]);
+ expect(findUnsupportedV2PermissionPaths({
+ agent: { build: { permissions: {} }, plan: { permission: {} } },
+ agents: { review: { permissions: [] } },
+ mode: { chat: { permissions: "deny" }, other: "not-a-record" },
+ })).toEqual([
+ ["agents", "review", "permissions"],
+ ["agent", "build", "permissions"],
+ ["mode", "chat", "permissions"],
+ ]);
+ });
+
+ test("ignores non-record input and permissions keys nested anywhere else", () => {
+ expect(findUnsupportedV2PermissionPaths(null)).toEqual([]);
+ expect(findUnsupportedV2PermissionPaths([{ permissions: {} }])).toEqual([]);
+ expect(findUnsupportedV2PermissionPaths("permissions")).toEqual([]);
+ expect(findUnsupportedV2PermissionPaths({ mcp: { srv: { permissions: {} } }, agent: "x" })).toEqual([]);
+ });
+});
+
+describe("diagnoseOpencodeConfigCompat", () => {
+ test("scans the engine's global files and the workspace candidates, tolerating comments, missing and malformed files", async () => {
+ const root = await createRoot();
+ const globalDir = join(root, "global-config");
+ const workspace = join(root, "workspace");
+ const env = { ...process.env, OPENCODE_CONFIG_DIR: globalDir };
+
+ expect(globalOpencodeConfigFiles(env)).toEqual([
+ join(globalDir, "config.json"),
+ join(globalDir, "opencode.json"),
+ join(globalDir, "opencode.jsonc"),
+ ]);
+ expect(workspaceOpencodeConfigFiles(workspace)).toEqual([
+ join(workspace, "opencode.jsonc"),
+ join(workspace, "opencode.json"),
+ join(workspace, ".opencode", "opencode.jsonc"),
+ join(workspace, ".opencode", "opencode.json"),
+ ]);
+
+ // Nothing on disk yet: no findings, no throw.
+ expect(await diagnoseOpencodeConfigCompat({ workspaceRoots: [workspace], env })).toEqual([]);
+
+ await writeConfig(join(globalDir, "opencode.jsonc"), [
+ "{",
+ " // comment and trailing comma are valid JSONC",
+ ' "$schema": "https://opencode.ai/config.json",',
+ ' "permissions": { "bash": "deny" },',
+ "}",
+ ].join("\n"));
+ await writeConfig(join(globalDir, "config.json"), "{ not json");
+ await writeConfig(join(workspace, ".opencode", "opencode.json"), {
+ permission: { webfetch: "deny" },
+ agent: { build: { permissions: { bash: "allow" } } },
+ });
+ await writeConfig(join(workspace, "opencode.json"), { permission: { bash: "deny" } });
+
+ const findings = await diagnoseOpencodeConfigCompat({ workspaceRoots: [workspace, workspace, " "], env });
+ expect(findings).toEqual([
+ {
+ scope: "global",
+ file: join(globalDir, "opencode.jsonc"),
+ issues: [{ path: ["permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE }],
+ },
+ {
+ scope: "workspace",
+ file: join(workspace, ".opencode", "opencode.json"),
+ issues: [{ path: ["agent", "build", "permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE }],
+ },
+ ]);
+ expect(formatOpencodeConfigCompatFinding(findings[0]!)).toBe(
+ `Configuration is invalid at ${join(globalDir, "opencode.jsonc")}: ${OPENCODE_V2_PERMISSIONS_MESSAGE} (permissions)`,
+ );
+ });
+});
+
+describe("assertOpencodeConfigCompat", () => {
+ test("a global V2 permissions file throws with the engine's message, the file, and the fix", async () => {
+ const root = await createRoot();
+ const globalDir = join(root, "global-config");
+ const file = join(globalDir, "opencode.json");
+ await writeConfig(file, { permissions: { bash: "deny" } });
+ const { logger, lines } = recordingLogger();
+
+ let thrown: unknown;
+ try {
+ await assertOpencodeConfigCompat({ workspaceRoots: [join(root, "workspace")], env: { ...process.env, OPENCODE_CONFIG_DIR: globalDir }, logger });
+ } catch (error) {
+ thrown = error;
+ }
+
+ expect(thrown).toBeInstanceOf(OpencodeConfigCompatError);
+ if (!(thrown instanceof OpencodeConfigCompatError)) throw new Error("Expected OpencodeConfigCompatError");
+ expect(thrown.code).toBe("opencode_config_invalid");
+ expect(thrown.findings).toHaveLength(1);
+ expect(thrown.message).toContain(`Configuration is invalid at ${file}`);
+ expect(thrown.message).toContain(OPENCODE_V2_PERMISSIONS_MESSAGE);
+ expect(thrown.message).toContain("(permissions)");
+ expect(thrown.message).toContain(OPENCODE_CONFIG_COMPAT_HINT);
+ expect(lines).toHaveLength(1);
+ expect(lines[0]).toMatchObject({
+ level: "error",
+ attributes: { "opencode.config.scope": "global", "opencode.config.file": file, "opencode.config.issues": "permissions" },
+ });
+ });
+
+ test("a workspace V2 permissions file only warns and returns the finding", async () => {
+ const root = await createRoot();
+ const globalDir = join(root, "global-config");
+ const workspace = join(root, "workspace");
+ const file = join(workspace, ".opencode", "opencode.jsonc");
+ await writeConfig(join(globalDir, "opencode.json"), { permission: { bash: "deny" } });
+ await writeConfig(file, { mode: { chat: { permissions: {} } } });
+ const { logger, lines } = recordingLogger();
+
+ const findings = await assertOpencodeConfigCompat({ workspaceRoots: [workspace], env: { ...process.env, OPENCODE_CONFIG_DIR: globalDir }, logger });
+
+ expect(findings).toEqual([
+ { scope: "workspace", file, issues: [{ path: ["mode", "chat", "permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE }] },
+ ]);
+ expect(lines).toHaveLength(1);
+ expect(lines[0]).toMatchObject({
+ level: "warn",
+ attributes: { "opencode.config.scope": "workspace", "opencode.config.file": file, "opencode.config.issues": "mode.chat.permissions" },
+ });
+ });
+});
+
+describe("parseOpencodeConfigErrorBody", () => {
+ test("turns the engine's 400 ConfigInvalidError body into an actionable message", () => {
+ const parsed = parseOpencodeConfigErrorBody({
+ name: "ConfigInvalidError",
+ data: {
+ path: "/ws/.opencode/opencode.json",
+ issues: [{ path: ["permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE }, { path: ["agent", "build", "permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE }, "junk"],
+ },
+ });
+ expect(parsed).toEqual({
+ name: "ConfigInvalidError",
+ file: "/ws/.opencode/opencode.json",
+ message: `OpenCode configuration is invalid at /ws/.opencode/opencode.json: ${OPENCODE_V2_PERMISSIONS_MESSAGE} (permissions); ${OPENCODE_V2_PERMISSIONS_MESSAGE} (agent.build.permissions)`,
+ issues: [
+ { path: ["permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE },
+ { path: ["agent", "build", "permissions"], message: OPENCODE_V2_PERMISSIONS_MESSAGE },
+ ],
+ });
+ });
+
+ test("keeps a plain message, treats the engine's 'config' placeholder as no file, and covers the JSON error", () => {
+ expect(parseOpencodeConfigErrorBody({ name: "ConfigJsonError", data: { path: "/ws/opencode.json", message: "Unexpected token" } })).toEqual({
+ name: "ConfigJsonError",
+ file: "/ws/opencode.json",
+ message: "OpenCode configuration is invalid at /ws/opencode.json: Unexpected token",
+ issues: [],
+ });
+ expect(parseOpencodeConfigErrorBody({ name: "ConfigInvalidError", data: { path: "config" } })).toEqual({
+ name: "ConfigInvalidError",
+ file: null,
+ message: "OpenCode configuration is invalid",
+ issues: [],
+ });
+ });
+
+ test("returns null for every other engine error body", () => {
+ expect(parseOpencodeConfigErrorBody({ name: "UnknownError", data: { message: "boom" } })).toBeNull();
+ expect(parseOpencodeConfigErrorBody({ name: "ConfigRemoteAuthError", data: { url: "x", remote: "y" } })).toBeNull();
+ expect(parseOpencodeConfigErrorBody({ message: "fetch failed" })).toBeNull();
+ expect(parseOpencodeConfigErrorBody("ConfigInvalidError")).toBeNull();
+ expect(parseOpencodeConfigErrorBody(null)).toBeNull();
+ });
+});
diff --git a/apps/server/src/opencode-config-compat.ts b/apps/server/src/opencode-config-compat.ts
new file mode 100644
index 00000000..a8c39b69
--- /dev/null
+++ b/apps/server/src/opencode-config-compat.ts
@@ -0,0 +1,212 @@
+/**
+ * Pre-flight compatibility check for user-owned OpenCode config files.
+ *
+ * The bundled engine (OpenCode V1, pinned in constants.json) lowers V2-style
+ * config on load (packages/opencode/src/config/v2-compat.ts). Most V2 keys
+ * degrade to a "configuration compatibility diagnostic" warning, but a
+ * `permissions` key — top-level, or under `agent`/`agents`/`mode.<name>` — is
+ * fatal since 1.18.32: the engine throws ConfigInvalidError. In the global
+ * config that aborts `opencode serve` at boot (exit 1); in a workspace config
+ * every instance-scoped route for that directory answers 400 ConfigInvalidError.
+ *
+ * This module mirrors that one fatal rule so the server can name the file and
+ * the offending keys before the engine is spawned, and translates the engine's
+ * ConfigInvalidError response body into an actionable API error instead of a
+ * generic opencode_request_failed.
+ */
+import { join } from "node:path";
+import { globalOpencodeConfigDir, workspaceOpencodeConfigCandidates } from "@omnirush/paths";
+import { readJsoncFile } from "./jsonc.js";
+
+export const OPENCODE_V2_PERMISSIONS_MESSAGE =
+ 'V2 permissions are not supported by OpenCode V1. Use V1 "permission" rules or run opencode2.';
+
+export const OPENCODE_CONFIG_COMPAT_HINT =
+ 'Rename "permissions" to "permission" (OpenCode V1 rules) or remove it, then restart OmniRush.ai.';
+
+export type OpencodeConfigCompatScope = "global" | "workspace";
+
+export type OpencodeConfigCompatIssue = { path: string[]; message: string };
+
+export type OpencodeConfigCompatFinding = {
+ /** "global" files abort the engine at boot; "workspace" files break that directory's instance. */
+ scope: OpencodeConfigCompatScope;
+ file: string;
+ issues: OpencodeConfigCompatIssue[];
+};
+
+export type OpencodeConfigErrorBody = {
+ name: string;
+ file: string | null;
+ message: string;
+ issues: OpencodeConfigCompatIssue[];
+};
+
+type CompatLogger = {
+ log: (level: "warn" | "error", message: string, attributes?: Record<string, unknown>) => void;
+};
+
+/** Engine error names the HTTP error middleware answers with status 400 and `{ name, data }`. */
+const OPENCODE_CONFIG_ERROR_NAMES = new Set([
+ "ConfigInvalidError",
+ "ConfigJsonError",
+ "ConfigFrontmatterError",
+ "ConfigDirectoryTypoError",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+ return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Mirror of the engine's fatal rule in ConfigV2Compat.lower: a `permissions`
+ * key at the top level or directly under any `agents`/`agent`/`mode` entry.
+ * Key presence is what the engine checks, so the value is irrelevant.
+ */
+export function findUnsupportedV2PermissionPaths(config: unknown): string[][] {
+ if (!isRecord(config)) return [];
+ const paths: string[][] = [];
+ if (Object.hasOwn(config, "permissions")) paths.push(["permissions"]);
+ for (const key of ["agents", "agent", "mode"]) {
+ const agents = config[key];
+ if (!isRecord(agents)) continue;
+ for (const [name, agent] of Object.entries(agents)) {
+ if (isRecord(agent) && Object.hasOwn(agent, "permissions")) paths.push([key, name, "permissions"]);
+ }
+ }
+ return paths;
+}
+
+/** Files the engine merges into its global config at boot, in load order. */
+export function globalOpencodeConfigFiles(env: NodeJS.ProcessEnv = process.env): string[] {
+ const dir = globalOpencodeConfigDir({ env });
+ return ["config.json", "opencode.json", "opencode.jsonc"].map((name) => join(dir, name));
+}
+
+/** Files the engine merges into a workspace instance's config. */
+export function workspaceOpencodeConfigFiles(workspaceRoot: string): string[] {
+ return workspaceOpencodeConfigCandidates(workspaceRoot);
+}
+
+export async function inspectOpencodeConfigFile(
+ scope: OpencodeConfigCompatScope,
+ file: string,
+): Promise<OpencodeConfigCompatFinding | null> {
+ let data: unknown;
+ try {
+ // Unreadable or malformed files are the engine's own (pre-existing)
+ // ConfigJsonError; this check only covers the rule introduced by 1.18.32.
+ const result = await readJsoncFile<unknown>(file, null, { allowInvalid: true });
+ if (result.missing || result.invalid) return null;
+ data = result.data;
+ } catch {
+ return null;
+ }
+ const paths = findUnsupportedV2PermissionPaths(data);
+ if (paths.length === 0) return null;
+ return {
+ scope,
+ file,
+ issues: paths.map((path) => ({ path, message: OPENCODE_V2_PERMISSIONS_MESSAGE })),
+ };
+}
+
+export async function diagnoseOpencodeConfigCompat(input: {
+ workspaceRoots?: string[];
+ env?: NodeJS.ProcessEnv;
+}): Promise<OpencodeConfigCompatFinding[]> {
+ const env = input.env ?? process.env;
+ const targets: Array<{ scope: OpencodeConfigCompatScope; file: string }> = [
+ ...globalOpencodeConfigFiles(env).map((file) => ({ scope: "global" as const, file })),
+ ];
+ const seenRoots = new Set<string>();
+ for (const root of input.workspaceRoots ?? []) {
+ const trimmed = root.trim();
+ if (!trimmed || seenRoots.has(trimmed)) continue;
+ seenRoots.add(trimmed);
+ for (const file of workspaceOpencodeConfigFiles(trimmed)) targets.push({ scope: "workspace", file });
+ }
+ const findings = await Promise.all(targets.map(({ scope, file }) => inspectOpencodeConfigFile(scope, file)));
+ return findings.filter((finding): finding is OpencodeConfigCompatFinding => finding !== null);
+}
+
+function formatIssues(issues: OpencodeConfigCompatIssue[]): string {
+ return issues.map((issue) => `${issue.message} (${issue.path.join(".")})`).join("; ");
+}
+
+/** Same wording the engine prints when it refuses the file, plus the OmniRush.ai fix. */
+export function formatOpencodeConfigCompatFinding(finding: OpencodeConfigCompatFinding): string {
+ return `Configuration is invalid at ${finding.file}: ${formatIssues(finding.issues)}`;
+}
+
+export function opencodeConfigCompatLogAttributes(finding: OpencodeConfigCompatFinding): Record<string, unknown> {
+ return {
+ "opencode.config.scope": finding.scope,
+ "opencode.config.file": finding.file,
+ "opencode.config.issues": finding.issues.map((issue) => issue.path.join(".")).join(","),
+ "opencode.config.message": OPENCODE_V2_PERMISSIONS_MESSAGE,
+ };
+}
+
+export class OpencodeConfigCompatError extends Error {
+ readonly code = "opencode_config_invalid";
+ readonly findings: OpencodeConfigCompatFinding[];
+
+ constructor(findings: OpencodeConfigCompatFinding[]) {
+ super([
+ "OpenCode cannot start with the current global configuration.",
+ ...findings.map(formatOpencodeConfigCompatFinding),
+ OPENCODE_CONFIG_COMPAT_HINT,
+ ].join("\n"));
+ this.name = "OpencodeConfigCompatError";
+ this.findings = findings;
+ }
+}
+
+/**
+ * Run before spawning the managed engine. Global findings throw (the engine
+ * would exit at boot anyway, with the same message buried in its stderr);
+ * workspace findings only log, because the engine boots and other workspaces
+ * keep working — that workspace's routes surface opencode_config_invalid.
+ */
+export async function assertOpencodeConfigCompat(input: {
+ workspaceRoots?: string[];
+ env?: NodeJS.ProcessEnv;
+ logger?: CompatLogger;
+}): Promise<OpencodeConfigCompatFinding[]> {
+ const findings = await diagnoseOpencodeConfigCompat(input);
+ const fatal = findings.filter((finding) => finding.scope === "global");
+ for (const finding of findings) {
+ input.logger?.log(
+ finding.scope === "global" ? "error" : "warn",
+ finding.scope === "global"
+ ? "OpenCode global configuration uses V2 permissions; the bundled engine refuses to start."
+ : "OpenCode workspace configuration uses V2 permissions; the engine will reject that workspace.",
+ opencodeConfigCompatLogAttributes(finding),
+ );
+ }
+ if (fatal.length > 0) throw new OpencodeConfigCompatError(fatal);
+ return findings;
+}
+
+/**
+ * Parse the body of an engine config error (`{ name: "ConfigInvalidError",
+ * data: { path, issues?, message? } }`, HTTP 400) into an actionable message.
+ * Returns null for anything else so callers keep their generic mapping.
+ */
+export function parseOpencodeConfigErrorBody(body: unknown): OpencodeConfigErrorBody | null {
+ if (!isRecord(body) || typeof body.name !== "string" || !OPENCODE_CONFIG_ERROR_NAMES.has(body.name)) return null;
+ const data = isRecord(body.data) ? body.data : {};
+ const file = typeof data.path === "string" && data.path && data.path !== "config" ? data.path : null;
+ const detail = typeof data.message === "string" ? data.message.trim() : "";
+ const issues: OpencodeConfigCompatIssue[] = Array.isArray(data.issues)
+ ? data.issues.flatMap((issue) => {
+ if (!isRecord(issue) || typeof issue.message !== "string") return [];
+ const path = Array.isArray(issue.path) ? issue.path.filter((segment): segment is string => typeof segment === "string") : [];
+ return [{ path, message: issue.message }];
+ })
+ : [];
+ const parts = [detail, formatIssues(issues)].filter(Boolean);
+ const message = `OpenCode configuration is invalid${file ? ` at ${file}` : ""}${parts.length ? `: ${parts.join("; ")}` : ""}`;
+ return { name: body.name, file, message, issues };
+}
diff --git a/apps/server/src/opencode-plugins/system-prompt-composition.test.ts b/apps/server/src/opencode-plugins/system-prompt-composition.test.ts
index 8a9ccb68..a67f5120 100644
--- a/apps/server/src/opencode-plugins/system-prompt-composition.test.ts
+++ b/apps/server/src/opencode-plugins/system-prompt-composition.test.ts
@@ -112,3 +112,30 @@ test("all OmniRush.ai prompt hooks retain one ordered system message", async ()
expect(empty.system).toHaveLength(1);
expect(empty.system[0].startsWith("\n")).toBe(false);
});
+
+test("the base prompt carries one Editing files rule between the working style and artifact sections", async () => {
+ const heading = "\n\n## Editing files\n\n";
+ expect(occurrences(OMNIRUSH_AGENT_PROMPT, heading)).toBe(1);
+
+ const start = OMNIRUSH_AGENT_PROMPT.indexOf(heading);
+ const end = OMNIRUSH_AGENT_PROMPT.indexOf("\n\n## ", start + heading.length);
+ expect(start).toBeGreaterThan(OMNIRUSH_AGENT_PROMPT.indexOf("## Working style"));
+ expect(end).toBeGreaterThan(start);
+ expect(OMNIRUSH_AGENT_PROMPT.slice(end).startsWith("\n\n## OmniRush.ai Artifacts")).toBe(true);
+
+ // The failure the rule addresses: the model quotes lines that are no longer
+ // (or never were) in the file, then resends the identical patch.
+ const section = OMNIRUSH_AGENT_PROMPT.slice(start + heading.length, end);
+ expect(section).toContain("expected lines were not found");
+ expect(section).toContain("the file changed since you read it");
+ expect(section).toContain("Read the file again before retrying");
+ expect(section).toContain("never resend the same patch");
+ expect(section).toContain("smaller hunks with unambiguous context");
+ expect(section).toContain("keep the file's existing line endings");
+ expect(section.split(/\s+/).filter(Boolean).length).toBeLessThan(80);
+
+ // The composed prompt keeps the rule exactly once, in the base prompt.
+ const [prompt] = await composeReadyPrompt();
+ expect(occurrences(prompt, "## Editing files")).toBe(1);
+ expect(prompt.indexOf("## Editing files")).toBeLessThan(prompt.indexOf("You are running inside OmniRush.ai."));
+});
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 9d46bb3b..665b86a4 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -83,6 +83,7 @@ import {
import { installCloudPlugin, readCloudPluginResolved, readInstalledCloudPlugins, removeCloudPlugin } from "./cloud-plugins.js";
import { resolveClaudePluginBundle } from "./claude-plugin-bundle.js";
import { resolveWorkspaceOpencodeConnection } from "./opencode-connection.js";
+import { parseOpencodeConfigErrorBody } from "./opencode-config-compat.js";
import { listPortableFiles } from "./portable-files.js";
import {
collectWorkspaceExportWarnings,
@@ -1977,6 +1978,20 @@ export function unwrapOpencodeResult<T, E>(result: OpencodeClientResult<T, E>, p
path,
});
}
+ // The engine answers 400 `{ name: "Config…Error", data: { path, issues } }`
+ // when a user-owned opencode.json(c) is rejected (since 1.18.32 a V2
+ // `permissions` key does this for every instance-scoped route). That is
+ // the user's file, not an engine outage: keep the engine's own message.
+ const configError = parseOpencodeConfigErrorBody(result.error);
+ if (configError) {
+ throw new ApiError(422, "opencode_config_invalid", configError.message, {
+ status: result.response.status,
+ name: configError.name,
+ file: configError.file,
+ issues: configError.issues,
+ path,
+ });
+ }
throw new ApiError(502, "opencode_request_failed", "OpenCode request failed", {
status: result.response.status,
body: result.error,
diff --git a/apps/server/src/server.unwrapOpencodeResult.test.ts b/apps/server/src/server.unwrapOpencodeResult.test.ts
index ef830000..acd4b464 100644
--- a/apps/server/src/server.unwrapOpencodeResult.test.ts
+++ b/apps/server/src/server.unwrapOpencodeResult.test.ts
@@ -41,6 +41,46 @@ describe("unwrapOpencodeResult", () => {
});
});
+ test("maps the engine's ConfigInvalidError body to opencode_config_invalid with the engine's own message", () => {
+ // 1.18.32 answers every instance-scoped route this way when a workspace
+ // opencode.json(c) carries a V2 `permissions` key.
+ const message = 'V2 permissions are not supported by OpenCode V1. Use V1 "permission" rules or run opencode2.';
+ const error = {
+ name: "ConfigInvalidError",
+ data: { path: "/ws/.opencode/opencode.json", issues: [{ path: ["permissions"], message }] },
+ };
+ const failure = captureFailure(() => unwrapOpencodeResult({
+ data: undefined,
+ error,
+ response: new Response(null, { status: 400 }),
+ }, "/session"));
+
+ expect(failure).toBeInstanceOf(ApiError);
+ expect(failure).toMatchObject({
+ status: 422,
+ code: "opencode_config_invalid",
+ message: `OpenCode configuration is invalid at /ws/.opencode/opencode.json: ${message} (permissions)`,
+ details: {
+ status: 400,
+ name: "ConfigInvalidError",
+ file: "/ws/.opencode/opencode.json",
+ issues: [{ path: ["permissions"], message }],
+ path: "/session",
+ },
+ });
+ });
+
+ test("keeps the generic mapping for non-config engine errors", () => {
+ const error = { name: "UnknownError", data: { message: "Unexpected server error.", ref: "err_1" } };
+ const failure = captureFailure(() => unwrapOpencodeResult({
+ data: undefined,
+ error,
+ response: new Response(null, { status: 500 }),
+ }, "/session"));
+
+ expect(failure).toMatchObject({ status: 502, code: "opencode_request_failed", details: { status: 500, body: error } });
+ });
+
test("returns data unchanged", () => {
const data = { id: "session-1" };
expect(unwrapOpencodeResult({ data, error: undefined, response: new Response() }, "/session")).toBe(data);
diff --git a/constants.json b/constants.json
index ac4e37e8..da2c0879 100644
--- a/constants.json
+++ b/constants.json
@@ -1,4 +1,4 @@
{
- "opencodeVersion": "v1.18.18",
+ "opencodeVersion": "v1.18.32",
"opencodeV2Version": "0.0.0-beta-19086"
}
diff --git a/docs/opencode-v2-parallel-lane.md b/docs/opencode-v2-parallel-lane.md
index e11df54d..14a832e7 100644
--- a/docs/opencode-v2-parallel-lane.md
+++ b/docs/opencode-v2-parallel-lane.md
@@ -69,7 +69,7 @@ eliminates those costs for provider changes
| Area | Current v1 integration |
| --- | --- |
-| Engine binary | OmniRush.ai uses the anomalyco/opencode fork pinned in `constants.json` as `"opencodeVersion": "v1.18.18"`; desktop sidecar preparation downloads it in `apps/desktop/scripts/prepare-sidecar.mjs:35-48`. |
+| Engine binary | OmniRush.ai uses the anomalyco/opencode fork pinned in `constants.json` as `"opencodeVersion": "v1.18.32"`; desktop sidecar preparation downloads it in `apps/desktop/scripts/prepare-sidecar.mjs:35-48`. |
| Spawn | `apps/server/src/managed-opencode.ts:147-234` runs `opencode serve --hostname --port --cors '*'`, supplies `OPENCODE_SERVER_USERNAME` and `OPENCODE_SERVER_PASSWORD`, waits for stdout `opencode server listening on <url>`, and sets `OPENCODE_CONFIG` to the runtime configuration file. |
| Desktop boot | `apps/desktop/electron/main.mjs:1385-1445` enters `apps/desktop/electron/runtime.mjs:1882-2028` through `startOmniRushServerInner`, then starts the in-process server at `apps/server/src/embedded.ts:190-281`, which owns the child engine. |
| Server client | The engine client factory is `apps/server/src/server.ts:1246-1280`. |
diff --git a/docs/skills-and-mcp.md b/docs/skills-and-mcp.md
index d8919af0..cbc2d266 100644
--- a/docs/skills-and-mcp.md
+++ b/docs/skills-and-mcp.md
@@ -151,6 +151,9 @@ The engine caches its skill catalog per project instance and needs an instance r
**Removing an MCP server left tools behind in a running session.**
The engine drops the registration immediately, but a session that already started a turn keeps its captured tool set until the turn ends.
+**The app reports "Configuration is invalid at … V2 permissions are not supported by OpenCode V1", or a workspace answers `opencode_config_invalid`.**
+The bundled engine is OpenCode V1 (pinned in `constants.json`). Since engine 1.18.32 a `permissions` key in a user-owned `opencode.json(c)` — top level, or under `agent`, `agents` or `mode.<name>` — is rejected instead of ignored (the older 1.18.18 engine served such files normally). The server checks those files before spawning the engine: a `permissions` key in the global file (`~/.config/opencode/opencode.json(c)`, `config.json`, or the `OPENCODE_CONFIG_DIR` directory) stops startup with the message above naming the file; a `permissions` key in `<workspace>/.opencode/opencode.json(c)` or `<workspace>/opencode.json(c)` is logged as a warning, the engine still starts, server routes that read the engine for that workspace return `422 opencode_config_invalid` with the engine's message and the file path in `details`, and the native engine proxy passes the engine's own `400 ConfigInvalidError` body through unchanged. Other V2-only keys (`plugins`, `providers`, `websearch`, `warming`, …) are dropped with a "configuration compatibility diagnostic" warning in the engine log and do not block anything. Fix: rename `permissions` to `permission` (V1 rules) or remove it, then restart OmniRush.ai.
+
**Where are the files?**
- Server state directory: `~/.config/omnirush/` (or the directory of `OMNIRUSH_SERVER_CONFIG`), containing `runtime.sqlite` (runtime DB), `runtime-opencode-config.json` (engine-visible config) and the managed MCP vault.
- Engine data: `~/.local/share/opencode/` (logs under `log/`).
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fb10f6d6..ba4c6970 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -153,9 +153,6 @@ importers:
'@modelcontextprotocol/sdk':
specifier: ^1.29.0
version: 1.29.0(patch_hash=b9b29e6a319e94ea968476aa440eb8586b5da9db6b8011ce749c384d186f8a10)([email protected])
- '@opencode-ai/sdk':
- specifier: ^1.18.15
- version: 1.18.18
'@omnirush-ee/telemetry-contracts':
specifier: workspace:*
version: link:../../ee/packages/telemetry-contracts
@@ -177,6 +174,9 @@ importers:
'@omnirush/workbook':
specifier: workspace:*
version: link:../../packages/workbook
+ '@opencode-ai/sdk':
+ specifier: ^1.18.15
+ version: 1.18.18
'@paper-design/shaders-react':
specifier: 0.0.72
version: 0.0.72(@types/[email protected])([email protected])
@@ -337,9 +337,6 @@ importers:
'@modelcontextprotocol/sdk':
specifier: ^1.29.0
version: 1.29.0(patch_hash=b9b29e6a319e94ea968476aa440eb8586b5da9db6b8011ce749c384d186f8a10)([email protected])
- '@opencode-ai/sdk':
- specifier: ^1.18.15
- version: 1.18.18
'@omnirush/browser-logins':
specifier: workspace:*
version: link:../../packages/browser-logins
@@ -358,6 +355,9 @@ importers:
'@omnirush/types':
specifier: workspace:*
version: link:../../packages/types
+ '@opencode-ai/sdk':
+ specifier: ^1.18.32
+ version: 1.18.32
'@sentry/electron':
specifier: ^7.16.0
version: 7.16.0(@opentelemetry/[email protected](@opentelemetry/[email protected]))(@opentelemetry/[email protected](@opentelemetry/[email protected]))
@@ -450,15 +450,15 @@ importers:
'@modelcontextprotocol/sdk':
specifier: ^1.29.0
version: 1.29.0(patch_hash=b9b29e6a319e94ea968476aa440eb8586b5da9db6b8011ce749c384d186f8a10)([email protected])
- '@opencode-ai/sdk':
- specifier: ^1.18.15
- version: 1.18.18
'@omnirush/enterprise-mcp-client':
specifier: workspace:*
version: link:../../packages/enterprise-mcp-client
'@omnirush/types':
specifier: workspace:*
version: link:../../packages/types
+ '@opencode-ai/sdk':
+ specifier: ^1.18.32
+ version: 1.18.32
better-sqlite3:
specifier: ^13.0.2
version: 13.0.2
@@ -590,36 +590,6 @@ importers:
'@modelcontextprotocol/server':
specifier: ^2.0.0
version: 2.0.0
- '@opentelemetry/api':
- specifier: 1.9.1
- version: 1.9.1
- '@opentelemetry/api-logs':
- specifier: 0.220.0
- version: 0.220.0
- '@opentelemetry/exporter-logs-otlp-proto':
- specifier: 0.220.0
- version: 0.220.0(@opentelemetry/[email protected])
- '@opentelemetry/exporter-metrics-otlp-proto':
- specifier: 0.220.0
- version: 0.220.0(@opentelemetry/[email protected])
- '@opentelemetry/exporter-trace-otlp-proto':
- specifier: 0.220.0
- version: 0.220.0(@opentelemetry/[email protected])
- '@opentelemetry/sdk-logs':
- specifier: 0.220.0
- version: 0.220.0(@opentelemetry/[email protected])
- '@opentelemetry/sdk-metrics':
- specifier: 2.9.0
- version: 2.9.0(@opentelemetry/[email protected])
- '@opentelemetry/sdk-node':
- specifier: 0.220.0
- version: 0.220.0(@opentelemetry/[email protected])
- '@opentelemetry/sdk-trace-node':
- specifier: 2.9.0
- version: 2.9.0(@opentelemetry/[email protected])
- '@opentelemetry/semantic-conventions':
- specifier: 1.42.0
- version: 1.42.0
'@omnirush-ee/cloud-runtime':
specifier: workspace:*
version: link:../../packages/cloud-runtime
@@ -659,6 +629,36 @@ importers:
'@omnirush/types':
specifier: workspace:*
version: link:../../../packages/types
+ '@opentelemetry/api':
+ specifier: 1.9.1
+ version: 1.9.1
+ '@opentelemetry/api-logs':
+ specifier: 0.220.0
+ version: 0.220.0
+ '@opentelemetry/exporter-logs-otlp-proto':
+ specifier: 0.220.0
+ version: 0.220.0(@opentelemetry/[email protected])
+ '@opentelemetry/exporter-metrics-otlp-proto':
+ specifier: 0.220.0
+ version: 0.220.0(@opentelemetry/[email protected])
+ '@opentelemetry/exporter-trace-otlp-proto':
+ specifier: 0.220.0
+ version: 0.220.0(@opentelemetry/[email protected])
+ '@opentelemetry/sdk-logs':
+ specifier: 0.220.0
+ version: 0.220.0(@opentelemetry/[email protected])
+ '@opentelemetry/sdk-metrics':
+ specifier: 2.9.0
+ version: 2.9.0(@opentelemetry/[email protected])
+ '@opentelemetry/sdk-node':
+ specifier: 0.220.0
+ version: 0.220.0(@opentelemetry/[email protected])
+ '@opentelemetry/sdk-trace-node':
+ specifier: 2.9.0
+ version: 2.9.0(@opentelemetry/[email protected])
+ '@opentelemetry/semantic-conventions':
+ specifier: 1.42.0
+ version: 1.42.0
'@sentry/hono':
specifier: 10.64.0
version: 10.64.0(@hono/[email protected]([email protected]))(@sentry/[email protected](@opentelemetry/[email protected](@opentelemetry/[email protected]))(@opentelemetry/[email protected](@opentelemetry/[email protected])))([email protected])
@@ -808,6 +808,18 @@ importers:
ee/apps/den-web:
dependencies:
+ '@omnirush-ee/telemetry-contracts':
+ specifier: workspace:*
+ version: link:../../packages/telemetry-contracts
+ '@omnirush-ee/utils':
+ specifier: workspace:*
+ version: link:../../packages/utils
+ '@omnirush/types':
+ specifier: workspace:*
+ version: link:../../../packages/types
+ '@omnirush/ui':
+ specifier: workspace:*
+ version: link:../../../packages/ui
'@opentelemetry/api':
specifier: 1.9.1
version: 1.9.1
@@ -841,18 +853,6 @@ importers:
'@opentelemetry/semantic-conventions':
specifier: 1.42.0
version: 1.42.0
- '@omnirush-ee/telemetry-contracts':
- specifier: workspace:*
- version: link:../../packages/telemetry-contracts
- '@omnirush-ee/utils':
- specifier: workspace:*
- version: link:../../packages/utils
- '@omnirush/types':
- specifier: workspace:*
- version: link:../../../packages/types
- '@omnirush/ui':
- specifier: workspace:*
- version: link:../../../packages/ui
'@paper-design/shaders-react':
specifier: 0.0.72
version: 0.0.72(@types/[email protected])([email protected])
@@ -3069,6 +3069,9 @@ packages:
'@opencode-ai/[email protected]':
resolution: {integrity: sha512-GwgwhW+vE8FWSDw730SjzqNhsWXB0uJjbFOiqFkmM+USFuG13HuTlGe6SR2ixt+WXxoD6FV1hILWqsXyqej9hQ==}
+ '@opencode-ai/[email protected]':
+ resolution: {integrity: sha512-Wi3WtH/cLA3C0ga05lyDb7zac+SzbST9MPwCve1Ffod0xwzHdy9G2gnxvMAR4RBRhKJS32Rgk2cR+fxBhAVSQw==}
+
'@opentelemetry/[email protected]':
resolution: {integrity: sha512-CmVa4ImJ+ynfrPMNaAXHET6Bhb44SwzmfyVJFq9ni2jgXJR/l7C6gfVFddNmHP+ZOkP9cf4f9DBe68qVLTHc9w==}
engines: {node: '>=8.0.0'}
@@ -11543,6 +11546,10 @@ snapshots:
dependencies:
cross-spawn: 7.0.6
+ '@opencode-ai/[email protected]':
+ dependencies:
+ cross-spawn: 7.0.6
+
'@opentelemetry/[email protected]':
dependencies:
'@opentelemetry/api': 1.9.1