@cortexkit/opencode-magic-context 0.42.5 → 0.43.0

package/src/shared/opencode-config-dir.ts

@@ -9,19 +9,64 @@ export type {
     OpenCodeConfigPaths,
 } from "./opencode-config-dir-types";
 
-function getCliConfigDir(): string {
-    const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-    if (envConfigDir) {
-        return resolve(envConfigDir);
-    }
+/**
+ * The user's home directory, preferring `$HOME` over the cached value.
+ *
+ * `os.homedir()` reads `$HOME` once when the process starts and never again,
+ * so a test (or a wrapper) that sets `HOME` afterwards would otherwise be
+ * silently ignored and we would read the developer's real config. `$HOME` is
+ * normally unset on Windows, where the cached value is the right answer.
+ */
+function resolveHomeDir(): string {
+    return process.env.HOME?.trim() || homedir();
+}
 
+/**
+ * OpenCode's GLOBAL config directory: `$XDG_CONFIG_HOME/opencode`, falling
+ * back to `~/.config/opencode` (on every platform, Windows included — OpenCode
+ * does not use %APPDATA%).
+ *
+ * This helper names the loader's XDG layer, not every OpenCode surface called
+ * "config". In 1.18.30, `Global.Path.config` is the pure-XDG path
+ * (`packages/core/src/global.ts:13`) and the loader merges it once at
+ * `packages/opencode/src/config/config.ts:412-413`. Its later directories loop
+ * accepts only `.opencode` paths or the exact `OPENCODE_CONFIG_DIR` value
+ * (`config.ts:437-441`), so the XDG layer is skipped there and the env path is
+ * merged last. The detector mirrors that loader order via
+ * {@link getOpenCodeConfigDirs}.
+ *
+ * Service consumers see a different value: `Global.make()` injects
+ * `Flag.OPENCODE_CONFIG_DIR ?? Path.config` as `config`
+ * (`packages/core/src/global.ts:64`), so setting the env var replaces the
+ * service's value even though the loader still merges the XDG layer.
+ */
+export function getOpenCodeGlobalConfigDir(): string {
     if (process.platform === "win32") {
-        return join(homedir(), ".config", "opencode");
+        return join(resolveHomeDir(), ".config", "opencode");
     }
 
-    return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+    return join(process.env.XDG_CONFIG_HOME || join(resolveHomeDir(), ".config"), "opencode");
+}
+
+function getEnvConfigDir(): string | undefined {
+    const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+    return envConfigDir ? resolve(envConfigDir) : undefined;
+}
+
+function getCliConfigDir(): string {
+    return getEnvConfigDir() ?? getOpenCodeGlobalConfigDir();
 }
 
+/**
+ * The single directory Magic Context WRITES its OpenCode-side config into.
+ *
+ * `OPENCODE_CONFIG_DIR` wins here on purpose: among the directories OpenCode
+ * reads it has the highest precedence, so a setting written there is the one
+ * that takes effect. Do NOT use this to decide what OpenCode RESOLVED — for
+ * that you must read every directory in {@link getOpenCodeConfigDirs}, because
+ * a value the user set in the global directory is still live when
+ * `OPENCODE_CONFIG_DIR` points somewhere that does not override it.
+ */
 export function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string {
     return getCliConfigDir();
 }
@@ -36,3 +81,31 @@ export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenC
         omoConfig: join(configDir, "magic-context.jsonc"),
     };
 }
+
+/**
+ * Every user-tier directory OpenCode reads config from, ordered from LOWEST to
+ * HIGHEST precedence — later entries override earlier ones, which is the order
+ * OpenCode merges them in.
+ *
+ * Verified against the opencode 1.18.30 binary (`ConfigPaths.directories` plus
+ * the global loader in `Config.loadInstanceState`) and confirmed on a live host
+ * with `opencode debug config`:
+ *
+ *   1. `$XDG_CONFIG_HOME/opencode` — always read, whatever the environment says
+ *   2. `~/.opencode`               — always scanned, even outside a project
+ *   3. `$OPENCODE_CONFIG_DIR`      — appended last, so it wins ties
+ *
+ * The important part is that entry 3 is an ADDITION, not a replacement. A
+ * launcher that exports `OPENCODE_CONFIG_DIR` to a directory holding only
+ * plugin scaffolding does not stop OpenCode from reading the user's real
+ * config in entry 1 — so neither may we.
+ *
+ * Project-level directories are deliberately not included: they depend on the
+ * working directory and are resolved by the caller that knows it.
+ */
+export function getOpenCodeConfigDirs(): string[] {
+    const dirs = [getOpenCodeGlobalConfigDir(), join(resolveHomeDir(), ".opencode")];
+    const envDir = getEnvConfigDir();
+    if (envDir) dirs.push(envDir);
+    return [...new Set(dirs)];
+}

