npm - akemon - Versions diffs - 0.3.5 → 0.3.7 - Mend

akemon 0.3.5 → 0.3.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/DATA_POLICY.md +128 -0
package/README.md +156 -19
package/TRADEMARK.md +74 -0
package/dist/akemon-home.js +56 -0
package/dist/akemon-message.js +107 -0
package/dist/best-effort.js +8 -0
package/dist/cli.js +1411 -132
package/dist/cognitive-artifact-store.js +101 -0
package/dist/cognitive-event-log.js +47 -0
package/dist/config.js +45 -9
package/dist/context.js +27 -6
package/dist/core/contracts/layers.js +1 -0
package/dist/core/contracts/permission.js +1 -0
package/dist/core/contracts/workspace.js +1 -0
package/dist/core-cognitive-module.js +768 -0
package/dist/engine-peripheral.js +127 -26
package/dist/engine-routing.js +58 -17
package/dist/interactive-session.js +361 -0
package/dist/local-interconnect.js +156 -0
package/dist/local-registry.js +178 -0
package/dist/mcp-server.js +4 -1
package/dist/memory-proposal.js +379 -0
package/dist/memory-recorder.js +368 -0
package/dist/orphan-scan.js +36 -24
package/dist/passive-reflection-cognitive-module.js +172 -0
package/dist/peripheral-registry.js +235 -0
package/dist/permission-audit.js +132 -0
package/dist/relay-client.js +68 -9
package/dist/relay-mode.js +34 -0
package/dist/relay-peripheral.js +139 -49
package/dist/runtime-platform.js +122 -0
package/dist/secretariat/client.js +87 -0
package/dist/self.js +15 -6
package/dist/server.js +3695 -439
package/dist/social-discovery.js +231 -0
package/dist/software-agent-peripheral.js +314 -235
package/dist/software-agent-result-cli.js +69 -0
package/dist/software-agent-stream-cli.js +23 -0
package/dist/software-agent-transport.js +177 -0
package/dist/task-module.js +243 -0
package/dist/task-registry.js +756 -0
package/dist/vendor/xterm/addon-fit.js +2 -0
package/dist/vendor/xterm/addon-search.js +2 -0
package/dist/vendor/xterm/addon-web-links.js +2 -0
package/dist/vendor/xterm/xterm.css +285 -0
package/dist/vendor/xterm/xterm.js +2 -0
package/dist/work-memory.js +339 -0
package/dist/workbench-peripheral-guide.js +79 -0
package/dist/workbench-session.js +1074 -0
package/dist/workbench.html +4011 -0
package/package.json +11 -4
package/scripts/build.cjs +24 -0
package/scripts/check-architecture-baseline.cjs +68 -0
package/scripts/test.cjs +38 -0

package/dist/relay-peripheral.js CHANGED Viewed

@@ -8,9 +8,53 @@
  * Migration strategy: server.ts can import and use this directly — no need for
  * the full Core/EventBus wiring yet. That comes later.
  */
+import { createHash } from "crypto";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { join } from "path";
-import { gamesDir, notesDir, pagesDir, selfDir, loadLatestIdentity, loadRecentCanvasEntries, loadGameList, loadGame, loadNotesList, loadNote, loadPageList, loadPage, loadDirectives, directivesSummary, loadBioState, } from "./self.js";
+import { agentRelayImportsDir } from "./akemon-home.js";
+import { actorRef } from "./akemon-message.js";
+import { appendPermissionAuditRecord } from "./permission-audit.js";
+import { logBestEffortError } from "./best-effort.js";
+import { selfDir, loadLatestIdentity, loadRecentCanvasEntries, loadGameList, loadGame, loadNotesList, loadNote, loadPageList, loadPage, loadDirectives, directivesSummary, loadBioState, } from "./self.js";
+function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 8);
+}
+function safeRelayArtifactSlug(slug) {
+    const raw = String(slug || "untitled").trim() || "untitled";
+    const base = raw
+        .replace(/[^A-Za-z0-9._-]+/g, "_")
+        .replace(/^\.+/, "")
+        .replace(/[. ]+$/g, "")
+        .slice(0, 100) || "untitled";
+    const portableBase = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i.test(base) ? `_${base}` : base;
+    return portableBase === raw && raw.length <= 100 ? portableBase : `${portableBase}-${shortHash(raw)}`;
+}
+async function stageRelayArtifactImport(input) {
+    const dir = join(agentRelayImportsDir(input.agentName), input.kind);
+    await mkdir(dir, { recursive: true });
+    const filename = `${safeRelayArtifactSlug(input.slug)}.${input.extension}`;
+    const artifactPath = join(dir, filename);
+    try {
+        await readFile(artifactPath, "utf-8");
+        return false;
+    }
+    catch { }
+    await writeFile(artifactPath, input.content, "utf-8");
+    await writeFile(`${artifactPath}.relay-import.json`, JSON.stringify({
+        schemaVersion: 1,
+        source: "relay",
+        authority: "remote-projection",
+        canonicalSelfMemory: false,
+        importedInto: "inbox",
+        relayAgent: input.agentName,
+        kind: input.kind,
+        originalSlug: input.slug,
+        localFile: filename,
+        sourceUrl: input.sourceUrl,
+        importedAt: new Date().toISOString(),
+    }, null, 2) + "\n", "utf-8");
+    return true;
+}
 export class RelayPeripheral {
     id = "relay";
     name = "Akemon Relay";
@@ -266,7 +310,9 @@ export class RelayPeripheral {
                 signal: AbortSignal.timeout(10_000),
             });
         }
