akemon 0.3.3 → 0.3.5

package/dist/server.js

@@ -2,6 +2,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { exec } from "child_process";
 import { scanAndKillOrphans } from "./orphan-scan.js";
+import { timingSafeEqual } from "node:crypto";
 import { createServer } from "http";
 import { createInterface } from "readline";
 import { mkdir } from "fs/promises";
@@ -86,8 +87,35 @@ function bearerToken(req) {
 }
 function isOwnerRequest(req, options) {
     const token = bearerToken(req);
-    const validTokens = [options.secretKey, options.key].filter(Boolean);
-    return !!token && validTokens.includes(token);
+    const validTokens = [options.secretKey, options.key]
+        .filter((validToken) => typeof validToken === "string" && validToken.length > 0);
+    return !!token && validTokens.some((validToken) => constantTimeTokenEqual(token, validToken));
+}
+function constantTimeTokenEqual(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    const length = Math.max(leftBuffer.length, rightBuffer.length, 1);
+    const leftPadded = Buffer.alloc(length);
+    const rightPadded = Buffer.alloc(length);
+    leftBuffer.copy(leftPadded);
+    rightBuffer.copy(rightPadded);
+    return timingSafeEqual(leftPadded, rightPadded) && leftBuffer.length === rightBuffer.length;
+}
+function writeJsonResponse(res, statusCode, body, pretty = false) {
+    res.writeHead(statusCode, { "Content-Type": "application/json" })
+        .end(JSON.stringify(body, null, pretty ? 2 : 0));
+}
+function requireOwnerRequest(req, res, options) {
+    if (isOwnerRequest(req, options))
+        return true;
+    writeJsonResponse(res, 401, { error: "Owner token required" });
+    return false;
+}
+function requireSoftwareAgent(res, softwareAgent) {
+    if (softwareAgent)
+        return softwareAgent;
+    writeJsonResponse(res, 503, { error: "Software agent peripheral not ready" });
+    return null;
 }
 function readJsonBody(req, maxBytes = 256 * 1024) {
     return new Promise((resolve, reject) => {
@@ -118,79 +146,193 @@ function readJsonBody(req, maxBytes = 256 * 1024) {
         req.on("error", reject);
     });
 }
-export async function handleSoftwareAgentRunHttp(req, res, deps) {
-    if (!isOwnerRequest(req, deps.options)) {
-        res.writeHead(401, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: "Owner token required" }));
-        return;
-    }
-    if (!deps.softwareAgent) {
-        res.writeHead(503, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
-        return;
-    }
+async function readOwnerSoftwareAgentEnvelope(req, res, deps) {
     let body;
     try {
         body = await readJsonBody(req);
     }
     catch (err) {
-        res.writeHead(400, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: err.message || "Invalid request body" }));
-        return;
+        writeJsonResponse(res, 400, { error: err.message || "Invalid request body" });
+        return null;
     }
-    let envelope;
     try {
-        envelope = createOwnerTaskEnvelope(body, deps.workdir);
+        const envelope = createOwnerTaskEnvelope(body, deps.workdir);
+        envelope.memorySummary = await buildSoftwareAgentMemorySummary({
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+            envelope,
+            request: body,
+        });
+        return envelope;
     }
     catch (err) {
-        res.writeHead(400, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: err.message || "Invalid software-agent envelope" }));
-        return;
+        writeJsonResponse(res, 400, { error: err.message || "Invalid software-agent envelope" });
+        return null;
     }
