akemon 0.3.2 → 0.3.3

package/dist/cli.js

@@ -14,6 +14,39 @@ 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;
+}
+async function callLocalOwnerEndpoint(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";
+    const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+        ...init,
+        headers: {
+            ...headers,
+            ...init.headers,
+        },
+    });
+    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;
+}
 program
     .name("akemon")
     .description("Agent work marketplace — train your agent, let it work for others")
@@ -145,8 +178,6 @@ program
     .option("--deliverable <text>", "Expected output shape")
     .option("--timeout-ms <ms>", "Task timeout in milliseconds")
     .action(async (goalParts, opts) => {
-    const credentials = await getOrCreateRelayCredentials();
-    const port = parseInt(opts.port) || 3000;
     const body = {
         goal: goalParts.join(" "),
         roleScope: opts.roleScope,
@@ -167,31 +198,35 @@ program
         }
         body.timeoutMs = timeoutMs;
     }
-    const res = await fetch(`http://127.0.0.1:${port}/self/software-agent/run`, {
+    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-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

@@ -158,6 +158,41 @@ export async function handleSoftwareAgentRunHttp(req, res, deps) {
             .end(JSON.stringify({ error: err.message || String(err) }));
     }
 }
+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 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";
@@ -261,6 +296,20 @@ export async function serve(options) {
                 });
                 return;
             }
+            if (req.url === "/self/software-agent/status" && req.method === "GET") {
+                await handleSoftwareAgentStatusHttp(req, res, {
+                    options,
+                    softwareAgent: codexSoftwareAgent,
+                });
+                return;
+            }
+            if (req.url === "/self/software-agent/reset" && req.method === "POST") {
+                await handleSoftwareAgentResetHttp(req, res, {
+                    options,
+                    softwareAgent: codexSoftwareAgent,
+                });
+                return;
+            }
             // Auth check
             if (options.key) {
                 const token = bearerToken(req);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "akemon",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/lhead/akemon"
+    "url": "git+https://github.com/lhead/akemon.git"
   },
   "keywords": [
     "ai",
@@ -18,7 +18,7 @@
     "gemini"
   ],
   "bin": {
-    "akemon": "./dist/cli.js"
+    "akemon": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -26,7 +26,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc && cp src/live.html dist/live.html",
+    "build": "rm -rf dist && tsc && cp src/live.html dist/live.html",
     "dev": "tsc --watch",
     "start": "node dist/cli.js",
     "postinstall": "node scripts/fix-node-pty.cjs",

package/dist/context.test.js

@@ -1,90 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it, before, after } from "node:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-// We import the functions we need to test. appendMessage and loadConversation
-// need a workdir on disk; parseConversation is internal — tested via loadConversation.
-import { appendMessage, loadConversation } from "./context.js";
-const agentName = "test-agent";
-// ---------------------------------------------------------------------------
-// appendMessage + loadConversation round-trip
-// ---------------------------------------------------------------------------
-describe("appendMessage / loadConversation", () => {
-    let workdir = "";
-    before(async () => {
-        workdir = await mkdtemp(join(tmpdir(), "ctx-test-"));
-    });
-    after(async () => {
-        await rm(workdir, { recursive: true, force: true });
-    });
-    it("writes a chat message and reads it back with kind='chat'", async () => {
-        const convId = "test-chat";
-        await appendMessage(workdir, agentName, convId, "User", "hello", "chat");
-        const conv = await loadConversation(workdir, agentName, convId);
-        assert.equal(conv.rounds.length, 1);
-        assert.equal(conv.rounds[0].role, "user");
-        assert.equal(conv.rounds[0].content, "hello");
-        assert.equal(conv.rounds[0].kind, "chat");
-    });
-    it("writes an order message with [order] tag and reads kind='order'", async () => {
-        const convId = "test-order";
-        await appendMessage(workdir, agentName, convId, "User", "order request", "order");
-        await appendMessage(workdir, agentName, convId, "Agent", "order delivered", "order");
-        const conv = await loadConversation(workdir, agentName, convId);
-        assert.equal(conv.rounds.length, 2);
-        assert.equal(conv.rounds[0].kind, "order");
-        assert.equal(conv.rounds[0].role, "user");
-        assert.equal(conv.rounds[1].kind, "order");
-        assert.equal(conv.rounds[1].role, "agent");
-    });
-    it("defaults to kind='chat' when kind arg is omitted", async () => {
-        const convId = "test-default-kind";
-        await appendMessage(workdir, agentName, convId, "Agent", "hi there");
-        const conv = await loadConversation(workdir, agentName, convId);
-        assert.equal(conv.rounds[0].kind, "chat");
-    });
-    it("parses mixed chat + order rounds correctly", async () => {
-        const convId = "test-mixed";
-        await appendMessage(workdir, agentName, convId, "User", "chat message", "chat");
-        await appendMessage(workdir, agentName, convId, "User", "order task", "order");
-        await appendMessage(workdir, agentName, convId, "Agent", "chat reply", "chat");
-        await appendMessage(workdir, agentName, convId, "Agent", "order result", "order");
-        const conv = await loadConversation(workdir, agentName, convId);
-        assert.equal(conv.rounds.length, 4);
-        assert.equal(conv.rounds[0].kind, "chat");
-        assert.equal(conv.rounds[1].kind, "order");
-        assert.equal(conv.rounds[2].kind, "chat");
-        assert.equal(conv.rounds[3].kind, "order");
-    });
-    it("parses legacy file (no [kind] tag) as kind='chat' for backward-compat", async () => {
-        const convId = "test-legacy";
-        // Write a legacy-style file manually (no [order] tag)
-        const { mkdir, writeFile } = await import("node:fs/promises");
-        const dir = join(workdir, ".akemon", "agents", agentName, "conversations");
-        await mkdir(dir, { recursive: true });
-        const legacyContent = "## Summary\n\n\n## Recent\n[2026-04-23 10:00] User: old message\n[2026-04-23 10:01] Agent: old reply\n";
-        await writeFile(join(dir, `${convId}.md`), legacyContent);
-        const conv = await loadConversation(workdir, agentName, convId);
-        assert.equal(conv.rounds.length, 2);
-        assert.equal(conv.rounds[0].kind, "chat");
-        assert.equal(conv.rounds[1].kind, "chat");
-    });
-    it("[order] tag appears in the raw file content", async () => {
-        const convId = "test-tag-on-disk";
-        await appendMessage(workdir, agentName, convId, "User", "buy something", "order");
-        const { readFile: rf } = await import("node:fs/promises");
-        const dir = join(workdir, ".akemon", "agents", agentName, "conversations");
-        const raw = await rf(join(dir, `${convId}.md`), "utf-8");
-        assert.ok(raw.includes("[order] User: buy something"), `raw file should contain [order] tag: ${raw}`);
-    });
-    it("chat message does NOT have [order] tag in raw file", async () => {
-        const convId = "test-no-tag-on-disk";
-        await appendMessage(workdir, agentName, convId, "User", "just chatting", "chat");
-        const { readFile: rf } = await import("node:fs/promises");
-        const dir = join(workdir, ".akemon", "agents", agentName, "conversations");
-        const raw = await rf(join(dir, `${convId}.md`), "utf-8");
-        assert.ok(!raw.includes("[order]"), `chat line should NOT contain [order] tag: ${raw}`);
-        assert.ok(raw.includes("User: just chatting"));
-    });
-});