-        catch { }
+        catch (error) {
+            logBestEffortError("relay session context set", error);
+        }
     }
     // ---------------------------------------------------------------------------
     // 10. Explore — plain-text environment briefing for Modules
@@ -406,6 +452,9 @@ export class RelayPeripheral {
                 personality: bio.personality,
             },
         });
+        let syncedGames = 0;
+        let syncedNotes = 0;
+        let syncedPages = 0;
         // Sync games
         try {
             const localGames = await loadGameList(workdir, agentName);
@@ -413,10 +462,13 @@ export class RelayPeripheral {
                 const html = await loadGame(workdir, agentName, g.slug);
                 if (html && html.includes("<!DOCTYPE html>")) {
                     this.syncGame(g.slug, g.title, g.description, html);
+                    syncedGames++;
                 }
             }
         }
-        catch { }
+        catch (error) {
+            logBestEffortError("relay sync games", error);
+        }
         // Sync notes
         try {
             const localNotes = await loadNotesList(workdir, agentName);
@@ -424,10 +476,13 @@ export class RelayPeripheral {
                 const content = await loadNote(workdir, agentName, n.slug);
                 if (content) {
                     this.syncNote(n.slug, n.title, content);
+                    syncedNotes++;
                 }
             }
         }
-        catch { }
+        catch (error) {
+            logBestEffortError("relay sync notes", error);
+        }
         // Sync pages
         try {
             const localPages = await loadPageList(workdir, agentName);
@@ -435,82 +490,117 @@ export class RelayPeripheral {
                 const html = await loadPage(workdir, agentName, p.slug);
                 if (html && html.includes("<!DOCTYPE html>")) {
                     this.syncPage(p.slug, p.title, p.description, html);
+                    syncedPages++;
                 }
             }
         }
-        catch { }
+        catch (error) {
+            logBestEffortError("relay sync pages", error);
+        }
+        try {
+            await appendPermissionAuditRecord(agentName, {
+                actionKind: "relay-publication",
+                action: "relay.sync-to-relay",
+                requestedBy: actorRef("system", "relay-sync", "local"),
+                performedBy: actorRef("agent", agentName, "relay"),
+                target: actorRef("relay", this.baseUrl, "relay"),
+                riskLevel: "low",
+                memoryScope: "public",
+                workdir,
+                projectScope: "global",
+                transport: "relay",
+                decision: {
+                    result: "allowed",
+                    mode: "automatic",
+                    reason: "Relay peripheral published local public projections to relay.",
+                },
+                metadata: {
+                    fields: ["self_intro", "canvas", "mood", "profile_html", "directives_summary", "bio_state"],
+                    broadcast: !!broadcast,
+                    syncedGames,
+                    syncedNotes,
+                    syncedPages,
+                },
+            });
+        }
+        catch (error) {
+            logBestEffortError("relay sync audit append", error);
+        }
     }
