@drakon-systems/multi-clawd 1.8.5 → 1.8.6

package/README.md

@@ -367,7 +367,7 @@ openclaw plugins install (Get-Location).Path
 **Or let your agent install it.** Running an OpenClaw assistant or Claude
 Code on the target machine already? Paste it this and go make coffee:
 
-> Read https://raw.githubusercontent.com/Drakon-Systems-Ltd/multi-clawd/v1.8.5/SETUP-AGENT.md
+> Read https://raw.githubusercontent.com/Drakon-Systems-Ltd/multi-clawd/v1.8.6/SETUP-AGENT.md
 > and follow it to set up multi-clawd on this machine. I own a second
 > Claude account — ask me when you need me to log in.
 

package/dist/session-store.js

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+export const SQLITE_STORE_RELPATH = join("agent", "openclaw-agent.sqlite");
+export const JSON_STORE_RELPATH = join("sessions", "sessions.json");
+export function locateSessionStore(agentDir, exists = existsSync, list = readdirSync) {
+    const sqlitePath = join(agentDir, SQLITE_STORE_RELPATH);
+    if (exists(sqlitePath))
+        return { kind: "sqlite", path: sqlitePath };
+    const jsonPath = join(agentDir, JSON_STORE_RELPATH);
+    if (exists(jsonPath))
+        return { kind: "json", path: jsonPath };
+    const sessionsDir = join(agentDir, "sessions");
+    if (exists(sessionsDir) && holdsSessionArtifacts(sessionsDir, list))
+        return { kind: "missing", path: jsonPath };
+    return null;
+}
+function holdsSessionArtifacts(sessionsDir, list) {
+    let names;
+    try {
+        names = list(sessionsDir);
+    }
+    catch {
+        return false;
+    }
+    return names.some((n) => n.endsWith(".json") || n.endsWith(".jsonl") || !n.includes("."));
+}
+async function defaultOpener() {
+    const { DatabaseSync } = await importSqliteQuietly();
+    return (path) => new DatabaseSync(path, { readOnly: true });
+}
+async function importSqliteQuietly() {
+    const original = process.emitWarning;
+    const quiet = (warning, ...rest) => {
+        const text = typeof warning === "string" ? warning : warning.message;
+        if (text.includes("SQLite is an experimental feature"))
+            return;
+        return original.call(process, warning, ...rest);
+    };
+    process.emitWarning = quiet;
+    try {
+        return await import("node:sqlite");
+    }
+    finally {
+        process.emitWarning = original;
+    }
+}
+export async function readSqliteSessionStore(path, open) {
+    let opener;
+    try {
+        opener = open ?? (await defaultOpener());
+    }
+    catch (err) {
+        return {
+            error: `node:sqlite unavailable on this runtime (${describe(err)}) — Node ≥ 22.13 required to audit a SQLite session store`,
+            skippedRows: 0,
+        };
+    }
+    let db;
+    try {
+        db = opener(path);
+        const rows = db.prepare("SELECT session_key, entry_json FROM session_nodes").all();
+        const entries = {};
+        let skippedRows = 0;
+        for (const row of rows) {
+            const parsed = parseRow(row);
+            if (parsed === undefined) {
+                skippedRows++;
+                continue;
+            }
+            entries[parsed.key] = parsed.entry;
+        }
+        return { entries, skippedRows };
+    }
+    catch (err) {
+        return { error: describe(err), skippedRows: 0 };
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+        }
+    }
+}
+export function readJsonSessionStore(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { error: "store is not a JSON object", skippedRows: 0 };
+        }
+        return { entries: parsed, skippedRows: 0 };
+    }
+    catch (err) {
+        return { error: describe(err), skippedRows: 0 };
+    }
+}
+export async function readSessionStore(location, open) {
+    switch (location.kind) {
+        case "sqlite":
+            return readSqliteSessionStore(location.path, open);
+        case "json":
+            return readJsonSessionStore(location.path);
+        case "missing":
+            return { error: "no session store found (neither SQLite database nor sessions.json)", skippedRows: 0 };
+    }
+}
+function parseRow(row) {
+    if (!row || typeof row !== "object")
+        return undefined;
+    const { session_key: key, entry_json: json } = row;
+    if (typeof key !== "string" || typeof json !== "string")
+        return undefined;
+    try {
+        const entry = JSON.parse(json);
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return undefined;
+        return { key, entry: entry };
+    }
+    catch {
+        return undefined;
+    }
+}
+function describe(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "multi-clawd",
   "name": "multi-clawd",
-  "version": "1.8.5",
+  "version": "1.8.6",
   "description": "Register additional Claude Code logins (Max/Pro accounts) as first-class OpenClaw CLI backends for cross-account failover, keeping the full skills/MCP harness on every account.",
   "cliBackends": [
     "claw1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakon-systems/multi-clawd",
-  "version": "1.8.5",
+  "version": "1.8.6",
   "description": "Multi-account Claude Code failover for OpenClaw — register additional Claude (Max/Pro) logins as first-class CLI backends and keep the full skills/MCP harness across every account. Also imports those accounts' setup tokens into Hermes Agent's Anthropic credential pool.",
   "type": "module",
   "license": "MIT",

package/scripts/cli.mjs

@@ -222,21 +222,24 @@ async function chain(args = []) {
     );
   }
 
-  // Session pins, across every agent's session store.
+  // Session pins, across every agent's session store (2026.8.x SQLite database
+  // or the older sessions.json — src/session-store.ts owns the where/how).
   const sessionFindings = [];
   const agentsDir = join(homedir(), ".openclaw", "agents");
   try {
+    const store = await import(resolve(__dirname, "..", "dist", "session-store.js"));
     for (const agent of readdirSync(agentsDir)) {
-      const p = join(agentsDir, agent, "sessions", "sessions.json");
-      if (!existsSync(p)) continue;
-      try {
-        sessionFindings.push(...ca.auditSessionOverrides(JSON.parse(rf(p, "utf8")), Boolean(poolId)));
-      } catch {
-        /* unreadable store — skip, doctor reports install health */
+      const location = store.locateSessionStore(join(agentsDir, agent));
+      if (!location) continue;
+      const read = await store.readSessionStore(location);
+      if (!read.entries) {
+        console.log(`${DIM}  (session store ${location.path} not audited: ${read.error} — see doctor)${RESET}`);
+        continue;
       }
+      sessionFindings.push(...ca.auditSessionOverrides(read.entries, Boolean(poolId)));
     }
   } catch {
-    /* no agents dir */
+    /* no agents dir, or dist not built — doctor reports install health */
   }
   section("SESSION PINS", sessionFindings, (f) =>
     raw ? f.surface : f.surface.replace(/^session (.*)$/, (_, k) => `session ${ca.maskSessionKey(k)}`),

package/scripts/doctor.mjs

@@ -393,16 +393,20 @@ if (!pool) {
   if (warns.length === 0) ok(`effective chain: all live Claude tiers route through the ${poolId} pool`);
 
   // ── case 2: session-level /model overrides ─────────────────────────────────
-  // Enumerate agents/*/sessions/sessions.json. A store that is expected (its
-  // agent has a sessions/ dir) but absent/unparseable gets a LOUD skip — never
-  // a silent pass; a missed off-pool pin is worse than an extra line.
+  // Enumerate every agent's session store — the 2026.8.x per-agent SQLite
+  // database, or the older sessions.json map (src/session-store.ts owns the
+  // where and the how). A store that is expected but absent/unreadable gets a
+  // LOUD skip — never a silent pass; a missed off-pool pin is worse than an
+  // extra line.
+  const { locateSessionStore, readSessionStore } = await import(
+    join(EXT_DIR, "dist", "session-store.js")
+  ).catch(() => import(join(REPO_DIR, "dist", "session-store.js")));
   const AGENTS_DIR = join(HOME, ".openclaw", "agents");
   const stores = [];
   try {
     for (const agent of readdirSync(AGENTS_DIR)) {
-      const sessionsDir = join(AGENTS_DIR, agent, "sessions");
-      if (!existsSync(sessionsDir)) continue; // not an agent-with-sessions
-      stores.push(join(sessionsDir, "sessions.json"));
+      const location = locateSessionStore(join(AGENTS_DIR, agent));
+      if (location) stores.push(location);
     }
   } catch {
     /* no agents dir at all */
@@ -412,14 +416,17 @@ if (!pool) {
   } else {
     let sessionWarns = 0;
     let readable = 0;
-    for (const storePath of stores) {
-      const parsed = readJson(storePath);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        warn(`session-override check SKIPPED for ${storePath} (store unreadable)`);
+    for (const location of stores) {
+      const read = await readSessionStore(location);
+      if (!read.entries) {
+        warn(`session-override check SKIPPED for ${location.path} (${read.error})`);
         continue;
       }
       readable++;
-      const sessionFindings = auditSessionOverrides(parsed, true);
+      if (read.skippedRows > 0) {
+        warn(`${location.path}: ${read.skippedRows} session row(s) unparseable — those sessions were not audited`);
+      }
+      const sessionFindings = auditSessionOverrides(read.entries, true);
       for (const f of sessionFindings) {
         warn(`${renderSurface(f.surface)}: ${f.ref} ${f.reason}`);
         sessionWarns++;