@nudge-ui/mcp 0.2.0 → 0.2.2

package/dist/server.js

@@ -1,9 +1,12 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { realpath } from "node:fs/promises";
 import { createRequire } from "node:module";
+import { isAbsolute } from "node:path";
 import { z } from "zod";
-import { validateRoutes } from "./internal/agent-protocol.js";
 import { createLoopbackBridge, } from "./bridge.js";
+import { AdapterRouting } from "./adapterRouting.js";
+import { DiscoveredProjectRouter, diagnoseProjectSessions, discoverProjectSessions } from "./discovery.js";
 export const MCP_SERVER_NAME = "nudge-ui";
 export const MCP_SERVER_VERSION = readPackageVersion();
 function readPackageVersion() {
@@ -18,12 +21,15 @@ function readPackageVersion() {
 }
 /** Instructions are sent through MCP initialization for every host. */
 export const MCP_SERVER_INSTRUCTIONS = [
-    "Nudge UI is a local browser companion for one project workspace.",
-    "Browser pairing requires the app origin to be configured explicitly with --origin or NUDGE_UI_ORIGIN; an unconfigured bridge accepts no HTTP pairing.",
-    "Call nudge_listen (or nudge_connect) immediately at task start and keep the call open while waiting for a browser request; the bridge may be running before a listener exists.",
+    "Nudge UI is a local browser companion for one exact project workspace or Git worktree.",
+    "Supply workspaceRoot with the absolute checkout or application path you are editing on every tool call. Listing and selecting sessions requires this explicit scope; repeat the same workspaceRoot and sessionId for status, Canvas, and release calls. Never use the MCP process working directory to infer the task workspace.",
+    "When the user asks to listen to Nudge, call nudge_list_sessions when that tool is available; if several apps are running, select only a session marked matchesApplication.",
+    "Call nudge_listen (or nudge_connect) and keep the call open while waiting for a browser request; the bridge may be running before a listener exists.",
     "After a prompt is delivered, edit the project source using the host's normal approval flow.",
     "Report completed, failed, or interrupted status with nudge_report_status before listening again.",
+    "When the user asks to stop listening, call nudge_release when that tool is available so another agent can claim the project session.",
     "Canvas tools operate only on same-origin routes from the paired project.",
+    "Automated browsers such as Playwright and headless Chrome get the plain app without the Nudge editor; add ?nudge-ui=on to a URL only when testing Nudge itself.",
     "No request, prompt, or browser state is persisted by this companion.",
 ].join(" ");
 function textResult(value) {
@@ -39,12 +45,21 @@ function errorResult(error) {
     };
 }
 function promptResult(request) {
-    return textResult({
-        requestId: request.requestId,
-        projectId: request.projectId,
-        prompt: request.prompt,
-        ...(request.changeRevision === undefined ? {} : { changeRevision: request.changeRevision }),
-    });
+    const content = [{
+            type: "text",
+            text: JSON.stringify({
+                requestId: request.requestId,
+                projectId: request.projectId,
+                prompt: request.prompt,
+                ...(request.changeRevision === undefined ? {} : { changeRevision: request.changeRevision }),
+                ...(request.clientDispatchId === undefined ? {} : { clientDispatchId: request.clientDispatchId }),
+                ...(request.sketches === undefined ? {} : { sketches: request.sketches }),
+            }),
+        }];
+    for (const attachment of request.attachments ?? []) {
+        content.push({ type: "text", text: `Sketch image: ${attachment.filename}` }, { type: "image", data: attachment.data, mimeType: attachment.mimeType });
+    }
+    return { content };
 }
 function commandResult(result) {
     return {
@@ -59,27 +74,44 @@ function boundedWorkspaceRoot(value) {
         throw new TypeError("workspaceRoot must be a bounded non-empty string");
     return value;
 }
-function installTools(mcpServer, bridge) {
-    const listen = async (_args, extra) => {
+function installTools(mcpServer, bridge, routing) {
+    const target = async (args) => {
+        if (routing)
+            return await routing.target(args);
+        if (bridge instanceof DiscoveredProjectRouter && args.workspaceRoot !== undefined
+            && await realpath(args.workspaceRoot) !== bridge.applicationRoot) {
+            throw new Error("This legacy MCP configuration is restricted to another application. Rerun agent setup to migrate it to the reusable adapter.");
+        }
+        return bridge;
+    };
+    const workspaceInput = z.string().min(1).max(4096)
+        .refine(isAbsolute, "workspaceRoot must be an absolute path.")
+        .describe("Absolute path of the checkout or application being edited.");
+    const scopeInput = {
+        workspaceRoot: routing ? workspaceInput : workspaceInput.optional(),
+        sessionId: z.string().uuid().optional(),
+    };
+    const listen = async (args, extra) => {
         try {
-            return promptResult(await bridge.waitForPrompt(extra.signal));
+            return promptResult(await (await target(args)).waitForPrompt(extra.signal, args.sessionId));
         }
         catch (error) {
             return errorResult(error);
         }
     };
-    const listenDescription = "Call this immediately at task start. Wait for one browser prompt. Keep this standard MCP call open, then call nudge_report_status and listen again after the request ends.";
-    const emptyInput = {};
+    const listenDescription = "When the user asks to listen to Nudge, wait for one browser prompt. Keep this standard MCP call open, then call nudge_report_status and listen again after the request ends.";
+    const emptyInput = scopeInput;
+    const listenInput = scopeInput;
     mcpServer.registerTool("nudge_listen", {
         title: "Listen for Nudge requests",
         description: listenDescription,
-        inputSchema: emptyInput,
+        inputSchema: listenInput,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     }, listen);
     mcpServer.registerTool("nudge_connect", {
         title: "Connect to Nudge",
         description: "Open the long-lived Nudge browser connection and wait for one prompt.",
-        inputSchema: emptyInput,
+        inputSchema: listenInput,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     }, listen);
     mcpServer.registerTool("nudge_get_status", {
@@ -87,11 +119,51 @@ function installTools(mcpServer, bridge) {
         description: "Read the in-memory browser pairing and request status for this project.",
         inputSchema: emptyInput,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, async () => textResult(bridge.getStatus()));
+    }, async (args) => {
+        try {
+            return textResult(await (await target(args)).getStatus());
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+    if (routing || bridge?.listSessions) {
+        mcpServer.registerTool("nudge_list_sessions", {
+            title: "List Nudge project sessions",
+            description: "List live local Nudge sessions for the supplied checkout or application path. The workspaceRoot value is required so the adapter can select only sessions in that explicit scope.",
+            inputSchema: emptyInput,
+            annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        }, async (args) => textResult(routing ? await discoverProjectSessions(args.workspaceRoot, routing.registryRoot) : await bridge.listSessions()));
+    }
+    if (routing) {
+        mcpServer.registerTool("nudge_diagnose", {
+            title: "Diagnose Nudge discovery",
+            description: "Diagnose Nudge discovery for the supplied checkout or application path. The result includes the resolved registry, workspace, and application scope plus counts for missing registrations, invalid descriptors or health responses, unreachable loopback endpoints, and incompatible bridge protocols; credentials are never exposed.",
+            inputSchema: scopeInput,
+            annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        }, async (args) => textResult(await diagnoseProjectSessions(args.workspaceRoot, routing.registryRoot)));
+    }
+    if (routing || bridge?.release) {
+        mcpServer.registerTool("nudge_release", {
+            title: "Release Nudge session",
+            description: "Stop listening and release this adapter's project-session claim so another agent can connect.",
+            inputSchema: emptyInput,
+            annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        }, async (args) => {
+            try {
+                await (await target(args)).release();
+                return textResult({ released: true });
+            }
+            catch (error) {
+                return errorResult(error);
+            }
+        });
+    }
     mcpServer.registerTool("nudge_report_status", {
         title: "Report Nudge request status",
-        description: "Report working, completed, failed, or interrupted status for the prompt currently being handled.",
+        description: "Report working, completed, failed, or interrupted status for the prompt currently being handled. Report completed only after implementing the request; the browser removes its submitted sketches if their revisions are unchanged.",
         inputSchema: {
+            ...scopeInput,
             requestId: z.string().min(1).max(256),
             status: z.enum(["working", "completed", "failed", "interrupted"]),
             summary: z.string().max(32_000).optional(),
@@ -106,8 +178,8 @@ function installTools(mcpServer, bridge) {
             ...(args.error === undefined ? {} : { error: args.error }),
         };
         try {
-            bridge.updateRequestStatus(update);
-            return textResult(bridge.getStatus());
+            const updated = await (await target(args)).updateRequestStatus(update);
+            return textResult(updated ?? await (await target(args)).getStatus());
         }
         catch (error) {
             return errorResult(error);
@@ -118,9 +190,9 @@ function installTools(mcpServer, bridge) {
         description: "Read the paired browser's current Canvas groups and focus.",
         inputSchema: emptyInput,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, async () => {
+    }, async (args) => {
         try {
-            return commandResult(await bridge.dispatchCanvasCommand({ type: "read-state" }));
+            return commandResult(await (await target(args)).dispatchCanvasCommand({ type: "read-state" }));
         }
         catch (error) {
             return errorResult(error);
@@ -130,6 +202,7 @@ function installTools(mcpServer, bridge) {
         title: "Present routes in Canvas",
         description: "Append or focus an agent-owned, labeled comparison group of same-origin project routes in Canvas.",
         inputSchema: {
+            ...scopeInput,
             label: z.string().min(1).max(160),
             groupId: z.string().min(1).max(256).regex(/^agent-[A-Za-z0-9._:-]+$/).optional(),
             routes: z.array(z.object({
@@ -141,14 +214,11 @@ function installTools(mcpServer, bridge) {
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     }, async (args) => {
         try {
-            if (!bridge.effectiveOrigin)
-                throw new Error("Canvas routes require a paired or configured browser origin.");
-            const routes = validateRoutes(args.routes, bridge.effectiveOrigin);
-            return commandResult(await bridge.dispatchCanvasCommand({
+            return commandResult(await (await target(args)).dispatchCanvasCommand({
                 type: "present-routes",
                 groupId: args.groupId ?? `agent-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
                 label: args.label,
-                routes,
+                routes: args.routes,
             }));
         }
         catch (error) {
@@ -158,11 +228,11 @@ function installTools(mcpServer, bridge) {
     mcpServer.registerTool("nudge_focus_canvas_group", {
         title: "Focus Canvas group",
         description: "Focus an existing Canvas comparison group by its stable group ID.",
-        inputSchema: { groupId: z.string().min(1).max(256) },
+        inputSchema: { ...scopeInput, groupId: z.string().min(1).max(256) },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     }, async (args) => {
         try {
-            return commandResult(await bridge.dispatchCanvasCommand({ type: "focus-group", groupId: args.groupId }));
+            return commandResult(await (await target(args)).dispatchCanvasCommand({ type: "focus-group", groupId: args.groupId }));
         }
         catch (error) {
             return errorResult(error);
@@ -173,9 +243,9 @@ function installTools(mcpServer, bridge) {
         description: "Fit all current Canvas cards into the browser board.",
         inputSchema: emptyInput,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, async () => {
+    }, async (args) => {
         try {
-            return commandResult(await bridge.dispatchCanvasCommand({ type: "fit-all" }));
+            return commandResult(await (await target(args)).dispatchCanvasCommand({ type: "fit-all" }));
         }
         catch (error) {
             return errorResult(error);
@@ -184,11 +254,11 @@ function installTools(mcpServer, bridge) {
     mcpServer.registerTool("nudge_remove_canvas_group", {
         title: "Remove agent Canvas group",
         description: "Remove an agent-owned Canvas comparison group. The browser refuses removal of user-owned groups.",
-        inputSchema: { groupId: z.string().min(1).max(256).regex(/^agent-[A-Za-z0-9._:-]+$/) },
+        inputSchema: { ...scopeInput, groupId: z.string().min(1).max(256).regex(/^agent-[A-Za-z0-9._:-]+$/) },
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
     }, async (args) => {
         try {
-            return commandResult(await bridge.dispatchCanvasCommand({ type: "remove-group", groupId: args.groupId }));
+            return commandResult(await (await target(args)).dispatchCanvasCommand({ type: "remove-group", groupId: args.groupId }));
         }
         catch (error) {
             return errorResult(error);
@@ -252,3 +322,41 @@ export function createAgentCompanion(options) {
         close,
     };
 }
+/** Creates a stdio MCP adapter that discovers project-owned bridges. */
+export async function createDiscoveredAgentAdapter(options) {
+    const routing = options.workspaceRoot === undefined ? new AdapterRouting(options.registryRoot) : undefined;
+    const router = options.workspaceRoot === undefined
+        ? undefined
+        : await DiscoveredProjectRouter.create(options.workspaceRoot, options.registryRoot);
+    const mcpServer = new McpServer({
+        name: options.serverName ?? MCP_SERVER_NAME,
+        version: options.serverVersion ?? MCP_SERVER_VERSION,
+    }, { instructions: MCP_SERVER_INSTRUCTIONS });
+    installTools(mcpServer, router, routing);
+    let transport = null;
+    let started = false;
+    let closePromise = null;
+    return {
+        mcpServer,
+        router: (router ?? routing),
+        async start(providedTransport) {
+            if (started)
+                return;
+            if (closePromise)
+                throw new Error("The Nudge MCP adapter is closing.");
+            started = true;
+            transport = providedTransport ?? new StdioServerTransport();
+            await mcpServer.connect(transport);
+        },
+        close() {
+            if (closePromise)
+                return closePromise;
+            closePromise = (async () => {
+                await (router ?? routing).close();
+                if (transport)
+                    await mcpServer.close().catch(() => undefined);
+            })();
+            return closePromise;
+        },
+    };
+}

package/dist/sessionRegistry.d.ts

@@ -0,0 +1,17 @@
+import { type SessionHealth } from "./projectSessionClient.js";
+import type { StoredProjectSession } from "./project.js";
+export interface LiveProjectSession {
+    readonly descriptor: StoredProjectSession;
+    readonly health: SessionHealth;
+}
+export interface SessionInspection {
+    readonly descriptorCount: number;
+    readonly invalidCount: number;
+    readonly incompatibleCount: number;
+    readonly unreachable: readonly Pick<StoredProjectSession, "workspaceRoot" | "appRoot" | "sessionId">[];
+    readonly live: LiveProjectSession[];
+}
+/** Separates absent, invalid, incompatible, and unreachable registrations. */
+export declare function inspectProjectSessions(registryRoot: string): Promise<SessionInspection>;
+/** Keeps only compatible bridges that answer authenticated probes. */
+export declare function readLiveProjectSessions(registryRoot: string): Promise<LiveProjectSession[]>;

package/dist/sessionRegistry.js

@@ -0,0 +1,121 @@
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+import { AGENT_PROTOCOL_VERSION } from "./internal/agent-protocol.js";
+import { ProjectSessionResponseError, readSessionHealth } from "./projectSessionClient.js";
+const PROBE_TIMEOUT_MS = 750;
+const MAX_DESCRIPTOR_BYTES = 32 * 1024;
+/** Separates absent, invalid, incompatible, and unreachable registrations. */
+export async function inspectProjectSessions(registryRoot) {
+    const names = (await readRegistryDirectory(registryRoot)).filter((name) => name.endsWith(".json"));
+    const records = await Promise.all(names.map((name) => readDescriptor(resolve(registryRoot, name))));
+    const descriptors = records.filter((record) => typeof record === "object");
+    const probes = await Promise.all(descriptors.map(probeSession));
+    return {
+        descriptorCount: names.length,
+        invalidCount: records.filter((record) => record === undefined).length
+            + probes.filter((probe) => probe.kind === "invalid").length,
+        incompatibleCount: records.filter((record) => record === "incompatible").length,
+        unreachable: descriptors.filter((_, index) => probes[index]?.kind === "unreachable")
+            .map(({ workspaceRoot, appRoot, sessionId }) => ({ workspaceRoot, appRoot, sessionId })),
+        live: probes.flatMap((probe) => probe.kind === "live" ? [probe.session] : []),
+    };
+}
+/** Keeps only compatible bridges that answer authenticated probes. */
+export async function readLiveProjectSessions(registryRoot) {
+    return (await inspectProjectSessions(registryRoot)).live;
+}
+async function readRegistryDirectory(registryRoot) {
+    try {
+        return await readdir(registryRoot);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function readDescriptor(path) {
+    try {
+        const metadata = await lstat(path);
+        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > MAX_DESCRIPTOR_BYTES)
+            return undefined;
+        if (typeof process.getuid === "function" && metadata.uid !== process.getuid())
+            return undefined;
+        if ((metadata.mode & 0o077) !== 0)
+            return undefined;
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (!isStoredSession(parsed))
+            return undefined;
+        if (parsed.protocolVersion !== AGENT_PROTOCOL_VERSION)
+            return "incompatible";
+        const [workspaceRoot, appRoot] = await Promise.all([realpath(parsed.workspaceRoot), realpath(parsed.appRoot)]);
+        return { ...parsed, protocolVersion: AGENT_PROTOCOL_VERSION, workspaceRoot, appRoot };
+    }
+    catch {
+        // Records can disappear during shutdown or refer to a removed worktree.
+        return undefined;
+    }
+}
+async function probeSession(descriptor) {
+    try {
+        const health = await readSessionHealth(descriptor, PROBE_TIMEOUT_MS);
+        if (!isSessionHealth(health) || health.projectId !== descriptor.projectId)
+            return { kind: "invalid" };
+        return { kind: "live", session: { descriptor, health } };
+    }
+    catch (error) {
+        // An HTTP response proves that the endpoint exists. Network and timeout errors are unreachable.
+        return { kind: error instanceof ProjectSessionResponseError ? "invalid" : "unreachable" };
+    }
+}
+function isSessionHealth(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const health = value;
+    return typeof health.projectId === "string"
+        && health.available === true
+        && typeof health.claimed === "boolean"
+        && isAgentStatusSnapshot(health.status);
+}
+function isAgentStatusSnapshot(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const status = value;
+    return status.protocolVersion === AGENT_PROTOCOL_VERSION
+        && typeof status.projectId === "string"
+        && (status.connection === "offline" || status.connection === "listening" || status.connection === "paired" || status.connection === "working")
+        && typeof status.listenerActive === "boolean"
+        && typeof status.paired === "boolean"
+        && (status.request === null || (typeof status.request === "object" && !Array.isArray(status.request)));
+}
+function isLoopbackEndpoint(value) {
+    if (typeof value !== "string")
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:"
+            && (url.hostname === "127.0.0.1" || url.hostname === "[::1]" || url.hostname === "::1" || url.hostname === "localhost")
+            && url.pathname === "/" && !url.username && !url.password && !url.search && !url.hash;
+    }
+    catch {
+        return false;
+    }
+}
+function isStoredSession(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const session = value;
+    return session.schemaVersion === 1
+        && typeof session.protocolVersion === "number" && Number.isSafeInteger(session.protocolVersion)
+        && typeof session.sessionId === "string" && session.sessionId.length > 0
+        && typeof session.projectId === "string" && session.projectId.length > 0
+        && typeof session.workspaceRoot === "string" && session.workspaceRoot.length > 0
+        && typeof session.appRoot === "string" && session.appRoot.length > 0
+        && (session.gitCommonDir === undefined || typeof session.gitCommonDir === "string")
+        && (session.branch === undefined || typeof session.branch === "string")
+        && typeof session.origin === "string"
+        && isLoopbackEndpoint(session.endpoint)
+        && typeof session.startedAt === "string"
+        && typeof session.pid === "number" && Number.isSafeInteger(session.pid)
+        && typeof session.controlToken === "string" && session.controlToken.length >= 32 && session.controlToken.length <= 256;
+}

package/dist/sessionSelection.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectSession, StoredProjectSession } from "./project.js";
+/** Canonical paths resolved before discovery or selection. */
+export interface SessionScope {
+    readonly workspaceRoot: string;
+    readonly applicationRoot: string;
+}
+interface SelectionOptions extends SessionScope {
+    readonly requestedSessionId?: string;
+    readonly previousSession?: Pick<ProjectSession, "sessionId" | "appRoot">;
+}
+/** A workspace-root adapter can select any application in that exact workspace. */
+export declare function matchesApplication(session: ProjectSession, scope: SessionScope): boolean;
+/** Chooses a live session without accessing files, making requests, or claiming it. */
+export declare function selectProjectSession(sessions: readonly StoredProjectSession[], options: SelectionOptions): StoredProjectSession;
+export {};

package/dist/sessionSelection.js

@@ -0,0 +1,41 @@
+/** A workspace-root adapter can select any application in that exact workspace. */
+export function matchesApplication(session, scope) {
+    return session.workspaceRoot === scope.workspaceRoot
+        && (scope.applicationRoot === scope.workspaceRoot || session.appRoot === scope.applicationRoot);
+}
+/** Chooses a live session without accessing files, making requests, or claiming it. */
+export function selectProjectSession(sessions, options) {
+    const candidates = sessions.filter((session) => matchesApplication(session, options));
+    const applicationScoped = options.applicationRoot !== options.workspaceRoot;
+    if (options.requestedSessionId) {
+        const requested = candidates.find((session) => session.sessionId === options.requestedSessionId);
+        if (requested)
+            return requested;
+        throw new Error(applicationScoped
+            ? "The selected Nudge session is not live for this exact application."
+            : "The selected Nudge session is not live in this exact workspace.");
+    }
+    if (options.previousSession)
+        return restoreSelection(candidates, options.previousSession);
+    if (candidates.length === 1)
+        return candidates[0];
+    if (!sessions.some((session) => session.workspaceRoot === options.workspaceRoot)) {
+        throw new Error("No live Nudge project session matches this exact workspace. Start the project development server first.");
+    }
+    if (candidates.length === 0 && applicationScoped) {
+        throw new Error("No live Nudge project session matches this exact application. Start its development server first.");
+    }
+    throw new Error("Several Nudge apps are running in this workspace. Call nudge_list_sessions, then pass sessionId to nudge_listen.");
+}
+function restoreSelection(candidates, previous) {
+    const current = candidates.find((session) => session.sessionId === previous.sessionId);
+    if (current)
+        return current;
+    const replacements = candidates.filter((session) => session.appRoot === previous.appRoot);
+    if (replacements.length === 1)
+        return replacements[0];
+    if (replacements.length > 1) {
+        throw new Error("Several restarted Nudge sessions match the selected app. Pass sessionId explicitly.");
+    }
+    throw new Error("The previously selected Nudge app is no longer running.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudge-ui/mcp",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Optional local MCP companion for pairing Nudge UI with coding agents.",
   "license": "MIT",
   "repository": {
@@ -42,6 +42,11 @@
       "types": "./dist/server.d.ts",
       "import": "./dist/server.js",
       "default": "./dist/server.js"
+    },
+    "./project": {
+      "types": "./dist/project.d.ts",
+      "import": "./dist/project.js",
+      "default": "./dist/project.js"
     }
   },
   "dependencies": {