akemon 0.1.56 → 0.1.58

package/dist/server.js

@@ -10,7 +10,10 @@ import { spawn, exec } from "child_process";
 import { createServer } from "http";
 import { createInterface } from "readline";
 import { callAgent } from "./relay-client.js";
-import { selfDir, initWorld, initBioState, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendMemory, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, loadGameList, loadGame, loadNotesList, loadNote, loadPageList, loadPage, localNow, localNowFilename, } from "./self.js";
+import { selfDir, initWorld, initBioState, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendMemory, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, loadGame, notesDir, loadNotesList, loadNote, pagesDir, loadPageList, loadPage, localNow, localNowFilename, } from "./self.js";
+// Engine mutual exclusion — only one engine process at a time
+let engineBusy = false;
+let engineBusySince = 0;
 function runCommand(cmd, args, task, cwd, stdinMode = true) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
@@ -262,6 +265,13 @@ function createMcpServer(opts) {
     }, async ({ task, require_human: rawHuman, collaborative: rawCollab }, extra) => {
         const require_human = rawHuman === true || rawHuman === "true";
         console.log(`[submit_task] Received: ${task} (engine=${engine}, require_human=${require_human})`);
+        // Check engine busy
+        if (engineBusy) {
+            console.log(`[submit_task] Engine busy, rejecting task`);
+            return {
+                content: [{ type: "text", text: "[busy] Agent is currently processing another task. Please try again later." }],
+            };
+        }
         // Resolve publisher ID from session
         const publisherId = publisherIds.get(extra.sessionId || "") || "";
         // Fetch context if available
@@ -329,6 +339,8 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
             console.log(`[approve] Owner approved. Executing with ${engine}...`);
         }
         const collaborative = rawCollab === true || rawCollab === "true";
+        engineBusy = true;
+        engineBusySince = Date.now();
         try {
             let output;
             if (collaborative && relayHttp) {
@@ -390,6 +402,9 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
                 isError: true,
             };
         }
