akemon 0.3.5 → 0.3.7

package/dist/interactive-session.js

@@ -0,0 +1,361 @@
+import { WorkbenchSessionManager, normalizeWorkbenchInputMode, normalizeWorkbenchResizeRequest, normalizeWorkbenchStartRequest, } from "./workbench-session.js";
+import { sig } from "./types.js";
+export const INTERACTIVE_SESSION_REQUEST = "interactive-session:request";
+export const INTERACTIVE_SESSION_RESPONSE = "interactive-session:response";
+const DEFAULT_SEND_INPUT_WAIT_MS = 600;
+const MAX_SEND_INPUT_WAIT_MS = 10_000;
+const OUTPUT_POLL_INTERVAL_MS = 100;
+export class InteractiveSessionManager extends WorkbenchSessionManager {
+}
+export class InteractiveSessionPeripheral {
+    id = "interactive-session:local";
+    name = "Local Interactive Sessions";
+    capabilities = [
+        "interactive-session",
+        "list_sessions",
+        "inspect_session",
+        "start_session",
+        "send_input",
+        "set_input_mode",
+        "stop_session",
+        "resize_session",
+        "capture_output",
+    ];
+    tags = ["interactive-session", "terminal", "local"];
+    manager;
+    bus = null;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    async start(bus) {
+        this.bus = bus;
+    }
+    async stop() {
+        this.bus = null;
+    }
+    async send(signal) {
+        if (signal.type !== INTERACTIVE_SESSION_REQUEST)
+            return null;
+        const action = normalizeInteractiveSessionAction(signal.data);
+        const observation = await this.execute(action);
+        return sig(INTERACTIVE_SESSION_RESPONSE, observation, this.id);
+    }
+    async explore() {
+        const sessions = this.manager.listSessions();
+        if (!sessions.length)
+            return "No interactive sessions are currently tracked.";
+        return sessions.map((session) => [
+            `${session.sessionId}: ${session.tool} ${session.status}`,
+            `command: ${session.commandLineDisplay}`,
+            `workdir: ${session.workdir}`,
+            `updated: ${session.updatedAt}`,
+        ].join("\n")).join("\n\n");
+    }
+    async execute(action) {
+        return executeInteractiveSessionAction(this.manager, action);
+    }
+}
+export async function executeInteractiveSessionAction(manager, action) {
+    try {
+        switch (action.capability) {
+            case "list_sessions": {
+                const sessions = manager.listSessions();
+                return interactiveSessionObservation(action, true, narrateInteractiveSessions(sessions), {
+                    sessions: sessions.map(interactiveSessionObservationData),
+                });
+            }
+            case "inspect_session": {
+                const sessionId = resolveInteractiveSessionId(manager, stringArg(action.args, "sessionId"));
+                return inspectInteractiveSessionObservation(manager.getSession(sessionId), sessionId, action.reason);
+            }
+            case "start_session": {
+                const session = await manager.startSession(normalizeWorkbenchStartRequest(action.args || {}));
+                return interactiveSessionObservation(action, true, narrateInteractiveSessionAction("started", session), {
+                    session: interactiveSessionObservationData(session),
+                });
+            }
+            case "send_input": {
+                const sessionId = resolveInteractiveSessionId(manager, stringArg(action.args, "sessionId"), { runningOnly: true });
+                const before = manager.getSession(sessionId)?.tail || "";
+                const ownerInput = stringArg(action.args, "input");
+                const session = manager.writeInput(sessionId, {
+                    input: withSubmitInput(ownerInput),
+                });
+                const waitMs = normalizeSendInputWaitMs(action.args?.waitMs);
+                const latestSession = await waitForInteractiveSessionOutput(manager, sessionId, before, session, waitMs);
+                const output = tailDelta(before, latestSession.tail);
+                return interactiveSessionObservation(action, true, narrateInteractiveSessionInputSent(latestSession, ownerInput, output, waitMs), {
+                    session: interactiveSessionObservationData(latestSession),
+                    input: ownerInput,
+                    waitMs,
+                    newOutput: outputPreviewText(output),
+                });
+            }
+            case "set_input_mode": {
+                const sessionId = resolveInteractiveSessionId(manager, stringArg(action.args, "sessionId"));
+                const session = manager.setInputMode(sessionId, normalizeWorkbenchInputMode(stringArg(action.args, "inputMode")));
+                return interactiveSessionObservation(action, true, narrateInteractiveSessionInputModeChanged(session), {
+                    session: interactiveSessionObservationData(session),
+                });
+            }
+            case "stop_session": {
+                const sessionId = resolveInteractiveSessionId(manager, stringArg(action.args, "sessionId"), { runningOnly: true });
+                const session = manager.stopSession(sessionId);
+                return interactiveSessionObservation(action, true, narrateInteractiveSessionAction("stopped", session), {
+                    session: interactiveSessionObservationData(session),
+                });
+            }
+            case "resize_session": {
+                const sessionId = resolveInteractiveSessionId(manager, stringArg(action.args, "sessionId"), { runningOnly: true });
+                const session = manager.resizeSession(sessionId, normalizeWorkbenchResizeRequest(action.args || {}));
+                return interactiveSessionObservation(action, true, narrateInteractiveSessionResize(session), {
+                    session: interactiveSessionObservationData(session),
+                });
+            }
+            case "capture_output": {
+                const sessionId = resolveInteractiveSessionId(manager, stringArg(action.args, "sessionId"));
+                const session = manager.getSession(sessionId);
+                return interactiveSessionObservation(action, !!session, narrateInteractiveSessionInspection(session, sessionId), {
+                    ...(session ? { session: interactiveSessionObservationData(session), output: session.tail } : {}),
+                }, session ? undefined : `Interactive session ${sessionId} was not found.`);
+            }
+        }
+    }
+    catch (error) {
+        return interactiveSessionObservation(action, false, `I could not complete this interactive session action: ${error?.message || String(error)}`, undefined, error?.message || String(error));
+    }
+}
+function normalizeInteractiveSessionAction(data) {
+    const capability = typeof data.capability === "string" ? data.capability : "";
+    if (!isInteractiveSessionCapability(capability)) {
+        throw new Error("Invalid interactive session capability");
+    }
+    const args = data.args && typeof data.args === "object" && !Array.isArray(data.args)
+        ? data.args
+        : {};
+    const reason = typeof data.reason === "string" && data.reason.trim() ? data.reason.trim() : undefined;
+    return { capability, args, reason };
+}
+function isInteractiveSessionCapability(value) {
+    return value === "list_sessions"
+        || value === "inspect_session"
+        || value === "start_session"
+        || value === "send_input"
+        || value === "set_input_mode"
+        || value === "stop_session"
+        || value === "resize_session"
+        || value === "capture_output";
+}
+function interactiveSessionObservation(action, ok, summary, data, error) {
+    return {
+        kind: "peripheral_observation",
+        peripheral: "interactive-session",
+        capability: action.capability,
+        ok,
+        reason: action.reason,
+        summary,
+        ...(data ? { data } : {}),
+        ...(error ? { error } : {}),
+    };
+}
+function stringArg(args, key) {
+    const value = args?.[key];
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`Missing required string field: ${key}`);
+    }
+    return value;
+}
+function withSubmitInput(input) {
+    return input.endsWith("\r") || input.endsWith("\n") ? input : `${input}\r`;
+}
+function normalizeSendInputWaitMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return DEFAULT_SEND_INPUT_WAIT_MS;
+    return Math.max(0, Math.min(Math.round(value), MAX_SEND_INPUT_WAIT_MS));
+}
+function resolveInteractiveSessionId(manager, value, options) {
+    const normalized = value.trim().toLowerCase();
+    const byStartedAt = normalized === "latest" || normalized === "last";
+    const byActive = normalized === "active" || normalized === "current";
+    const byUpdatedAt = normalized === "recent" || byActive;
+    if (!byStartedAt && !byUpdatedAt)
+        return value;
+    if (byActive) {
+        const active = manager.getActiveSession();
+        if (active) {
+            if (options?.runningOnly === true && active.status !== "running") {
+                throw new Error(`Active Workbench session ${active.sessionId} is not running`);
+            }
+            return active.sessionId;
+        }
+    }
+    const sessions = manager.listSessions()
+        .filter((session) => options?.runningOnly !== true || session.status === "running")
+        .sort((left, right) => {
+        if (byStartedAt) {
+            const byStart = right.startedAt.localeCompare(left.startedAt);
+            return byStart || right.updatedAt.localeCompare(left.updatedAt);
+        }
+        const byUpdate = right.updatedAt.localeCompare(left.updatedAt);
+        return byUpdate || right.startedAt.localeCompare(left.startedAt);
+    });
+    const session = sessions[0];
+    if (!session) {
+        throw new Error(options?.runningOnly === true
+            ? `No running Workbench session is available for ${value}`
+            : `No Workbench session is available for ${value}`);
+    }
+    return session.sessionId;
+}
+async function waitForInteractiveSessionOutput(manager, sessionId, beforeTail, initialSession, waitMs) {
+    if (waitMs <= 0)
+        return manager.getSession(sessionId) || initialSession;
+    const deadline = Date.now() + waitMs;
+    let latestSession = manager.getSession(sessionId) || initialSession;
+    while (Date.now() < deadline) {
+        latestSession = manager.getSession(sessionId) || latestSession;
+        if (tailDelta(beforeTail, latestSession.tail) || latestSession.status !== "running") {
+            return latestSession;
+        }
+        await delay(Math.min(OUTPUT_POLL_INTERVAL_MS, Math.max(1, deadline - Date.now())));
+    }
+    return manager.getSession(sessionId) || latestSession;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function tailDelta(before, after) {
+    if (!after || after === before)
+        return "";
+    if (after.startsWith(before))
+        return after.slice(before.length).trim();
+    return after.trim();
+}
+function narrateInteractiveSessions(sessions) {
+    if (!sessions.length) {
+        return "There are no Workbench sessions right now. You can ask me to start Codex, Claude, a shell, or a custom command.";
+    }
+    const running = sessions.filter((session) => session.status === "running").length;
+    const lines = [
+        `I see ${sessions.length} Workbench session(s). ${running} are still running.`,
+        "",
+    ];
+    for (const session of sessions) {
+        lines.push(`- ${session.sessionId}: ${session.tool}, status ${session.status}, input ${session.inputMode}, command ${session.commandLineDisplay}.`);
+    }
+    return lines.join("\n");
+}
+function inspectInteractiveSessionObservation(session, sessionId, reason) {
+    return {
+        kind: "peripheral_observation",
+        peripheral: "interactive-session",
+        capability: "inspect_session",
+        ok: session !== null,
+        reason,
+        summary: narrateInteractiveSessionInspection(session, sessionId),
+        ...(session ? { data: { session: interactiveSessionObservationData(session) } } : {}),
+        ...(!session ? { error: `Interactive session ${sessionId} was not found.` } : {}),
+    };
+}
+function interactiveSessionObservationData(session) {
+    return {
+        sessionId: session.sessionId,
+        tool: session.tool,
+        status: session.status,
+        command: session.commandLineDisplay,
+        inputMode: session.inputMode,
+        workdir: session.workdir,
+        cols: session.cols,
+        rows: session.rows,
+        logPath: session.logPath,
+        outputChars: session.outputChars,
+        tail: outputPreviewText(session.tail),
+        startedAt: session.startedAt,
+        updatedAt: session.updatedAt,
+        endedAt: session.endedAt,
+        exitCode: session.exitCode,
+        error: session.error,
+    };
+}
+function narrateInteractiveSessionInspection(session, sessionId) {
+    if (!session) {
+        return `I could not find Workbench session ${sessionId}.`;
+    }
+    const lines = [
+        `Session ${session.sessionId} is ${session.status}.`,
+        `Tool: ${session.tool}.`,
+        `Command: ${session.commandLineDisplay}.`,
+        `Input mode: ${session.inputMode}.`,
+        `Workdir: ${session.workdir}.`,
+        `Log: ${session.logPath}.`,
+    ];
+    const outputPreview = outputPreviewText(session.tail);
+    if (outputPreview) {
+        lines.push("", "Recent output:", outputPreview);
+    }
+    else {
+        lines.push("", "I do not see output in this session yet.");
+    }
+    return lines.join("\n");
+}
+function narrateInteractiveSessionAction(action, session) {
+    if (action === "started") {
+        return [
+            `I started a ${session.tool} session: ${session.sessionId}.`,
+            `Command: ${session.commandLineDisplay}.`,
+            `Input mode: ${session.inputMode}.`,
+            `Workdir: ${session.workdir}.`,
+            "You can ask me to send text to it, or take over directly in the terminal.",
+        ].join("\n");
+    }
+    return [
+        `I stopped session ${session.sessionId}.`,
+        `It was running ${session.tool}; final status is ${session.status}.`,
+        `Session log: ${session.logPath}.`,
+    ].join("\n");
+}
+function narrateInteractiveSessionInputModeChanged(session) {
+    return [
+        `I set session ${session.sessionId} input mode to ${session.inputMode}.`,
+        session.inputMode === "tui"
+            ? "This uses bracketed paste plus a delayed Enter for interactive TUIs such as Codex or Cursor running inside a shell."
+            : "This writes input as normal line-oriented terminal input.",
+    ].join("\n");
+}
+function narrateInteractiveSessionInputSent(session, input, output = "", waitMs = DEFAULT_SEND_INPUT_WAIT_MS) {
+    const trimmed = input.replace(/\s+$/g, "");
+    const preview = trimmed.length > 120 ? `${trimmed.slice(0, 117)}...` : trimmed;
+    const lines = [
+        `I sent that input to session ${session.sessionId}.`,
+        preview ? `Content: ${preview}` : "Content: an empty Enter key.",
+        `Input mode was ${session.inputMode}.`,
+        `Session status is ${session.status}.`,
+    ];
+    const outputPreview = outputPreviewText(output);
+    if (outputPreview) {
+        lines.push("", "Recent output:", outputPreview);
+    }
+    else {
+        const waited = waitMs > DEFAULT_SEND_INPUT_WAIT_MS
+            ? ` I waited about ${formatWaitSeconds(waitMs)}.`
+            : "";
+        lines.push("", `I do not see new output from the session yet.${waited}`);
+    }
+    return lines.join("\n");
+}
+function formatWaitSeconds(waitMs) {
+    const seconds = Math.round(waitMs / 100) / 10;
+    return `${seconds}s`;
+}
+function outputPreviewText(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return "";
+    return trimmed.length > 2000 ? `${trimmed.slice(-2000)}` : trimmed;
+}
+function narrateInteractiveSessionResize(session) {
+    return [
+        `I synced session ${session.sessionId} to ${session.cols} columns and ${session.rows} rows.`,
+        `Session status is ${session.status}.`,
+    ].join("\n");
+}

package/dist/local-interconnect.js

@@ -0,0 +1,156 @@
+import http from "http";
+import { mkdir, appendFile } from "fs/promises";
+import { join } from "path";
+import { agentContactsDir, cleanAgentName } from "./akemon-home.js";
+import { actorRef, createAkemonMessage, isAkemonMessageEnvelope, textFromAkemonMessage, } from "./akemon-message.js";
+export function createLocalAkemonMessage(input) {
+    const sourceAgent = cleanAgentName(input.sourceAgent);
+    const targetAgent = cleanAgentName(input.targetAgent);
+    return createAkemonMessage({
+        type: "akemon.message",
+        source: actorRef("agent", sourceAgent, "local"),
+        target: actorRef("agent", targetAgent, "local"),
+        conversationId: input.conversationId,
+        memoryScope: input.memoryScope || "task",
+        permissions: {
+            ...(input.requiresOwnerApproval ? { requiresOwnerApproval: true } : {}),
+        },
+        transport: "local",
+        payload: {
+            text: input.text,
+            format: "text",
+            kind: "chat",
+        },
+    });
+}
+export function requireLocalAkemonMessageEnvelope(value) {
+    const candidate = (value && typeof value === "object" && "message" in value)
+        ? value.message
+        : value;
+    if (!isAkemonMessageEnvelope(candidate)) {
+        throw new Error("Invalid Akemon message envelope");
+    }
+    return candidate;
+}
+export function buildLocalAkemonMessageTask(message) {
+    const text = textFromAkemonMessage(message);
+    return [
+        "[Akemon local message]",
+        `Message id: ${message.id}`,
+        `From: ${message.source.kind}:${message.source.id}`,
+        `To: ${message.target.kind}:${message.target.id}`,
+        `Memory scope: ${message.memoryScope}`,
+        `Owner approval requested: ${message.permissions.requiresOwnerApproval === true ? "yes" : "no"}`,
+        "",
+        text,
+    ].join("\n");
+}
+export function createLocalAkemonResponseMessage(input) {
+    return createAkemonMessage({
+        type: "akemon.message",
+        source: actorRef("agent", cleanAgentName(input.responderAgent), "local"),
+        target: input.request.source,
+        conversationId: input.request.conversationId,
+        memoryScope: "public",
+        transport: "local",
+        metadata: { inReplyTo: input.request.id },
+        payload: {
+            text: input.result,
+            format: "text",
+            kind: "chat",
+        },
+    });
+}
+export async function appendLocalPeerContact(record) {
+    const ownerAgent = cleanAgentName(record.ownerAgent);
+    const peerAgent = cleanAgentName(record.peerAgent);
+    const dir = agentContactsDir(ownerAgent);
+    await mkdir(dir, { recursive: true });
+    const normalized = {
+        schemaVersion: 1,
+        ts: record.ts,
+        ownerAgent,
+        peerAgent,
+        direction: record.direction,
+        messageId: record.messageId,
+        ...(record.conversationId ? { conversationId: record.conversationId } : {}),
+    };
+    await appendFile(join(dir, "local-peers.jsonl"), `${JSON.stringify(normalized)}\n`, "utf-8");
+}
+export async function submitLocalAkemonMessageToMcp(input) {
+    const initBody = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-03-26",
+            capabilities: {},
+            clientInfo: { name: "akemon-local-message", version: "1.0" },
+        },
+    });
+    const doRequest = (body, sessionId) => {
+        return new Promise((resolve, reject) => {
+            const headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+                "Content-Length": String(Buffer.byteLength(body)),
+                "x-publisher-id": input.message.source.id,
+            };
+            if (sessionId)
+                headers["mcp-session-id"] = sessionId;
+            const req = http.request({
+                hostname: "127.0.0.1",
+                port: input.localPort,
+                path: "/mcp",
+                method: "POST",
+                headers,
+            }, (res) => {
+                const chunks = [];
+                res.on("data", (chunk) => chunks.push(chunk));
+                res.on("end", () => {
+                    const sid = res.headers["mcp-session-id"];
+                    resolve({ data: Buffer.concat(chunks).toString(), sessionId: sid || sessionId });
+                });
+            });
+            req.on("error", reject);
+            req.write(body);
+            req.end();
+        });
+    };
+    const initialized = await doRequest(initBody);
+    const task = buildLocalAkemonMessageTask(input.message);
+    const callBody = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: {
+            name: "submit_task",
+            arguments: {
+                task,
+                require_human: input.message.permissions.requiresOwnerApproval === true,
+            },
+        },
+    });
+    const { data } = await doRequest(callBody, initialized.sessionId);
+    return extractMcpTextResponse(data);
+}
+export function extractMcpTextResponse(data) {
+    let result = data;
+    try {
+        const lines = data.split("\n");
+        let lastData = "";
+        for (const line of lines) {
+            if (line.startsWith("data: "))
+                lastData = line.slice(6);
+        }
+        const parsed = JSON.parse(lastData || data);
+        const content = parsed?.result?.content;
+        if (Array.isArray(content)) {
+            result = content.map((item) => item?.text || "").join("\n");
+        }
+    }
+    catch {
+        // use raw response
+    }
+    return result;
+}

