akm-cli 0.9.31 → 0.10.261001-beta

package/dist/integrations/harnesses/opencode/session-log.js

@@ -4,10 +4,13 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { toErrorMessage } from "../../../core/common.js";
+import { warnOnce } from "../../../core/warn.js";
 import { openDatabase } from "../../../storage/database.js";
 import { openSqliteReadSnapshot } from "../../../storage/sqlite-read-snapshot.js";
-import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
 import { AbstractSessionLogProvider } from "../../session-logs/provider-base.js";
+import { hasV1Session, listV1Sessions, readV1Session, V1_TABLES } from "./session-log-v1.js";
+import { listV2Sessions, readV2Session, V2_TABLES, v2SessionState } from "./session-log-v2.js";
 function getOpenCodeBaseDir() {
     if (process.platform === "darwin") {
         return path.join(os.homedir(), "Library", "Application Support", "opencode");
@@ -15,15 +18,28 @@ function getOpenCodeBaseDir() {
     return path.join(os.homedir(), ".local", "share", "opencode");
 }
 /**
- * Opencode session storage:
+ * OpenCode session storage: one SQLite file, `<base>/opencode.db`, whose
+ * layout decides the reader, never the installed binary or its version:
  *
- *   SQLite (current, observed 2026-06): `<base>/opencode.db` — a Drizzle-managed
- *   database with `session` / `message` / `part` tables. Message text lives in
- *   `part` rows (`data` JSON, `type: "text"`); `message.data` holds role/timing.
- *   This is the sole supported layout.
+ *   - V1: `session` table, with `message` / `part` for content (`session-log-v1.ts`).
+ *   - V2: `session_v2` / `session_message` tables (`session-log-v2.ts`).
+ *   - Both: a natively upgraded V1 file keeps its V1 tables and gains the V2
+ *     ones. Sessions are merged by id, V2 winning, V1-only ones kept.
+ *   - Neither: an unsupported layout, reported, never presented as empty.
+ *
+ * The file is opened read-only and never migrated or written.
  */
 /** Filename of opencode's SQLite session store, relative to its base dir. */
 const OPENCODE_DB_FILENAME = "opencode.db";
+function tableNames(db) {
+    const rows = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
+    return new Set(rows.map((r) => r.name));
+}
+function classify(tables) {
+    const v1 = V1_TABLES.every((t) => tables.has(t));
+    const v2 = V2_TABLES.every((t) => tables.has(t));
+    return v1 || v2 ? { kind: "ok", v1, v2 } : { kind: "unsupported", tables: [...tables].sort() };
+}
 export class OpenCodeProvider extends AbstractSessionLogProvider {
     name = "opencode";
     #baseDir = getOpenCodeBaseDir();
@@ -34,147 +50,120 @@ export class OpenCodeProvider extends AbstractSessionLogProvider {
     #dbPath(base) {
         return path.join(base, OPENCODE_DB_FILENAME);
     }
+    /** Classify the store under `location` (default: opencode's data dir) without listing anything. */
+    inspectStore(location) {
+        const dbPath = this.#dbPath(location ?? this.#baseDir);
+        if (!fs.existsSync(dbPath))
+            return { kind: "missing" };
+        let db;
+        try {
+            db = openDatabase(dbPath, { readonly: true, create: false });
+        }
+        catch (error) {
+            return { kind: "unreadable", reason: toErrorMessage(error) };
+        }
+        try {
+            return classify(tableNames(db));
+        }
+        catch (error) {
+            return { kind: "unreadable", reason: toErrorMessage(error) };
+        }
+        finally {
+            db.close();
+        }
+    }
     listSessions(input = {}) {
-        const base = input.location ?? this.#baseDir;
-        const sinceMs = input.sinceMs ?? 0;
-        const dbPath = this.#dbPath(base);
+        const dbPath = this.#dbPath(input.location ?? this.#baseDir);
         if (!fs.existsSync(dbPath))
             return [];
-        return this.#listSessionsFromDb(dbPath, sinceMs, input.isolatedSnapshot ?? false);
-    }
-    readSession(ref) {
-        return this.#readSessionFromDb(ref);
-    }
-    /**
-     * List sessions from the SQLite store. `filePath` on each summary is the
-     * `opencode.db` path so {@link readSession} can route back to the DB reader.
-     * Returns `[]` (never throws) when the DB is unreadable or lacks the expected
-     * schema — callers treat a missing harness as "no sessions".
-     */
-    #listSessionsFromDb(dbPath, sinceMs, isolatedSnapshot) {
         let db;
         try {
-            const opened = isolatedSnapshot
+            db = input.isolatedSnapshot
                 ? openSqliteReadSnapshot(dbPath)
                 : openDatabase(dbPath, { readonly: true, create: false });
-            if (!opened)
-                return [];
-            db = opened;
         }
-        catch {
+        catch (error) {
+            this.#warnUnavailable(dbPath, `cannot open it (${toErrorMessage(error)})`);
             return [];
         }
+        if (!db)
+            return [];
         try {
-            const rows = db
-                .prepare("SELECT id, title, directory, time_created, time_updated FROM session WHERE time_updated >= ? ORDER BY time_updated DESC")
-                .all(sinceMs);
-            return rows.map((r) => this.sessionRef({
-                sessionId: r.id,
-                filePath: dbPath,
-                startedAt: typeof r.time_created === "number" ? r.time_created : undefined,
-                endedAt: typeof r.time_updated === "number" ? r.time_updated : undefined,
-                projectHint: typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined,
-                title: typeof r.title === "string" && r.title.length > 0 ? r.title : undefined,
-            }));
+            const status = classify(tableNames(db));
+            if (status.kind !== "ok") {
+                this.#warnUnavailable(dbPath, `it has neither the OpenCode 1 (${V1_TABLES.join("/")}) nor the OpenCode 2 (${V2_TABLES.join("/")}) tables`);
+                return [];
+            }
+            return this.#listFromDb(db, dbPath, input.sinceMs ?? 0, status.v1, status.v2);
         }
-        catch {
-            // Missing `session` table / unexpected schema — treat as no sessions.
+        catch (error) {
+            this.#warnUnavailable(dbPath, `cannot query it (${toErrorMessage(error)})`);
             return [];
         }
         finally {
             db.close();
         }
     }
-    /**
-     * Read one session from the SQLite store. Message text lives in `part` rows
-     * (`type: "text"`); `message.data` carries role + timing. One event per
-     * message, text-parts concatenated in time order. Returns empty events
-     * (never throws) when the DB is unreadable.
-     */
-    #readSessionFromDb(ref) {
+    readSession(ref) {
         const emptyRef = this.sessionRef({ sessionId: ref.sessionId, filePath: ref.filePath });
+        const empty = { ref: emptyRef, events: [], inlineRefs: [] };
         let db;
         try {
             db = openDatabase(ref.filePath, { readonly: true, create: false });
         }
-        catch {
-            return { ref: emptyRef, events: [], inlineRefs: [] };
+        catch (error) {
+            this.#warnUnavailable(ref.filePath, `cannot open it (${toErrorMessage(error)})`);
+            return empty;
         }
         try {
-            const meta = db
-                .prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?")
-                .get(ref.sessionId);
-            const startedAt = typeof meta?.time_created === "number" ? meta.time_created : undefined;
-            const endedAt = typeof meta?.time_updated === "number" ? meta.time_updated : undefined;
-            const title = typeof meta?.title === "string" && meta.title.length > 0 ? meta.title : undefined;
-            const projectHint = typeof meta?.directory === "string" && meta.directory.length > 0 ? meta.directory : undefined;
-            const messages = db
-                .prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC")
-                .all(ref.sessionId);
-            const parts = db
-                .prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC")
-                .all(ref.sessionId);
-            // Group text-part bodies by their parent message.
-            const textByMessage = new Map();
-            for (const part of parts) {
-                let parsed;
-                try {
-                    parsed = JSON.parse(part.data);
-                }
-                catch {
-                    continue;
-                }
-                if (parsed?.type !== "text")
-                    continue;
-                const text = parsed.text;
-                if (typeof text !== "string" || text.length < 1)
-                    continue;
-                const bucket = textByMessage.get(part.message_id) ?? [];
-                bucket.push(text);
-                textByMessage.set(part.message_id, bucket);
+            const status = classify(tableNames(db));
+            if (status.kind !== "ok") {
+                this.#warnUnavailable(ref.filePath, "it has no supported OpenCode 1 or OpenCode 2 session tables");
+                return empty;
             }
-            const events = [];
-            const inlineRefs = [];
-            for (const message of messages) {
-                let mdata = {};
-                try {
-                    mdata = JSON.parse(message.data);
-                }
-                catch {
-                    // role/timing unavailable — fall through with defaults
-                }
-                const role = typeof mdata.role === "string" ? mdata.role : "unknown";
-                const mtime = mdata.time?.created;
-                const ts = typeof mtime === "number"
-                    ? mtime
-                    : typeof message.time_created === "number"
-                        ? message.time_created
-                        : undefined;
-                const text = (textByMessage.get(message.id) ?? []).join("\n").trim();
-                if (text.length < 1)
-                    continue;
-                events.push({ harness: this.name, text, ts, sessionId: ref.sessionId, role, filePath: ref.filePath });
-                inlineRefs.push(...extractInlineRefMentions(text, ts));
-            }
-            events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+            // V2 owns a session that has messages there; otherwise a retained V1 copy (a
+            // session the upgrade has not copied, or copied without messages) is the history.
+            const v2 = status.v2 ? v2SessionState(db, ref.sessionId) : { exists: false, messages: 0 };
+            const useV2 = v2.exists && (v2.messages > 0 || !status.v1 || !hasV1Session(db, ref.sessionId));
+            const read = useV2
+                ? readV2Session(db, this.name, ref.sessionId, ref.filePath)
+                : readV1Session(db, this.name, ref.sessionId, ref.filePath);
             return {
-                ref: this.sessionRef({
-                    sessionId: ref.sessionId,
-                    filePath: ref.filePath,
-                    startedAt,
-                    endedAt,
-                    projectHint,
-                    title,
-                }),
-                events,
-                inlineRefs,
+                ref: this.sessionRef({ ...read.meta, filePath: ref.filePath }),
+                events: read.events,
+                inlineRefs: read.inlineRefs,
             };
         }
-        catch {
-            return { ref: emptyRef, events: [], inlineRefs: [] };
+        catch (error) {
+            this.#warnUnavailable(ref.filePath, `cannot read session ${ref.sessionId} (${toErrorMessage(error)})`);
+            return empty;
         }
         finally {
             db.close();
         }
     }
+    /** List each present layout; one failing layout is reported and the other still listed. */
+    #listFromDb(db, dbPath, sinceMs, v1, v2) {
+        const merged = new Map();
+        const attempt = (label, list) => {
+            try {
+                for (const meta of list())
+                    if (!merged.has(meta.sessionId))
+                        merged.set(meta.sessionId, meta);
+            }
+            catch (error) {
+                this.#warnUnavailable(dbPath, `its ${label} session tables cannot be queried (${toErrorMessage(error)})`);
+            }
+        };
+        if (v2)
+            attempt("OpenCode 2", () => listV2Sessions(db, sinceMs));
+        if (v1)
+            attempt("OpenCode 1", () => listV1Sessions(db, sinceMs));
+        return [...merged.values()]
+            .sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0))
+            .map((meta) => this.sessionRef({ ...meta, filePath: dbPath }));
+    }
+    #warnUnavailable(dbPath, why) {
+        warnOnce(`opencode-history:${dbPath}:${why}`, `OpenCode session history at ${dbPath} was not read: ${why}. This is an unsupported or damaged store, not an empty history.`);
+    }
 }

package/dist/integrations/harnesses/opencode/version.js

@@ -0,0 +1,98 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Which OpenCode major a binary is (#1049).
+ *
+ * akm drives two OpenCode majors through separate adapters. There is no config
+ * field for the choice: the binary says which major it is. {@link resolveOpencodeBin}
+ * picks the binary (the engine's own `bin`, else the newest OpenCode on PATH) and
+ * {@link detectOpencodeMajor} runs `<bin> --version` once per binary per process.
+ *
+ * - Major 1: OpenCode 1 adapters, plus a one-time warning recommending OpenCode 2.
+ * - Major 2: OpenCode 2 adapters.
+ * - Anything else, or a `--version` that fails or cannot be parsed: the newest
+ *   adapters akm knows (OpenCode 2) and a one-time warning with the raw output.
+ *   Detection never aborts; the dispatch reports whatever real error the binary
+ *   produces.
+ *
+ * PATH lookups are memoized too: PATH does not change inside a process, and
+ * every dispatch asks for the same one or two binaries.
+ */
+import childProcess from "node:child_process";
+import { warnOnce } from "../../../core/warn.js";
+import { defaultWhich } from "../../agent/detect.js";
+import { OPENCODE_SDK_SERVER_BIN } from "../../agent/profiles.js";
+/** OpenCode 2's own alias for its binary; it can sit next to an OpenCode 1 `opencode` on PATH. */
+export const OPENCODE2_BIN = "opencode2";
+const VERSION_TIMEOUT_MS = 30_000;
+const defaultProbe = (bin) => {
+    const result = childProcess.spawnSync(bin, ["--version"], {
+        encoding: "utf8",
+        env: process.env,
+        stdio: "pipe",
+        timeout: VERSION_TIMEOUT_MS,
+        killSignal: "SIGKILL",
+    });
+    if (result.error || result.status !== 0)
+        return undefined;
+    return (result.stdout ?? "").trim();
+};
+let probeOverride;
+const detected = new Map();
+const onPath = new Map();
+/** TEST-ONLY. Swap the `--version` probe (and forget every cached detection and PATH lookup); pass undefined to restore. */
+export function _setOpencodeVersionProbeForTests(fake) {
+    probeOverride = fake;
+    detected.clear();
+    onPath.clear();
+}
+/** `which`, memoized for the process when it is the default lookup. */
+function lookup(bin, which) {
+    if (which)
+        return which(bin) ?? undefined;
+    if (!onPath.has(bin))
+        onPath.set(bin, defaultWhich(bin));
+    return onPath.get(bin);
+}
+/** The major in `opencode --version` output (`1.18.34`, `opencode v2.0.26`), or undefined when there is none. */
+export function parseOpencodeMajor(versionOutput) {
+    const match = versionOutput.match(/(\d+)\.\d+/);
+    return match ? Number(match[1]) : undefined;
+}
+/**
+ * The binary an OpenCode engine runs: its own `bin` when it sets one, else the
+ * most recent OpenCode on PATH (`opencode2` when present, else `opencode`).
+ */
+export function resolveOpencodeBin(explicitBin, which) {
+    if (explicitBin)
+        return explicitBin;
+    return lookup(OPENCODE2_BIN, which) ? OPENCODE2_BIN : OPENCODE_SDK_SERVER_BIN;
+}
+/** Detect the OpenCode major of `bin`: one `--version` run per binary per process. */
+export function detectOpencodeMajor(bin, options = {}) {
+    const path = lookup(bin, options.which) ?? bin;
+    const cached = detected.get(path);
+    if (cached)
+        return cached;
+    const raw = (options.probe ?? probeOverride ?? defaultProbe)(path);
+    const version = raw ?? "";
+    const reportedMajor = raw === undefined ? undefined : parseOpencodeMajor(raw);
+    const major = reportedMajor === 1 ? 1 : 2;
+    if (reportedMajor === 1) {
+        warnOnce(`opencode-version:${path}`, `${path} is OpenCode ${version}. OpenCode 1 support continues, but upgrading to OpenCode 2 is recommended.`);
+    }
+    else if (reportedMajor !== 2) {
+        warnOnce(`opencode-version:${path}`, raw === undefined
+            ? `Could not run \`${path} --version\`, so its OpenCode major is unknown; treating it as OpenCode 2.`
+            : `${path} reported an unrecognized OpenCode version (${JSON.stringify(raw)}); treating it as OpenCode 2.`);
+    }
+    const info = {
+        major,
+        ...(reportedMajor !== undefined ? { reportedMajor } : {}),
+        version,
+        runnable: raw !== undefined,
+    };
+    detected.set(path, info);
+    return info;
+}

package/dist/integrations/harnesses/opencode-sdk/{harness.js → index.js}

@@ -2,24 +2,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * OpenCode SDK harness DESCRIPTOR (#564).
+ * OpenCode SDK harness descriptor (#564).
  *
- * This module is a dependency-graph LEAF: it imports only the harness base
- * types (`../types`) and nothing from `core/config` or the SDK runner. Keeping
- * the descriptor separate from the runtime runner (`./sdk-runner`, which pulls
- * `core/config`) is load-bearing: `HARNESS_REGISTRY` in `../index.ts` imports
- * this class from HERE, not from the per-harness barrel (`./index.ts`). The
- * barrel additionally re-exports `runOpencodeSdk`/`closeServer` from
- * `./sdk-runner`; that re-export makes the barrel transitively depend on
- * `core/config`, and `core/config/config-types` derives `VALID_HARNESS_IDS`
- * back from `../index.ts`. If the registry imported the class through the
- * barrel, that cycle would evaluate `../index.ts` (and `new
- * OpencodeSdkHarness()`) while the barrel — and hence this class binding — was
- * still initializing, throwing a temporal-dead-zone "Cannot access
- * 'OpencodeSdkHarness' before initialization" whenever the barrel is the first
- * module loaded in a fresh graph (e.g. the workflow-exec subprocess entry).
- * Importing the descriptor from this leaf keeps the registry a config-leaf and
- * breaks the cycle.
+ * Descriptor only. The runner (`./sdk-runner`) imports `core/config`, so the
+ * registry must never load it; `agent/runner-dispatch.ts` imports it directly.
  */
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
 import { MODEL_WORK_AGENT_INFERENCE } from "../opencode/model-config.js";
@@ -52,5 +38,7 @@ export class OpencodeSdkHarness extends BaseHarness {
     capabilities = caps({
         agentDispatch: true,
         detection: true,
+        modelWork: true,
+        nativeAgent: true,
     });
 }