akemon 0.3.2 → 0.3.4

package/README.md

@@ -164,11 +164,16 @@ akemon serve --name my-agent --engine claude
 
 # In another terminal, ask the local software peripheral to work in the repo
 akemon software-agent "Add one focused test and run the relevant test command."
+
+# Review recent software-agent runs
+akemon software-agent-tasks --limit 5
 ```
 
 This is different from `--engine`: engines are replaceable compute, while software agents are external software bodies with their own repo context, skills, tools, and execution loop.
 
-Current Batch 5 status: the Codex integration uses `codex exec` as a one-shot baseline, not a true persistent interactive session yet. It is owner-only, local-only, one task at a time, and every call is wrapped in an explicit task envelope with workdir, memory scope, risk level, allowed actions, and forbidden actions.
+Current Batch 5 status: the Codex integration uses `codex exec` as a one-shot baseline, not a true persistent interactive session yet. It is owner-only, local-only, one task at a time, streams local stdout/stderr by default, and every call is wrapped in an explicit task envelope with workdir, memory scope, risk level, allowed actions, and forbidden actions.
+
+Software-agent tasks default to the `akemon serve` workdir boundary. Use `--allow-outside-workdir` only when you explicitly want the software agent to run outside that root. Each run is recorded under `.akemon/agents/<name>/software-agent/tasks/` with the envelope, result, output summaries, and git worktree status.
 
 ## Serve Options
 

package/dist/cli.js

@@ -14,6 +14,166 @@ const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-
 const RELAY_WS = "wss://relay.akemon.dev";
 const RELAY_HTTP = "https://relay.akemon.dev";
 const program = new Command();
+function parsePortOption(port) {
+    const value = typeof port === "number" ? port : parseInt(String(port || "3000"));
+    return Number.isInteger(value) && value > 0 ? value : 3000;
+}
+function clampPositiveInt(value, fallback, max) {
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0)
+        return fallback;
+    return Math.min(parsed, max);
+}
+function printSoftwareAgentTaskList(tasks) {
+    if (!tasks.length) {
+        console.log("No software-agent tasks found.");
+        return;
+    }
+    for (const task of tasks) {
+        const result = task.result?.success === true ? "ok" : task.result?.success === false ? "error" : "pending";
+        const duration = typeof task.durationMs === "number" ? `${task.durationMs}ms` : "-";
+        const git = task.workdirStatus?.isRepo
+            ? (task.workdirStatus.dirty ? `dirty:${task.workdirStatus.changedFiles?.length || 0}` : "clean")
+            : "no-git";
+        const goal = truncateOneLine(task.envelope?.goal || "", 90);
+        console.log(`${task.taskId}  ${task.status}/${result}  ${duration}  ${git}  ${task.updatedAt || task.startedAt}`);
+        if (goal)
+            console.log(`  ${goal}`);
+    }
+}
+function truncateOneLine(value, max) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= max)
+        return oneLine;
+    return `${oneLine.slice(0, Math.max(0, max - 3))}...`;
+}
+async function callLocalOwnerEndpoint(path, opts, init = {}) {
+    const res = await fetchLocalOwnerEndpoint(path, opts, init);
+    const text = await res.text();
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { output: text };
+    }
+    if (!res.ok || data.success === false) {
+        console.error(data.error || text || `Request failed with HTTP ${res.status}`);
+        process.exit(1);
+    }
+    return data;
+}
+async function fetchLocalOwnerEndpoint(path, opts, init = {}) {
+    const credentials = await getOrCreateRelayCredentials();
+    const port = parsePortOption(opts.port);
+    const headers = {
+        Authorization: `Bearer ${credentials.secretKey}`,
+    };
+    if (init.body !== undefined)
+        headers["Content-Type"] = "application/json";
+    let res;
+    try {
+        res = await fetch(`http://127.0.0.1:${port}${path}`, {
+            ...init,
+            headers: {
+                ...headers,
+                ...init.headers,
+            },
+        });
+    }
+    catch (error) {
+        const cause = error.cause;
+        if (error instanceof TypeError && error.message === "fetch failed" && cause?.message === "bad port") {
+            console.error(`Port ${port} cannot be used for the local akemon serve connection. Choose a different --port.`);
+            process.exit(1);
+        }
+        if (error instanceof TypeError && error.message === "fetch failed") {
+            console.error(`Cannot connect to local akemon serve on port ${port}. Start it with: akemon serve --port ${port}`);
+            process.exit(1);
+        }
+        throw error;
+    }
+    return res;
+}
+async function streamLocalOwnerEndpoint(path, opts, body) {
+    const res = await fetchLocalOwnerEndpoint(path, opts, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        let data;
+        try {
+            data = text ? JSON.parse(text) : {};
+        }
+        catch {
+            data = { error: text };
+        }
+        console.error(data.error || text || `Request failed with HTTP ${res.status}`);
+        process.exit(1);
+    }
+    if (!res.body)
+        return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let failed = false;
+    const reader = res.body.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            if (handleSoftwareAgentStreamLine(line))
+                failed = true;
+        }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim() && handleSoftwareAgentStreamLine(buffer))
+        failed = true;
+    if (failed)
+        process.exit(1);
+}
+function handleSoftwareAgentStreamLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    let event;
+    try {
+        event = JSON.parse(trimmed);
+    }
+    catch {
+        process.stderr.write(`${trimmed}\n`);
+        return true;
+    }
+    if (event.type === "start" && event.taskId) {
+        process.stderr.write(`[software-agent] started ${event.taskId}\n`);
+        return false;
+    }
+    if (event.type === "stdout" && typeof event.chunk === "string") {
+        process.stdout.write(event.chunk);
+        return false;
+    }
+    if (event.type === "stderr" && typeof event.chunk === "string") {
+        process.stderr.write(event.chunk);
+        return false;
+    }
+    if (event.type === "end") {
+        const result = event.result;
+        if (result?.success === false && result.error) {
+            process.stderr.write(`${result.error}\n`);
+            return true;
+        }
+        return false;
+    }
+    if (event.type === "error") {
+        process.stderr.write(`${event.error || "Software-agent stream failed"}\n`);
+        return true;
+    }
+    return false;
+}
 program
     .name("akemon")
     .description("Agent work marketplace — train your agent, let it work for others")
