@minasoft/mina-ai-router 0.1.0

package/dist/apps/http-server/src/index.js

@@ -0,0 +1,755 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = require("node:http");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const node_child_process_1 = require("node:child_process");
+const src_1 = require("../../../packages/core/src");
+const provider_1 = require("../../../packages/mcp/src/provider");
+const src_2 = require("../../../packages/transports/src");
+const importEsm = new Function("specifier", "return import(specifier)");
+const runtimeModuleUrl = (0, node_url_1.pathToFileURL)((0, node_path_1.join)(__dirname, "../../../../node_modules/@minasoft/mcp-runtime/dist/index.js")).href;
+const port = Number(process.env.PORT ?? process.env.MINA_HTTP_PORT ?? 3333);
+const host = process.env.HOST ?? process.env.MINA_HTTP_HOST ?? "127.0.0.1";
+const statePath = process.env.MINA_ROUTER_STATE ?? (0, node_path_1.join)(process.cwd(), "data", "router-state.json");
+const context = createContext();
+let mcpHandlerPromise;
+function createContext() {
+    const fileState = new src_1.FileState(statePath);
+    const state = fileState.load();
+    const registry = new src_1.AgentRegistry(state.agents);
+    const requestStore = new src_1.RequestStore(state.requests);
+    const transports = new src_2.DefaultTransportRegistry()
+        .register("mock", new src_2.HeadlessTransport())
+        .register("headless", new src_2.HeadlessTransport())
+        .register("tmux", new src_2.TmuxTransport())
+        .register("zmux", new src_2.ZmuxTransport());
+    const baseContext = {
+        fileState,
+        registry,
+        requestStore,
+        save: () => fileState.save({
+            agents: registry.list(),
+            requests: requestStore.list(),
+        }),
+    };
+    const router = new src_1.AgentRouter({
+        registry,
+        requestStore,
+        transports,
+        onStateChanged: baseContext.save,
+    });
+    return {
+        ...baseContext,
+        transports,
+        router,
+    };
+}
+const server = (0, node_http_1.createServer)((request, response) => {
+    handleRequest(request, response).catch((error) => {
+        sendJson(response, 500, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+});
+server.listen(port, host, () => {
+    console.log(`Mina AI Router HTTP server`);
+    console.log(`UI:  http://${host}:${port}/`);
+    console.log(`MCP: http://${host}:${port}/mcp`);
+    console.log(`State: ${statePath}`);
+});
+async function handleRequest(request, response) {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? `${host}:${port}`}`);
+    if (request.method === "OPTIONS") {
+        sendOptions(response);
+        return;
+    }
+    if (url.pathname === "/" && request.method === "GET") {
+        sendHtml(response, renderAppHtml());
+        return;
+    }
+    if (url.pathname === "/mcp" && request.method === "POST") {
+        await handleMcp(request, response, url);
+        return;
+    }
+    if (url.pathname === "/api/state" && request.method === "GET") {
+        sendJson(response, 200, await getUiState());
+        return;
+    }
+    if (url.pathname === "/api/health" && request.method === "GET") {
+        sendJson(response, 200, await getHealth());
+        return;
+    }
+    if (url.pathname === "/api/fs/directories" && request.method === "POST") {
+        const body = await readJsonBody(request);
+        sendJson(response, 200, listDirectories(body));
+        return;
+    }
+    if (url.pathname === "/api/register" && request.method === "POST") {
+        const body = await readJsonBody(request);
+        const agent = registerAgent(body);
+        sendJson(response, 200, { agent, state: await getUiState() });
+        return;
+    }
+    const agentDeleteMatch = url.pathname.match(/^\/api\/agents\/([^/]+)$/);
+    if (agentDeleteMatch && request.method === "PATCH") {
+        const body = await readJsonBody(request);
+        const agent = updateAgent(decodeURIComponent(agentDeleteMatch[1]), body);
+        sendJson(response, 200, { agent, state: await getUiState() });
+        return;
+    }
+    if (agentDeleteMatch && request.method === "DELETE") {
+        const agent = context.registry.unregister(decodeURIComponent(agentDeleteMatch[1]));
+        context.save();
+        sendJson(response, 200, { agent, state: await getUiState() });
+        return;
+    }
+    const agentRestartMatch = url.pathname.match(/^\/api\/agents\/([^/]+)\/restart$/);
+    if (agentRestartMatch && request.method === "POST") {
+        const agent = restartAgent(decodeURIComponent(agentRestartMatch[1]));
+        sendJson(response, 200, { agent, state: await getUiState() });
+        return;
+    }
+    const agentTerminalMatch = url.pathname.match(/^\/api\/agents\/([^/]+)\/terminal$/);
+    if (agentTerminalMatch && request.method === "GET") {
+        sendJson(response, 200, captureAgentTerminal(decodeURIComponent(agentTerminalMatch[1])));
+        return;
+    }
+    const agentTerminalInputMatch = url.pathname.match(/^\/api\/agents\/([^/]+)\/terminal\/input$/);
+    if (agentTerminalInputMatch && request.method === "POST") {
+        const body = await readJsonBody(request);
+        sendJson(response, 200, sendAgentTerminalInput(decodeURIComponent(agentTerminalInputMatch[1]), body));
+        return;
+    }
+    if (url.pathname === "/api/agents/create-tmux" && request.method === "POST") {
+        const body = await readJsonBody(request);
+        const result = createTmuxAgent(body);
+        sendJson(response, 200, { ...result, state: await getUiState() });
+        return;
+    }
+    if (url.pathname === "/api/ask" && request.method === "POST") {
+        const body = await readJsonBody(request);
+        const target = typeof body.target === "string" ? body.target : "";
+        const task = typeof body.task === "string" ? body.task : "";
+        const timeoutMs = typeof body.timeoutMs === "number" ? body.timeoutMs : 300000;
+        if (!target || !task) {
+            sendJson(response, 400, { error: "target and task are required" });
+            return;
+        }
+        try {
+            const result = await context.router.callAgent({ target, task, timeoutMs });
+            context.save();
+            sendJson(response, 200, { result, state: await getUiState() });
+        }
+        catch (error) {
+            context.save();
+            sendJson(response, 500, {
+                error: error instanceof Error ? error.message : String(error),
+                state: await getUiState(),
+            });
+        }
+        return;
+    }
+    const requestActionMatch = url.pathname.match(/^\/api\/requests\/([^/]+)\/(retry|cancel|archive)$/);
+    if (requestActionMatch && request.method === "POST") {
+        const requestId = decodeURIComponent(requestActionMatch[1]);
+        const action = requestActionMatch[2];
+        const result = await handleRequestAction(requestId, action);
+        sendJson(response, 200, { result, state: await getUiState() });
+        return;
+    }
+    if (url.pathname === "/api/requests/archive-stale" && request.method === "POST") {
+        const body = await readJsonBody(request);
+        const olderThanMs = typeof body.olderThanMs === "number" ? body.olderThanMs : 30 * 60 * 1000;
+        const archived = archiveStaleRequests(olderThanMs);
+        sendJson(response, 200, { archived, state: await getUiState() });
+        return;
+    }
+    if (url.pathname === "/api/setup-codex-pair" && request.method === "POST") {
+        const body = await readJsonBody(request);
+        const result = setupCodexPair(body);
+        sendJson(response, 200, result);
+        return;
+    }
+    sendJson(response, 404, { error: "Not found" });
+}
+function archiveStaleRequests(olderThanMs) {
+    const staleStatuses = new Set(["created", "sent", "waiting"]);
+    const cutoff = Date.now() - olderThanMs;
+    const archived = [];
+    for (const request of context.requestStore.list()) {
+        if (!staleStatuses.has(request.status)) {
+            continue;
+        }
+        const updatedAt = Date.parse(request.updatedAt);
+        if (Number.isFinite(updatedAt) && updatedAt > cutoff) {
+            continue;
+        }
+        archived.push(context.requestStore.updateStatus(request.id, "archived", {
+            error: request.error ?? "Archived as stale by operator.",
+        }));
+    }
+    if (archived.length > 0) {
+        context.save();
+    }
+    return archived;
+}
+async function handleRequestAction(requestId, action) {
+    const request = context.requestStore.require(requestId);
+    if (action === "retry") {
+        return context.router.callAgent({
+            sourceAgent: request.sourceAgent,
+            target: request.targetAgent,
+            task: request.task,
+        });
+    }
+    if (action === "cancel") {
+        const updated = context.requestStore.updateStatus(requestId, "cancelled", {
+            error: "Cancelled by operator from Mina AI Router UI.",
+        });
+        context.save();
+        return updated;
+    }
+    if (action === "archive") {
+        const updated = context.requestStore.updateStatus(requestId, "archived");
+        context.save();
+        return updated;
+    }
+    throw new Error(`Unsupported request action "${action}".`);
+}
+async function handleMcp(request, response, url) {
+    const handler = await getMcpHandler();
+    const body = await readRawBody(request);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(request.headers)) {
+        if (Array.isArray(value)) {
+            headers.set(key, value.join(", "));
+        }
+        else if (value !== undefined) {
+            headers.set(key, value);
+        }
+    }
+    const fetchRequest = new Request(url.href, {
+        method: request.method,
+        headers,
+        body,
+    });
+    const fetchResponse = await handler(fetchRequest);
+    response.statusCode = fetchResponse.status;
+    fetchResponse.headers.forEach((value, key) => {
+        response.setHeader(key, value);
+    });
+    response.end(Buffer.from(await fetchResponse.arrayBuffer()));
+}
+async function getMcpHandler() {
+    if (mcpHandlerPromise) {
+        return mcpHandlerPromise;
+    }
+    mcpHandlerPromise = importEsm(runtimeModuleUrl).then((runtime) => {
+        const provider = (0, provider_1.createMinaMcpProvider)(context);
+        return runtime.createMcpFetchHandler(provider, {
+            cors: {
+                allowedOrigins: ["*"],
+            },
+            async context(request) {
+                return {
+                    requestId: request.headers.get("x-request-id") ?? undefined,
+                };
+            },
+        });
+    });
+    return mcpHandlerPromise;
+}
+async function getUiState() {
+    hydratePendingCapabilityNotices();
+    return {
+        statePath,
+        mcpUrl: `http://${host}:${port}/mcp`,
+        agents: await context.router.listAgentStatuses(),
+        requests: context.router.listRequests(),
+    };
+}
+async function getHealth() {
+    const agents = await context.router.listAgentStatuses();
+    const requests = context.router.listRequests();
+    const openRequests = requests.filter((request) => ["created", "sent", "waiting"].includes(request.status));
+    return {
+        ok: agents.every((agent) => agent.status !== "missing"),
+        statePath,
+        mcpUrl: `http://${host}:${port}/mcp`,
+        agents: {
+            total: agents.length,
+            available: agents.filter((agent) => agent.status === "available").length,
+            busy: agents.filter((agent) => agent.status === "busy").length,
+            missing: agents.filter((agent) => agent.status === "missing").length,
+            unknown: agents.filter((agent) => agent.status === "unknown").length,
+        },
+        requests: {
+            total: requests.length,
+            open: openRequests.length,
+            waiting: requests.filter((request) => request.status === "waiting").length,
+            answered: requests.filter((request) => request.status === "answered").length,
+            failed: requests.filter((request) => ["failed", "timeout", "cancelled"].includes(request.status)).length,
+            archived: requests.filter((request) => request.status === "archived").length,
+        },
+    };
+}
+function registerAgent(body) {
+    const id = requiredString(body.id, "id");
+    const projectRoot = stringValue(body.projectRoot) ?? process.cwd();
+    const capabilityNotice = inferCapabilityNotice(projectRoot);
+    const agent = {
+        id,
+        name: stringValue(body.name) ?? id,
+        agentType: stringValue(body.agentType) ?? "codex",
+        transport: (stringValue(body.transport) ?? "tmux"),
+        sessionId: stringValue(body.sessionId) ?? id,
+        projectRoot,
+        tmuxTarget: stringValue(body.tmuxTarget),
+        startupCommand: stringValue(body.startupCommand),
+        capabilitySummary: stringValue(body.capabilitySummary) ?? capabilityNotice.summary,
+        capabilitySources: stringValue(body.capabilitySources) ?? capabilityNotice.sources,
+    };
+    context.registry.register(agent);
+    context.save();
+    return agent;
+}
+function updateAgent(id, body) {
+    const current = context.registry.require(id);
+    const next = {
+        ...current,
+        name: stringValue(body.name) ?? current.name,
+        capabilitySummary: stringFieldValue(body, "capabilitySummary") ?? current.capabilitySummary,
+        capabilitySources: stringFieldValue(body, "capabilitySources") ?? current.capabilitySources,
+    };
+    context.registry.register(next);
+    context.save();
+    return next;
+}
+function listDirectories(body) {
+    const home = process.env.HOME ?? process.cwd();
+    const requestedPath = stringValue(body.path) ?? home;
+    const directoryPath = (0, node_path_1.resolve)(requestedPath);
+    if (!(0, node_fs_1.existsSync)(directoryPath)) {
+        throw new Error(`Directory does not exist: ${directoryPath}`);
+    }
+    if (!(0, node_fs_1.statSync)(directoryPath).isDirectory()) {
+        throw new Error(`Path is not a directory: ${directoryPath}`);
+    }
+    const showHidden = body.showHidden === true;
+    const entries = (0, node_fs_1.readdirSync)(directoryPath, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .filter((entry) => showHidden || !entry.name.startsWith("."))
+        .map((entry) => ({
+        name: entry.name,
+        path: (0, node_path_1.join)(directoryPath, entry.name),
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    return {
+        path: directoryPath,
+        parent: (0, node_path_1.dirname)(directoryPath),
+        home,
+        entries,
+    };
+}
+function restartAgent(id) {
+    const agent = context.registry.require(id);
+    if (agent.transport !== "tmux") {
+        throw new Error(`Agent "${id}" uses transport "${agent.transport}", not tmux.`);
+    }
+    const tmux = new src_2.TmuxClient();
+    tmux.killSession(agent.sessionId);
+    tmux.ensureSession(agent);
+    context.save();
+    return agent;
+}
+function captureAgentTerminal(id) {
+    const agent = context.registry.require(id);
+    if (agent.transport !== "tmux") {
+        throw new Error(`Agent "${id}" uses transport "${agent.transport}", not tmux.`);
+    }
+    const tmux = new src_2.TmuxClient({ captureLines: 120 });
+    const text = tmux.capture(agent.tmuxTarget ?? agent.sessionId);
+    return {
+        agent,
+        terminal: {
+            text,
+            capturedAt: new Date().toISOString(),
+            trustPrompt: agent.agentType === "codex" && isCodexTrustPrompt(text),
+            pendingRegistration: isPendingUiRegistration(agent),
+        },
+    };
+}
+function sendAgentTerminalInput(id, body) {
+    const agent = context.registry.require(id);
+    if (agent.transport !== "tmux") {
+        throw new Error(`Agent "${id}" uses transport "${agent.transport}", not tmux.`);
+    }
+    const target = agent.tmuxTarget ?? agent.sessionId;
+    const text = stringValue(body.text);
+    const enter = body.enter === true;
+    const tmux = new src_2.TmuxClient({ captureLines: 120 });
+    if (text) {
+        if (agent.agentType === "codex") {
+            tmux.sendCodexText(target, text);
+        }
+        else {
+            tmux.sendText(target, text);
+        }
+    }
+    else if (enter) {
+        tmux.sendEnter(target);
+    }
+    let registration = "unchanged";
+    if (enter && !text && isPendingUiRegistration(agent)) {
+        sleep(1200);
+        const capture = tmux.capture(target);
+        if (!(agent.agentType === "codex" && isCodexTrustPrompt(capture))) {
+            if (agent.agentType === "codex") {
+                tmux.sendCodexText(target, buildSelfRegistrationPrompt(agent));
+            }
+            else {
+                tmux.sendText(target, buildSelfRegistrationPrompt(agent));
+            }
+            registration = "registration prompt sent to agent";
+        }
+    }
+    return {
+        ok: true,
+        registration,
+        ...captureAgentTerminal(id),
+    };
+}
+function createTmuxAgent(body) {
+    const agentType = stringValue(body.agentType) ?? "codex";
+    if (agentType !== "codex" && agentType !== "claude") {
+        throw new Error("agentType must be codex or claude.");
+    }
+    const projectRoot = requiredString(body.projectRoot, "projectRoot");
+    if (!(0, node_fs_1.existsSync)(projectRoot)) {
+        throw new Error(`Project root does not exist: ${projectRoot}`);
+    }
+    const projectName = stringValue(body.name) ?? (0, node_path_1.basename)(projectRoot);
+    const id = stringValue(body.id) ?? sanitizeName(projectName);
+    const sessionId = stringValue(body.sessionId) ?? `${agentType}-${sanitizeName(projectName)}`;
+    const startupCommand = stringValue(body.startupCommand)
+        ?? (agentType === "codex" ? "codex --no-alt-screen" : "claude");
+    const command = startupCommand.split(/\s+/)[0];
+    assertCommandAvailable("tmux");
+    assertCommandAvailable(command);
+    const agent = {
+        id,
+        name: id,
+        agentType,
+        transport: "tmux",
+        sessionId,
+        projectRoot,
+        startupCommand,
+        ...uiCreatedCapabilityNotice(projectRoot),
+    };
+    const tmux = new src_2.TmuxClient();
+    const existed = tmux.hasSession(sessionId);
+    tmux.ensureSession(agent);
+    context.registry.register(agent);
+    context.save();
+    const sendRegistrationPrompt = body.sendRegistrationPrompt !== false;
+    let registration = "registration prompt skipped";
+    let nextAction;
+    if (sendRegistrationPrompt) {
+        const delayMs = typeof body.registerDelayMs === "number" ? body.registerDelayMs : 4000;
+        sleep(delayMs);
+        const capture = tmux.capture(sessionId);
+        if (agentType === "codex" && isCodexTrustPrompt(capture)) {
+            registration = "waiting for Codex directory trust approval";
+            nextAction = `Attach with "tmux attach -t ${sessionId}", approve the Codex trust prompt, then ask the agent to register this session with Mina AI Router.`;
+        }
+        else {
+            const prompt = buildSelfRegistrationPrompt(agent);
+            if (agentType === "codex") {
+                tmux.sendCodexText(sessionId, prompt);
+            }
+            else {
+                tmux.sendText(sessionId, prompt);
+            }
+            registration = "registration prompt sent to agent";
+        }
+    }
+    return {
+        agent,
+        existed,
+        registration,
+        nextAction,
+        attachCommand: `tmux attach -t ${sessionId}`,
+        mairAttachCommand: `mair attach ${id}`,
+    };
+}
+function setupCodexPair(body) {
+    const mainRoot = stringValue(body.mainRoot) ?? "/Users/stevenna/WebstormProjects/minasoftai";
+    const helperRoot = stringValue(body.helperRoot) ?? "/Users/stevenna/PycharmProjects/mina-ralph-loop-bootstrap-nextjs";
+    const helperId = stringValue(body.helperId) ?? "ralph";
+    const sessionId = stringValue(body.sessionId) ?? "mina-ralph-codex";
+    const agent = {
+        id: helperId,
+        name: helperId,
+        agentType: "codex",
+        transport: "tmux",
+        sessionId,
+        projectRoot: helperRoot,
+        startupCommand: stringValue(body.startupCommand) ?? "codex --no-alt-screen",
+    };
+    new src_2.TmuxClient().ensureSession(agent);
+    context.registry.register(agent);
+    context.save();
+    return {
+        statePath,
+        mainRoot,
+        helper: agent,
+        mcpUrl: `http://${host}:${port}/mcp`,
+        codexMcpAdd: `codex mcp add mina-ai-router --url http://${host}:${port}/mcp`,
+        startMainCodex: `cd ${mainRoot} && codex --no-alt-screen`,
+        attachHelper: `tmux attach -t ${sessionId}`,
+    };
+}
+function buildSelfRegistrationPrompt(agent) {
+    return [
+        "Use Mina AI Router MCP register_agent to register this visible CLI session.",
+        "Collect any missing context yourself when possible, but use these values as authoritative:",
+        `- id: ${agent.id}`,
+        `- name: ${agent.name}`,
+        `- agentType: ${agent.agentType}`,
+        `- transport: ${agent.transport}`,
+        `- sessionId: ${agent.sessionId}`,
+        `- projectRoot: ${agent.projectRoot}`,
+        `- startupCommand: ${agent.startupCommand ?? ""}`,
+        "",
+        "Before registering, create a concise capability notice for this session:",
+        "- Prefer capability docs in this order when present: CLAUDE.md/claude.md, AGENTS.md/agents.md, agent.md, README.md.",
+        "- If those files are missing, inspect package metadata and the project file tree to infer what this project/agent can help with.",
+        "- Set register_agent capabilitySummary to 2-5 short bullets or one short paragraph under 800 characters.",
+        "- Set register_agent capabilitySources to a comma-separated list of the files or project signals you used.",
+        "After registering, call list_agents and confirm this agent is available.",
+    ].join("\n");
+}
+function hydratePendingCapabilityNotices() {
+    let changed = false;
+    for (const agent of context.registry.list()) {
+        if (agent.capabilitySummary === "Pending self-registration capability notice."
+            && agent.capabilitySources === "created from Mina UI") {
+            const notice = uiCreatedCapabilityNotice(agent.projectRoot);
+            context.registry.register({
+                ...agent,
+                capabilitySummary: notice.capabilitySummary,
+                capabilitySources: notice.capabilitySources,
+            });
+            changed = true;
+        }
+    }
+    if (changed) {
+        context.save();
+    }
+}
+function uiCreatedCapabilityNotice(projectRoot) {
+    const notice = inferCapabilityNotice(projectRoot);
+    return {
+        capabilitySummary: notice.summary,
+        capabilitySources: `created from Mina UI; ${notice.sources}`,
+    };
+}
+function inferCapabilityNotice(projectRoot) {
+    const root = (0, node_path_1.resolve)(projectRoot);
+    const docCandidates = [
+        "CLAUDE.md",
+        "claude.md",
+        "AGENTS.md",
+        "agents.md",
+        "agent.md",
+        "README.md",
+    ];
+    for (const candidate of docCandidates) {
+        const filePath = (0, node_path_1.join)(root, candidate);
+        if (!(0, node_fs_1.existsSync)(filePath) || (0, node_fs_1.statSync)(filePath).isDirectory()) {
+            continue;
+        }
+        const summary = summarizeMarkdown(readSmallText(filePath), (0, node_path_1.basename)(root));
+        if (summary) {
+            return {
+                summary,
+                sources: `inferred from ${candidate}`,
+            };
+        }
+    }
+    const packagePath = (0, node_path_1.join)(root, "package.json");
+    if ((0, node_fs_1.existsSync)(packagePath) && !(0, node_fs_1.statSync)(packagePath).isDirectory()) {
+        try {
+            const packageJson = JSON.parse(readSmallText(packagePath));
+            const name = typeof packageJson.name === "string" ? packageJson.name : (0, node_path_1.basename)(root);
+            const description = typeof packageJson.description === "string" && packageJson.description.trim()
+                ? packageJson.description.trim()
+                : "JavaScript/TypeScript project";
+            const scripts = packageJson.scripts && typeof packageJson.scripts === "object"
+                ? Object.keys(packageJson.scripts).slice(0, 5)
+                : [];
+            const deps = {
+                ...objectValue(packageJson.dependencies),
+                ...objectValue(packageJson.devDependencies),
+            };
+            const frameworks = Object.keys(deps)
+                .filter((dependency) => ["next", "react", "vue", "svelte", "express", "fastify", "nestjs", "vite", "typescript"].includes(dependency))
+                .slice(0, 5);
+            return {
+                summary: [
+                    `${name}: ${description}.`,
+                    frameworks.length ? `Stack signals: ${frameworks.join(", ")}.` : "",
+                    scripts.length ? `Useful scripts: ${scripts.join(", ")}.` : "",
+                ].filter(Boolean).join(" "),
+                sources: "inferred from package.json",
+            };
+        }
+        catch {
+            return {
+                summary: `${(0, node_path_1.basename)(root)} appears to be a JavaScript/TypeScript project. Use project files to answer implementation, test, and architecture questions.`,
+                sources: "inferred from package.json",
+            };
+        }
+    }
+    const pyprojectPath = (0, node_path_1.join)(root, "pyproject.toml");
+    if ((0, node_fs_1.existsSync)(pyprojectPath) && !(0, node_fs_1.statSync)(pyprojectPath).isDirectory()) {
+        const text = readSmallText(pyprojectPath);
+        const name = text.match(/^name\s*=\s*"([^"]+)"/m)?.[1] ?? (0, node_path_1.basename)(root);
+        const description = text.match(/^description\s*=\s*"([^"]+)"/m)?.[1] ?? "Python project";
+        return {
+            summary: `${name}: ${description}. Use this agent for Python implementation, tests, CLI/runtime questions, and project-specific debugging.`,
+            sources: "inferred from pyproject.toml",
+        };
+    }
+    const entries = safeDirectoryEntries(root)
+        .filter((entry) => !entry.startsWith("."))
+        .slice(0, 8);
+    return {
+        summary: `${(0, node_path_1.basename)(root)} project agent. Use it for questions about this repository's files, structure, implementation details, and local test workflow.${entries.length ? ` Top-level entries: ${entries.join(", ")}.` : ""}`,
+        sources: "inferred from project directory",
+    };
+}
+function summarizeMarkdown(text, fallbackName) {
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^#+\s*/, "").replace(/^[-*]\s+/, "").trim())
+        .filter((line) => line && !line.startsWith("```") && !line.startsWith("|"));
+    const useful = lines
+        .filter((line) => !/^#{1,6}\s*$/.test(line))
+        .slice(0, 5)
+        .join(" ");
+    return truncateText(useful || `${fallbackName} project agent. Use it for project-specific implementation, debugging, testing, and architecture questions.`, 800);
+}
+function readSmallText(filePath) {
+    return (0, node_fs_1.readFileSync)(filePath, "utf8").slice(0, 12000);
+}
+function safeDirectoryEntries(directoryPath) {
+    try {
+        return (0, node_fs_1.readdirSync)(directoryPath).sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function truncateText(value, maxLength) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1).trim()}...` : normalized;
+}
+function isCodexTrustPrompt(capture) {
+    return capture.includes("Do you trust the contents of this directory?")
+        || capture.includes("Press enter to continue")
+        || capture.includes("Yes, continue");
+}
+function isPendingUiRegistration(agent) {
+    return agent.capabilitySources?.startsWith("created from Mina UI") ?? false;
+}
+function assertCommandAvailable(command) {
+    try {
+        (0, node_child_process_1.execFileSync)("which", [command], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch {
+        throw new Error(`Required command "${command}" is not available on PATH.`);
+    }
+}
+function sanitizeName(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "agent";
+}
+function sleep(milliseconds) {
+    if (!Number.isFinite(milliseconds) || milliseconds <= 0) {
+        return;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+function requiredString(value, field) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${field} is required`);
+    }
+    return value.trim();
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function stringFieldValue(body, field) {
+    return Object.prototype.hasOwnProperty.call(body, field) && typeof body[field] === "string"
+        ? body[field].trim()
+        : undefined;
+}
+async function readJsonBody(request) {
+    const raw = await readRawBody(request);
+    if (!raw.trim()) {
+        return {};
+    }
+    return JSON.parse(raw);
+}
+function readRawBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        request.on("error", reject);
+    });
+}
+function sendOptions(response) {
+    response.statusCode = 204;
+    setCors(response);
+    response.end();
+}
+function sendJson(response, status, value) {
+    const body = JSON.stringify(value, null, 2);
+    response.statusCode = status;
+    setCors(response);
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.end(body);
+}
+function sendHtml(response, body) {
+    response.statusCode = 200;
+    response.setHeader("content-type", "text/html; charset=utf-8");
+    response.end(body);
+}
+function setCors(response) {
+    response.setHeader("access-control-allow-origin", "*");
+    response.setHeader("access-control-allow-methods", "GET,POST,DELETE,OPTIONS");
+    response.setHeader("access-control-allow-headers", "content-type,mcp-protocol-version,x-request-id");
+}
+function renderAppHtml() {
+    const builtPath = (0, node_path_1.join)(__dirname, "ui.html");
+    if ((0, node_fs_1.existsSync)(builtPath)) {
+        return (0, node_fs_1.readFileSync)(builtPath, "utf8");
+    }
+    return (0, node_fs_1.readFileSync)((0, node_path_1.join)(process.cwd(), "apps", "http-server", "src", "ui.html"), "utf8");
+}