package/dist/local-registry.js

@@ -0,0 +1,178 @@
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { akemonHome, cleanAgentName } from "./akemon-home.js";
+import { isProcessAlive } from "./runtime-platform.js";
+export class LocalInstanceLookupError extends Error {
+    code;
+    candidates;
+    constructor(code, message, candidates = []) {
+        super(message);
+        this.code = code;
+        this.candidates = candidates;
+        this.name = "LocalInstanceLookupError";
+    }
+}
+export function localInstanceRegistryPath() {
+    return join(akemonHome(), "runtime", "instances.json");
+}
+export async function registerLocalInstance(input) {
+    const now = new Date().toISOString();
+    const pid = input.pid ?? process.pid;
+    const name = cleanAgentName(input.name);
+    const host = input.host || "127.0.0.1";
+    const record = {
+        schemaVersion: 1,
+        name,
+        pid,
+        port: normalizePort(input.port),
+        host,
+        endpoint: `http://${host}:${normalizePort(input.port)}`,
+        workdir: input.workdir,
+        mode: input.mode,
+        health: "running",
+        startedAt: input.startedAt || now,
+        updatedAt: now,
+        ...(input.relayHttp ? { relayHttp: input.relayHttp } : {}),
+    };
+    const instances = await loadRegistryRecords();
+    const next = instances
+        .filter((existing) => isProcessAlive(existing.pid))
+        .filter((existing) => !(existing.pid === pid && existing.name === name));
+    next.push(record);
+    await saveRegistryRecords(next);
+    return record;
+}
+export async function touchLocalInstance(name, pid = process.pid) {
+    const cleanedName = cleanAgentName(name);
+    const instances = await loadRegistryRecords();
+    let changed = false;
+    const now = new Date().toISOString();
+    const next = instances.filter((record) => {
+        const alive = isProcessAlive(record.pid);
+        if (!alive)
+            changed = true;
+        return alive;
+    }).map((record) => {
+        if (record.name === cleanedName && record.pid === pid) {
+            changed = true;
+            return { ...record, updatedAt: now };
+        }
+        return record;
+    });
+    if (changed)
+        await saveRegistryRecords(next);
+}
+export async function unregisterLocalInstance(name, pid = process.pid) {
+    const cleanedName = cleanAgentName(name);
+    const instances = await loadRegistryRecords();
+    const next = instances.filter((record) => !(record.name === cleanedName && record.pid === pid));
+    if (next.length !== instances.length)
+        await saveRegistryRecords(next);
+}
+export async function listRunningLocalInstances() {
+    const instances = await loadRegistryRecords();
+    const running = instances.filter((record) => isProcessAlive(record.pid));
+    if (running.length !== instances.length)
+        await saveRegistryRecords(running);
+    return running.sort((a, b) => a.name.localeCompare(b.name) || a.port - b.port || a.pid - b.pid);
+}
+export async function resolveLocalInstanceByName(name) {
+    const cleanedName = cleanAgentName(name);
+    const matches = (await listRunningLocalInstances()).filter((record) => record.name === cleanedName);
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length === 0) {
+        throw new LocalInstanceLookupError("not_found", `No running local Akemon named "${cleanedName}". Start it with: akemon run --name ${cleanedName}`);
+    }
+    throw new LocalInstanceLookupError("ambiguous", `Multiple running local Akemon instances are registered as "${cleanedName}". Use --port to select one explicitly.`, matches);
+}
+export async function resolveDefaultLocalInstance() {
+    const instances = await listRunningLocalInstances();
+    if (instances.length === 1)
+        return instances[0];
+    if (instances.length === 0) {
+        throw new LocalInstanceLookupError("not_found", "No running local Akemon instances are registered. Start one with: akemon run");
+    }
+    throw new LocalInstanceLookupError("ambiguous", "Multiple running local Akemon instances are registered. Use --name or --port to select one explicitly.", instances);
+}
+async function loadRegistryRecords() {
+    let raw;
+    try {
+        raw = await readFile(localInstanceRegistryPath(), "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const instances = Array.isArray(parsed)
+        ? parsed
+        : Array.isArray(parsed?.instances)
+            ? (parsed.instances ?? [])
+            : [];
+    return instances
+        .map((item) => {
+        try {
+            return normalizeRecord(item);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((record) => record !== null);
+}
+async function saveRegistryRecords(instances) {
+    const path = localInstanceRegistryPath();
+    await mkdir(dirname(path), { recursive: true });
+    const data = { schemaVersion: 1, instances };
+    const tmp = `${path}.${process.pid}.tmp`;
+    await writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    await rename(tmp, path);
+}
+function normalizeRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (typeof record.name !== "string")
+        return null;
+    const pid = record.pid;
+    const rawPort = record.port;
+    if (typeof pid !== "number" || typeof rawPort !== "number")
+        return null;
+    if (!Number.isInteger(pid) || !Number.isInteger(rawPort))
+        return null;
+    if (typeof record.workdir !== "string" || !record.workdir)
+        return null;
+    const mode = record.mode === "relay" ? "relay" : "local-only";
+    const host = typeof record.host === "string" && record.host ? record.host : "127.0.0.1";
+    const port = normalizePort(rawPort);
+    const endpoint = typeof record.endpoint === "string" && record.endpoint
+        ? record.endpoint
+        : `http://${host}:${port}`;
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: 1,
+        name: cleanAgentName(record.name),
+        pid,
+        port,
+        host,
+        endpoint,
+        workdir: record.workdir,
+        mode,
+        health: "running",
+        startedAt: typeof record.startedAt === "string" && record.startedAt ? record.startedAt : now,
+        updatedAt: typeof record.updatedAt === "string" && record.updatedAt ? record.updatedAt : now,
+        ...(typeof record.relayHttp === "string" && record.relayHttp ? { relayHttp: record.relayHttp } : {}),
+    };
+}
+function normalizePort(port) {
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new Error("Invalid local instance port");
+    }
+    return port;
+}