+}
+export async function handleSoftwareAgentRunHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
+    if (!softwareAgent)
+        return;
+    const envelope = await readOwnerSoftwareAgentEnvelope(req, res, deps);
+    if (!envelope)
+        return;
     try {
-        const result = await deps.softwareAgent.sendTask(envelope);
-        res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" })
-            .end(JSON.stringify(result, null, 2));
+        const result = await softwareAgent.sendTask(envelope);
+        writeJsonResponse(res, 200, redactSecrets(result), true);
     }
     catch (err) {
         const busy = String(err.message || "").includes("busy");
-        res.writeHead(busy ? 409 : 500, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: err.message || String(err) }));
+        writeJsonResponse(res, busy ? 409 : 500, { error: err.message || String(err) });
+    }
+}
+export async function handleSoftwareAgentRunStreamHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
+    if (!softwareAgent)
+        return;
+    const envelope = await readOwnerSoftwareAgentEnvelope(req, res, deps);
+    if (!envelope)
+        return;
+    const abortController = new AbortController();
+    let responseFinished = false;
+    let streamStarted = false;
+    res.on("close", () => {
+        if (!responseFinished)
+            abortController.abort();
+    });
+    const ensureStreamStarted = () => {
+        if (streamStarted)
+            return;
+        streamStarted = true;
+        res.writeHead(200, {
+            "Content-Type": "application/x-ndjson; charset=utf-8",
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        });
+        res.flushHeaders?.();
+    };
+    try {
+        await softwareAgent.sendTask(envelope, {
+            signal: abortController.signal,
+            observer: {
+                onStart(event) {
+                    ensureStreamStarted();
+                    writeSoftwareAgentStreamEvent(res, {
+                        type: "start",
+                        taskId: event.taskId,
+                        commandLine: event.commandLine,
+                    });
+                },
+                onStream(event) {
+                    ensureStreamStarted();
+                    writeSoftwareAgentStreamEvent(res, {
+                        type: event.stream,
+                        taskId: event.taskId,
+                        chunk: event.chunk,
+                    });
+                },
+                onEnd(event) {
+                    ensureStreamStarted();
+                    writeSoftwareAgentStreamEvent(res, {
+                        type: "end",
+                        taskId: event.taskId,
+                        exitCode: event.exitCode,
+                        durationMs: event.durationMs,
+                        result: event.result,
+                    });
+                },
+            },
+        });
+    }
+    catch (err) {
+        if (!streamStarted) {
+            const busy = String(err.message || "").includes("busy");
+            writeJsonResponse(res, busy ? 409 : 500, { error: err.message || String(err) });
+            responseFinished = true;
+            return;
+        }
+        writeSoftwareAgentStreamEvent(res, {
+            type: "error",
+            error: err.message || String(err),
+        });
+    }
+    finally {
+        responseFinished = true;
+        if (streamStarted && !res.writableEnded)
+            res.end();
     }
 }
 export async function handleSoftwareAgentStatusHttp(req, res, deps) {
-    if (!isOwnerRequest(req, deps.options)) {
-        res.writeHead(401, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: "Owner token required" }));
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
+    if (!softwareAgent)
+        return;
+    writeJsonResponse(res, 200, softwareAgent.getState(), true);
+}
+export async function handleSoftwareAgentTasksHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const basePath = "/self/software-agent/tasks";
+    const taskLedgerDir = softwareAgentTaskLedgerDir(deps.workdir, deps.agentName);
+    if (url.pathname === basePath) {
+        const limit = readPositiveIntQuery(url.searchParams.get("limit"), 20, 100);
+        const tasks = listSoftwareAgentTaskRecords(taskLedgerDir, limit);
+        writeJsonResponse(res, 200, { tasks }, true);
         return;
     }
-    if (!deps.softwareAgent) {
-        res.writeHead(503, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
+    if (url.pathname.startsWith(`${basePath}/`)) {
+        const taskId = decodeURIComponent(url.pathname.slice(basePath.length + 1));
+        if (!taskId || taskId.includes("/")) {
+            writeJsonResponse(res, 400, { error: "Invalid software-agent task id" });
+            return;
+        }
+        const task = readSoftwareAgentTaskRecord(taskLedgerDir, taskId);
+        if (!task) {
+            writeJsonResponse(res, 404, { error: "Software-agent task not found" });
+            return;
+        }
+        writeJsonResponse(res, 200, { task }, true);
         return;
     }
-    res.writeHead(200, { "Content-Type": "application/json" })
-        .end(JSON.stringify(deps.softwareAgent.getState(), null, 2));
+    writeJsonResponse(res, 404, { error: "Software-agent task endpoint not found" });
+}
+function softwareAgentTaskLedgerDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "software-agent", "tasks");
+}
+function softwareAgentContextSessionDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "software-agent", "sessions");
+}
+function readPositiveIntQuery(value, fallback, max) {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0)
+        return fallback;
+    return Math.min(parsed, max);
+}
+function writeSoftwareAgentStreamEvent(res, event) {
+    if (res.destroyed)
+        return;
+    res.write(`${JSON.stringify(redactSecrets(event))}\n`);
 }
 export async function handleSoftwareAgentResetHttp(req, res, deps) {
-    if (!isOwnerRequest(req, deps.options)) {
-        res.writeHead(401, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: "Owner token required" }));
+    if (!requireOwnerRequest(req, res, deps.options))
         return;