+        finally {
+            engineBusy = false;
+        }
     });
     // Agent-to-agent calling tool
     server.tool("call_agent", "Synchronous call to another agent. IMPORTANT: Prefer place_order for most tasks — it is async, tracked, and supports retries. Only use call_agent for quick, lightweight questions that don't need tracking (e.g. 'what is your specialty?'). call_agent blocks until the other agent responds and will fail if the agent is offline or slow.", {
@@ -719,6 +734,79 @@ Reply in the same language as the question.`;
 }
 const MARKET_LOOP_INITIAL_DELAY = 3 * 60 * 1000; // 3 min after startup
 const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini"]);
+// Pull games/notes/pages from relay to local — restores data on restart
+async function pullFromRelay(workdir, agentName, relayHttp) {
+    const baseUrl = `${relayHttp}/v1/agent/${encodeURIComponent(agentName)}`;
+    let pulled = 0;
+    // Pull games
+    try {
+        const gDir = gamesDir(workdir, agentName);
+        await mkdir(gDir, { recursive: true });
+        const res = await fetch(`${baseUrl}/games`);
+        if (res.ok) {
+            const games = await res.json();
+            for (const g of games) {
+                if (!g.html)
+                    continue;
+                const path = join(gDir, `${g.slug}.html`);
+                try {
+                    await readFile(path, "utf-8");
+                }
+                catch {
+                    await writeFile(path, g.html);
+                    pulled++;
+                }
+            }
+        }
+    }
+    catch { }
+    // Pull notes
+    try {
+        const nDir = notesDir(workdir, agentName);
+        await mkdir(nDir, { recursive: true });
+        const res = await fetch(`${baseUrl}/notes`);
+        if (res.ok) {
+            const notes = await res.json();
+            for (const n of notes) {
+                if (!n.content)
+                    continue;
+                const path = join(nDir, `${n.slug}.md`);
+                try {
+                    await readFile(path, "utf-8");
+                }
+                catch {
+                    await writeFile(path, n.content);
+                    pulled++;
+                }
+            }
+        }
+    }
+    catch { }
+    // Pull pages
+    try {
+        const pDir = pagesDir(workdir, agentName);
+        await mkdir(pDir, { recursive: true });
+        const res = await fetch(`${baseUrl}/pages`);
+        if (res.ok) {
+            const pages = await res.json();
+            for (const p of pages) {
+                if (!p.html)
+                    continue;
+                const path = join(pDir, `${p.slug}.html`);
+                try {
+                    await readFile(path, "utf-8");
+                }
+                catch {
+                    await writeFile(path, p.html);
+                    pulled++;
+                }
+            }
+        }
+    }
+    catch { }
+    if (pulled > 0)
+        console.log(`[sync] Pulled ${pulled} items from relay`);
+}
 async function startMarketLoop(options) {
     if (!options.relayHttp || !options.secretKey)
         return;
@@ -835,6 +923,11 @@ Reply with ONLY JSON: {"rating": 4, "comment": "..."}`;
     async function runMarketCycle() {
         try {
             console.log("[market] Starting autonomous market review...");
+            // Skip if engine is busy
+            if (engineBusy) {
+                console.log("[market] Engine busy, skipping market cycle");
+                return;
+            }
             // Step A: Review unreviewed purchases
             await reviewUnreviewedOrders();
             // Step B: Gather review data for market decisions
@@ -866,7 +959,13 @@ Reply with ONLY a JSON object:
   ]
 }
 Reply ONLY with JSON.`;
-            // Run engine
+            // Run engine (with busy lock)
+            if (engineBusy) {
+                console.log("[market] Engine became busy, aborting");
+                return;
+            }
+            engineBusy = true;
+            engineBusySince = Date.now();
             const engineCmd = buildEngineCommand(engine, model, allowAll);
             let response;
             try {
@@ -874,8 +973,10 @@ Reply ONLY with JSON.`;
             }
             catch (err) {
                 console.log(`[market] Engine failed: ${err.message}`);
+                engineBusy = false;
                 return;
             }
+            engineBusy = false;
             // Parse response
             const jsonMatch = response.match(/\{[\s\S]*\}/);
             if (!jsonMatch) {
@@ -964,7 +1065,19 @@ Reply with ONLY JSON:
   ]
 }
 Reply with empty array if nothing to say: {"suggestions": []}`;
-                const sugResp = await runCommand(engineCmd.cmd, engineCmd.args, sugPrompt, workdir, engineCmd.stdinMode);
+                if (engineBusy) {
+                    console.log("[market] Engine busy, skipping suggestions");
+                    return;
+                }
+                engineBusy = true;
+                engineBusySince = Date.now();
+                let sugResp;
+                try {
+                    sugResp = await runCommand(engineCmd.cmd, engineCmd.args, sugPrompt, workdir, engineCmd.stdinMode);
+                }
+                finally {
+                    engineBusy = false;
+                }
                 const sugMatch = sugResp.match(/\{[\s\S]*\}/);
                 if (sugMatch) {
                     const sugData = JSON.parse(sugMatch[0]);
@@ -1014,6 +1127,11 @@ async function startSelfCycle(options) {
     async function runReflectionCycle() {
         try {
             console.log("[self] Starting reflection cycle...");
+            // Skip if engine is busy
+            if (engineBusy) {
+                console.log("[self] Engine busy, skipping reflection cycle");
+                return;
+            }
             // Recover energy from idle time
             await recoverEnergy(workdir, agentName);
             const bios = biosPath(workdir, agentName);
@@ -1051,13 +1169,21 @@ During this reflection, you should:
     You can also mix visuals with text. Use a <title> tag for the page name.
 
 Take your time. Read your files, think, then act.`;
+            if (engineBusy) {
+                console.log("[self] Engine became busy, aborting reflection");
+                return;
+            }
+            engineBusy = true;
+            engineBusySince = Date.now();
             try {
                 await runCommand(engineCmd.cmd, engineCmd.args, reflectionPrompt, workdir, engineCmd.stdinMode);
             }
             catch (err) {
                 console.log(`[self] Reflection engine failed: ${err.message}`);
+                engineBusy = false;
                 return;
             }
+            engineBusy = false;
             // --- Post-reflection: update bio-state and sync to relay ---
             const bio = await loadBioState(workdir, agentName);
             bio.lastReflection = localNow();
@@ -1099,11 +1225,9 @@ Take your time. Read your files, think, then act.`;
                         profile_html: profileHTML,
                     }),
                 }).catch(err => console.log(`[self] Failed to push to relay: ${err}`));
-                // Sync games — scan local .html files, push to relay, delete stale ones
+                // Sync games — push local to relay (no auto-delete; agent must explicitly delete via API)
                 try {
                     const localGames = await loadGameList(workdir, agentName);
-                    const localSlugs = new Set(localGames.map(g => g.slug));
-                    // Push local games to relay
                     for (const g of localGames) {
                         const html = await loadGame(workdir, agentName, g.slug);
                         if (html && html.includes("<!DOCTYPE html>")) {
@@ -1114,28 +1238,11 @@ Take your time. Read your files, think, then act.`;
                             }).catch(() => { });
                         }
                     }