package/src/shared/opencode-db-path.test.ts

@@ -5,13 +5,18 @@ import { mkdirSync, mkdtempSync, rmSync, unlinkSync, utimesSync, writeFileSync }
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
+    assertOpenCodeStoreGeneration,
+    detectOpenCodeStoreGeneration,
     formatOpenCodeDbDoctorLine,
     formatOpenCodeDbMissingBanner,
     formatOpenCodeDbMissingStatusLine,
+    hasV1MessageTables,
     openCodeDbPathExists,
     resetOpenCodeDbPathStateForTesting,
     resolveOpenCodeDbPath,
+    sourceOpenCodeDatabaseFilename,
 } from "./opencode-db-path";
+import { Database } from "./sqlite";
 
 const ORIGINAL_ENV = {
     XDG_DATA_HOME: process.env.XDG_DATA_HOME,
@@ -173,6 +178,175 @@ describe("resolveOpenCodeDbPath", () => {
         });
     });
 
+    it("uses the verbatim v2 channel filename table without changing v1 defaults", () => {
+        const { dataHome, openCodeDir } = useDataHome();
+        for (const channel of ["latest", "dev", "beta", "next", "prod"]) {
+            expect(sourceOpenCodeDatabaseFilename("v2", channel, {})).toBe("opencode.db");
+        }
+        expect(sourceOpenCodeDatabaseFilename("v2", "a/b c!._-", {})).toBe("opencode-abc._-.db");
+        expect(
+            resolveOpenCodeDbPath("v2", {
+                dataHome,
+                channel: "local",
+                env: { OPENCODE_DB: "opencode2.db" },
+            }),
+        ).toEqual({
+            path: join(openCodeDir, "opencode2.db"),
+            source: "OPENCODE_DB",
+            channel: null,
+        });
+    });
+
+    it("detects store generations and refuses a mismatched schema before reading", () => {
+        const { openCodeDir } = useDataHome();
+        const v1Path = join(openCodeDir, "v1.db");
+        const v2Path = join(openCodeDir, "v2.db");
+        const v1 = new Database(v1Path);
+        const v2 = new Database(v2Path);
+        try {
+            v1.exec("CREATE TABLE message(id TEXT); CREATE TABLE part(id TEXT)");
+            v2.exec("CREATE TABLE session_message(id TEXT)");
+            expect(detectOpenCodeStoreGeneration(v1)).toBe("v1");
+            expect(detectOpenCodeStoreGeneration(v2)).toBe("v2");
+            expect(() => assertOpenCodeStoreGeneration(v2, "v1", v2Path)).toThrow(
+                "expected v1, found v2",
+            );
+            expect(() => assertOpenCodeStoreGeneration(v1, "v2", v1Path)).toThrow(
+                "expected v2, found v1",
+            );
+        } finally {
+            v1.close();
+            v2.close();
+        }
+    });
+
+    it("reads a live OpenCode 1.18.x store as v1 even though it ships session_message", () => {
+        const { openCodeDir } = useDataHome();
+        const livePath = join(openCodeDir, "live-v1.db");
+        const live = new Database(livePath);
+        try {
+            // Captured from a running OpenCode 1.18.30 store. session_message exists in v1,
+            // so a detector keyed on its presence calls a v1 host v2 and every v1 reader
+            // (historian chunk, marker discovery, message index, tool-owner backfill) then
+            // refuses. Keep this table list as observed, not as remembered.
+            for (const table of [
+                "account",
+                "event",
+                "message",
+                "part",
+                "permission",
+                "project",
+                "session",
+                "session_message",
+                "session_run_lease",
+                "todo",
+                "workspace",
+            ]) {
+                live.exec(`CREATE TABLE ${table}(id TEXT)`);
+            }
+            expect(detectOpenCodeStoreGeneration(live)).toBe("v1");
+            expect(() => assertOpenCodeStoreGeneration(live, "v1", livePath)).not.toThrow();
+            expect(() => assertOpenCodeStoreGeneration(live, "v2", livePath)).toThrow(
+                "expected v2, found v1",
+            );
+        } finally {
+            live.close();
+        }
+    });
+
+    it("reports v1 message capability on a migrated store accepted by both readers", () => {
+        const { openCodeDir } = useDataHome();
+        const migratedPath = join(openCodeDir, "migrated-v2.db");
+        const migrated = new Database(migratedPath);
+        try {
+            // Captured from an OpenCode 2.0.7 store that the v2 host migrated from a 1.18.x
+            // store: it keeps the v1 `message`/`part` tables beside its own schema, so it
+            // carries BOTH generations. `session_v2` is written only by an OpenCode 2 host
+            // (the 1.18.31 binary never references it). Keep this table list as observed.
+            for (const table of [
+                "account",
+                "account_state",
+                "control_account",
+                "credential",
+                "event",
+                "event_sequence",
+                "instruction_blob",
+                "instruction_entry",
+                "instruction_state",
+                "kv",
+                "message",
+                "migration",
+                "part",
+                "permission",
+                "project",
+                "project_directory",
+                "session",
+                "session_inbox",
+                "session_message",
+                "session_pending",
+                "session_share",
+                "session_v2",
+                "todo",
+                "workspace",
+                "worktree",
+            ]) {
+                migrated.exec(`CREATE TABLE ${table}(id TEXT)`);
+            }
+            expect(hasV1MessageTables(migrated)).toBe(true);
+            expect(() => assertOpenCodeStoreGeneration(migrated, "v2", migratedPath)).not.toThrow();
+            expect(() => assertOpenCodeStoreGeneration(migrated, "v1", migratedPath)).not.toThrow();
+        } finally {
+            migrated.close();
+        }
+    });
+
+    it("reads a fresh OpenCode 2 store as v2 only", () => {
+        const { openCodeDir } = useDataHome();
+        const freshV2Path = join(openCodeDir, "fresh-v2.db");
+        const freshV2 = new Database(freshV2Path);
+        try {
+            // Captured from a new OpenCode 2.0.7 data directory: no v1 message tables.
+            for (const table of [
+                "account",
+                "event",
+                "migration",
+                "permission",
+                "project",
+                "session_inbox",
+                "session_message",
+                "session_pending",
+                "session_v2",
+                "workspace",
+            ]) {
+                freshV2.exec(`CREATE TABLE ${table}(id TEXT)`);
+            }
+            expect(hasV1MessageTables(freshV2)).toBe(false);
+            expect(detectOpenCodeStoreGeneration(freshV2)).toBe("v2");
+            expect(() => assertOpenCodeStoreGeneration(freshV2, "v2", freshV2Path)).not.toThrow();
+            expect(() => assertOpenCodeStoreGeneration(freshV2, "v1", freshV2Path)).toThrow(
+                "expected v1, found v2",
+            );
+        } finally {
+            freshV2.close();
+        }
+    });
+
+    it("treats a store with no schema yet as empty rather than as a conflicting host", () => {
+        const { openCodeDir } = useDataHome();
+        const freshPath = join(openCodeDir, "fresh.db");
+        const fresh = new Database(freshPath);
+        try {
+            // A host that has not written its first row looks like this. Readers have always
+            // seen it as empty; refusing here throws inside the historian, marker and index
+            // readers on every fresh data directory.
+            expect(detectOpenCodeStoreGeneration(fresh)).toBe("unknown");
+            expect(() => assertOpenCodeStoreGeneration(fresh, "v1", freshPath)).not.toThrow();
+            expect(() => assertOpenCodeStoreGeneration(fresh, "v2", freshPath)).not.toThrow();
+        } finally {
+            fresh.close();
+        }
+    });
+
     it("formats the missing banner, status, and doctor lines by value", () => {
         const { openCodeDir } = useDataHome();
         const lookedFor = [

package/src/shared/opencode-db-path.ts

@@ -3,6 +3,40 @@ import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 
 export type OpenCodeDbPathSource = "OPENCODE_DB" | "channel" | "default" | "discovered";
+export type OpenCodeHostGeneration = "v1" | "v2";
+export type OpenCodeStoreGeneration = OpenCodeHostGeneration | "unknown";
+
+export interface ResolveOpenCodeDbPathOptions {
+    dataHome?: string;
+    channel?: string;
+    env?: NodeJS.ProcessEnv;
+}
+
+/**
+ * Decide the host generation from the version the executable reports, never
+ * from its name (the public installer places OpenCode 2 at
+ * `~/.opencode/bin/opencode` with a tiny `opencode2` shim beside it). The raw
+ * `--version` stdout carries a program-name prefix ("opencode v2.0.12"), so the
+ * major is the first digit run, not `parseInt` of the whole string.
+ *
+ * OpenCode 2's pre-GA betas were published under the old scope as
+ * `@opencode-ai/*@0.0.0-beta-<n>` (verified: `0.0.0-beta-19234` ships the V2
+ * `host`/`promise`/`effect` contract and the `compaction` hook); at GA the line
+ * moved to `@opencode/*@2.0.x`. A major of 0 therefore does not mean 1.x: the
+ * beta and dev pre-release shapes are OpenCode 2.
+ */
+export function openCodeHostGenerationFromVersion(
+    version: string | null | undefined,
+): OpenCodeHostGeneration {
+    const text = version ?? "";
+    if (/(?:^|\s|v)0\.0\.0-(?:beta|dev)-/.test(text)) return "v2";
+    const major = Number.parseInt(text.match(/\d+/)?.[0] ?? "", 10);
+    return Number.isFinite(major) && major >= 2 ? "v2" : "v1";
+}
+
+export interface OpenCodeStoreSchemaDatabase {
+    prepare(sql: string): { all(...params: unknown[]): unknown[] };
+}
 
 export interface OpenCodeDbPathResolution {
     path: string;
@@ -24,16 +58,22 @@ let cachedResolution: CachedResolution | null = null;
 let lastReadFailure: OpenCodeDbReadFailure | null = null;
 const claimedDiagnostics = new Set<string>();
 
-function openCodeDataDir(): string {
-    return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode");
+function openCodeDataDir(env: NodeJS.ProcessEnv = process.env, dataHome?: string): string {
+    return join(dataHome ?? env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode");
 }
 
-function environmentKey(dataDir: string): string {
+function environmentKey(
+    dataDir: string,
+    hostGeneration: OpenCodeHostGeneration,
+    channel: string | undefined,
+    env: NodeJS.ProcessEnv,
+): string {
     return [
+        hostGeneration,
         dataDir,
-        process.env.OPENCODE_DB ?? "",
-        process.env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
-        process.env.OPENCODE_CHANNEL ?? "",
+        env.OPENCODE_DB ?? "",
+        env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
+        channel ?? env.OPENCODE_CHANNEL ?? "",
     ].join("\0");
 }
 
@@ -81,8 +121,11 @@ function discoverOpenCodeDb(dataDir: string): OpenCodeDbPathResolution {
     return { path: existing.path, source: "discovered", channel };
 }
 
-function resolveFresh(dataDir: string): OpenCodeDbPathResolution {
-    const explicit = process.env.OPENCODE_DB;
+function resolveV1Fresh(
+    dataDir: string,
+    env: NodeJS.ProcessEnv = process.env,
+): OpenCodeDbPathResolution {
+    const explicit = env.OPENCODE_DB;
     if (explicit !== undefined && explicit.length > 0) {
         if (explicit === ":memory:") {
             return { path: explicit, source: "OPENCODE_DB", channel: null };
@@ -94,12 +137,12 @@ function resolveFresh(dataDir: string): OpenCodeDbPathResolution {
         };
     }
 
-    const disableChannelDb = process.env.OPENCODE_DISABLE_CHANNEL_DB;
+    const disableChannelDb = env.OPENCODE_DISABLE_CHANNEL_DB;
     if (disableChannelDb === "1" || disableChannelDb === "true") {
         return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
     }
 
-    const channel = process.env.OPENCODE_CHANNEL;
+    const channel = env.OPENCODE_CHANNEL;
     if (channel !== undefined && channel.length > 0) {
         return { path: channelPath(dataDir, channel), source: "channel", channel };
     }
@@ -107,10 +150,59 @@ function resolveFresh(dataDir: string): OpenCodeDbPathResolution {
     return discoverOpenCodeDb(dataDir);
 }
 
-/** Resolve an explicit DB override first, then channel paths; discover candidates when the compiled channel is unknown. */
-export function resolveOpenCodeDbPath(): OpenCodeDbPathResolution {
-    const dataDir = openCodeDataDir();
-    const key = environmentKey(dataDir);
+/** Match OpenCode 2's filename table and strip path separators from custom channels. */
+export function sourceOpenCodeDatabaseFilename(
+    hostGeneration: OpenCodeHostGeneration,
+    channel: string,
+    env: NodeJS.ProcessEnv = process.env,
+): string {
+    if (hostGeneration === "v1") {
+        const explicit = env.OPENCODE_DB;
+        if (explicit !== undefined && explicit.length > 0) return explicit;
+        if (env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
+            return "opencode.db";
+        }
+        return ["latest", "beta", "prod"].includes(channel)
+            ? "opencode.db"
+            : `opencode-${channel}.db`;
+    }
+
+    return (
+        env.OPENCODE_DB ??
+        (["latest", "dev", "beta", "next", "prod"].includes(channel) ||
+        env.OPENCODE_DISABLE_CHANNEL_DB === "1" ||
+        env.OPENCODE_DISABLE_CHANNEL_DB === "true"
+            ? "opencode.db"
+            : `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "")}.db`)
+    );
+}
+
+function resolveV2Fresh(
+    dataDir: string,
+    channel: string,
+    env: NodeJS.ProcessEnv,
+): OpenCodeDbPathResolution {
+    const filename = sourceOpenCodeDatabaseFilename("v2", channel, env);
+    const explicit = env.OPENCODE_DB !== undefined;
+    return {
+        path: filename === ":memory:" ? filename : join(dataDir, filename),
+        source: explicit ? "OPENCODE_DB" : env.OPENCODE_CHANNEL ? "channel" : "default",
+        channel: explicit ? null : channel,
+    };
+}
+
+/**
+ * Resolve the store for one host generation. The default is the historical v1
+ * resolver, including candidate discovery and all existing diagnostic text.
+ */
+export function resolveOpenCodeDbPath(
+    hostGeneration: OpenCodeHostGeneration = "v1",
+    options: ResolveOpenCodeDbPathOptions = {},
+): OpenCodeDbPathResolution {
+    const env = options.env ?? process.env;
+    const dataDir = openCodeDataDir(env, options.dataHome);
+    const channel = options.channel ?? env.OPENCODE_CHANNEL;
+    const key = environmentKey(dataDir, hostGeneration, channel, env);
     if (
         cachedResolution?.key === key &&
         (!cachedResolution.existed || existsSync(cachedResolution.resolution.path))
@@ -119,7 +211,10 @@ export function resolveOpenCodeDbPath(): OpenCodeDbPathResolution {
         // An absent result is re-probed so a DB created after plugin boot is detected.
     }
 
-    const resolution = resolveFresh(dataDir);
+    const resolution =
+        hostGeneration === "v2"
+            ? resolveV2Fresh(dataDir, channel ?? "latest", env)
+            : resolveV1Fresh(dataDir, env);
     cachedResolution = {
         key,
         resolution,
@@ -128,6 +223,89 @@ export function resolveOpenCodeDbPath(): OpenCodeDbPathResolution {
     return resolution;
 }
 
+function schemaTableNames(
+    db: OpenCodeStoreSchemaDatabase,
+    schema: "main" | "oc_backfill" = "main",
+): Set<string> {
+    const rows = db
+        .prepare(
+            `SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name IN ('message', 'part', 'session', 'project', 'session_message', 'session_v2')`,
+        )
+        .all() as Array<{ name?: unknown }>;
+    return new Set(rows.flatMap((row) => (typeof row.name === "string" ? [row.name] : [])));
+}
+
+/** Whether the schema has the legacy message tables required by v1-only readers. */
+export function hasV1MessageTables(
+    db: OpenCodeStoreSchemaDatabase,
+    schema: "main" | "oc_backfill" = "main",
+): boolean {
+    const tables = schemaTableNames(db, schema);
+    return tables.has("message") && tables.has("part");
+}
+
+/**
+ * Detect the persisted host schema.
+ *
+ * `session_message` does NOT identify v2: OpenCode 1.18.x ships that table beside `message`
+ * and `part` (verified against a live 1.18.30 store, pinned in this module's tests). Only the
+ * ABSENCE of the v1 message tables identifies a v2 store, so a v1 host is never mistaken for
+ * a v2 one. A store carrying neither is a host that has not written its schema yet.
+ */
+export function detectOpenCodeStoreGeneration(
+    db: OpenCodeStoreSchemaDatabase,
+    schema: "main" | "oc_backfill" = "main",
+): OpenCodeStoreGeneration {
+    const tables = schemaTableNames(db, schema);
+    const hasV1Messages = tables.has("message") && tables.has("part");
+    if (hasV1Messages) return "v1";
+    if (tables.has("session_message")) return "v2";
+    if (tables.has("session") || tables.has("project")) return "v1";
+    return "unknown";
+}
+
+/**
+ * A store the OpenCode 2 host migrated from a v1 store keeps the v1 `message`/`part` tables
+ * beside its own schema, so it carries BOTH generations and `detectOpenCodeStoreGeneration`
+ * (which must keep calling a 1.18.x store v1) reports v1. `session_v2` is written only by an
+ * OpenCode 2 host (1.18.x never creates it), so a store with it and `session_message` is
+ * readable by v2 readers regardless of any v1 tables it also kept.
+ */
+function hasMigratedV2Schema(tables: Set<string>): boolean {
+    return tables.has("session_message") && tables.has("session_v2");
+}
+
+/** A native OpenCode 2 store, or a v1 store an OpenCode 2 host has migrated. */
+function isOpenCodeV2Store(
+    db: OpenCodeStoreSchemaDatabase,
+    schema: "main" | "oc_backfill" = "main",
+): boolean {
+    return (
+        detectOpenCodeStoreGeneration(db, schema) === "v2" ||
+        hasMigratedV2Schema(schemaTableNames(db, schema))
+    );
+}
+
+/** Refuse before a generation-specific query can read the other host's schema. */
+export function assertOpenCodeStoreGeneration(
+    db: OpenCodeStoreSchemaDatabase,
+    expected: OpenCodeHostGeneration,
+    path: string,
+    schema: "main" | "oc_backfill" = "main",
+): void {
+    const actual = detectOpenCodeStoreGeneration(db, schema);
+    if (actual === expected) return;
+    if (expected === "v2" && isOpenCodeV2Store(db, schema)) return;
+    // A store with none of these tables has no schema YET — a host that has not written its
+    // first row, or a fresh data directory. That is "nothing to read", not a conflicting host,
+    // and readers have always treated it as empty. Refusing here made every reader throw before
+    // OpenCode created its tables, which is how this guard took down 15 host e2e tests.
+    if (actual === "unknown") return;
+    throw new Error(
+        `OpenCode store generation mismatch at ${path}: expected ${expected}, found ${actual}; refusing generation-specific database access`,
+    );
+}
+
 export function openCodeDbPathExists(
     resolution: OpenCodeDbPathResolution = resolveOpenCodeDbPath(),
 ): boolean {

package/src/shared/opencode-host-generation.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "bun:test";
+import { openCodeHostGenerationFromVersion } from "./opencode-db-path";
+
+// The generation is decided from the version the executable reports, never
+// from its name: the public installer puts OpenCode 2 at ~/.opencode/bin/opencode
+// with a tiny `opencode2` shim beside it, so the name says nothing. The raw
+// `--version` stdout carries a program-name prefix ("opencode v2.0.12"); a
+// parser that feeds that to Number.parseInt reads NaN and demotes every
+// standalone 2.x install to 1.x (AFT hit this on a clean VM, 2026-09-21).
+// OpenCode 2's pre-GA betas were `@opencode-ai/*@0.0.0-beta-<n>` — the V2 line
+// wearing the old scope's version string — so a major of 0 is v2, not v1.
+describe("OpenCode host generation from --version output", () => {
+    it.each([
+        ["opencode v2.0.12", "v2"],
+        ["v2.0.12", "v2"],
+        ["2.0.12", "v2"],
+        ["opencode v2.0.12\n", "v2"],
+        ["opencode 1.18.31", "v1"],
+        ["1.18.31", "v1"],
+        ["0.0.0-beta-19234", "v2"],
+        ["opencode v0.0.0-beta-19234", "v2"],
+        ["0.0.0-dev-42", "v2"],
+        ["0.9.3", "v1"],
+        [null, "v1"],
+        ["", "v1"],
+    ])("%p → %s", (raw, expected) => {
+        expect(openCodeHostGenerationFromVersion(raw)).toBe(expected);
+    });
+});