@@ -138,15 +298,15 @@ program
     .argument("<goal...>", "Task goal to send to the software agent")
     .option("-p, --port <port>", "Local akemon serve port", "3000")
     .option("-w, --workdir <path>", "Workdir for the software agent (default: serve workdir)")
+    .option("--allow-outside-workdir", "Allow the software agent workdir to be outside the serve workdir")
     .option("--role-scope <scope>", "Role scope: owner|public|order|agent|system", "owner")
     .option("--memory-scope <scope>", "Memory scope: none|public|task|owner", "owner")
     .option("--risk <level>", "Risk level: low|medium|high", "medium")
     .option("--memory-summary <text>", "Pre-filtered memory/context text to include")
     .option("--deliverable <text>", "Expected output shape")
     .option("--timeout-ms <ms>", "Task timeout in milliseconds")
+    .option("--no-stream", "Disable local streaming and wait for the final response")
     .action(async (goalParts, opts) => {
-    const credentials = await getOrCreateRelayCredentials();
-    const port = parseInt(opts.port) || 3000;
     const body = {
         goal: goalParts.join(" "),
         roleScope: opts.roleScope,
@@ -155,6 +315,8 @@ program
     };
     if (opts.workdir)
         body.workdir = opts.workdir;
+    if (opts.allowOutsideWorkdir)
+        body.allowOutsideWorkdir = true;
     if (opts.memorySummary)
         body.memorySummary = opts.memorySummary;
     if (opts.deliverable)
@@ -167,31 +329,59 @@ program
         }
         body.timeoutMs = timeoutMs;
     }
-    const res = await fetch(`http://127.0.0.1:${port}/self/software-agent/run`, {
+    if (opts.stream !== false) {
+        await streamLocalOwnerEndpoint("/self/software-agent/run-stream", opts, body);
+        return;
+    }
+    const data = await callLocalOwnerEndpoint("/self/software-agent/run", opts, {
         method: "POST",
-        headers: {
-            Authorization: `Bearer ${credentials.secretKey}`,
-            "Content-Type": "application/json",
-        },
         body: JSON.stringify(body),
     });
-    const text = await res.text();
-    let data;
-    try {
-        data = text ? JSON.parse(text) : {};
-    }
-    catch {
-        data = { output: text };
-    }
-    if (!res.ok || data.success === false) {
-        console.error(data.error || text || `Request failed with HTTP ${res.status}`);
-        process.exit(1);
-    }
     if (data.output)
         console.log(data.output);
     else
         console.log(JSON.stringify(data, null, 2));
 });
+program
+    .command("software-agent-status")
+    .description("Show the owner-only local software-agent peripheral state")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .action(async (opts) => {
+    const data = await callLocalOwnerEndpoint("/self/software-agent/status", opts, {
+        method: "GET",
+    });
+    console.log(JSON.stringify(data, null, 2));
+});
+program
+    .command("software-agent-tasks")
+    .description("List recent owner-only software-agent task ledger records")
+    .argument("[taskId]", "Task id to inspect")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .option("-l, --limit <n>", "Maximum recent tasks to list", "20")
+    .option("--json", "Print raw JSON")
+    .action(async (taskId, opts) => {
+    const path = taskId
+        ? `/self/software-agent/tasks/${encodeURIComponent(taskId)}`
+        : `/self/software-agent/tasks?limit=${clampPositiveInt(opts.limit, 20, 100)}`;
+    const data = await callLocalOwnerEndpoint(path, opts, {
+        method: "GET",
+    });
+    if (opts.json || taskId) {
+        console.log(JSON.stringify(taskId ? data.task : data, null, 2));
+        return;
+    }
+    printSoftwareAgentTaskList(Array.isArray(data.tasks) ? data.tasks : []);
+});
+program
+    .command("software-agent-reset")
+    .description("Reset the owner-only local software-agent peripheral session")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .action(async (opts) => {
+    const data = await callLocalOwnerEndpoint("/self/software-agent/reset", opts, {
+        method: "POST",
+    });
+    console.log(JSON.stringify(data, null, 2));
+});
 program
     .command("dashboard")
     .description("Open your agent dashboard in the browser")

