Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(opencode): carry selected legacy API credentials into v2 service (#900)

Gustavo Ye00042cdd7e6f
diff --git a/src/daemon/agent-driver/src/adapters/opencode/index.test.ts b/src/daemon/agent-driver/src/adapters/opencode/index.test.ts
index 8dcba5587..56997b883 100644
--- a/src/daemon/agent-driver/src/adapters/opencode/index.test.ts
+++ b/src/daemon/agent-driver/src/adapters/opencode/index.test.ts
@@ -1,9 +1,9 @@
import { EventEmitter } from "node:events";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { fakeLaunchContext } from "../../testing/adapter-fixture.js";
+import { fakeLaunchContext, fakePrepared } from "../../testing/adapter-fixture.js";
import { OpenCodeDriver } from "./index.js";
const spawnAgentProcess = vi.hoisted(() => vi.fn());
@@ -23,6 +23,7 @@ describe("OpenCodeDriver persistent v2 service", () => {
let driver: OpenCodeDriver;
beforeEach(() => {
+ spawnAgentProcess.mockClear();
driver = new OpenCodeDriver();
});
@@ -77,6 +78,30 @@ describe("OpenCodeDriver persistent v2 service", () => {
expect(spawnAgentProcess).not.toHaveBeenCalled();
});
+ it("uses the selected legacy API credential for the native v2 provider", async () => {
+ const directory = mkdtempSync(join(tmpdir(), "opencode-legacy-auth-"));
+ directories.push(directory);
+ const data = join(directory, "data");
+ const cache = join(directory, "cache");
+ mkdirSync(join(data, "opencode"), { recursive: true });
+ mkdirSync(join(cache, "opencode"), { recursive: true });
+ writeFileSync(join(data, "opencode", "auth.json"), JSON.stringify({
+ deepseek: { type: "api", key: "isolated-deepseek-key" },
+ unrelated: { type: "api", key: "must-not-escape" },
+ }));
+ writeFileSync(join(cache, "opencode", "models.json"), JSON.stringify({
+ deepseek: { env: ["DEEPSEEK_API_KEY"] }, unrelated: { env: ["OTHER_API_KEY"] },
+ }));
+ await driver.spawnService(fakeLaunchContext("opencode", directory, {
+ prepared: fakePrepared({ base: { XDG_DATA_HOME: data, XDG_CACHE_HOME: cache } }),
+ config: { runtimeConfig: { model: { kind: "named", name: "deepseek/deepseek-flash" } } },
+ }), 43123, "session-secret");
+ const [, args, options] = spawnAgentProcess.mock.calls.at(-1)!;
+ expect(options.env.DEEPSEEK_API_KEY).toBe("isolated-deepseek-key");
+ expect(options.env.OTHER_API_KEY).toBeUndefined();
+ expect(JSON.stringify(args)).not.toContain("isolated-deepseek-key");
+ });
+
it("spawns one loopback service without putting its password in argv", async () => {
const directory = mkdtempSync(join(tmpdir(), "opencode-driver-"));
directories.push(directory);
diff --git a/src/daemon/agent-driver/src/adapters/opencode/index.ts b/src/daemon/agent-driver/src/adapters/opencode/index.ts
index d685eb7ee..714167fbb 100644
--- a/src/daemon/agent-driver/src/adapters/opencode/index.ts
+++ b/src/daemon/agent-driver/src/adapters/opencode/index.ts
@@ -27,6 +27,7 @@ import {
OpenCodeServiceLane,
type OpenCodeServiceProcessFactory,
} from "./service-lane.js";
+import { legacyOpenCodeApiEnvironment } from "./legacy-auth.js";
import { discoverOpenCodeRecentContext } from "./recent-context.js";
function createOpenCodeMessageId(): string {
@@ -76,7 +77,9 @@ export class OpenCodeDriver implements BackendAdapter, OpenCodeServiceProcessFac
const { spawnEnv } = await prepareCliTransport(ctx, {
OPENCODE_SERVER_PASSWORD: password,
});
- const override = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command;
+ const fields = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
+ Object.assign(spawnEnv, await legacyOpenCodeApiEnvironment(spawnEnv, fields.model));
+ const override = fields.command;
const args = [
"serve",
"--pure",
diff --git a/src/daemon/agent-driver/src/adapters/opencode/legacy-auth.test.ts b/src/daemon/agent-driver/src/adapters/opencode/legacy-auth.test.ts
new file mode 100644
index 000000000..f35652984
--- /dev/null
+++ b/src/daemon/agent-driver/src/adapters/opencode/legacy-auth.test.ts
@@ -0,0 +1,100 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { legacyOpenCodeApiEnvironment } from "./legacy-auth.js";
+
+describe("legacy OpenCode API credentials", () => {
+ let directory: string;
+ let environment: Record<string, string>;
+ let authFile: string;
+ let catalogFile: string;
+
+ beforeEach(async () => {
+ directory = await mkdtemp(path.join(tmpdir(), "opencode-api-compat-"));
+ environment = { XDG_DATA_HOME: path.join(directory, "data"), XDG_CACHE_HOME: path.join(directory, "cache") };
+ authFile = path.join(environment.XDG_DATA_HOME!, "opencode", "auth.json");
+ catalogFile = path.join(environment.XDG_CACHE_HOME!, "opencode", "models.json");
+ await mkdir(path.dirname(authFile), { recursive: true });
+ await mkdir(path.dirname(catalogFile), { recursive: true });
+ await writeFile(authFile, JSON.stringify({
+ deepseek: { type: "api", key: "saved-key" }, other: { type: "api", key: "private-other-key" },
+ }));
+ await writeFile(catalogFile, JSON.stringify({ deepseek: { env: ["DEEPSEEK_API_KEY"] } }));
+ });
+
+ afterEach(async () => { await rm(directory, { recursive: true, force: true }); });
+
+ const resolve = (environment: Record<string, string>, model = "deepseek/deepseek-flash") =>
+ legacyOpenCodeApiEnvironment(environment, model);
+
+ it("exports only the selected provider's API key without changing input or auth", async () => {
+ const original = await readFile(authFile, "utf8");
+ expect(await resolve(environment)).toEqual({ DEEPSEEK_API_KEY: "saved-key" });
+ expect(environment.DEEPSEEK_API_KEY).toBeUndefined();
+ expect(await readFile(authFile, "utf8")).toBe(original);
+ });
+
+ it.each(["explicit-key", ""])("preserves an explicit credential, including an empty value (%s)", async (key) => {
+ expect(await resolve({ ...environment, DEEPSEEK_API_KEY: key })).toEqual({});
+ });
+
+ it("preserves an alternative native credential", async () => {
+ await writeFile(catalogFile, JSON.stringify({ deepseek: { env: ["DEEPSEEK_API_KEY", "DEEPSEEK_TOKEN"] } }));
+ expect(await resolve({ ...environment, DEEPSEEK_TOKEN: "explicit-token" })).toEqual({});
+ });
+
+ it("uses valid inline auth before the file and falls back for malformed inline auth", async () => {
+ expect(await resolve({ ...environment, OPENCODE_AUTH_CONTENT: JSON.stringify({ deepseek: { type: "api", key: "inline-key" } }) }))
+ .toEqual({ DEEPSEEK_API_KEY: "inline-key" });
+ expect(await resolve({ ...environment, OPENCODE_AUTH_CONTENT: "{" })).toEqual({ DEEPSEEK_API_KEY: "saved-key" });
+ expect(await resolve({ ...environment, OPENCODE_AUTH_CONTENT: "{}" })).toEqual({});
+ });
+
+ it.each([
+ { type: "oauth", access: "private-access", refresh: "private-refresh" },
+ { type: "api", key: " " }, { type: "api", key: 123 }, { type: "wellknown", key: "other" }, null,
+ ])("does not convert unsupported auth: %j", async (credential) => {
+ await writeFile(authFile, JSON.stringify({ deepseek: credential }));
+ expect(await resolve(environment)).toEqual({});
+ });
+
+ it.each(["unknown/model", "deepseek", "/model", ""])("does not invent a provider mapping for %s", async (model) => {
+ expect(await resolve(environment, model)).toEqual({});
+ });
+
+ it("leaves default models unchanged", async () => {
+ expect(await legacyOpenCodeApiEnvironment(environment, undefined)).toEqual({});
+ });
+
+ it.each(["auth", "catalog"])("tolerates missing, malformed and oversized %s files", async (kind) => {
+ const file = kind === "auth" ? authFile : catalogFile;
+ await rm(file);
+ expect(await resolve(environment)).toEqual({});
+ await writeFile(file, "{");
+ expect(await resolve(environment)).toEqual({});
+ await writeFile(file, " ".repeat((kind === "auth" ? 1 : 16) * 1024 * 1024 + 1));
+ expect(await resolve(environment)).toEqual({});
+ });
+
+ it("does not put secrets in non-credential environment variables", async () => {
+ await writeFile(catalogFile, JSON.stringify({ deepseek: { env: ["PATH", "LD_PRELOAD", "AWS_ACCESS_KEY_ID", 42] } }));
+ expect(await resolve(environment)).toEqual({});
+ });
+
+ it("honors an explicit catalog and does not use the default catalog for a custom source", async () => {
+ const custom = path.join(directory, "custom.json");
+ await writeFile(custom, JSON.stringify({ deepseek: { env: ["CUSTOM_TOKEN"] } }));
+ expect(await resolve({ ...environment, OPENCODE_MODELS_PATH: custom })).toEqual({ CUSTOM_TOKEN: "saved-key" });
+ expect(await resolve({ ...environment, OPENCODE_MODELS_URL: "https://catalog.example.invalid" })).toEqual({});
+ });
+
+ it("resolves standard paths from HOME when XDG paths are relative", async () => {
+ await mkdir(path.join(directory, ".local", "share", "opencode"), { recursive: true });
+ await mkdir(path.join(directory, ".cache", "opencode"), { recursive: true });
+ await writeFile(path.join(directory, ".local", "share", "opencode", "auth.json"), JSON.stringify({ deepseek: { type: "api", key: "home-key" } }));
+ await writeFile(path.join(directory, ".cache", "opencode", "models.json"), JSON.stringify({ deepseek: { env: ["DEEPSEEK_API_KEY"] } }));
+ expect(await resolve({ HOME: directory, USERPROFILE: directory, XDG_DATA_HOME: "relative", XDG_CACHE_HOME: "relative" }))
+ .toEqual({ DEEPSEEK_API_KEY: "home-key" });
+ });
+});
diff --git a/src/daemon/agent-driver/src/adapters/opencode/legacy-auth.ts b/src/daemon/agent-driver/src/adapters/opencode/legacy-auth.ts
new file mode 100644
index 000000000..40bcf4d1a
--- /dev/null
+++ b/src/daemon/agent-driver/src/adapters/opencode/legacy-auth.ts
@@ -0,0 +1,61 @@
+import { open } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+type Environment = Readonly<Record<string, string | undefined>>;
+
+function record(value: unknown): Record<string, unknown> | undefined {
+ return value !== null && typeof value === "object" && !Array.isArray(value)
+ ? value as Record<string, unknown>
+ : undefined;
+}
+
+function parse(value: string): Record<string, unknown> | undefined {
+ try { return record(JSON.parse(value)); } catch { return undefined; }
+}
+
+async function readJson(filename: string, maxBytes: number): Promise<Record<string, unknown> | undefined> {
+ try {
+ const file = await open(filename, "r");
+ try {
+ if ((await file.stat()).size > maxBytes) return undefined;
+ return parse(await file.readFile("utf8"));
+ } finally { await file.close(); }
+ } catch { return undefined; }
+}
+
+function xdgRoot(value: string | undefined, fallback: string): string {
+ return value && path.isAbsolute(value) ? value : fallback;
+}
+
+export async function legacyOpenCodeApiEnvironment(
+ environment: Environment,
+ model: string | undefined,
+): Promise<Record<string, string>> {
+ if (!model || model.indexOf("/") < 1) return {};
+ if (environment.OPENCODE_MODELS_URL
+ && environment.OPENCODE_MODELS_URL !== "https://models.opencode.ai"
+ && !environment.OPENCODE_MODELS_PATH) return {};
+ const provider = model.slice(0, model.indexOf("/"));
+ const home = (process.platform === "win32" ? environment.USERPROFILE : undefined)
+ || environment.HOME || homedir();
+ const cache = xdgRoot(environment.XDG_CACHE_HOME, path.join(home, ".cache"));
+ const catalog = await readJson(
+ environment.OPENCODE_MODELS_PATH || path.join(cache, "opencode", "models.json"),
+ 16 * 1024 * 1024,
+ );
+ const providerInfo = record(catalog?.[provider]);
+ const names = Array.isArray(providerInfo?.env)
+ ? providerInfo.env.filter((name): name is string => typeof name === "string")
+ : [];
+ if (names.some((name) => environment[name] !== undefined)) return {};
+ const name = names.find((name) => /^[A-Z][A-Z0-9_]*(?:_API_KEY|_TOKEN)$/.test(name));
+ if (!name) return {};
+ const data = xdgRoot(environment.XDG_DATA_HOME, path.join(home, ".local", "share"));
+ const auth = (environment.OPENCODE_AUTH_CONTENT ? parse(environment.OPENCODE_AUTH_CONTENT) : undefined)
+ ?? await readJson(path.join(data, "opencode", "auth.json"), 1024 * 1024);
+ const credential = record(auth?.[provider]);
+ return credential?.type === "api" && typeof credential.key === "string" && credential.key.trim()
+ ? { [name]: credential.key }
+ : {};
+}