@cursor/july 0.1.37 → 0.1.39

package/dist/files-backends/cursor-hosted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cursor-hosted.d.ts","sourceRoot":"","sources":["../../src/files-backends/cursor-hosted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAGH,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,YAAY,EAGlB,MAAM,aAAa,CAAC;AAWrB;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,gCACjB,CAAC;AAgBhC;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAGT;AAED,MAAM,WAAW,wBAAwB;IACvC,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAuCD,KAAK,kBAAkB,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG;IAChD,gFAAgF;IAChF,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;CACrD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,wBAA6B,GACrC,kBAAkB,CAyWpB"}
+{"version":3,"file":"cursor-hosted.d.ts","sourceRoot":"","sources":["../../src/files-backends/cursor-hosted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAGH,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,YAAY,EAGlB,MAAM,aAAa,CAAC;AAWrB;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,gCACjB,CAAC;AAgBhC;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAGT;AAED,MAAM,WAAW,wBAAwB;IACvC,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAuCD,KAAK,kBAAkB,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG;IAChD,gFAAgF;IAChF,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;CACrD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,wBAA6B,GACrC,kBAAkB,CAoXpB"}

package/dist/files-backends/cursor-hosted.js

@@ -368,10 +368,21 @@ export function cursorHostedFiles(options = {}) {
                         method: "GET",
                         redirect: "manual",
                     });
-                    if (response.status === 404 || response.status === 403) {
-                        // A presigned GET for a missing object surfaces as 403 on S3.
+                    if (response.status === 404) {
                         return undefined;
                     }
+                    // A 403 here is deliberately *not* absence. Absence was already
+                    // settled above: the store refuses to presign a path with no live
+                    // object, so reaching this point means the object existed moments
+                    // ago. What produces a 403 after a good presign is an expired or
+                    // clock-skewed signature, a policy change, or a delete that raced the
+                    // GET — all transient or retryable, none of them "definitively gone".
+                    //
+                    // Reporting them as absence is how a store blip becomes data loss:
+                    // `undefined` on a continuation read is taken as "unknown token", and
+                    // the engine mints a fresh session under it, forking the thread. The
+                    // delete race resolves itself on retry, where the presign returns 404
+                    // and this correctly reads as a miss.
                     if (!response.ok) {
                         throw new Error(`cursorHostedFiles: download of "${key}" failed (HTTP ${response.status})`);
                     }

package/dist/internal/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/internal/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EASrB,KAAK,UAAU,EAqBhB,MAAM,aAAa,CAAC;AA0BrB,MAAM,WAAW,uBAAuB;IACtC,sDAAsD;IACtD,YAAY,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3E;AAmBD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASrE;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,EAAE,CAAC,CA2B1B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC,CAoBzD;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAAuB,GAAG;IACjC,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;CACtB,GACL,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC,CAgBzD;AAWD,iFAAiF;AACjF,eAAO,MAAM,cAAc,EAAE,GAAG,CAAC,MAAM,CAIrC,CAAC;AAEH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,YAAY,CAAC,CAiEvB;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAElE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,MAAM,CAOnE;AA8oBD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAiB3E;AAkrBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,gBAAgB,CA6InE"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/internal/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EASrB,KAAK,UAAU,EAuBhB,MAAM,aAAa,CAAC;AA2BrB,MAAM,WAAW,uBAAuB;IACtC,sDAAsD;IACtD,YAAY,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3E;AAmBD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASrE;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,EAAE,CAAC,CA2B1B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC,CAoBzD;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAAuB,GAAG;IACjC,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;CACtB,GACL,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC,CAgBzD;AAWD,iFAAiF;AACjF,eAAO,MAAM,cAAc,EAAE,GAAG,CAAC,MAAM,CAIrC,CAAC;AAEH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,YAAY,CAAC,CAiEvB;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAElE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,MAAM,CAOnE;AA2pBD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAiB3E;AAgxBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,gBAAgB,CA6InE"}

package/dist/internal/discovery.js

@@ -31,7 +31,7 @@ import { pathToFileURL } from "node:url";
 import { resolveABMaxPlaygroundSessions } from "../ab.js";
 import { resolveArtifactsMax } from "../artifacts.js";
 import { httpChannel } from "../channels.js";
