@mcoda/agent-setup 0.1.66

package/dist/react/index.d.ts

@@ -0,0 +1,68 @@
+import * as React from "react";
+import type { McodaAgentCatalogEntry, McodaAgentSetupClient, McodaAgentSetupSnapshot, McodaSelfHostedServer, McodaStageDefinition } from "../types.js";
+export interface McodaAgentSetupPageProps {
+    client: McodaAgentSetupClient;
+    stages?: McodaStageDefinition[];
+    title?: string;
+    className?: string;
+    labels?: Partial<McodaAgentSetupLabels>;
+    components?: Partial<McodaAgentSetupComponentOverrides>;
+}
+export interface McodaAgentSetupLabels {
+    saveKey: string;
+    syncAgents: string;
+    saveAssignments: string;
+    cloud: string;
+    selfHosted: string;
+}
+export interface McodaAgentSetupComponentOverrides {
+    AgentCatalogSummary: typeof AgentCatalogSummary;
+    MswarmAccessCard: typeof MswarmAccessCard;
+    StageAgentAssignments: typeof StageAgentAssignments;
+    AgentSourceSelect: typeof AgentSourceSelect;
+    SelfHostedServerSelect: typeof SelfHostedServerSelect;
+    AgentSearchSelect: typeof AgentSearchSelect;
+}
+export declare function McodaAgentSetupPage(props: McodaAgentSetupPageProps): React.ReactElement;
+export declare function AgentCatalogSummary(props: {
+    snapshot: McodaAgentSetupSnapshot;
+}): React.ReactElement;
+export declare function MswarmAccessCard(props: {
+    apiKey: string;
+    busy?: boolean;
+    labels?: Partial<McodaAgentSetupLabels>;
+    snapshot?: McodaAgentSetupSnapshot | null;
+    onApiKeyChange: (value: string) => void;
+    onSaveKey: () => void;
+    onSyncAgents: () => void;
+}): React.ReactElement;
+export declare function StageAgentAssignments(props: {
+    stages: McodaStageDefinition[];
+    snapshot: McodaAgentSetupSnapshot;
+    assignments: Record<string, string | null>;
+    labels?: Partial<McodaAgentSetupLabels>;
+    busy?: boolean;
+    onAssignmentChange: (stageKey: string, slug: string | null) => void;
+    onSaveAssignments: () => void;
+}): React.ReactElement;
+export declare function AgentSourceSelect(props: {
+    value: "cloud" | "self_hosted";
+    labels?: Partial<McodaAgentSetupLabels>;
+    onChange: (value: "cloud" | "self_hosted") => void;
+}): React.ReactElement;
+export declare function SelfHostedServerSelect(props: {
+    servers: McodaSelfHostedServer[];
+    value: string;
+    onChange: (value: string) => void;
+}): React.ReactElement;
+export declare function AgentSearchSelect(props: {
+    agents: McodaAgentCatalogEntry[];
+    value: string;
+    onChange: (value: string) => void;
+    rowHeight?: number;
+    viewportHeight?: number;
+}): React.ReactElement;
+export { createMcodaAgentSetupClient } from "../client.js";
+export { defaultMcodaStageDefinitions } from "../defaultStages.js";
+export type * from "../types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"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"}

package/dist/react/index.js