-    /** Pull games/notes/pages from relay to local — restores data on restart */
-    async pullFromRelay(workdir, agentName) {
+    /**
+     * Pull games/notes/pages from relay into the local inbox.
+     * Relay artifacts are external projections, not canonical self memory.
+     */
+    async pullFromRelay(_workdir, agentName) {
         const baseUrl = `${this.config.httpUrl}/v1/agent/${encodeURIComponent(agentName)}`;
-        let pulled = 0;
-        // Pull games
+        let staged = 0;
+        // Stage games
         try {
-            const gDir = gamesDir(workdir, agentName);
-            await mkdir(gDir, { recursive: true });
-            const res = await fetch(`${baseUrl}/games`);
+            const listUrl = `${baseUrl}/games`;
+            const res = await fetch(listUrl);
             if (res.ok) {
                 const games = await res.json();
                 for (const g of games) {
-                    if (!g.html)
+                    if (!g.slug || !g.html)
                         continue;
-                    const path = join(gDir, `${g.slug}.html`);
-                    try {
-                        await readFile(path, "utf-8");
-                    }
-                    catch {
-                        await writeFile(path, g.html);
-                        pulled++;
-                    }
+                    if (await stageRelayArtifactImport({
+                        agentName,
+                        kind: "games",
+                        slug: g.slug,
+                        extension: "html",
+                        content: g.html,
+                        sourceUrl: `${baseUrl}/games/${encodeURIComponent(g.slug)}`,
+                    }))
+                        staged++;
                 }
             }
         }
         catch { }
-        // Pull notes
+        // Stage notes
         try {
-            const nDir = notesDir(workdir, agentName);
-            await mkdir(nDir, { recursive: true });
-            const res = await fetch(`${baseUrl}/notes`);
+            const listUrl = `${baseUrl}/notes`;
+            const res = await fetch(listUrl);
             if (res.ok) {
                 const notes = await res.json();
                 for (const n of notes) {
-                    if (!n.content)
+                    if (!n.slug || !n.content)
                         continue;
-                    const path = join(nDir, `${n.slug}.md`);
-                    try {
-                        await readFile(path, "utf-8");
-                    }
-                    catch {
-                        await writeFile(path, n.content);
-                        pulled++;
-                    }
+                    if (await stageRelayArtifactImport({
+                        agentName,
+                        kind: "notes",
+                        slug: n.slug,
+                        extension: "md",
+                        content: n.content,
+                        sourceUrl: `${baseUrl}/notes/${encodeURIComponent(n.slug)}`,
+                    }))
+                        staged++;
                 }
             }
         }
         catch { }
-        // Pull pages
+        // Stage pages
         try {
-            const pDir = pagesDir(workdir, agentName);
-            await mkdir(pDir, { recursive: true });
-            const res = await fetch(`${baseUrl}/pages`);
+            const listUrl = `${baseUrl}/pages`;
+            const res = await fetch(listUrl);
             if (res.ok) {
                 const pages = await res.json();
                 for (const p of pages) {
-                    if (!p.html)
+                    if (!p.slug || !p.html)
                         continue;
-                    const path = join(pDir, `${p.slug}.html`);
-                    try {
-                        await readFile(path, "utf-8");
-                    }
-                    catch {
-                        await writeFile(path, p.html);
-                        pulled++;
-                    }
+                    if (await stageRelayArtifactImport({
+                        agentName,
+                        kind: "pages",
+                        slug: p.slug,
+                        extension: "html",
+                        content: p.html,
+                        sourceUrl: `${baseUrl}/pages/${encodeURIComponent(p.slug)}`,
+                    }))
+                        staged++;
                 }
             }
         }
         catch { }
-        if (pulled > 0)
-            console.log(`[sync] Pulled ${pulled} items from relay`);
+        if (staged > 0)
+            console.log(`[sync] Staged ${staged} relay items in inbox/relay-imports`);
     }
 }

package/dist/runtime-platform.js ADDED Viewed