-    }
-    if (!deps.softwareAgent) {
-        res.writeHead(503, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
+    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
+    if (!softwareAgent)
         return;
-    }
     try {
-        await deps.softwareAgent.resetSession();
-        res.writeHead(200, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ ok: true, state: deps.softwareAgent.getState() }, null, 2));
+        await softwareAgent.resetSession();
+        writeJsonResponse(res, 200, { ok: true, state: softwareAgent.getState() }, true);
     }
     catch (err) {
-        res.writeHead(500, { "Content-Type": "application/json" })
-            .end(JSON.stringify({ error: err.message || String(err) }));
+        writeJsonResponse(res, 500, { error: err.message || String(err) });
     }
 }
 import { RelayPeripheral } from "./relay-peripheral.js";
@@ -205,9 +347,11 @@ import { LongTermModule } from "./longterm-module.js";
 import { ReflectionModule } from "./reflection-module.js";
 import { ScriptModule } from "./script-module.js";
 import { FileEventLog, PersistentEventBus } from "./event-bus.js";
-import { CodexSoftwareAgentPeripheral, createOwnerTaskEnvelope } from "./software-agent-peripheral.js";
+import { CodexSoftwareAgentPeripheral, createOwnerTaskEnvelope, listSoftwareAgentTaskRecords, readSoftwareAgentTaskRecord, } from "./software-agent-peripheral.js";
+import { buildSoftwareAgentMemorySummary } from "./software-agent-memory.js";
 import { SIG, sig } from "./types.js";
 import { loadConversation, listConversations, buildLLMContext } from "./context.js";
+import { redactSecrets } from "./redaction.js";
 import { createMcpServer, initMcpProxy, createMcpProxyServer } from "./mcp-server.js";
 import { autoRoute, runCollaborativeQuery } from "./agent-utils.js";
 // createMcpServer, initMcpProxy, createMcpProxyServer → see mcp-server.ts
@@ -216,11 +360,11 @@ const LLM_ENGINES = LLM_ENGINES_SET;
 // Engine execution — delegates to EnginePeripheral (V2 Step 3)
 // ---------------------------------------------------------------------------
 /** Unified engine runner — delegates to EnginePeripheral */
-function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay, signal, origin, routing, taskId) {
+function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay, signal, origin, routing, taskId, routeRequest) {
     if (!_engineP) {
         throw new Error("Engine peripheral not initialized");
     }
-    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId);
+    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId, routeRequest);
     // Sync trace back to module-level for reporting
     result.then(() => { lastEngineTrace = _engineP.lastTrace; }).catch(() => { lastEngineTrace = _engineP.lastTrace; });
     return result;