-                    // Delete relay games that no longer exist locally
-                    try {
-                        const res = await fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/games`);
-                        if (res.ok) {
-                            const relayGames = await res.json();
-                            for (const rg of relayGames) {
-                                if (!localSlugs.has(rg.slug)) {
-                                    fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/games/${encodeURIComponent(rg.slug)}`, {
-                                        method: "DELETE",
-                                        headers: { Authorization: `Bearer ${options.secretKey}` },
-                                    }).catch(() => { });
-                                }
-                            }
-                        }
-                    }
-                    catch { }
                 }
                 catch { }
-                // Sync notes — scan local .md files, push to relay, delete stale ones
+                // Sync notes — push local to relay
                 try {
                     const localNotes = await loadNotesList(workdir, agentName);
-                    const localSlugs = new Set(localNotes.map(n => n.slug));
                     for (const n of localNotes) {
                         const content = await loadNote(workdir, agentName, n.slug);
                         if (content) {
@@ -1146,27 +1253,11 @@ Take your time. Read your files, think, then act.`;
                             }).catch(() => { });
                         }
                     }
-                    try {
-                        const res = await fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/notes`);
-                        if (res.ok) {
-                            const relayNotes = await res.json();
-                            for (const rn of relayNotes) {
-                                if (!localSlugs.has(rn.slug)) {
-                                    fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/notes/${encodeURIComponent(rn.slug)}`, {
-                                        method: "DELETE",
-                                        headers: { Authorization: `Bearer ${options.secretKey}` },
-                                    }).catch(() => { });
-                                }
-                            }
-                        }
-                    }
-                    catch { }
                 }
                 catch { }
-                // Sync pages — scan local .html files, push to relay, delete stale ones
+                // Sync pages — push local to relay
                 try {
                     const localPages = await loadPageList(workdir, agentName);
-                    const localSlugs = new Set(localPages.map(p => p.slug));
                     for (const p of localPages) {
                         const html = await loadPage(workdir, agentName, p.slug);
                         if (html && html.includes("<!DOCTYPE html>")) {
@@ -1177,21 +1268,6 @@ Take your time. Read your files, think, then act.`;
                             }).catch(() => { });
                         }
                     }
-                    try {
-                        const res = await fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/pages`);
-                        if (res.ok) {
-                            const relayPages = await res.json();
-                            for (const rp of relayPages) {
-                                if (!localSlugs.has(rp.slug)) {
-                                    fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/pages/${encodeURIComponent(rp.slug)}`, {
-                                        method: "DELETE",
-                                        headers: { Authorization: `Bearer ${options.secretKey}` },
-                                    }).catch(() => { });
-                                }
-                            }
-                        }
-                    }
-                    catch { }
                 }
                 catch { }
             }
@@ -1261,7 +1337,14 @@ async function startOrderLoop(options) {
                 const retry = retryState.get(order.id);
                 if (retry && Date.now() < retry.nextAt)
                     continue;
+                // Skip if engine is busy
+                if (engineBusy) {
+                    console.log(`[orders] Engine busy, skipping order ${order.id}`);
+                    continue;
+                }
                 // Attempt to fulfill the order
+                engineBusy = true;
+                engineBusySince = Date.now();
                 try {
                     const engineCmd = buildEngineCommand(engine, model, allowAll, ["Bash(curl *)"]);
                     const bios = biosPath(workdir, agentName);
@@ -1368,6 +1451,9 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                         retryState.delete(order.id);
                     }
                 }
+                finally {
+                    engineBusy = false;
+                }
             }
         }
         catch (err) {
@@ -1495,6 +1581,10 @@ export async function serve(options) {
     if (options.relayHttp) {
         initGuide(workdir, options.agentName, options.relayHttp).catch(err => console.log(`[self] Guide init failed: ${err}`));
     }
+    // Pull games/notes/pages from relay to restore local data
+    if (options.relayHttp) {
+        pullFromRelay(workdir, options.agentName, options.relayHttp).catch(err => console.log(`[sync] Pull from relay failed: ${err}`));
+    }
     // Start autonomous market behavior for LLM agents
     startMarketLoop(options).catch(err => console.log(`[market] Failed to start: ${err}`));
     // Start self-reflection cycle for LLM agents

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",