-import { cursorAccountServersHasMixedWildcard, DEFAULT_MODEL, MAX_RUNNING_TURNS_LIMIT, normalizeCursorAccountServers, toPublicCloudInfo, } from "../types.js";
+import { cursorAccountServersHasMixedWildcard, DEFAULT_MODEL, isInlineStdioConnection, MAX_RUNNING_TURNS_LIMIT, normalizeCursorAccountServers, toPublicCloudInfo, } from "../types.js";
 import { registerAuthoredModuleLoaders } from "./authored-loaders.js";
 import { normalizePositiveInt } from "./bounded-int.js";
 import { getDefinitionKind } from "./brand.js";
@@ -41,6 +41,7 @@ import { parseFrontmatter } from "./frontmatter.js";
 import { isReservedSecretName, MAX_EGRESS_DOMAINS, validateEgressDomain, validateSecretName, } from "./hosting.js";
 import { toolInputJsonSchema } from "./json-schema.js";
 import { MCP_ENDPOINT_PATH, mcpEndpointToolNames } from "./mcp-endpoint.js";
+import { packageInlineStdioConnection } from "./package-inline-stdio.js";
 import { withIdentityPreamble } from "./workspace.js";
 const MODULE_EXTENSIONS = new Set([".ts", ".mts", ".js", ".mjs"]);
 const NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
@@ -739,6 +740,18 @@ function hasAuthorizationHeader(headers) {
     }
     return Object.keys(headers).some((key) => key.toLowerCase() === "authorization");
 }
+function connectionHasSpawnOrRemote(connection) {
+    if ("cursorAccount" in connection && connection.cursorAccount === true) {
+        return true;
+    }
+    if ("agent" in connection && !isBlank(connection.agent)) {
+        return true;
+    }
+    if ("url" in connection && !isBlank(connection.url)) {
+        return true;
+    }
+    return "command" in connection && !isBlank(connection.command);
+}
 function connectionTransport(connection) {
     if ("cursorAccount" in connection && connection.cursorAccount === true) {
         const servers = normalizeCursorAccountServers(connection.servers);
@@ -850,6 +863,23 @@ function loadConnections(ctx, connectionsDir) {
                 continue;
             }
             const connection = definition;
+            if (isInlineStdioConnection(connection) &&
+                connectionHasSpawnOrRemote(connection)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "MCP connection `tools` cannot be combined with `command`, `url`, `agent`, or `cursorAccount`. Author TypeScript tools, or point at an existing server, not both.",
+                });
+                continue;
+            }
+            if (isInlineStdioConnection(connection)) {
+                const packed = yield loadInlineStdioConnection(ctx, name, entryPath, connection);
+                if (packed === undefined) {
+                    continue;
+                }
+                connections.push(packed);
+                continue;
+            }
             if ("url" in connection &&
                 connection.oauth === true &&
                 hasAuthorizationHeader(connection.headers)) {
@@ -875,7 +905,7 @@ function loadConnections(ctx, connectionsDir) {
                 ctx.diagnostics.push({
                     severity: "error",
                     path: displayPath(ctx, entryPath),
-                    message: "MCP connections require a `url` (http/sse), a `command` (stdio), an `agent` (peer agent slug on the same serve host), or `cursorAccount: true` (the Cursor account's MCP connectors).",
+                    message: "MCP connections require a `url` (http/sse), a `command` (stdio), `tools` (TypeScript packaged as stdio), an `agent` (peer agent slug on the same serve host), or `cursorAccount: true` (the Cursor account's MCP connectors).",
                 });
                 continue;
             }
@@ -908,6 +938,69 @@ function loadConnections(ctx, connectionsDir) {
         return connections;
     });
 }
+function loadInlineStdioConnection(ctx, name, entryPath, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tools = connection.tools;
+        const names = Object.keys(tools);
+        if (names.length === 0) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, entryPath),
+                message: "MCP connection `tools` must declare at least one tool.",
+            });
+            return undefined;
+        }
+        for (const toolName of names) {
+            if (!NAME_PATTERN.test(toolName)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `MCP tool name "${toolName}" must match ${NAME_PATTERN}.`,
+                });
+                return undefined;
+            }
+            const tool = tools[toolName];
+            if (tool === undefined || isBlank(tool.description)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `MCP tool "${toolName}" requires a non-empty description.`,
+                });
+                return undefined;
+            }
+            if (typeof tool.execute !== "function") {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `MCP tool "${toolName}" requires an execute(input) function.`,
+                });
+                return undefined;
+            }
+        }
+        try {
+            const transport = yield packageInlineStdioConnection({
+                name,
+                entryPath,
+                tools,
+                absWorkingDir: ctx.rootDir,
+            });
+            return {
+                name,
+                transport,
+                description: connection.description,
+                hostOnly: connection.hostOnly,
+            };
+        }
+        catch (error) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, entryPath),
+                message: `Failed to package inline stdio MCP connection: ${errorMessage(error)}`,
+            });
+            return undefined;
+        }
+    });
+}
 // ============================================================================
 // Subagents
 // ============================================================================