package/dist/server.js

@@ -141,6 +141,12 @@ export async function handleSoftwareAgentRunHttp(req, res, deps) {
     let envelope;
     try {
         envelope = createOwnerTaskEnvelope(body, deps.workdir);
+        envelope.memorySummary = await buildSoftwareAgentMemorySummary({
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+            envelope,
+            request: body,
+        });
     }
     catch (err) {
         res.writeHead(400, { "Content-Type": "application/json" })
@@ -158,6 +164,196 @@ export async function handleSoftwareAgentRunHttp(req, res, deps) {
             .end(JSON.stringify({ error: err.message || String(err) }));
     }
 }
+export async function handleSoftwareAgentRunStreamHttp(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;
+    }
+    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;
+    }
+    let envelope;
+    try {
+        envelope = createOwnerTaskEnvelope(body, deps.workdir);
+        envelope.memorySummary = await buildSoftwareAgentMemorySummary({
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+            envelope,
+            request: body,
+        });
+    }
+    catch (err) {
+        res.writeHead(400, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: err.message || "Invalid software-agent 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 deps.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,
+                        result: event.result,
+                    });
+                },
+            },
+        });
+    }
+    catch (err) {
+        if (!streamStarted) {
+            const busy = String(err.message || "").includes("busy");
+            res.writeHead(busy ? 409 : 500, { "Content-Type": "application/json" })
+                .end(JSON.stringify({ 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" }));
+        return;
+    }
+    if (!deps.softwareAgent) {
+        res.writeHead(503, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
+        return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" })
+        .end(JSON.stringify(deps.softwareAgent.getState(), null, 2));
+}
+export async function handleSoftwareAgentTasksHttp(req, res, deps) {
+    if (!isOwnerRequest(req, deps.options)) {
+        res.writeHead(401, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Owner token required" }));
+        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);
+        res.writeHead(200, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ tasks }, null, 2));
+        return;
+    }
+    if (url.pathname.startsWith(`${basePath}/`)) {
+        const taskId = decodeURIComponent(url.pathname.slice(basePath.length + 1));
+        if (!taskId || taskId.includes("/")) {
+            res.writeHead(400, { "Content-Type": "application/json" })
+                .end(JSON.stringify({ error: "Invalid software-agent task id" }));
+            return;
+        }
+        const task = readSoftwareAgentTaskRecord(taskLedgerDir, taskId);
+        if (!task) {
+            res.writeHead(404, { "Content-Type": "application/json" })
+                .end(JSON.stringify({ error: "Software-agent task not found" }));
+            return;
+        }
+        res.writeHead(200, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ task }, null, 2));
+        return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" })
+        .end(JSON.stringify({ error: "Software-agent task endpoint not found" }));
+}
+function softwareAgentTaskLedgerDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "software-agent", "tasks");
+}
+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(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" }));
+        return;
+    }
+    if (!deps.softwareAgent) {
+        res.writeHead(503, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
+        return;
+    }
+    try {
+        await deps.softwareAgent.resetSession();
+        res.writeHead(200, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ ok: true, state: deps.softwareAgent.getState() }, null, 2));
+    }
+    catch (err) {
+        res.writeHead(500, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: err.message || String(err) }));
+    }
+}
 import { RelayPeripheral } from "./relay-peripheral.js";
 import { EnginePeripheral, LLM_ENGINES as LLM_ENGINES_SET } from "./engine-peripheral.js";
 import { EngineQueue } from "./engine-queue.js";
@@ -170,7 +366,8 @@ 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 { createMcpServer, initMcpProxy, createMcpProxyServer } from "./mcp-server.js";
@@ -253,10 +450,44 @@ 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;
+            }
+            if (req.url === "/self/software-agent/status" && req.method === "GET") {
+                await handleSoftwareAgentStatusHttp(req, res, {
+                    options,
+                    softwareAgent: codexSoftwareAgent,
+                });
+                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,
                     softwareAgent: codexSoftwareAgent,
                 });
                 return;
@@ -449,10 +680,13 @@ export async function serve(options) {
         workdir,
         model: process.env.AKEMON_CODEX_MODEL,
         sandbox: "workspace-write",
+        taskLedgerDir: softwareAgentTaskLedgerDir(workdir, options.agentName),
     });
-    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.