@openpalm/lib 0.11.0-beta.9 → 0.11.0-rc.18

package/src/control-plane/host-opencode.test.ts

@@ -16,10 +16,9 @@ function makeState(homeDir: string): ControlPlaneState {
   return {
     homeDir,
     configDir: join(homeDir, "config"),
-    stashDir: join(homeDir, "stash"),
+    stashDir: join(homeDir, "knowledge"),
     workspaceDir: join(homeDir, "workspace"),
-    cacheDir: join(homeDir, "cache"),
-    stateDir: join(homeDir, "state"),
+    dataDir: join(homeDir, "data"),
     stackDir: join(homeDir, "config/stack"),
     services: {},
     artifacts: { compose: "" },
@@ -104,6 +103,48 @@ describe("detectHostOpenCode", () => {
       expect(status.providerCount).toBe(0);
     });
   });
+
+  it("returns modelPreferences when model and small_model are set", () => {
+    const configDir = join(xdgRoot, "config", "opencode");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(join(configDir, "opencode.json"), JSON.stringify({
+      provider: { groq: {} },
+      model: "groq/llama-3.3-70b-versatile",
+      small_model: "groq/llama-3.1-8b-instant",
+    }));
+    withXdgEnv(`${xdgRoot}/config`, `${xdgRoot}/data`, () => {
+      const status = detectHostOpenCode();
+      expect(status.modelPreferences).toBeDefined();
+      expect(status.modelPreferences?.model).toBe("groq/llama-3.3-70b-versatile");
+      expect(status.modelPreferences?.small_model).toBe("groq/llama-3.1-8b-instant");
+    });
+  });
+
+  it("omits modelPreferences when no model fields are set", () => {
+    const configDir = join(xdgRoot, "config", "opencode");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(join(configDir, "opencode.json"), JSON.stringify({
+      provider: { groq: {} },
+    }));
+    withXdgEnv(`${xdgRoot}/config`, `${xdgRoot}/data`, () => {
+      const status = detectHostOpenCode();
+      expect(status.modelPreferences).toBeUndefined();
+    });
+  });
+
+  it("returns partial modelPreferences when only model is set", () => {
+    const configDir = join(xdgRoot, "config", "opencode");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(join(configDir, "opencode.json"), JSON.stringify({
+      provider: { anthropic: {} },
+      model: "anthropic/claude-sonnet-4-5",
+    }));
+    withXdgEnv(`${xdgRoot}/config`, `${xdgRoot}/data`, () => {
+      const status = detectHostOpenCode();
+      expect(status.modelPreferences?.model).toBe("anthropic/claude-sonnet-4-5");
+      expect(status.modelPreferences?.small_model).toBeUndefined();
+    });
+  });
 });
 
 // ── importHostOpenCode ────────────────────────────────────────────────────────