package/dist/internal/framework-storage-selection.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Which backend framework session state is mirrored to.
+ *
+ * Framework state — session records, event chunks, the continuation index —
+ * is how a session outlives the process that served it. Today that mirror
+ * exists only when the agent author wrote `agent/storage.ts`, which makes
+ * platform durability an agent-level decision: of the first-party agents,
+ * some choose `cursorHostedStorage()` and some choose `fileKv()` (pod-local
+ * disk, lost on pod replacement), and one selects between them at runtime by
+ * reading the deployment-id environment variable itself.
+ *
+ * That selection is a hosting-mode question, not an authoring question, and
+ * this module is where it will move. It deliberately reproduces today's
+ * behavior exactly for now — authored definition or nothing — so the change
+ * that makes framework durability automatic is a change to
+ * {@link selectFrameworkStorageDefinition} alone, reviewable on its own and
+ * revertable without touching the engine.
+ *
+ * Local disk is not part of this decision. `<stateRoot>/sessions/<id>/`
+ * already holds `session.json` and `events.ndjson` unconditionally, through
+ * the session store; what this selects is the durable mirror *beyond* the
+ * pod's filesystem.
+ */
+import type { StorageDefinition } from "../storage.js";
+export interface FrameworkStorageSelectionInput {
+    /** `agent/storage.ts`, when the author wrote one. */
+    readonly authored: StorageDefinition | undefined;
+}
+/**
+ * Pick the backend for framework session state.
+ *
+ * Returns `undefined` when there is no mirror, in which case the pod's local
+ * disk is the only copy — the condition F0 exists to remove for hosted
+ * deployments.
+ */
+export declare function selectFrameworkStorageDefinition(input: FrameworkStorageSelectionInput): StorageDefinition | undefined;
+//# sourceMappingURL=framework-storage-selection.d.ts.map

package/dist/internal/framework-storage-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-storage-selection.d.ts","sourceRoot":"","sources":["../../src/internal/framework-storage-selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,WAAW,8BAA8B;IAC7C,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;CAClD;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,8BAA8B,GACpC,iBAAiB,GAAG,SAAS,CAI/B"}

package/dist/internal/framework-storage-selection.js

@@ -0,0 +1,35 @@
+/**
+ * Which backend framework session state is mirrored to.
+ *
+ * Framework state — session records, event chunks, the continuation index —
+ * is how a session outlives the process that served it. Today that mirror
+ * exists only when the agent author wrote `agent/storage.ts`, which makes
+ * platform durability an agent-level decision: of the first-party agents,
+ * some choose `cursorHostedStorage()` and some choose `fileKv()` (pod-local
+ * disk, lost on pod replacement), and one selects between them at runtime by
+ * reading the deployment-id environment variable itself.
+ *
+ * That selection is a hosting-mode question, not an authoring question, and
+ * this module is where it will move. It deliberately reproduces today's
+ * behavior exactly for now — authored definition or nothing — so the change
+ * that makes framework durability automatic is a change to
+ * {@link selectFrameworkStorageDefinition} alone, reviewable on its own and
+ * revertable without touching the engine.
+ *
+ * Local disk is not part of this decision. `<stateRoot>/sessions/<id>/`
+ * already holds `session.json` and `events.ndjson` unconditionally, through
+ * the session store; what this selects is the durable mirror *beyond* the
+ * pod's filesystem.
+ */
+/**
+ * Pick the backend for framework session state.
+ *
+ * Returns `undefined` when there is no mirror, in which case the pod's local
+ * disk is the only copy — the condition F0 exists to remove for hosted
+ * deployments.
+ */
+export function selectFrameworkStorageDefinition(input) {
+    // Today: the author decides, or there is no mirror. Hosting-mode selection
+    // replaces this body; every caller already routes through here.
+    return input.authored;
+}

package/dist/internal/inline-stdio-define-stub.d.ts

@@ -0,0 +1,3 @@
+/** Bundled stand-in for `@anysphere/agent-serve/connections` / `@cursor/july/connections`. */
+export declare function defineConnection<T>(config: T): T;
+//# sourceMappingURL=inline-stdio-define-stub.d.ts.map