@@ -288,10 +432,20 @@ export async function serve(options) {
         if (!isQuiet)
             console.log(`[http] ${req.method} ${req.url} session=${req.headers["mcp-session-id"] || "none"}`);
         try {
+            if (req.url === "/self/software-agent/run-stream" && req.method === "POST") {
+                await handleSoftwareAgentRunStreamHttp(req, res, {
+                    options,
+                    workdir,
+                    agentName: options.agentName,
+                    softwareAgent: codexSoftwareAgent,
+                });
+                return;
+            }
             if (req.url === "/self/software-agent/run" && req.method === "POST") {
                 await handleSoftwareAgentRunHttp(req, res, {
                     options,
                     workdir,
+                    agentName: options.agentName,
                     softwareAgent: codexSoftwareAgent,
                 });
                 return;
@@ -303,6 +457,16 @@ export async function serve(options) {
                 });
                 return;
             }
+            const requestPath = req.url?.split("?")[0] || "";
+            if (req.method === "GET"
+                && (requestPath === "/self/software-agent/tasks" || requestPath.startsWith("/self/software-agent/tasks/"))) {
+                await handleSoftwareAgentTasksHttp(req, res, {
+                    options,
+                    workdir,
+                    agentName: options.agentName,
+                });
+                return;
+            }
             if (req.url === "/self/software-agent/reset" && req.method === "POST") {
                 await handleSoftwareAgentResetHttp(req, res, {
                     options,
@@ -498,10 +662,16 @@ export async function serve(options) {
         workdir,
         model: process.env.AKEMON_CODEX_MODEL,
         sandbox: "workspace-write",
+        taskLedgerDir: softwareAgentTaskLedgerDir(workdir, options.agentName),
+        contextSessionDir: softwareAgentContextSessionDir(workdir, options.agentName),
+        envPolicy: options.softwareAgentEnvPolicy,
+        envAllowlist: options.softwareAgentEnvAllowlist,
     });
-    await codexSoftwareAgent.start(bus);
     // Peripheral registry — Core routes by capability
     const peripherals = [relay, engineP, codexSoftwareAgent];
+    for (const peripheral of peripherals) {
+        await peripheral.start(bus);
+    }
     // requestCompute: acquire the engine slot (priority-aware), execute with a
     // hard timeout, and release. The slot release and subprocess kill are both
     // driven by the same AbortController so a stuck engine can't hold the lock.
@@ -533,7 +703,7 @@ export async function serve(options) {
         const abortController = new AbortController();
         const timer = setTimeout(() => abortController.abort(), ENGINE_EXEC_TIMEOUT_MS);
         try {
-            const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal, req.origin, routing, req.taskId);
+            const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal, req.origin, routing, req.taskId, req.engineHints);
             emitTokenUsage(prompt.length, response.length);
             return { success: true, response };
         }

package/dist/software-agent-memory.js

@@ -0,0 +1,139 @@
+import { buildLLMContext, loadConversation } from "./context.js";
+import { buildRoleContext, loadRoles, resolveRoles } from "./role-module.js";
+const DEFAULT_CONTEXT_BUDGET = 6000;
+const OWNER_MEMORY_EXCLUDE_TERMS = [
+    "owner",
+    "private",
+    "personal",
+    "note",
+    "diary",
+    "bio",
+];
+export async function buildSoftwareAgentMemorySummary(opts) {
+    const budget = opts.contextBudget ?? DEFAULT_CONTEXT_BUDGET;
+    const parts = [
+        "[Akemon memory boundary]",
+        `Role scope: ${opts.envelope.roleScope}`,
+        `Memory scope: ${opts.envelope.memoryScope}`,
+        boundaryDescription(opts.envelope.roleScope, opts.envelope.memoryScope),
+    ];
+    if (opts.envelope.memoryScope === "none") {
+        parts.push("No Akemon memory/context is included for this task.");
+        return parts.join("\n");
+    }
+    const request = normalizeRequest(opts.request);
+    const roleTrigger = readRequestString(request, "roleTrigger") || triggerForRoleScope(opts.envelope.roleScope);
+    const productName = readRequestString(request, "productName");
+    const productId = readRequestString(request, "productId");
+    const rolePolicy = await resolveRoleMemoryPolicy(opts.workdir, opts.agentName, roleTrigger);
+    if (rolePolicy.exclude.length) {
+        parts.push(`Active role exclusions: ${rolePolicy.exclude.join(", ")}`);
+    }
+    const roleContext = await buildRoleContext(opts.workdir, opts.agentName, roleTrigger, productName, productId);
+    if (roleContext.trim()) {
+        parts.push("");
+        parts.push("[Role/product context]");
+        parts.push(limitText(roleContext.trim(), Math.floor(budget * 0.55)));
+    }
+    const taskContext = readRequestString(request, "taskContext");
+    if (taskContext) {
+        parts.push("");
+        parts.push("[Task-provided context]");
+        parts.push(limitText(taskContext, Math.floor(budget * 0.25)));
+    }
+    const conversationId = readRequestString(request, "conversationId");
+    if (conversationId && canIncludeConversation(opts.envelope.roleScope, opts.envelope.memoryScope)) {
+        const conv = await loadConversation(opts.workdir, opts.agentName, conversationId);
+        const { text } = buildLLMContext(conv, Math.floor(budget * 0.3));
+        if (text.trim()) {
+            parts.push("");
+            parts.push("[Conversation context]");
+            parts.push(text.trim());
+        }
+    }
+    else if (conversationId) {
+        parts.push("");
+        parts.push("[Excluded conversation context]");
+        parts.push("A conversationId was supplied, but conversation memory is only included for owner-scoped software-agent tasks in v1.");
+    }
+    const ownerMemory = readRequestString(request, "memorySummary");
+    if (ownerMemory && canIncludeOwnerMemory(opts.envelope.roleScope, opts.envelope.memoryScope)) {
+        if (roleExcludesOwnerMemory(rolePolicy)) {
+            parts.push("");
+            parts.push("[Role-excluded owner memory]");
+            parts.push(`The active role (${rolePolicy.roleName || "unknown"}) excludes ${rolePolicy.exclude.join(", ")}, so owner-provided memory was not included.`);
+        }
+        else {
+            parts.push("");
+            parts.push("[Owner-visible memory]");
+            parts.push(limitText(ownerMemory, Math.floor(budget * 0.35)));
+        }
+    }
+    else if (ownerMemory) {
+        parts.push("");
+        parts.push("[Excluded owner memory]");
+        parts.push("A memorySummary was supplied, but it was not included because this envelope is not owner/owner scoped.");
+    }
+    return limitText(parts.join("\n"), budget);
+}
+export function canIncludeOwnerMemory(roleScope, memoryScope) {
+    return roleScope === "owner" && memoryScope === "owner";
+}
+function canIncludeConversation(roleScope, memoryScope) {
+    return roleScope === "owner" && (memoryScope === "owner" || memoryScope === "task");
+}
+function triggerForRoleScope(roleScope) {
+    switch (roleScope) {
+        case "owner": return "trigger:chat:owner";
+        case "public": return "trigger:chat:public";
+        case "order": return "trigger:order";
+        case "agent": return "trigger:agent_call";
+        case "system": return "trigger:system";
+    }
+}
+function boundaryDescription(roleScope, memoryScope) {
+    if (roleScope === "owner" && memoryScope === "owner") {
+        return "Owner-scoped task: owner-visible memory may be included after Akemon-side selection.";
+    }
+    if (memoryScope === "none") {
+        return "No-memory task: do not use Akemon private memory, conversation history, or subjective state.";
+    }
+    return "Non-owner task: exclude owner private conversations, personal notes, bio state, diary, subjective impressions, and owner-only memory.";
+}
+async function resolveRoleMemoryPolicy(workdir, agentName, roleTrigger) {
+    const roles = await loadRoles(workdir, agentName);
+    const { primary } = resolveRoles(roles, roleTrigger);
+    return {
+        roleName: primary?.name || null,
+        exclude: primary?.exclude || [],
+    };
+}
+function roleExcludesOwnerMemory(policy) {
+    return policy.exclude.some((item) => {
+        const normalized = item.toLowerCase();
+        return OWNER_MEMORY_EXCLUDE_TERMS.some((term) => normalized.includes(term));
+    });
+}
+function normalizeRequest(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Invalid request: expected object");
+    }
+    return value;
+}
+function readRequestString(request, field) {
+    const value = request[field];
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value !== "string")
+        throw new Error(`Invalid ${field}: expected string`);
+    return value.trim();
+}
+function limitText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const head = Math.floor(maxChars * 0.45);
+    const tail = Math.max(0, maxChars - head - 40);
+    return `${text.slice(0, head)}\n[truncated ${text.length - head - tail} chars]\n${text.slice(-tail)}`;
+}