@@ -0,0 +1,122 @@
+import { spawn } from "child_process";
+import { tmpdir } from "os";
+export function getRuntimePlatform(platform = process.platform) {
+    return {
+        platform,
+        tempDir: tmpdir(),
+        defaultShell: defaultShellForPlatform(platform),
+        capabilities: runtimeCapabilities(platform),
+    };
+}
+export function runtimeCapabilities(platform = process.platform) {
+    const isPosixDesktop = platform === "darwin" || platform === "linux";
+    return {
+        canSpawnProcess: true,
+        canOpenBrowser: platform === "darwin" || platform === "linux" || platform === "win32",
+        canStartPty: isPosixDesktop,
+        canKillProcessTree: isPosixDesktop || platform === "win32",
+        canScanOrphanProcesses: isPosixDesktop,
+        supportsProcessGroups: isPosixDesktop,
+    };
+}
+export function defaultShellForPlatform(platform = process.platform) {
+    if (platform === "win32")
+        return process.env.ComSpec || process.env.COMSPEC || "cmd.exe";
+    return process.env.SHELL || "/bin/sh";
+}
+export async function openUrl(url, platform = process.platform) {
+    const command = openUrlCommand(url, platform);
+    if (!command) {
+        throw new Error(`Opening browser is not supported on platform: ${platform}`);
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn(command.command, command.args, {
+            stdio: "ignore",
+            detached: true,
+            windowsHide: true,
+        });
+        child.once("error", reject);
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}
+export function openUrlCommand(url, platform = process.platform) {
+    if (platform === "darwin")
+        return { command: "open", args: [url] };
+    if (platform === "linux")
+        return { command: "xdg-open", args: [url] };
+    if (platform === "win32")
+        return { command: "cmd", args: ["/c", "start", "", url] };
+    return null;
+}
+export function shouldDetachChildProcess(platform = process.platform) {
+    return runtimeCapabilities(platform).supportsProcessGroups;
+}
+export function terminateProcessTree(pid, options = {}, platform = process.platform) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return;
+    const signal = options.signal || "SIGTERM";
+    if (platform === "win32") {
+        runTaskkill(pid, signal === "SIGKILL");
+    }
+    else if (runtimeCapabilities(platform).supportsProcessGroups) {
+        try {
+            process.kill(-pid, signal);
+        }
+        catch { }
+    }
+    else {
+        try {
+            process.kill(pid, signal);
+        }
+        catch { }
+    }
+    if (options.forceAfterMs !== undefined && signal !== "SIGKILL") {
+        const timer = setTimeout(() => {
+            terminateProcessTree(pid, { signal: "SIGKILL" }, platform);
+        }, options.forceAfterMs);
+        timer.unref?.();
+    }
+}
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export function assertPortablePathSegment(value, label = "path segment") {
+    const cleaned = value.trim();
+    if (!cleaned)
+        throw new Error(`Invalid ${label}: must not be empty`);
+    if (/[/\\]/.test(cleaned))
+        throw new Error(`Invalid ${label}: must not contain path separators`);
+    if (/[<>:"|?*\x00-\x1f\x7f]/.test(cleaned)) {
+        throw new Error(`Invalid ${label}: contains characters that are not portable across filesystems`);
+    }
+    if (/[. ]$/.test(cleaned)) {
+        throw new Error(`Invalid ${label}: must not end with a dot or space`);
+    }
+    const upper = cleaned.toUpperCase();
+    if (/^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\..*)?$/.test(upper)) {
+        throw new Error(`Invalid ${label}: reserved Windows device name`);
+    }
+    return cleaned;
+}
+function runTaskkill(pid, force) {
+    const args = ["/PID", String(pid), "/T"];
+    if (force)
+        args.push("/F");
+    const child = spawn("taskkill", args, {
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.on("error", () => { });
+    child.unref();
+}

package/dist/secretariat/client.js ADDED Viewed

@@ -0,0 +1,87 @@
+import { actorRef, createAkemonMessage } from "../akemon-message.js";
+export class SecretariatClient {
+    requestJson;
+    constructor(transport) {
+        this.requestJson = transport.requestJson;
+    }
+    submitOwnerIntent(input) {
+        return this.requestJson("/self/message", {
+            method: "POST",
+            body: JSON.stringify({
+                message: input.message,
+                ...(input.wait === false ? { wait: false } : {}),
+            }),
+        });
+    }
+    queueOwnerFollowUp(input) {
+        const message = {
+            ...input.message,
+            metadata: {
+                ...(input.message.metadata || {}),
+                followUpForTaskId: input.taskId,
+            },
+        };
+        return this.requestJson("/self/message", {
+            method: "POST",
+            body: JSON.stringify({ message }),
+        });
+    }
+    async getTaskStatus(taskId) {
+        return this.requestJson(`/self/tasks/${encodeURIComponent(taskId)}`, { method: "GET" });
+    }
+    async getTaskReport(taskId) {
+        return this.getTaskStatus(taskId);
+    }
+    async listConversationTasks(input = {}) {
+        const params = new URLSearchParams();
+        params.set("limit", String(input.limit || 50));
+        if (input.status)
+            params.set("status", input.status);
+        if (input.route)
+            params.set("route", input.route);
+        if (input.visibility)
+            params.set("visibility", input.visibility);
+        const response = await this.requestJson(`/self/tasks?${params.toString()}`, { method: "GET" });
+        if (!input.conversationId)
+            return response;
+        const tasks = (response.tasks || []).filter((task) => task.conversationId === input.conversationId);
+        const taskIds = new Set(tasks.map((task) => task.taskId));
+        return {
+            ...response,
+            tasks,
+            taskViews: (response.taskViews || []).filter((view) => taskIds.has(view.taskId)),
+        };
+    }
+}
+export function createOwnerChatMessage(input) {
+    return createAkemonMessage({
+        type: "akemon.message",
+        id: input.id,
+        createdAt: input.createdAt,
+        source: actorRef("owner", "owner", "local"),
+        target: actorRef("agent", input.targetAgent, "local"),
+        conversationId: input.conversationId,
+        memoryScope: input.memoryScope || "owner",
+        permissions: {},
+        transport: "local",
+        metadata: input.metadata,
+        payload: {
+            text: input.text,
+            format: "text",
+            kind: "chat",
+        },
+    });
+}
+export function taskIdFromOwnerChatMessage(message) {
+    const suffix = message.id || `${message.conversationId || "local"}_${Date.now()}`;
+    return `task_${suffix.replace(/[^a-zA-Z0-9_.:-]/g, "_")}`;
+}
+export function taskIsTerminal(task) {
+    if (!task)
+        return false;
+    return task.stage === "done"
+        || task.stage === "blocked"
+        || task.status === "succeeded"
+        || task.status === "failed"
+        || task.status === "info";
+}

package/dist/self.js CHANGED Viewed

@@ -4,10 +4,12 @@
  * Manages the agent's self-awareness: world knowledge, first-person memory,
  * identity (five questions), bio-simulation, and inner canvas.
  *
- * All data lives in .akemon/agents/{name}/self/ — separate from work context.
+ * All self data lives in Akemon home under agents/{name}/self/ — separate from
+ * project work context.
  */
 import { readFile, writeFile, appendFile, mkdir, readdir } from "fs/promises";
 import { join } from "path";
+import { agentConfigPath as homeAgentConfigPath, agentAuditDir, agentContactsDir, agentHomeDir, agentInboxDir, agentSelfDir, globalWorkMemoryDir, } from "./akemon-home.js";
 /** Local timestamp string like "2026-03-26T19:13:26" (server timezone, no Z suffix) */
 export function localNow() {
     const d = new Date();
@@ -21,8 +23,8 @@ export function localNowFilename() {
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
-export function selfDir(workdir, agentName) {
-    return join(workdir, ".akemon", "agents", agentName, "self");
+export function selfDir(_workdir, agentName) {
+    return agentSelfDir(agentName);
 }
 function worldPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "world.md");
@@ -60,8 +62,8 @@ export function guidePath(workdir, agentName) {
 export function biosPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "bios.md");
 }
-function agentConfigPath(workdir, agentName) {
-    return join(workdir, ".akemon", "agents", agentName, "config.json");
+function agentConfigPath(_workdir, agentName) {
+    return homeAgentConfigPath(agentName);
 }
 export function directivesPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "tasks.md");
@@ -139,6 +141,7 @@ const DEFAULT_CONFIG = {
     auto_offline_enabled: true,
     hunger_decay_interval: 300_000, // 5 minutes per hunger point (was 30s — way too fast)
     context_budget: 4096,
+    owner_language: "auto",
 };
 export async function initAgentConfig(workdir, agentName) {
     const p = agentConfigPath(workdir, agentName);
@@ -146,8 +149,14 @@ export async function initAgentConfig(workdir, agentName) {
         await readFile(p, "utf-8");
     }
     catch {
-        await mkdir(join(workdir, ".akemon", "agents", agentName), { recursive: true });
+        const home = agentHomeDir(agentName);
+        await mkdir(selfDir(workdir, agentName), { recursive: true });
+        await mkdir(globalWorkMemoryDir(agentName), { recursive: true });
+        await mkdir(agentAuditDir(agentName), { recursive: true });
+        await mkdir(agentContactsDir(agentName), { recursive: true });
+        await mkdir(agentInboxDir(agentName), { recursive: true });
         await writeFile(p, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+        console.log(`[self] First use for agent "${agentName}"; created identity home at ${home}`);
         console.log(`[self] Created config.json with defaults`);
     }
 }