package/dist/internal/inline-stdio-define-stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-stdio-define-stub.d.ts","sourceRoot":"","sources":["../../src/internal/inline-stdio-define-stub.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAEhD"}

package/dist/internal/inline-stdio-define-stub.js

@@ -0,0 +1,4 @@
+/** Bundled stand-in for `@anysphere/agent-serve/connections` / `@cursor/july/connections`. */
+export function defineConnection(config) {
+    return config;
+}

package/dist/internal/inline-stdio-mcp.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generic newline-delimited JSON-RPC stdio MCP server for packaged
+ * `defineConnection({ tools })` modules. Bundled into `node -e` so a
+ * repo-less cloud VM can spawn it. Keep this file free of framework
+ * barrels and the official MCP SDK.
+ */
+type InlineTool = {
+    description: string;
+    inputSchema?: {
+        safeParse?: (value: unknown) => {
+            success: boolean;
+            data?: unknown;
+            error?: {
+                issues?: Array<{
+                    path: unknown[];
+                    message: string;
+                }>;
+            };
+        };
+    };
+    execute: (input: Record<string, unknown>) => unknown | Promise<unknown>;
+};
+export type InlineStdioCatalogEntry = {
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+export type InlineStdioDefinition = {
+    tools?: Record<string, InlineTool>;
+};
+export declare function serveInlineStdioMcp(serverName: string, definition: InlineStdioDefinition, catalog: Record<string, InlineStdioCatalogEntry>): void;
+export {};
+//# sourceMappingURL=inline-stdio-mcp.d.ts.map

package/dist/internal/inline-stdio-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-stdio-mcp.d.ts","sourceRoot":"","sources":["../../src/internal/inline-stdio-mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH,KAAK,UAAU,GAAG;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QACZ,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK;YAC9B,OAAO,EAAE,OAAO,CAAC;YACjB,IAAI,CAAC,EAAE,OAAO,CAAC;YACf,KAAK,CAAC,EAAE;gBAAE,MAAM,CAAC,EAAE,KAAK,CAAC;oBAAE,IAAI,EAAE,OAAO,EAAE,CAAC;oBAAC,OAAO,EAAE,MAAM,CAAA;iBAAE,CAAC,CAAA;aAAE,CAAC;SAClE,CAAC;KACH,CAAC;IACF,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACpC,CAAC;AAmKF,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,qBAAqB,EACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,GAC/C,IAAI,CAwBN"}

package/dist/internal/inline-stdio-mcp.js

@@ -0,0 +1,180 @@
+/**
+ * Generic newline-delimited JSON-RPC stdio MCP server for packaged
+ * `defineConnection({ tools })` modules. Bundled into `node -e` so a
+ * repo-less cloud VM can spawn it. Keep this file free of framework
+ * barrels and the official MCP SDK.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const PROTOCOL_VERSION = "2025-03-26";
+function write(message) {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+function stringifyResult(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    return JSON.stringify(result);
+}
+function isMcpEnvelope(result) {
+    return (typeof result === "object" &&
+        result !== null &&
+        "content" in result &&
+        Array.isArray(result.content));
+}
+function validateInput(tool, args) {
+    var _a;
+    var _b;
+    const record = typeof args === "object" && args !== null
+        ? args
+        : {};
+    const schema = tool.inputSchema;
+    if (schema === undefined || typeof schema.safeParse !== "function") {
+        return { ok: true, value: record };
+    }
+    const parsed = schema.safeParse(args !== null && args !== void 0 ? args : {});
+    if (parsed.success) {
+        const value = typeof parsed.data === "object" && parsed.data !== null
+            ? parsed.data
+            : record;
+        return { ok: true, value };
+    }
+    const issues = (_b = (_a = parsed.error) === null || _a === void 0 ? void 0 : _a.issues) !== null && _b !== void 0 ? _b : [];
+    const message = issues
+        .map((issue) => {
+        const path = issue.path.join(".");
+        return path === "" ? issue.message : `${path}: ${issue.message}`;
+    })
+        .join("; ") || "invalid input";
+    return { ok: false, message };
+}
+function handle(message, serverName, tools, catalog) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const method = message.method;
+        if (typeof method !== "string" || !("id" in message)) {
+            return;
+        }
+        const id = message.id;
+        const params = typeof message.params === "object" && message.params !== null
+            ? message.params
+            : {};
+        try {
+            if (method === "initialize") {
+                const requested = params.protocolVersion;
+                write({
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        protocolVersion: typeof requested === "string" ? requested : PROTOCOL_VERSION,
+                        capabilities: { tools: {} },
+                        serverInfo: { name: serverName, version: "0.1.0" },
+                    },
+                });
+                return;
+            }
+            if (method === "ping") {
+                write({ jsonrpc: "2.0", id, result: {} });
+                return;
+            }
+            if (method === "tools/list") {
+                write({
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        tools: Object.entries(catalog).map(([name, entry]) => ({
+                            name,
+                            description: entry.description,
+                            inputSchema: entry.inputSchema,
+                        })),
+                    },
+                });
+                return;
+            }
+            if (method === "tools/call") {
+                const name = params.name;
+                const tool = typeof name === "string" ? tools[name] : undefined;
+                if (tool === undefined) {
+                    write({
+                        jsonrpc: "2.0",
+                        id,
+                        result: {
+                            content: [{ type: "text", text: `Unknown tool: ${String(name)}` }],
+                            isError: true,
+                        },
+                    });
+                    return;
+                }
+                const checked = validateInput(tool, params.arguments);
+                if (!checked.ok) {
+                    write({
+                        jsonrpc: "2.0",
+                        id,
+                        result: {
+                            content: [{ type: "text", text: checked.message }],
+                            isError: true,
+                        },
+                    });
+                    return;
+                }
+                const result = yield tool.execute(checked.value);
+                if (isMcpEnvelope(result)) {
+                    write({ jsonrpc: "2.0", id, result });
+                    return;
+                }
+                write({
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        content: [{ type: "text", text: stringifyResult(result) }],
+                    },
+                });
+                return;
+            }
+            write({
+                jsonrpc: "2.0",
+                id,
+                error: { code: -32601, message: `Method not found: ${method}` },
+            });
+        }
+        catch (error) {
+            write({
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32603,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    });
+}
+export function serveInlineStdioMcp(serverName, definition, catalog) {
+    var _a;
+    const tools = (_a = definition.tools) !== null && _a !== void 0 ? _a : {};
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+        buffer += chunk;
+        let newline = buffer.indexOf("\n");
+        while (newline !== -1) {
+            const line = buffer.slice(0, newline).replace(/\r$/, "");
+            buffer = buffer.slice(newline + 1);
+            if (line.length > 0) {
+                try {
+                    void handle(JSON.parse(line), serverName, tools, catalog);
+                }
+                catch (error) {
+                    process.stderr.write(`${serverName}: failed to parse MCP message: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+            }
+            newline = buffer.indexOf("\n");
+        }
+    });
+}

package/dist/internal/json-dir-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Small filesystem helpers for one-JSON-file-per-id persistence under a
+ * project-relative directory (eval run snapshots, A/B aggregate snapshots).
+ */
+export declare function assertNonEmptyDir(dir: string, fnName: string): string;
+/** Resolve `dir` against `projectRoot` when relative. */
+export declare function resolveProjectRelativeDir(args: {
+    dir: string;
+    projectRoot: string;
+}): string;
+/** List `*.json` basenames in `root` (any order). Missing dir → []. */
+export declare function listJsonBasenames(root: string): Promise<string[]>;
+/**
+ * Read and JSON.parse every `*.json` file under `root`. Missing dir → [].
+ * Unreadable or corrupt files are skipped so one bad snapshot cannot wipe
+ * the rest of the history.
+ */
+export declare function readJsonDir<T>(root: string, options?: {
+    sortBasenames?: "asc" | "desc";
+}): Promise<T[]>;
+/** Atomically write JSON under `root`/`fileName` (temp file + rename). */
+export declare function writeJsonFile(args: {
+    root: string;
+    fileName: string;
+    value: unknown;
+}): Promise<void>;
+/** Best-effort delete; ignores missing files. */
+export declare function deleteFileInDir(args: {
+    root: string;
+    fileName: string;
+}): Promise<void>;
+//# sourceMappingURL=json-dir-store.d.ts.map

package/dist/internal/json-dir-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-dir-store.d.ts","sourceRoot":"","sources":["../../src/internal/json-dir-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAKrE;AAED,yDAAyD;AACzD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,CAET;AAWD,uEAAuE;AACvE,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWvE;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;CAAE,GAC3C,OAAO,CAAC,CAAC,EAAE,CAAC,CAiBd;AAED,0EAA0E;AAC1E,wBAAsB,aAAa,CAAC,IAAI,EAAE;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhB;AAED,iDAAiD;AACjD,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhB"}

package/dist/internal/package-inline-stdio.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Package `defineConnection({ tools })` into a `node -e` stdio transport a
+ * repo-less cloud VM can spawn.
+ */
+import type { ConnectionTransport, InlineStdioConnectionConfig } from "../types.js";
+export declare function packageInlineStdioConnection(options: {
+    name: string;
+    entryPath: string;
+    tools: InlineStdioConnectionConfig["tools"];
+    absWorkingDir: string;
+}): Promise<ConnectionTransport>;
+//# sourceMappingURL=package-inline-stdio.d.ts.map

package/dist/internal/package-inline-stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-inline-stdio.d.ts","sourceRoot":"","sources":["../../src/internal/package-inline-stdio.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,KAAK,EACV,mBAAmB,EACnB,2BAA2B,EAE5B,MAAM,aAAa,CAAC;AA+BrB,wBAAsB,4BAA4B,CAAC,OAAO,EAAE;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,2BAA2B,CAAC,OAAO,CAAC,CAAC;IAC5C,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAsE/B"}

package/dist/internal/package-inline-stdio.js

@@ -0,0 +1,109 @@
+/**
+ * Package `defineConnection({ tools })` into a `node -e` stdio transport a
+ * repo-less cloud VM can spawn.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as esbuild from "esbuild";
+import { toolInputJsonSchema } from "./json-schema.js";
+const require = createRequire(import.meta.url);
+const CONNECTION_SPECIFIERS = new Set([
+    "@anysphere/agent-serve/connections",
+    "@cursor/july/connections",
+    "@cursor/agentkit/connections",
+]);
+function sibling(basename) {
+    const dir = fileURLToPath(new URL(".", import.meta.url));
+    const ts = join(dir, `${basename}.ts`);
+    return existsSync(ts) ? ts : join(dir, `${basename}.js`);
+}
+function jsonSchemaCatalog(tools) {
+    const catalog = {};
+    for (const [name, tool] of Object.entries(tools)) {
+        catalog[name] = {
+            description: tool.description,
+            inputSchema: toolInputJsonSchema(tool.inputSchema),
+        };
+    }
+    return catalog;
+}
+export function packageInlineStdioConnection(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const runtimePath = sibling("inline-stdio-mcp");
+        const stubPath = sibling("inline-stdio-define-stub");
+        const catalog = jsonSchemaCatalog(options.tools);
+        const result = yield esbuild.build({
+            entryPoints: ["inline-stdio-entry"],
+            bundle: true,
+            write: false,
+            platform: "node",
+            format: "esm",
+            target: "node22",
+            minify: true,
+            legalComments: "none",
+            absWorkingDir: options.absWorkingDir,
+            alias: {
+                zod: require.resolve("zod"),
+            },
+            plugins: [
+                {
+                    name: "inline-stdio-entry",
+                    setup(build) {
+                        build.onResolve({ filter: /^inline-stdio-entry$/ }, () => ({
+                            path: "inline-stdio-entry",
+                            namespace: "inline-stdio",
+                        }));
+                        build.onLoad({ filter: /.*/, namespace: "inline-stdio" }, () => ({
+                            contents: `import definition from ${JSON.stringify(options.entryPath)};
+import { serveInlineStdioMcp } from ${JSON.stringify(runtimePath)};
+serveInlineStdioMcp(
+  ${JSON.stringify(options.name)},
+  definition,
+  ${JSON.stringify(catalog)}
+);
+`,
+                            resolveDir: dirname(options.entryPath),
+                            loader: "ts",
+                        }));
+                    },
+                },
+                {
+                    name: "inline-stdio-connection-stub",
+                    setup(build) {
+                        build.onResolve({ filter: /.*/ }, (args) => {
+                            if (CONNECTION_SPECIFIERS.has(args.path)) {
+                                return { path: stubPath };
+                            }
+                            return undefined;
+                        });
+                    },
+                },
+            ],
+        });
+        const file = (_a = result.outputFiles) === null || _a === void 0 ? void 0 : _a[0];
+        if (file === undefined) {
+            throw new Error(`Failed to package inline stdio MCP connection "${options.name}": esbuild produced no output.`);
+        }
+        const source = file.text.replace(/^#!.*\r?\n/, "");
+        if (source.trim() === "") {
+            throw new Error(`Failed to package inline stdio MCP connection "${options.name}": empty bundle.`);
+        }
+        return {
+            type: "stdio",
+            command: "node",
+            args: ["--input-type=module", "-e", source],
+        };
+    });
+}