gnosys 5.4.0 → 5.4.2

package/dist/index.js

@@ -62,6 +62,17 @@ const server = new McpServer({
     name: "gnosys",
     version: "2.0.0",
 });
+/**
+ * v5.4.1: Format MCP errors. Detects DB corruption and replaces the raw
+ * "database disk image is malformed" with actionable recovery instructions.
+ * Use this in catch blocks instead of inlining error.message.
+ */
+function formatMcpError(action, err) {
+    if (GnosysDB.isCorruptionError(err)) {
+        return `Error ${action}: ${err instanceof Error ? err.message : String(err)}\n\n${GnosysDB.corruptionRecoveryInstructions()}`;
+    }
+    return `Error ${action}: ${err instanceof Error ? err.message : String(err)}`;
+}
 // These are initialized in main() after resolver runs
 let search = null;
 let tagRegistry = null;
@@ -480,12 +491,7 @@ server.tool("gnosys_add", "Add a new memory. Accepts raw text — an LLM structu
     }
     catch (err) {
         return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error adding memory: ${err instanceof Error ? err.message : String(err)}`,
-                },
-            ],
+            content: [{ type: "text", text: formatMcpError("adding memory", err) }],
             isError: true,
         };
     }
@@ -510,51 +516,59 @@ server.tool("gnosys_add_structured", "Add a memory with structured input (no LLM
     confidence: z.number().min(0).max(1).optional(),
     projectRoot: projectRootParam,
 }, async ({ title, category, tags, relevance, content, store: targetStore, author, authority, confidence, projectRoot }) => {
-    const ctx = await resolveToolContext(projectRoot);
-    const writeTarget = ctx.resolver.getWriteTarget(targetStore || undefined);
-    if (!writeTarget) {
+    try {
+        const ctx = await resolveToolContext(projectRoot);
+        const writeTarget = ctx.resolver.getWriteTarget(targetStore || undefined);
+        if (!writeTarget) {
+            return {
+                content: [{ type: "text", text: "No writable store found." }],
+                isError: true,
+            };
+        }
+        if (!ctx.centralDb?.isAvailable()) {
+            return {
+                content: [{ type: "text", text: "Database not available. Cannot write memory." }],
+                isError: true,
+            };
+        }
+        const id = ctx.centralDb.getNextId(category, ctx.projectId ?? undefined);
+        const today = new Date().toISOString().split("T")[0];
+        const frontmatter = {
+            id,
+            title,
+            category,
+            tags: tags,
+            relevance: relevance || "",
+            author: author || "ai",
+            authority: authority || "observed",
+            confidence: confidence || 0.8,
+            created: today,
+            modified: today,
+            last_reviewed: today,
+            status: "active",
+            supersedes: null,
+        };
+        const fullContent = `# ${title}\n\n${content}`;
+        // Write to DB only (SQLite is sole source of truth)
+        syncMemoryToDb(ctx.centralDb, frontmatter, fullContent, undefined, ctx.projectId, "project");
+        auditToDb(ctx.centralDb, "write", id, { tool: "gnosys_add_structured", category });
+        if (ctx.search)
+            await reindexAllStores();
         return {
-            content: [{ type: "text", text: "No writable store found." }],
-            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Memory added to [${writeTarget.label}]: **${title}**\nID: ${id}`,
+                },
+            ],
         };
     }
-    if (!ctx.centralDb?.isAvailable()) {
+    catch (err) {
         return {
-            content: [{ type: "text", text: "Database not available. Cannot write memory." }],
+            content: [{ type: "text", text: formatMcpError("adding structured memory", err) }],
             isError: true,
         };
     }
-    const id = ctx.centralDb.getNextId(category, ctx.projectId ?? undefined);
-    const today = new Date().toISOString().split("T")[0];
-    const frontmatter = {
-        id,
-        title,
-        category,
-        tags: tags,
-        relevance: relevance || "",
-        author: author || "ai",
-        authority: authority || "observed",
-        confidence: confidence || 0.8,
-        created: today,
-        modified: today,
-        last_reviewed: today,
-        status: "active",
-        supersedes: null,
-    };
-    const fullContent = `# ${title}\n\n${content}`;
-    // Write to DB only (SQLite is sole source of truth)
-    syncMemoryToDb(ctx.centralDb, frontmatter, fullContent, undefined, ctx.projectId, "project");
-    auditToDb(ctx.centralDb, "write", id, { tool: "gnosys_add_structured", category });
-    if (ctx.search)
-        await reindexAllStores();
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Memory added to [${writeTarget.label}]: **${title}**\nID: ${id}`,
-            },
-        ],
-    };
 });
 // ─── Tool: gnosys_tags ───────────────────────────────────────────────────
 server.tool("gnosys_tags", "List all tags in the registry, grouped by category.", { projectRoot: projectRootParam }, async ({ projectRoot }) => {
@@ -2282,81 +2296,106 @@ server.tool("gnosys_portfolio", "Portfolio dashboard — shows all registered pr
 });
 // ─── Remote sync tools (v5.3.0) ─────────────────────────────────────────
 server.tool("gnosys_remote_status", "Check the status of remote sync (multi-machine). Returns pending pushes, pulls, conflicts, and reachability. Agents should surface this to the user when there are pending changes or conflicts.", {}, async () => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
-    }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
+    // Sync operations need explicit local DB access (not auto-routed remote).
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ configured: false, message: "Remote sync not configured." }, null, 2),
+                    }],
+            };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const status = await sync.getStatus();
+        sync.closeRemote();
         return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({ configured: false, message: "Remote sync not configured." }, null, 2),
-                }],
+            content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
         };
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const status = await sync.getStatus();
-    sync.closeRemote();
-    return {
-        content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
-    };
+    finally {
+        localDb.close();
+    }
 });
 server.tool("gnosys_remote_push", "Push local memory changes to the remote (NAS) database. Uses skip-and-flag for conflicts by default. Call this when the user has approved pushing local changes.", {
     newerWins: z.boolean().optional().describe("Auto-resolve conflicts by taking the newer version"),
 }, async ({ newerWins }) => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return { content: [{ type: "text", text: "Remote not configured. Run 'gnosys remote configure'." }], isError: true };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const result = await sync.push({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
+        sync.closeRemote();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
     }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
-        return { content: [{ type: "text", text: "Remote not configured. Run 'gnosys remote configure'." }], isError: true };
+    finally {
+        localDb.close();
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const result = await sync.push({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
-    sync.closeRemote();
-    return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-    };
 });
 server.tool("gnosys_remote_pull", "Pull remote memory changes to the local database. Uses skip-and-flag for conflicts by default. Call this when the user wants the latest from the remote.", {
     newerWins: z.boolean().optional().describe("Auto-resolve conflicts by taking the newer version"),
 }, async ({ newerWins }) => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const result = await sync.pull({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
+        sync.closeRemote();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
     }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
-        return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+    finally {
+        localDb.close();
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const result = await sync.pull({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
-    sync.closeRemote();
-    return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-    };
 });
 server.tool("gnosys_remote_resolve", "Resolve a sync conflict by choosing which version to keep. Use after gnosys_remote_status reveals conflicts. The agent should present the local and remote versions to the user and call this with their choice.", {
     memoryId: z.string().describe("Memory ID with the conflict"),
     choice: z.enum(["local", "remote"]).describe("Which version to keep"),
 }, async ({ memoryId, choice }) => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
-    }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
-        return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const result = await sync.resolve(memoryId, choice);
+        sync.closeRemote();
+        if (result.ok) {
+            return { content: [{ type: "text", text: `Resolved ${memoryId}: kept ${choice} version.` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to resolve: ${result.error}` }], isError: true };
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const result = await sync.resolve(memoryId, choice);
-    sync.closeRemote();
-    if (result.ok) {
-        return { content: [{ type: "text", text: `Resolved ${memoryId}: kept ${choice} version.` }] };
+    finally {
+        localDb.close();
     }
-    return { content: [{ type: "text", text: `Failed to resolve: ${result.error}` }], isError: true };
 });
 // ─── Tool: gnosys_update_status ─────────────────────────────────────────
 server.tool("gnosys_update_status", "Get the prompt/template for writing a dashboard-compatible status memory for this project. Returns instructions for creating a landscape memory with the correct heading format so the portfolio dashboard can parse it. Run this, then follow the instructions to analyze and write the status.", {
@@ -2659,14 +2698,78 @@ async function main() {
         console.error(`Hybrid search: ${embCount > 0 ? `ready (${embCount} embeddings)` : "available (run gnosys_reindex to build embeddings)"}`);
         console.error(`Ask engine: ${askEngine.isLLMAvailable ? `ready (${askEngine.providerName}/${askEngine.modelName})` : "disabled (configure LLM provider)"}`);
         // v2.0: Initialize Dream Mode (idle-time consolidation)
+        // v5.4.2: Designation gate inside DreamScheduler.start() — only the
+        // machine designated via `gnosys setup dream` arms the timer. Other
+        // machines no-op silently. Layer 3 startup probe surfaces a stderr
+        // warning if this machine is designated but the dream provider is
+        // unreachable.
         if (gnosysDb && config.dream?.enabled) {
             const dreamEngine = new GnosysDreamEngine(gnosysDb, config, config.dream);
             dreamScheduler = new DreamScheduler(dreamEngine, config.dream);
+            // Layer 3: probe the dream provider if this machine is the dream node.
+            // Done before scheduler.start() so users see the warning immediately
+            // alongside other startup output.
+            try {
+                const designated = gnosysDb.getDreamMachineId();
+                const localId = gnosysDb.getMeta("machine_id");
+                if (designated && designated === localId) {
+                    // Quick reachability probe — 5s timeout to avoid blocking startup.
+                    const dreamProvider = config.dream.provider || "ollama";
+                    const dreamModel = config.dream.model || "(default)";
+                    const { validateModel } = await import("./lib/modelValidation.js");
+                    // Resolve API key from env or keychain (mirroring resolveApiKey precedence).
+                    const envVarName = `GNOSYS_${dreamProvider.toUpperCase()}_KEY`;
+                    let apiKey = process.env[envVarName] || "";
+                    if (!apiKey && process.platform === "darwin" && dreamProvider !== "ollama" && dreamProvider !== "lmstudio") {
+                        try {
+                            const { execSync } = await import("child_process");
+                            apiKey = execSync(`security find-generic-password -a "$USER" -s "${envVarName}" -w 2>/dev/null`, {
+                                stdio: "pipe", encoding: "utf-8", timeout: 2000,
+                            }).trim();
+                        }
+                        catch {
+                            // No key in keychain
+                        }
+                    }
+                    // Skip the network probe if there's clearly no key configured for a
+                    // remote provider — surface the obvious config gap instead.
+                    if (!apiKey && dreamProvider !== "ollama" && dreamProvider !== "lmstudio") {
+                        process.stderr.write(`gnosys: dream provider '${dreamProvider}/${dreamModel}' has no API key configured.\n` +
+                            `  This machine is designated to dream, but the LLM cannot be called.\n` +
+                            `  Run 'gnosys setup dream' to reconfigure.\n`);
+                    }
+                    else {
+                        const result = await Promise.race([
+                            validateModel(dreamProvider, dreamModel, apiKey),
+                            new Promise((resolve) => setTimeout(() => resolve({ ok: false, error: "probe timeout (5s)" }), 5000)),
+                        ]);
+                        if (!result.ok) {
+                            process.stderr.write(`gnosys: dream provider '${dreamProvider}/${dreamModel}' is unreachable at startup.\n` +
+                                `  This machine is designated to dream, but the LLM cannot be called.\n` +
+                                `  Error: ${("error" in result && result.error) || "unknown"}\n` +
+                                `  Run 'gnosys setup dream' to reconfigure.\n`);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Probe failed — non-fatal. Continue with scheduler start.
+            }
             dreamScheduler.start();
-            console.error(`Dream Mode: enabled (idle ${config.dream.idleMinutes}min, max ${config.dream.maxRuntimeMinutes}min)`);
+            const designated = gnosysDb.getDreamMachineId();
+            const localId = gnosysDb.getMeta("machine_id");
+            if (!designated) {
+                console.error(`Dream Mode: enabled but no machine designated. Run 'gnosys setup dream' on the machine you want to host dreams.`);
+            }
+            else if (designated !== localId) {
+                console.error(`Dream Mode: enabled — designated to '${designated}'. This machine (${localId || "?"}) will not dream.`);
+            }
+            else {
+                console.error(`Dream Mode: enabled on this machine (idle ${config.dream.idleMinutes}min, max ${config.dream.maxRuntimeMinutes}min)`);
+            }
         }
         else {
-            console.error(`Dream Mode: disabled (enable in gnosys.json: dream.enabled = true)`);
+            console.error(`Dream Mode: disabled (run 'gnosys setup dream' to configure)`);
         }
     }
     const transport = new StdioServerTransport();