@@ -132,6 +173,8 @@ describe("importHostOpenCode", () => {
     writeFileSync(join(hostConfigDir, "opencode.json"), JSON.stringify({
       provider: { anthropic: { name: "Anthropic" }, groq: {} },
       model: "anthropic/claude-3-5-sonnet",
+      small_model: "openai/gpt-4o-mini",
+      disabled_providers: ["groq"],
       // These should be stripped:
       plugin: [{ module: "some-plugin" }],
       mcp: { server: {} },
@@ -153,14 +196,16 @@ describe("importHostOpenCode", () => {
     const destConfig = JSON.parse(readFileSync(join(opHome, "config", "assistant", "opencode.json"), "utf-8"));
     expect(destConfig.provider).toEqual({ anthropic: { name: "Anthropic" }, groq: {} });
     expect(destConfig.model).toBe("anthropic/claude-3-5-sonnet");
+    expect(destConfig.small_model).toBe("openai/gpt-4o-mini");
+    expect(destConfig.disabled_providers).toEqual(["groq"]);
     expect(destConfig.plugin).toBeUndefined();
     expect(destConfig.mcp).toBeUndefined();
 
     // Verify auth.json was written
-    expect(existsSync(join(opHome, "config", "auth.json"))).toBe(true);
+    expect(existsSync(join(opHome, "knowledge", "secrets", "auth.json"))).toBe(true);
 
     // Verify auth.json permissions are 0o600
-    const authStat = statSync(join(opHome, "config", "auth.json"));
+    const authStat = statSync(join(opHome, "knowledge", "secrets", "auth.json"));
     // On Linux, mode & 0o777 extracts permission bits
     expect(authStat.mode & 0o777).toBe(0o600);
   });
@@ -217,6 +262,34 @@ describe("importHostOpenCode", () => {
     expect(written.provider.anthropic.name).toBe("Host Anthropic");
   });
 
+  it("keeps existing model defaults and fills only missing host fields", () => {
+    const hostConfigDir = join(xdgRoot, "config", "opencode");
+    mkdirSync(hostConfigDir, { recursive: true });
+    writeFileSync(join(hostConfigDir, "opencode.json"), JSON.stringify({
+      provider: { openai: { name: "Host OpenAI" } },
+      model: "openai/gpt-4.1",
+      small_model: "openai/gpt-4.1-mini",
+      disabled_providers: ["groq"],
+    }));
+
+    const state = makeState(opHome);
+    const destDir = join(opHome, "config", "assistant");
+    mkdirSync(destDir, { recursive: true });
+    writeFileSync(join(destDir, "opencode.json"), JSON.stringify({
+      provider: { anthropic: { name: "Existing Anthropic" } },
+      model: "anthropic/claude-sonnet-4",
+    }));
+
+    withXdgEnv(`${xdgRoot}/config`, `${xdgRoot}/data`, () => {
+      importHostOpenCode(state);
+    });
+
+    const written = JSON.parse(readFileSync(join(destDir, "opencode.json"), "utf-8"));
+    expect(written.model).toBe("anthropic/claude-sonnet-4");
+    expect(written.small_model).toBe("openai/gpt-4.1-mini");
+    expect(written.disabled_providers).toEqual(["groq"]);
+  });
+
   it("returns zero counts when no host config is present", () => {
     const state = makeState(opHome);
     withXdgEnv(`${xdgRoot}/config`, `${xdgRoot}/data`, () => {
@@ -228,10 +301,9 @@ describe("importHostOpenCode", () => {
   });
 
   it("partial-merge auth: does not overwrite existing credential, adds new one", () => {
-    // Pre-seed OP_HOME/config/auth.json with one existing credential
-    const opConfigDir = join(opHome, "config");
-    mkdirSync(opConfigDir, { recursive: true });
-    writeFileSync(join(opConfigDir, "auth.json"), JSON.stringify({
+    // Pre-seed OP_HOME/knowledge/secrets/auth.json with one existing credential
+    mkdirSync(join(opHome, "knowledge", "secrets"), { recursive: true });
+    writeFileSync(join(opHome, "knowledge", "secrets", "auth.json"), JSON.stringify({
       azure: { type: "api", key: "existing" },
     }));
 
@@ -252,7 +324,7 @@ describe("importHostOpenCode", () => {
     });
 
     // Verify azure key was NOT overwritten
-    const written = JSON.parse(readFileSync(join(opConfigDir, "auth.json"), "utf-8")) as Record<string, { key: string }>;
+    const written = JSON.parse(readFileSync(join(opHome, "knowledge", "secrets", "auth.json"), "utf-8")) as Record<string, { key: string }>;
     expect(written.azure.key).toBe("existing");
     // Verify groq was added
     expect(written.groq.key).toBe("gsk-host");

package/src/control-plane/host-opencode.ts

@@ -11,12 +11,14 @@
  *   - auth.json is copied byte-for-byte and chmodded 0o600. Its contents
  *     are never parsed, logged, or returned to callers.
  *   - opencode.json is parsed to strip plugin/mcp/permission keys before
- *     writing; only provider/model/small_model/disabled_providers are kept.
+ *     writing; provider definitions are always kept, and top-level model
+ *     defaults are imported only when OP_HOME does not already define them.
  *   - Conflict detection compares provider IDs; existing credentials are
  *     preserved unless overwriteConflicts=true.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, copyFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { dirname } from "node:path";
 import type { ControlPlaneState } from "./types.js";
 import { authJsonPath, assistantConfigDir } from "./paths.js";
 
@@ -31,6 +33,8 @@ export type HostOpenCodeStatus = {
   providerCount: number;
   /** Number of credential entries in auth.json (0 when not found) */
   credentialCount: number;
+  /** Model preferences from the host's opencode.json, if present */
+  modelPreferences?: { model?: string; small_model?: string };
 };
 
 export type HostImportResult = {
@@ -64,7 +68,7 @@ function hostAuthJsonPath(): string {
 
 // ── opencode.json parsing ────────────────────────────────────────────────────
 
-/** Keys that are safe to import from host opencode.json into OP_HOME config */
+/** Keys that are safe to import from host opencode.json into OP_HOME config. */
 const ALLOWED_CONFIG_KEYS = new Set(["$schema", "provider", "model", "small_model", "disabled_providers"]);
 
 type OpenCodeJson = Record<string, unknown>;
@@ -78,8 +82,18 @@ function readJsonFileSafe(path: string): OpenCodeJson | null {
 }
 
 function stripDisallowedKeys(obj: OpenCodeJson): OpenCodeJson {
+  const next: OpenCodeJson = {};
+  if (typeof obj.$schema === 'string') next.$schema = obj.$schema;
+  if (obj.provider && typeof obj.provider === 'object' && !Array.isArray(obj.provider)) {
+    next.provider = obj.provider;
+  }
+  if (typeof obj.model === 'string') next.model = obj.model;
+  if (typeof obj.small_model === 'string') next.small_model = obj.small_model;
+  if (Array.isArray(obj.disabled_providers) && obj.disabled_providers.every((entry) => typeof entry === 'string')) {
+    next.disabled_providers = obj.disabled_providers;
+  }
   return Object.fromEntries(
-    Object.entries(obj).filter(([k]) => ALLOWED_CONFIG_KEYS.has(k))
+    Object.entries(next).filter(([k]) => ALLOWED_CONFIG_KEYS.has(k))
   );
 }
 
@@ -116,9 +130,16 @@ export function detectHostOpenCode(): HostOpenCodeStatus {
   }
 
   let providerCount = 0;
+  let modelPreferences: { model?: string; small_model?: string } | undefined;
   if (configExists) {
     const parsed = readJsonFileSafe(configPath);
     providerCount = parsed ? countProviders(parsed) : 0;
+    if (parsed) {
+      const prefs: { model?: string; small_model?: string } = {};
+      if (typeof parsed.model === 'string' && parsed.model) prefs.model = parsed.model;
+      if (typeof parsed.small_model === 'string' && parsed.small_model) prefs.small_model = parsed.small_model;
+      if (prefs.model || prefs.small_model) modelPreferences = prefs;
+    }
   }
 
   let credentialCount = 0;
@@ -131,6 +152,7 @@ export function detectHostOpenCode(): HostOpenCodeStatus {
     authPath: authExists ? authPath : undefined,
     providerCount,
     credentialCount,
+    ...(modelPreferences ? { modelPreferences } : {}),
   };
 }
 
@@ -181,21 +203,28 @@ export function importHostOpenCode(
         }
       }
 
-      const merged: OpenCodeJson = {
-        ...existing,
-        ...sanitized,
-        ...(Object.keys(mergedProviders).length > 0 ? { provider: mergedProviders } : {}),
-      };
-
-      writeFileSync(destPath, JSON.stringify(merged, null, 2) + "\n");
-    }
+       const merged: OpenCodeJson = {
+         ...existing,
+         ...(typeof existing.$schema === 'undefined' && typeof sanitized.$schema !== 'undefined'
+           ? { $schema: sanitized.$schema }
+           : {}),
+         ...(Object.keys(mergedProviders).length > 0 ? { provider: mergedProviders } : {}),
+       };
+
+       for (const key of ["model", "small_model", "disabled_providers"] as const) {
+         if (typeof merged[key] === 'undefined' && typeof sanitized[key] !== 'undefined') {
+           merged[key] = sanitized[key];
+         }
+       }
+
+       writeFileSync(destPath, JSON.stringify(merged, null, 2) + "\n");
+     }
   }
 
   // ── auth.json ──────────────────────────────────────────────────────────
   if (status.authPath) {
     const destPath = authJsonPath(state);
-    const destDir = state.configDir;
-    mkdirSync(destDir, { recursive: true });
+    mkdirSync(dirname(destPath), { recursive: true, mode: 0o700 });
 
     if (existsSync(destPath) && !overwriteConflicts) {
       // Merge: copy only keys that do not already exist in OP_HOME auth.json