@@ -0,0 +1,295 @@
+import * as React from "react";
+import { defaultMcodaStageDefinitions } from "../defaultStages.js";
+import { filterAgentOptions, getVirtualAgentWindow, } from "../headless/catalog.js";
+const DEFAULT_LABELS = {
+    saveKey: "Save Key",
+    syncAgents: "Sync Agents",
+    saveAssignments: "Save Assignments",
+    cloud: "Cloud",
+    selfHosted: "Self-hosted",
+};
+export function McodaAgentSetupPage(props) {
+    const labels = { ...DEFAULT_LABELS, ...(props.labels ?? {}) };
+    const stages = props.stages ?? defaultMcodaStageDefinitions;
+    const components = {
+        AgentCatalogSummary,
+        MswarmAccessCard,
+        StageAgentAssignments,
+        ...(props.components ?? {}),
+    };
+    const [snapshot, setSnapshot] = React.useState(null);
+    const [assignments, setAssignments] = React.useState({});
+    const [apiKey, setApiKey] = React.useState("");
+    const [busy, setBusy] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const refresh = React.useCallback(async () => {
+        setBusy(true);
+        setError(null);
+        try {
+            const next = await props.client.fetchSnapshot();
+            setSnapshot(next);
+            setAssignments(next.assignments);
+        }
+        catch (caught) {
+            setError(caught instanceof Error ? caught.message : String(caught));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [props.client]);
+    React.useEffect(() => {
+        void refresh();
+    }, [refresh]);
+    const saveKey = async () => {
+        if (!apiKey.trim())
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            const next = await props.client.configureMswarmApiKey({ apiKey });
+            setApiKey("");
+            setSnapshot(next);
+            setAssignments(next.assignments);
+        }
+        catch (caught) {
+            setError(caught instanceof Error ? caught.message : String(caught));
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    const syncAgents = async () => {
+        setBusy(true);
+        setError(null);
+        try {
+            const next = await props.client.syncAgents();
+            setSnapshot(next);
+            setAssignments(next.assignments);
+        }
+        catch (caught) {
+            setError(caught instanceof Error ? caught.message : String(caught));
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    const saveAssignments = async () => {
+        setBusy(true);
+        setError(null);
+        try {
+            const next = await props.client.updateAssignments({ assignments });
+            setSnapshot(next);
+            setAssignments(next.assignments);
+        }
+        catch (caught) {
+            setError(caught instanceof Error ? caught.message : String(caught));
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return React.createElement("section", { className: joinClasses("mcoda-agent-setup", props.className) }, React.createElement("header", { className: "mcoda-agent-setup__header" }, React.createElement("h1", null, props.title ?? "mcoda Agent Setup"), React.createElement("button", { type: "button", disabled: busy, onClick: refresh }, "Refresh")), error
+        ? React.createElement("p", { className: "mcoda-agent-setup__error" }, error)
+        : null, snapshot
+        ? React.createElement(components.AgentCatalogSummary, { snapshot })
+        : React.createElement("p", null, busy ? "Loading" : "No snapshot loaded"), React.createElement(components.MswarmAccessCard, {
+        apiKey,
+        busy,
+        labels,
+        snapshot,
+        onApiKeyChange: setApiKey,
+        onSaveKey: saveKey,
+        onSyncAgents: syncAgents,
+    }), snapshot
+        ? React.createElement(components.StageAgentAssignments, {
+            stages,
+            snapshot,
+            assignments,
+            labels,
+            onAssignmentChange: (stageKey, slug) => setAssignments((current) => ({ ...current, [stageKey]: slug })),
+            onSaveAssignments: saveAssignments,
+            busy,
+        })
+        : null);
+}
+export function AgentCatalogSummary(props) {
+    const { snapshot } = props;
+    const warningEntries = Object.entries(snapshot.catalog.errors);
+    return React.createElement("div", { className: "mcoda-agent-setup__summary" }, React.createElement("div", null, `Provider: ${snapshot.provider}`), React.createElement("div", null, `mswarm Key: ${snapshot.mswarmApiKeyConfigured
+        ? `configured${snapshot.mswarmApiKeyLast4 ? ` (${snapshot.mswarmApiKeyLast4})` : ""}`
+        : "missing"}`), React.createElement("div", null, `Synced Agents: ${snapshot.catalog.localAgents.length}`), React.createElement("div", null, `Cloud Agents: ${snapshot.catalog.cloudAgents.length}`), React.createElement("div", null, `Self-hosted Servers: ${snapshot.catalog.selfHostedServers.length}`), warningEntries.length
+        ? React.createElement("ul", { className: "mcoda-agent-setup__warnings" }, warningEntries.map(([key, value]) => React.createElement("li", { key }, `${key}: ${value}`)))
+        : null);
+}
+export function MswarmAccessCard(props) {
+    const labels = { ...DEFAULT_LABELS, ...(props.labels ?? {}) };
+    return React.createElement("section", { className: "mcoda-agent-setup__access" }, React.createElement("h2", null, "mswarm Access"), React.createElement("input", {
+        type: "password",
+        value: props.apiKey,
+        autoComplete: "off",
+        onChange: (event) => props.onApiKeyChange(event.target.value),
+        placeholder: props.snapshot?.mswarmApiKeyConfigured
+            ? "Replace mswarm API key"
+            : "mswarm API key",
+    }), React.createElement("button", {
+        type: "button",
+        disabled: props.busy || !props.apiKey.trim(),
+        onClick: props.onSaveKey,
+    }, labels.saveKey), React.createElement("button", { type: "button", disabled: props.busy, onClick: props.onSyncAgents }, labels.syncAgents));
+}
+export function StageAgentAssignments(props) {
+    const labels = { ...DEFAULT_LABELS, ...(props.labels ?? {}) };
+    const sourceSelect = AgentSourceSelect;
+    const serverSelect = SelfHostedServerSelect;
+    const agentSelect = AgentSearchSelect;
+    const [sources, setSources] = React.useState({});
+    const [servers, setServers] = React.useState({});
+    React.useEffect(() => {
+        const nextSources = {};
+        const nextServers = {};
+        for (const stage of props.stages) {
+            const assignment = props.assignments[stage.stageKey];
+            if (!assignment)
+                continue;
+            const selfHostedServer = props.snapshot.catalog.selfHostedServers.find((server) => server.agents.some((agent) => agent.slug === assignment));
+            if (selfHostedServer) {
+                nextSources[stage.stageKey] = "self_hosted";
+                nextServers[stage.stageKey] = selfHostedServer.id;
+                continue;
+            }
+            if (props.snapshot.catalog.cloudAgents.some((agent) => agent.slug === assignment)) {
+                nextSources[stage.stageKey] = "cloud";
+            }
+        }
+        setSources((current) => ({ ...nextSources, ...current }));
+        setServers((current) => ({ ...nextServers, ...current }));
+    }, [props.assignments, props.snapshot.catalog.cloudAgents, props.snapshot.catalog.selfHostedServers, props.stages]);
+    return React.createElement("section", { className: "mcoda-agent-setup__assignments" }, React.createElement("h2", null, "Stage Assignments"), React.createElement("div", { className: "mcoda-agent-setup__stage-list" }, props.stages.map((stage) => {
+        const source = sources[stage.stageKey] ??
+            (stage.preferredSource === "self_hosted" ? "self_hosted" : "cloud");
+        const serverId = servers[stage.stageKey];
+        const server = props.snapshot.catalog.selfHostedServers.find((candidate) => candidate.id === serverId);
+        const agents = source === "cloud"
+            ? props.snapshot.catalog.cloudAgents
+            : server?.agents ?? [];
+        return React.createElement("div", { className: "mcoda-agent-setup__stage-row", key: stage.stageKey }, React.createElement("div", null, React.createElement("strong", null, stage.displayName), stage.description
+            ? React.createElement("p", null, stage.description)
+            : null), React.createElement(sourceSelect, {
+            value: source,
+            labels,
+            onChange: (value) => setSources((current) => ({ ...current, [stage.stageKey]: value })),
+        }), source === "self_hosted"
+            ? React.createElement(serverSelect, {
+                servers: props.snapshot.catalog.selfHostedServers,
+                value: serverId ?? "",
+                onChange: (value) => setServers((current) => ({ ...current, [stage.stageKey]: value })),
+            })
+            : null, React.createElement(agentSelect, {
+            agents,
+            value: props.assignments[stage.stageKey] ?? "",
+            onChange: (slug) => props.onAssignmentChange(stage.stageKey, slug || null),
+        }));
+    })), React.createElement("button", {
+        type: "button",
+        disabled: props.busy,
+        onClick: props.onSaveAssignments,
+    }, labels.saveAssignments));
+}
+export function AgentSourceSelect(props) {
+    const labels = { ...DEFAULT_LABELS, ...(props.labels ?? {}) };
+    return React.createElement("select", {
+        value: props.value,
+        onChange: (event) => props.onChange(event.target.value === "self_hosted" ? "self_hosted" : "cloud"),
+    }, React.createElement("option", { value: "cloud" }, labels.cloud), React.createElement("option", { value: "self_hosted" }, labels.selfHosted));
+}
+export function SelfHostedServerSelect(props) {
+    const [query, setQuery] = React.useState("");
+    const filteredServers = props.servers.length > 8 && query.trim()
+        ? props.servers.filter((server) => [server.label, server.id, server.nodeId, server.serverName, server.remoteSlugPrefix]
+            .filter(Boolean)
+            .join(" ")
+            .toLowerCase()
+            .includes(query.trim().toLowerCase()))
+        : props.servers;
+    return React.createElement("div", { className: "mcoda-agent-setup__server-select" }, props.servers.length > 8
+        ? React.createElement("input", {
+            value: query,
+            onChange: (event) => setQuery(event.target.value),
+            placeholder: "Search server",
+        })
+        : null, React.createElement("select", {
+        value: props.value,
+        onChange: (event) => props.onChange(event.target.value),
+    }, React.createElement("option", { value: "" }, "Select server"), filteredServers.map((server) => React.createElement("option", { key: server.id, value: server.id }, `${server.label} (${server.agentCount})`))));
+}
+export function AgentSearchSelect(props) {
+    const [query, setQuery] = React.useState("");
+    const [scrollTop, setScrollTop] = React.useState(0);
+    const [activeIndex, setActiveIndex] = React.useState(0);
+    const filtered = React.useMemo(() => filterAgentOptions(props.agents, query), [props.agents, query]);
+    const rowHeight = props.rowHeight ?? 40;
+    const viewportHeight = props.viewportHeight ?? 240;
+    const windowed = getVirtualAgentWindow(filtered, {
+        scrollTop,
+        rowHeight,
+        viewportHeight,
+    });
+    const selected = props.agents.find((agent) => agent.slug === props.value);
+    React.useEffect(() => {
+        setActiveIndex(0);
+    }, [query, props.agents]);
+    const onKeyDown = (event) => {
+        if (event.key === "Escape") {
+            setQuery("");
+            return;
+        }
+        if (event.key === "ArrowDown") {
+            event.preventDefault();
+            setActiveIndex((current) => Math.min(filtered.length - 1, current + 1));
+            return;
+        }
+        if (event.key === "ArrowUp") {
+            event.preventDefault();
+            setActiveIndex((current) => Math.max(0, current - 1));
+            return;
+        }
+        if (event.key === "Enter" && filtered[activeIndex]) {
+            event.preventDefault();
+            props.onChange(filtered[activeIndex].slug);
+        }
+    };
+    return React.createElement("div", { className: "mcoda-agent-setup__agent-search", onKeyDown }, React.createElement("input", {
+        value: query,
+        onChange: (event) => setQuery(event.target.value),
+        "aria-label": "Search agents",
+        placeholder: "Search agent, model, provider, or slug",
+    }), selected
+        ? React.createElement("div", { className: "mcoda-agent-setup__selected-agent" }, selected.displayName ?? selected.slug)
+        : null, React.createElement("div", null, `Showing all ${filtered.length} agents`), React.createElement("div", {
+        className: "mcoda-agent-setup__agent-list",
+        role: "listbox",
+        style: { maxHeight: viewportHeight, overflowY: "auto" },
+        onScroll: (event) => setScrollTop(event.currentTarget.scrollTop),
+    }, React.createElement("div", { style: { height: windowed.beforeHeight } }), windowed.items.map((agent) => {
+        const absoluteIndex = filtered.findIndex((candidate) => candidate.slug === agent.slug);
+        const active = absoluteIndex === activeIndex;
+        return (React.createElement("button", {
+            key: agent.slug,
+            type: "button",
+            className: agent.slug === props.value || active
+                ? "mcoda-agent-setup__agent-row mcoda-agent-setup__agent-row--selected"
+                : "mcoda-agent-setup__agent-row",
+            role: "option",
+            "aria-selected": agent.slug === props.value,
+            style: { minHeight: rowHeight },
+            onClick: () => props.onChange(agent.slug),
+        }, React.createElement("span", null, agent.displayName ?? agent.slug), React.createElement("small", null, [agent.model ?? agent.defaultModel, agent.provider, agent.healthStatus]
+            .filter(Boolean)
+            .join(" / ")), React.createElement("code", null, agent.slug)));
+    }), React.createElement("div", { style: { height: windowed.afterHeight } })));
+}
+function joinClasses(...values) {
+    return values.filter(Boolean).join(" ");
+}
+export { createMcodaAgentSetupClient } from "../client.js";
+export { defaultMcodaStageDefinitions } from "../defaultStages.js";

package/dist/server/cliRuntime.d.ts

@@ -0,0 +1,12 @@
+import type { McodaRuntimeAdapter } from "../types.js";
+export interface CliMcodaRuntimeAdapterInput {
+    command?: string;
+    cwd?: string;
+    timeoutMs?: number;
+    runCommand?: (command: string, args: string[], options: {
+        cwd?: string;
+        timeoutMs?: number;
+    }) => Promise<unknown>;
+}
+export declare function createCliMcodaRuntimeAdapter(input?: CliMcodaRuntimeAdapterInput): McodaRuntimeAdapter;
+//# sourceMappingURL=cliRuntime.d.ts.map

package/dist/server/cliRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliRuntime.d.ts","sourceRoot":"","sources":["../../src/server/cliRuntime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAIV,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,CACX,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,KAC1C,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,GAAE,2BAAgC,GACtC,mBAAmB,CA4GrB"}

package/dist/server/cliRuntime.js

@@ -0,0 +1,130 @@
+import { spawn } from "node:child_process";
+import { normalizeAgentCatalogEntries } from "../headless/normalization.js";
+import { isCloudAgent, isSelfHostedAgent } from "../headless/catalog.js";
+export function createCliMcodaRuntimeAdapter(input = {}) {
+    const command = input.command ?? "mcoda";
+    const run = input.runCommand ??
+        ((cmd, args, options) => runJsonCommand(cmd, args, options));
+    const runAgents = async (args, fallback) => normalizeAgentCatalogEntries(await run(command, args, {
+        cwd: input.cwd,
+        timeoutMs: input.timeoutMs,
+    }), fallback);
+    const listLocal = async (options) => runAgents([
+        "agent",
+        "list",
+        "--json",
+        ...(options?.refreshHealth ? ["--refresh-health"] : []),
+    ], {
+        source: "local_registry",
+        synced: true,
+    });
+    return {
+        runtime: {
+            mode: "cli_fallback",
+            requiresMcodaCli: true,
+        },
+        async configureMswarmApiKey() {
+            throw new Error("The CLI mcoda runtime adapter does not configure mswarm API keys until mcoda exposes a stdin-safe secret command.");
+        },
+        async listCloudAgents(options) {
+            return runAgents([
+                "cloud",
+                "agent",
+                "list",
+                "--json",
+                ...(options?.provider ? ["--provider", options.provider] : []),
+            ], {
+                source: "cloud_catalog",
+                synced: false,
+                managedKind: "cloud",
+            });
+        },
+        async syncCloudAgents(options) {
+            await run(command, [
+                "cloud",
+                "agent",
+                "sync",
+                "--prune",
+                "--json",
+                ...(options?.provider ? ["--provider", options.provider] : []),
+            ], {
+                cwd: input.cwd,
+                timeoutMs: input.timeoutMs,
+            });
+            return (await listLocal(options)).filter(isCloudAgent);
+        },
+        async listSelfHostedAgents(options) {
+            return runAgents([
+                "self-hosted",
+                "agent",
+                "list",
+                "--provider",
+                options?.provider ?? "mcoda",
+                "--json",
+            ], {
+                source: "self_hosted_catalog",
+                synced: false,
+                managedKind: "self_hosted",
+            });
+        },
+        async syncSelfHostedAgents(options) {
+            await run(command, [
+                "self-hosted",
+                "agent",
+                "sync",
+                "--provider",
+                options?.provider ?? "mcoda",
+                "--prune",
+                "--json",
+            ], {
+                cwd: input.cwd,
+                timeoutMs: input.timeoutMs,
+            });
+            return (await listLocal(options)).filter(isSelfHostedAgent);
+        },
+        listLocalAgents: listLocal,
+    };
+}
+async function runJsonCommand(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeout = options.timeoutMs
+            ? setTimeout(() => {
+                child.kill("SIGTERM");
+                reject(new Error(`Command timed out after ${options.timeoutMs}ms`));
+            }, options.timeoutMs)
+            : undefined;
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (timeout)
+                clearTimeout(timeout);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (timeout)
+                clearTimeout(timeout);
+            if (code !== 0) {
+                reject(new Error(stderr.trim() || `Command failed with exit code ${code}`));
+                return;
+            }
+            try {
+                resolve(stdout.trim() ? JSON.parse(stdout) : {});
+            }
+            catch (error) {
+                reject(new Error(`Command did not return valid JSON: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        });
+    });
+}

package/dist/server/httpHandlers.d.ts

@@ -0,0 +1,13 @@
+import type { McodaAgentSetupHttpRequest, McodaAgentSetupHttpResponse, McodaAgentSetupService } from "../types.js";
+export interface McodaAgentSetupHttpHandlers {
+    getAgentSettings(request?: unknown): Promise<McodaAgentSetupHttpResponse>;
+    postMswarmApiKey(body: unknown, request?: unknown): Promise<McodaAgentSetupHttpResponse>;
+    postAgentsSync(body?: unknown, request?: unknown): Promise<McodaAgentSetupHttpResponse>;
+    patchAgentSettings(body: unknown, request?: unknown): Promise<McodaAgentSetupHttpResponse>;
+    postAgentsTest(body: unknown, request?: unknown): Promise<McodaAgentSetupHttpResponse>;
+}
+export declare function createMcodaAgentSetupHttpHandlers(service: McodaAgentSetupService): McodaAgentSetupHttpHandlers;
+export declare function createMcodaAgentSetupHttpHandler(service: McodaAgentSetupService, options?: {
+    basePath?: string;
+}): (request: McodaAgentSetupHttpRequest) => Promise<McodaAgentSetupHttpResponse>;
+//# sourceMappingURL=httpHandlers.d.ts.map

package/dist/server/httpHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpHandlers.d.ts","sourceRoot":"","sources":["../../src/server/httpHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,2BAA2B,EAC3B,sBAAsB,EACvB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAC1E,gBAAgB,CACd,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACxC,cAAc,CACZ,IAAI,CAAC,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACxC,kBAAkB,CAChB,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACxC,cAAc,CACZ,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,2BAA2B,CAAC,CAAC;CACzC;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,sBAAsB,GAC9B,2BAA2B,CA0E7B;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,sBAAsB,EAC/B,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,CAAC,OAAO,EAAE,0BAA0B,KAAK,OAAO,CAAC,2BAA2B,CAAC,CA8B/E"}

package/dist/server/httpHandlers.js

@@ -0,0 +1,130 @@
+export function createMcodaAgentSetupHttpHandlers(service) {
+    return {
+        async getAgentSettings(request) {
+            return jsonResponse(200, await service.fetchSnapshot(request));
+        },
+        async postMswarmApiKey(body, request) {
+            const record = asRecord(body);
+            return jsonResponse(200, await service.configureMswarmApiKey({
+                apiKey: stringValue(record.mswarm_api_key) ??
+                    stringValue(record.mswarmApiKey) ??
+                    stringValue(record.apiKey) ??
+                    "",
+                reasonCode: stringValue(record.reason_code) ??
+                    stringValue(record.reasonCode) ??
+                    undefined,
+                metadata: asOptionalRecord(record.metadata),
+            }, request));
+        },
+        async postAgentsSync(body, request) {
+            const record = asRecord(body);
+            return jsonResponse(200, await service.syncAgents({
+                reasonCode: stringValue(record.reason_code) ??
+                    stringValue(record.reasonCode) ??
+                    undefined,
+                metadata: asOptionalRecord(record.metadata),
+            }, request));
+        },
+        async patchAgentSettings(body, request) {
+            const record = asRecord(body);
+            return jsonResponse(200, await service.updateAssignments({
+                assignments: asStringNullRecord(record.assignments),
+                reasonCode: stringValue(record.reason_code) ??
+                    stringValue(record.reasonCode) ??
+                    undefined,
+                metadata: asOptionalRecord(record.metadata),
+            }, request));
+        },
+        async postAgentsTest(body, request) {
+            const record = asRecord(body);
+            return jsonResponse(200, await service.testAgent({
+                slug: stringValue(record.slug) ?? "",
+                prompt: stringValue(record.prompt) ?? undefined,
+                timeoutMs: numberValue(record.timeout_ms) ?? numberValue(record.timeoutMs) ?? undefined,
+            }, request));
+        },
+    };
+}
+export function createMcodaAgentSetupHttpHandler(service, options = {}) {
+    const handlers = createMcodaAgentSetupHttpHandlers(service);
+    const basePath = normalizePath(options.basePath ?? "/api/mcoda");
+    return async (request) => {
+        try {
+            const method = request.method.trim().toUpperCase();
+            const route = normalizeRoute(request.path ?? request.url ?? "/", basePath);
+            const rawRequest = request.raw ?? request;
+            if (method === "GET" && route === "/agent-settings") {
+                return handlers.getAgentSettings(rawRequest);
+            }
+            if (method === "POST" && route === "/mswarm-api-key") {
+                return handlers.postMswarmApiKey(request.body, rawRequest);
+            }
+            if (method === "POST" && route === "/agents/sync") {
+                return handlers.postAgentsSync(request.body, rawRequest);
+            }
+            if (method === "PATCH" && route === "/agent-settings") {
+                return handlers.patchAgentSettings(request.body, rawRequest);
+            }
+            if (method === "POST" && route === "/agents/test") {
+                return handlers.postAgentsTest(request.body, rawRequest);
+            }
+            return jsonResponse(404, { error: "not found" });
+        }
+        catch (error) {
+            return jsonResponse(400, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+}
+function jsonResponse(status, body) {
+    return {
+        status,
+        headers: {
+            "content-type": "application/json",
+        },
+        body,
+    };
+}
+function normalizeRoute(pathOrUrl, basePath) {
+    let pathname = pathOrUrl;
+    try {
+        pathname = new URL(pathOrUrl, "http://localhost").pathname;
+    }
+    catch {
+        pathname = pathOrUrl.split("?")[0] ?? pathOrUrl;
+    }
+    const normalized = normalizePath(pathname);
+    if (normalized === basePath)
+        return "/";
+    if (normalized.startsWith(`${basePath}/`)) {
+        return normalized.slice(basePath.length) || "/";
+    }
+    return normalized;
+}
+function normalizePath(pathname) {
+    const prefixed = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    return prefixed.replace(/\/+$/, "") || "/";
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asOptionalRecord(value) {
+    const record = asRecord(value);
+    return Object.keys(record).length ? record : undefined;
+}
+function asStringNullRecord(value) {
+    const record = asRecord(value);
+    return Object.fromEntries(Object.entries(record).map(([key, entry]) => [
+        key,
+        typeof entry === "string" && entry.trim() ? entry : null,
+    ]));
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/server/inMemoryRuntime.d.ts

@@ -0,0 +1,8 @@
+import type { McodaAgentCatalogEntry, McodaRuntimeAdapter } from "../types.js";
+export interface InMemoryMcodaRuntimeAdapterInput {
+    cloudAgents?: McodaAgentCatalogEntry[];
+    selfHostedAgents?: McodaAgentCatalogEntry[];
+    localAgents?: McodaAgentCatalogEntry[];
+}
+export declare function createInMemoryMcodaRuntimeAdapter(input?: InMemoryMcodaRuntimeAdapterInput): McodaRuntimeAdapter;
+//# sourceMappingURL=inMemoryRuntime.d.ts.map