@alumnium/cursor 0.0.0-stage → 0.24.0-alpha.2

package/src/index.cjs

@@ -0,0 +1,1194 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode
+      ? (__toESMCache_node ??= new WeakMap())
+      : (__toESMCache_esm ??= new WeakMap());
+    var cached = cache.get(mod);
+    if (cached) return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to =
+    isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default")
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target;
+  if ((mod && typeof mod === "object") || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true,
+        });
+  }
+  if (canCache) cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap()).get(from),
+    desc;
+  if (entry) return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name),
+    });
+};
+
+// cursor/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  CursorLanguageModel: () => CursorLanguageModel,
+  cursorProviders: () => cursorProviders,
+});
+module.exports = __toCommonJS(exports_src);
+
+// cursor/src/llm/CursorLanguageModel.ts
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_provider = require("@ai-sdk/provider");
+var import_zod = require("zod");
+var import_internal = require("@alumnium/core/internal");
+var logger = import_internal.Logger.get(
+  "packages/typescript/cursor/src/llm/CursorLanguageModel.ts",
+);
+var CHAT_CONTEXT = `# Execution context
+You are used as a chat completion model inside another application.
+Do NOT read or write files, run terminal commands, search the web, or use any
+built-in or MCP tools. Reply with a single final assistant message directly.`;
+var ToolCallsResponse = import_zod.z.object({
+  tool_calls: import_zod.z.array(
+    import_zod.z.object({
+      name: import_zod.z.string(),
+      arguments: import_zod.z
+        .record(import_zod.z.string(), import_zod.z.unknown())
+        .optional(),
+      args: import_zod.z
+        .record(import_zod.z.string(), import_zod.z.unknown())
+        .optional(),
+    }),
+  ),
+});
+
+class CursorLanguageModel {
+  specificationVersion = "v4";
+  provider = "cursor";
+  modelId;
+  supportedUrls = {};
+  #options;
+  #sandbox = true;
+  constructor(options) {
+    this.modelId = options.modelId;
+    this.#options = options;
+  }
+  async doGenerate(options) {
+    const abort = createAbortScope(options.abortSignal);
+    try {
+      return await this.#generateOnce(options, abort);
+    } catch (error) {
+      options.abortSignal?.throwIfAborted();
+      if (
+        this.#sandbox &&
+        error instanceof Error &&
+        error.name === "ConfigurationError" &&
+        /sandbox/i.test(error.message)
+      ) {
+        logger.warn(
+          "Cursor SDK sandboxing is not supported; retrying without it.",
+        );
+        this.#sandbox = false;
+        return await this.doGenerate(options);
+      }
+      if (
+        error instanceof Error &&
+        (error.name === "RateLimitError" ||
+          error.name === "TimeoutError" ||
+          ("isRetryable" in error && error.isRetryable === true))
+      ) {
+        throw new import_provider.APICallError({
+          message: error.message,
+          url: "cursor://local",
+          requestBodyValues: { model: this.modelId },
+          isRetryable: true,
+          cause: error,
+        });
+      }
+      throw error;
+    } finally {
+      abort.dispose();
+    }
+  }
+  async doStream(options) {
+    const result = await this.doGenerate(options);
+    return {
+      stream: new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "stream-start",
+            warnings: result.warnings,
+          });
+          controller.enqueue({ type: "response-metadata", ...result.response });
+          for (const part of result.content) {
+            if (part.type === "text") {
+              const id = crypto.randomUUID();
+              controller.enqueue({ type: "text-start", id });
+              controller.enqueue({ type: "text-delta", id, delta: part.text });
+              controller.enqueue({ type: "text-end", id });
+            } else if (part.type === "tool-call") {
+              controller.enqueue(part);
+            }
+          }
+          controller.enqueue({
+            type: "finish",
+            usage: result.usage,
+            finishReason: result.finishReason,
+          });
+          controller.close();
+        },
+      }),
+    };
+  }
+  async #generateOnce(options, abort) {
+    const signal = options.abortSignal;
+    signal?.throwIfAborted();
+    const prompt = serializePrompt(options);
+    const contract = responseContract(options);
+    const sdk = await abort.run((this.#options.sdkLoader ?? loadCursorSdk)());
+    const root = await import_promises.default.mkdtemp(
+      import_node_path.default.join(
+        import_node_os.default.tmpdir(),
+        "alumnium-cursor-",
+      ),
+    );
+    let agent;
+    try {
+      const cwd = import_node_path.default.join(root, "workspace");
+      await import_promises.default.mkdir(cwd);
+      const store = new sdk.JsonlLocalAgentStore(
+        import_node_path.default.join(root, "store"),
+      );
+      signal?.throwIfAborted();
+      agent = await abort.run(
+        sdk.Agent.create({
+          ...(this.#options.apiKey ? { apiKey: this.#options.apiKey } : {}),
+          model: { id: this.modelId },
+          local: {
+            cwd,
+            settingSources: [],
+            sandboxOptions: { enabled: this.#sandbox },
+            store,
+          },
+        }),
+        async (lateAgent) => {
+          try {
+            lateAgent.close();
+          } finally {
+            await import_promises.default.rm(root, {
+              recursive: true,
+              force: true,
+            });
+          }
+        },
+      );
+      const first = await send(
+        agent,
+        {
+          text: [prompt.text, CHAT_CONTEXT, contract].filter(Boolean).join(`
+
+`),
+          images: prompt.images,
+        },
+        abort,
+      );
+      const usages = [first.usage];
+      let content;
+      try {
+        content = parseResponse(first.result ?? "", options);
+      } catch (error) {
+        const retry = await send(
+          agent,
+          {
+            text: `Your previous reply was invalid: ${error instanceof Error ? error.message : String(error)}
+Respond again following this contract exactly:
+${contract}`,
+          },
+          abort,
+        );
+        usages.push(retry.usage);
+        content = parseResponse(retry.result ?? "", options);
+      }
+      return {
+        content,
+        finishReason: {
+          unified: content.some((part) => part.type === "tool-call")
+            ? "tool-calls"
+            : "stop",
+          raw: "finished",
+        },
+        usage: toUsage(usages),
+        warnings: [],
+        response: { id: first.id, modelId: this.modelId },
+      };
+    } finally {
+      try {
+        agent?.close();
+      } finally {
+        await import_promises.default.rm(root, {
+          recursive: true,
+          force: true,
+        });
+      }
+    }
+  }
+}
+async function loadCursorSdk() {
+  return import("@cursor/sdk");
+}
+function serializePrompt(options) {
+  const images = [];
+  const sections = options.prompt.map((message) => {
+    const text =
+      message.role === "system"
+        ? message.content
+        : message.content.map((part) => {
+            if (part.type === "text" || part.type === "reasoning")
+              return part.text;
+            if (part.type === "tool-call")
+              return JSON.stringify({
+                tool_call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: part.input,
+              });
+            if (part.type === "tool-result")
+              return JSON.stringify({
+                tool_call_id: part.toolCallId,
+                name: part.toolName,
+                output: part.output,
+              });
+            if (part.type === "file" && part.mediaType.startsWith("image/")) {
+              if (part.data.type === "url") return part.data.url.toString();
+              if (part.data.type === "data") {
+                images.push({
+                  mimeType: part.mediaType,
+                  data:
+                    typeof part.data.data === "string"
+                      ? part.data.data
+                      : Buffer.from(part.data.data).toString("base64"),
+                });
+                return `[image ${images.length} attached]`;
+              }
+            }
+            throw new import_provider.UnsupportedFunctionalityError({
+              functionality: `Cursor prompt part: ${part.type}`,
+            });
+          }).join(`
+`);
+    const role = message.role === "tool" ? "tool_result" : message.role;
+    return `<${role}>
+${text}
+</${role}>`;
+  });
+  return {
+    text: sections.join(`
+
+`),
+    images,
+  };
+}
+function responseContract(options) {
+  if (options.responseFormat?.type === "json") {
+    return `# Structured output
+Respond with ONLY valid JSON, with no other text.
+${options.responseFormat.description ?? ""}
+JSON schema: ${JSON.stringify(options.responseFormat.schema ?? {})}`;
+  }
+  const tools = activeTools(options);
+  if (!tools.length) return "";
+  return `# Tool calling
+Decide which of these tools to call to fulfill the request. Do not execute them yourself.
+Available tools (JSON schema per tool):
+${JSON.stringify(tools)}
+Respond with ONLY a JSON object of this exact shape and no other text:
+{"tool_calls": [{"name": "<tool_name>", "arguments": {<parameters>}}]}
+List multiple entries when several calls are needed, in execution order.
+${options.toolChoice?.type === "required" || options.toolChoice?.type === "tool" ? "You MUST call at least one of the listed tools." : 'If no tool applies, respond with {"tool_calls": []}.'}`;
+}
+function activeTools(options) {
+  if (options.toolChoice?.type === "none") return [];
+  return (options.tools ?? [])
+    .map((tool) => {
+      if (tool.type !== "function")
+        throw new import_provider.UnsupportedFunctionalityError({
+          functionality: "Cursor provider-defined tools",
+        });
+      return tool;
+    })
+    .filter(
+      (tool) =>
+        options.toolChoice?.type !== "tool" ||
+        tool.name === options.toolChoice.toolName,
+    );
+}
+function parseResponse(text, options) {
+  if (options.responseFormat?.type === "json")
+    return [{ type: "text", text: JSON.stringify(parseJson(text)) }];
+  const tools = activeTools(options);
+  if (!tools.length) return [{ type: "text", text }];
+  const calls = ToolCallsResponse.parse(parseJson(text)).tool_calls;
+  if (
+    !calls.length &&
+    (options.toolChoice?.type === "required" ||
+      options.toolChoice?.type === "tool")
+  )
+    throw new Error("At least one tool call is required");
+  return calls.map((call) => {
+    if (!tools.some((tool) => tool.name === call.name))
+      throw new Error(`Unknown or disallowed tool: ${call.name}`);
+    return {
+      type: "tool-call",
+      toolCallId: `call_${crypto.randomUUID()}`,
+      toolName: call.name,
+      input: JSON.stringify(call.arguments ?? call.args ?? {}),
+    };
+  });
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {}
+  const start = text.search(/[[{]/);
+  let depth = 0;
+  let quoted = false;
+  let escaped = false;
+  for (let index = start; index >= 0 && index < text.length; index++) {
+    const char = text[index];
+    if (escaped) escaped = false;
+    else if (quoted && char === "\\") escaped = true;
+    else if (char === '"') quoted = !quoted;
+    else if (!quoted) {
+      if (char === "{" || char === "[") depth++;
+      else if ((char === "}" || char === "]") && --depth === 0)
+        return JSON.parse(text.slice(start, index + 1));
+    }
+  }
+  throw new Error("Response does not contain valid JSON");
+}
+async function send(agent, payload, abort) {
+  abort.signal?.throwIfAborted();
+  const run = await abort.run(agent.send(payload), (lateRun) => {
+    lateRun.cancel().catch(() => {});
+  });
+  let result;
+  try {
+    result = await abort.run(run.wait());
+  } catch (error) {
+    run.cancel().catch(() => {});
+    throw error;
+  }
+  if (result.status !== "finished")
+    throw new Error(
+      `Cursor agent run ${result.status}: ${result.error?.message ?? "no error details"}`,
+    );
+  return result;
+}
+function createAbortScope(signal) {
+  signal?.throwIfAborted();
+  let onAbort = () => {};
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(signal?.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  return {
+    signal,
+    async run(promise, onLateResult) {
+      if (!signal) return promise;
+      return Promise.race([
+        promise.then(async (value) => {
+          if (signal.aborted) {
+            await onLateResult?.(value);
+            signal.throwIfAborted();
+          }
+          return value;
+        }),
+        aborted,
+      ]);
+    },
+    dispose() {
+      signal?.removeEventListener("abort", onAbort);
+    },
+  };
+}
+function toUsage(usages) {
+  const reported = usages.filter((usage) => usage !== undefined);
+  function sum(key) {
+    return reported.some((usage) => usage[key] !== undefined)
+      ? reported.reduce((total, usage) => total + (usage[key] ?? 0), 0)
+      : undefined;
+  }
+  const noCache = sum("inputTokens");
+  const cacheRead = sum("cacheReadTokens");
+  const cacheWrite = sum("cacheWriteTokens");
+  return {
+    inputTokens: {
+      total:
+        noCache === undefined
+          ? undefined
+          : noCache + (cacheRead ?? 0) + (cacheWrite ?? 0),
+      noCache,
+      cacheRead,
+      cacheWrite,
+    },
+    outputTokens: {
+      total: sum("outputTokens"),
+      text: undefined,
+      reasoning: sum("reasoningTokens"),
+    },
+  };
+}
+// cursor/src/llm/cursorProviders.ts
+var import_internal3 = require("@alumnium/core/internal");
+
+// cursor/src/standalone/installCursorSdk.ts
+var import_node_crypto = require("node:crypto");
+var import_promises3 = __toESM(require("node:fs/promises"), 1);
+var import_node_module2 = require("node:module");
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_zlib = require("node:zlib");
+var import_internal2 = require("@alumnium/core/internal");
+
+// cursor/src/standalone/cursorSdkManifest.ts
+var CURSOR_SDK_PACKAGE_NAME = "@cursor/sdk";
+
+// cursor/src/standalone/cursorSdkResolver.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_module = __toESM(require("node:module"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var installedVendorRoots = new Map();
+function installVendorResolveHook(vendorRoot, packageNames) {
+  const existing = installedVendorRoots.get(vendorRoot);
+  if (existing) return existing;
+  const vendorNodeModules = import_node_path2.default.join(
+    vendorRoot,
+    "node_modules",
+  );
+  const vendorPrefix = vendorRoot + import_node_path2.default.sep;
+  const resolutionCache = new Map();
+  const moduleWithResolveFilename = import_node_module.default;
+  const resolveFilename = moduleWithResolveFilename._resolveFilename;
+  moduleWithResolveFilename._resolveFilename = function (...args) {
+    const [request, parent] = args;
+    if (
+      typeof request === "string" &&
+      isBareSpecifier(request) &&
+      parent?.filename?.startsWith(vendorPrefix)
+    ) {
+      let resolved = resolutionCache.get(request);
+      if (!resolutionCache.has(request)) {
+        const { packageName, subpath } = splitBareSpecifier(request);
+        resolved = packageNames.has(packageName)
+          ? resolvePackageEntry(vendorNodeModules, packageName, subpath)
+          : undefined;
+        resolutionCache.set(request, resolved);
+      }
+      if (resolved) return resolved;
+    }
+    return resolveFilename.call(this, ...args);
+  };
+  const handle = {
+    uninstall() {
+      moduleWithResolveFilename._resolveFilename = resolveFilename;
+      installedVendorRoots.delete(vendorRoot);
+    },
+  };
+  installedVendorRoots.set(vendorRoot, handle);
+  return handle;
+}
+function isBareSpecifier(request) {
+  return (
+    !request.startsWith(".") &&
+    !import_node_path2.default.isAbsolute(request) &&
+    !request.startsWith("node:") &&
+    !request.startsWith("bun:")
+  );
+}
+function splitBareSpecifier(request) {
+  const segments = request.split("/");
+  const nameLength = request.startsWith("@") ? 2 : 1;
+  return {
+    packageName: segments.slice(0, nameLength).join("/"),
+    subpath:
+      segments.length > nameLength
+        ? `./${segments.slice(nameLength).join("/")}`
+        : ".",
+  };
+}
+function resolvePackageEntry(vendorNodeModules, packageName, subpath) {
+  const packageDir = import_node_path2.default.join(
+    vendorNodeModules,
+    packageName,
+  );
+  const manifest = readPackageManifest(packageDir);
+  if (!manifest) return;
+  if (manifest.exports != null) {
+    const target = lookupExports(manifest.exports, subpath);
+    return target === undefined
+      ? undefined
+      : resolveExportTarget(packageDir, target);
+  }
+  const candidate =
+    subpath === "."
+      ? typeof manifest.main === "string"
+        ? manifest.main
+        : "index.js"
+      : subpath;
+  return probeFile(import_node_path2.default.join(packageDir, candidate));
+}
+var manifestCache = new Map();
+function readPackageManifest(packageDir) {
+  if (!manifestCache.has(packageDir)) {
+    let manifest;
+    try {
+      manifest = JSON.parse(
+        import_node_fs.default.readFileSync(
+          import_node_path2.default.join(packageDir, "package.json"),
+          "utf-8",
+        ),
+      );
+    } catch {
+      manifest = undefined;
+    }
+    manifestCache.set(packageDir, manifest);
+  }
+  return manifestCache.get(packageDir);
+}
+function lookupExports(exports2, subpath) {
+  const isSubpathMap =
+    typeof exports2 === "object" &&
+    exports2 !== null &&
+    !Array.isArray(exports2) &&
+    Object.keys(exports2).every((key) => key === "." || key.startsWith("./"));
+  if (!isSubpathMap) return subpath === "." ? exports2 : undefined;
+  const map = exports2;
+  if (subpath in map) return map[subpath];
+  for (const [key, value] of Object.entries(map)) {
+    const asterisk = key.indexOf("*");
+    if (asterisk < 0 || key.indexOf("*", asterisk + 1) >= 0) continue;
+    const prefix = key.slice(0, asterisk);
+    const suffix = key.slice(asterisk + 1);
+    if (
+      subpath.length > prefix.length + suffix.length &&
+      subpath.startsWith(prefix) &&
+      subpath.endsWith(suffix)
+    ) {
+      const wildcard = subpath.slice(
+        prefix.length,
+        subpath.length - suffix.length,
+      );
+      return typeof value === "string"
+        ? value.replaceAll("*", wildcard)
+        : value;
+    }
+  }
+  return;
+}
+var ACCEPTED_CONDITIONS = new Set(["require", "node", "default"]);
+function resolveExportTarget(packageDir, target) {
+  if (typeof target === "string") {
+    if (!target.startsWith("./")) return;
+    const resolved = import_node_path2.default.join(packageDir, target);
+    return isFile(resolved) ? resolved : undefined;
+  }
+  if (Array.isArray(target)) {
+    for (const entry of target) {
+      const resolved = resolveExportTarget(packageDir, entry);
+      if (resolved) return resolved;
+    }
+    return;
+  }
+  if (typeof target === "object" && target !== null) {
+    for (const [condition, value] of Object.entries(target)) {
+      if (!ACCEPTED_CONDITIONS.has(condition)) continue;
+      const resolved = resolveExportTarget(packageDir, value);
+      if (resolved) return resolved;
+    }
+  }
+  return;
+}
+function probeFile(candidate) {
+  for (const probe of [
+    candidate,
+    `${candidate}.js`,
+    `${candidate}.json`,
+    import_node_path2.default.join(candidate, "index.js"),
+    import_node_path2.default.join(candidate, "index.json"),
+  ]) {
+    if (isFile(probe)) return probe;
+  }
+  return;
+}
+function isFile(filePath) {
+  try {
+    return import_node_fs.default.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// cursor/src/standalone/cursorSdkVendorManifest.ts
+var cursorSdkVendorManifest = {
+  sdkVersion: "1.0.30",
+  packages: [
+    {
+      name: "@bufbuild/protobuf",
+      version: "1.10.0",
+      integrity:
+        "sha512-QDdVFLoN93Zjg36NoQPZfsVH9tZew7wKDKyV5qRdj8ntT4wQCOradQjRaTdwMhWUYsgKsvCINKKm87FdEk96Ag==",
+    },
+    {
+      name: "@connectrpc/connect",
+      version: "1.7.0",
+      integrity:
+        "sha512-iNKdJRi69YP3mq6AePRT8F/HrxWCewrhxnLMNm0vpqXAR8biwzRtO6Hjx80C6UvtKJ5sFmffQT7I4Baecz389w==",
+    },
+    {
+      name: "@connectrpc/connect-node",
+      version: "1.7.0",
+      integrity:
+        "sha512-6vaPIkG/NyhxlYgytLoR9KYbPhczEboFB2OYWkA9qvUz1K7efXfeGrlRxoLtpa+r8VxyIOw73w5ktNe743nD+A==",
+    },
+    {
+      name: "@connectrpc/connect-web",
+      version: "1.7.0",
+      integrity:
+        "sha512-qyP0YOnUPRWwCc/VfsoydMJvkb7EyUPr2q9sHgBuJzbADjiqck1gKH5V5ZPzPhTLBvmz5UvG+wiZ5sMRQHU1MQ==",
+    },
+    {
+      name: "@cursor/sdk",
+      version: "1.0.30",
+      integrity:
+        "sha512-s3gIXfTD3w8ys+KFE81JjjoiJcynkHsf/JCDyXrnbliIac3dkT59hwYZII3XhsT1DlXIfqg+YzSMru6w1CkZow==",
+    },
+    {
+      name: "@cursor/sdk-darwin-arm64",
+      version: "1.0.30",
+      integrity:
+        "sha512-O0w2fLd6jxrvAUOJGsKBs8VSi5OojqqEOMFBzHTHS82wU/DX3ZlizK3czzCXxDKs3l8j/BVQwVCxP9jMFcf41Q==",
+      os: "darwin",
+      cpu: "arm64",
+      bin: {
+        rg: "bin/rg",
+      },
+    },
+    {
+      name: "@cursor/sdk-darwin-x64",
+      version: "1.0.30",
+      integrity:
+        "sha512-TdjreV7V6gtSKbUaXDarfE1735PES6uzLgLxp42E5kT6EXpjQhKsifdsYOMdsO/RBw166kya/XxG24L/FUfEHA==",
+      os: "darwin",
+      cpu: "x64",
+      bin: {
+        rg: "bin/rg",
+      },
+    },
+    {
+      name: "@cursor/sdk-linux-arm64",
+      version: "1.0.30",
+      integrity:
+        "sha512-1+bsmri6vJ2YuqL/SQ6QSx/ymu2eBzjGgT1bTgN47tCzxDgNOKacXtghpx4zdHM5AmOtT+aLXVVxXjStXmNtcA==",
+      os: "linux",
+      cpu: "arm64",
+      bin: {
+        rg: "bin/rg",
+      },
+    },
+    {
+      name: "@cursor/sdk-linux-x64",
+      version: "1.0.30",
+      integrity:
+        "sha512-5TRAM1xNwVr0Lox2ay5U5h+VY1OeqJLgnS28da7mx+ZkmeAU+hzuUFq2/lcIqoJrp2qBRdUH5WzI44JNtjBKmg==",
+      os: "linux",
+      cpu: "x64",
+      bin: {
+        rg: "bin/rg",
+      },
+    },
+    {
+      name: "@cursor/sdk-win32-x64",
+      version: "1.0.30",
+      integrity:
+        "sha512-kVjpWmLTFLL131TQm3ytz1HbAeyjBRAHMtr6vyLtbBMuLBb0la5igvt58Xi8mXwekymWXim1+rZj7ZYUO3K1rw==",
+      os: "win32",
+      cpu: "x64",
+      bin: {
+        rg: "bin/rg.exe",
+      },
+    },
+    {
+      name: "@fastify/busboy",
+      version: "2.1.1",
+      integrity:
+        "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==",
+    },
+    {
+      name: "@statsig/client-core",
+      version: "3.31.0",
+      integrity:
+        "sha512-SuxQD6TmVszPG7FoMKwTk/uyBuVFk7XnxI3T/E0uyb7PL7GNjONtfsoh+NqBBVUJVse0CUeSFfgJPoZy1ZOslQ==",
+    },
+    {
+      name: "@statsig/js-client",
+      version: "3.31.0",
+      integrity:
+        "sha512-LFa5E0LjT6sTfZv3sNGoyRLSZ1078+agdgOA+Vm1ecjG+KbSOfBLTW7hMwimrJ29slRwbYDzbtKaPJo/R37N2g==",
+    },
+    {
+      name: "undici",
+      version: "5.29.0",
+      integrity:
+        "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==",
+    },
+    {
+      name: "zod",
+      version: "3.25.76",
+      integrity:
+        "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+    },
+  ],
+};
+
+// cursor/src/standalone/untar.ts
+var import_promises2 = __toESM(require("node:fs/promises"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var BLOCK_SIZE = 512;
+var OFFSETS = {
+  name: [0, 100],
+  mode: [100, 8],
+  size: [124, 12],
+  checksum: [148, 8],
+  typeflag: 156,
+  prefix: [345, 155],
+};
+async function untarInto(tarBytes, destDir) {
+  let offset = 0;
+  let pendingPath;
+  while (offset + BLOCK_SIZE <= tarBytes.length) {
+    const header = tarBytes.subarray(offset, offset + BLOCK_SIZE);
+    if (isZeroBlock(header)) break;
+    verifyChecksum(header);
+    const size = readNumeric(header, ...OFFSETS.size);
+    const dataStart = offset + BLOCK_SIZE;
+    if (dataStart + size > tarBytes.length) {
+      throw new Error("Truncated tar archive");
+    }
+    const data = tarBytes.subarray(dataStart, dataStart + size);
+    offset = dataStart + Math.ceil(size / BLOCK_SIZE) * BLOCK_SIZE;
+    const typeflag = String.fromCharCode(header[OFFSETS.typeflag] ?? 0);
+    if (typeflag === "x") {
+      pendingPath = parsePaxPath(data) ?? pendingPath;
+      continue;
+    }
+    if (typeflag === "L") {
+      pendingPath = decodeToNul(data);
+      continue;
+    }
+    if (typeflag === "1" || typeflag === "2") {
+      throw new Error(
+        `Tar entry "${decodeToNul(header.subarray(...spanOf(OFFSETS.name)))}" is a link; links are not allowed in npm tarballs`,
+      );
+    }
+    if (typeflag !== "0" && typeflag !== "\x00" && typeflag !== "5") {
+      pendingPath = undefined;
+      continue;
+    }
+    const entryPath = pendingPath ?? ustarPath(header);
+    pendingPath = undefined;
+    const segments = sanitizedSegments(entryPath).slice(1);
+    if (!segments.length) continue;
+    const target = import_node_path3.default.join(destDir, ...segments);
+    if (typeflag === "5") {
+      await import_promises2.default.mkdir(target, { recursive: true });
+      continue;
+    }
+    await import_promises2.default.mkdir(
+      import_node_path3.default.dirname(target),
+      { recursive: true },
+    );
+    const mode = readNumeric(header, ...OFFSETS.mode);
+    await import_promises2.default.writeFile(target, data, {
+      mode: mode & 73 ? 493 : 420,
+    });
+  }
+}
+function spanOf(field) {
+  return [field[0], field[0] + field[1]];
+}
+function isZeroBlock(block) {
+  return block.every((byte) => byte === 0);
+}
+function verifyChecksum(header) {
+  const stored = readNumeric(header, ...OFFSETS.checksum);
+  const [checksumStart, checksumEnd] = spanOf(OFFSETS.checksum);
+  let computed = 0;
+  for (let index = 0; index < BLOCK_SIZE; index++) {
+    computed +=
+      index >= checksumStart && index < checksumEnd ? 32 : header[index];
+  }
+  if (computed !== stored) {
+    throw new Error("Tar header checksum mismatch — the archive is corrupted");
+  }
+}
+function readNumeric(header, start, length) {
+  const first = header[start];
+  if (first & 128) {
+    let value = first & 127;
+    for (let index = start + 1; index < start + length; index++) {
+      value = value * 256 + header[index];
+    }
+    return value;
+  }
+  const text = decodeToNul(header.subarray(start, start + length)).trim();
+  return text ? Number.parseInt(text, 8) : 0;
+}
+function decodeToNul(bytes) {
+  const nul = bytes.indexOf(0);
+  return new TextDecoder().decode(nul < 0 ? bytes : bytes.subarray(0, nul));
+}
+function ustarPath(header) {
+  const name = decodeToNul(header.subarray(...spanOf(OFFSETS.name)));
+  const prefix = decodeToNul(header.subarray(...spanOf(OFFSETS.prefix)));
+  return prefix ? `${prefix}/${name}` : name;
+}
+function parsePaxPath(data) {
+  const text = Buffer.from(data).toString("latin1");
+  let cursor = 0;
+  let result;
+  while (cursor < text.length) {
+    const lengthEnd = text.indexOf(" ", cursor);
+    if (lengthEnd < 0) break;
+    const recordLength = Number(text.slice(cursor, lengthEnd));
+    if (!Number.isInteger(recordLength) || recordLength <= 0) break;
+    const recordEnd = cursor + recordLength;
+    const equals = text.indexOf("=", lengthEnd + 1);
+    if (equals > 0 && equals < recordEnd) {
+      const key = text.slice(lengthEnd + 1, equals);
+      if (key === "path") {
+        const value = text.slice(equals + 1, recordEnd - 1);
+        result = Buffer.from(value, "latin1").toString("utf8");
+      }
+    }
+    cursor = recordEnd;
+  }
+  return result;
+}
+function sanitizedSegments(entryPath) {
+  if (entryPath.startsWith("/") || /^[A-Za-z]:/.test(entryPath)) {
+    throw new Error(`Tar entry "${entryPath}" has an absolute path`);
+  }
+  const segments = entryPath
+    .split("/")
+    .filter((segment) => segment !== "" && segment !== ".");
+  for (const segment of segments) {
+    if (segment === ".." || segment.includes("\\") || segment.includes(":")) {
+      throw new Error(`Tar entry "${entryPath}" has an unsafe path`);
+    }
+  }
+  return segments;
+}
+
+// cursor/src/standalone/installCursorSdk.ts
+var logger2 = import_internal2.Logger.get(
+  "packages/typescript/cursor/src/standalone/installCursorSdk.ts",
+);
+var MARKER_FILENAME = ".alumnium-complete";
+var STALE_PARTIAL_AGE_MS = 24 * 60 * 60 * 1000;
+var loadPromise;
+function loadVendoredCursorSdk() {
+  loadPromise ??= loadVendoredCursorSdkInternal().catch((error) => {
+    loadPromise = undefined;
+    throw error;
+  });
+  return loadPromise;
+}
+async function loadVendoredCursorSdkInternal() {
+  const manifest = cursorSdkVendorManifest;
+  const explicitDir = import_internal2.Env.ALUMNIUM_CURSOR_SDK_DIR;
+  let vendorRoot;
+  if (explicitDir) {
+    vendorRoot = import_node_path4.default.resolve(explicitDir);
+    await assertExplicitVendorDir(vendorRoot, manifest);
+  } else {
+    vendorRoot = import_node_path4.default.join(
+      import_node_os2.default.homedir(),
+      ".alumnium",
+      "vendor",
+      "cursor-sdk",
+      manifest.sdkVersion,
+    );
+    await ensureVendorTree(manifest, vendorRoot);
+  }
+  return loadSdkFromVendorRoot(manifest, vendorRoot);
+}
+async function ensureVendorTree(manifest, vendorRoot) {
+  const markerPath = import_node_path4.default.join(
+    vendorRoot,
+    MARKER_FILENAME,
+  );
+  if (await pathExists(markerPath)) return;
+  await import_promises3.default.rm(vendorRoot, {
+    recursive: true,
+    force: true,
+  });
+  const packages = packagesForPlatform(manifest);
+  logger2.info(
+    `Downloading the Cursor SDK (~24 MB, one time) from registry.npmjs.org into ${vendorRoot}`,
+  );
+  const partialDir = `${vendorRoot}.partial-${process.pid}-${crypto.randomUUID().slice(0, 8)}`;
+  try {
+    for (const pkg of packages) {
+      try {
+        await import_internal2.retry({ maxAttempts: 3, backOff: 500 }, () =>
+          downloadAndExtract(pkg, partialDir),
+        );
+      } catch (error) {
+        throw new Error(
+          `Failed to download Cursor SDK package ${pkg.name}@${pkg.version} from registry.npmjs.org: ` +
+            `${error instanceof Error ? error.message : String(error)}. ` +
+            "The Cursor provider performs a one-time ~24 MB download on first use. " +
+            "Check network/proxy settings (HTTPS_PROXY is honored), or point " +
+            "ALUMNIUM_CURSOR_SDK_DIR at a pre-installed node_modules tree.",
+          { cause: error },
+        );
+      }
+    }
+    await import_promises3.default.writeFile(
+      import_node_path4.default.join(partialDir, MARKER_FILENAME),
+      JSON.stringify(
+        {
+          sdkVersion: manifest.sdkVersion,
+          installedAt: new Date().toISOString(),
+          platform: `${process.platform}-${process.arch}`,
+        },
+        null,
+        2,
+      ),
+    );
+    await promoteToVendorRoot(partialDir, markerPath, vendorRoot);
+  } finally {
+    await import_promises3.default
+      .rm(partialDir, { recursive: true, force: true })
+      .catch(() => {});
+    await sweepStalePartials(vendorRoot);
+  }
+}
+function packagesForPlatform(
+  manifest,
+  platform = process.platform,
+  arch = process.arch,
+) {
+  const [universal, platformSpecific] = manifest.packages.reduce(
+    ([plain, restricted], pkg) => {
+      (pkg.os || pkg.cpu ? restricted : plain).push(pkg);
+      return [plain, restricted];
+    },
+    [[], []],
+  );
+  const ripgrep =
+    platformSpecific.find((pkg) => pkg.os === platform && pkg.cpu === arch) ??
+    (platform === "win32"
+      ? platformSpecific.find((pkg) => pkg.os === "win32" && pkg.cpu === "x64")
+      : undefined);
+  if (!ripgrep) {
+    logger2.warn(
+      `No Cursor ripgrep package for ${platform}-${arch}; Cursor agent file-search tools may be unavailable.`,
+    );
+    return universal;
+  }
+  return [...universal, ripgrep];
+}
+async function downloadAndExtract(pkg, partialDir) {
+  const basename = pkg.name.split("/").pop();
+  const url = `https://registry.npmjs.org/${pkg.name}/-/${basename}-${pkg.version}.tgz`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} fetching ${url}`);
+  }
+  const tgzBytes = new Uint8Array(await response.arrayBuffer());
+  const digest = import_node_crypto
+    .createHash("sha512")
+    .update(tgzBytes)
+    .digest("base64");
+  const expected = pkg.integrity.slice("sha512-".length);
+  if (digest !== expected) {
+    throw new Error(
+      `Integrity check failed for ${pkg.name}@${pkg.version} (expected sha512-${expected}, got sha512-${digest}) — ` +
+        "the download may be corrupted or tampered with; report at " +
+        "https://github.com/alumnium-hq/alumnium/issues if it persists",
+    );
+  }
+  await untarInto(
+    import_node_zlib.gunzipSync(tgzBytes),
+    import_node_path4.default.join(partialDir, "node_modules", pkg.name),
+  );
+}
+async function promoteToVendorRoot(partialDir, markerPath, vendorRoot) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await import_promises3.default.rename(partialDir, vendorRoot);
+      return;
+    } catch (error) {
+      if (await pathExists(markerPath)) return;
+      if (attempt >= 3) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 200 * attempt));
+    }
+  }
+}
+async function sweepStalePartials(vendorRoot) {
+  try {
+    const parentDir = import_node_path4.default.dirname(vendorRoot);
+    const prefix = `${import_node_path4.default.basename(vendorRoot)}.partial-`;
+    for (const entry of await import_promises3.default.readdir(parentDir)) {
+      if (!entry.startsWith(prefix)) continue;
+      const entryPath = import_node_path4.default.join(parentDir, entry);
+      const { mtimeMs } = await import_promises3.default.stat(entryPath);
+      if (Date.now() - mtimeMs > STALE_PARTIAL_AGE_MS) {
+        await import_promises3.default.rm(entryPath, {
+          recursive: true,
+          force: true,
+        });
+      }
+    }
+  } catch {}
+}
+async function assertExplicitVendorDir(vendorRoot, manifest) {
+  const manifestPath = import_node_path4.default.join(
+    vendorRoot,
+    "node_modules",
+    CURSOR_SDK_PACKAGE_NAME,
+    "package.json",
+  );
+  let installedVersion;
+  try {
+    installedVersion = JSON.parse(
+      await import_promises3.default.readFile(manifestPath, "utf-8"),
+    ).version;
+  } catch (error) {
+    throw new Error(
+      `ALUMNIUM_CURSOR_SDK_DIR is set to ${vendorRoot} but ${manifestPath} cannot be read`,
+      { cause: error },
+    );
+  }
+  if (installedVersion !== manifest.sdkVersion) {
+    logger2.warn(
+      `ALUMNIUM_CURSOR_SDK_DIR holds @cursor/sdk@${installedVersion}, but this Alumnium build expects ${manifest.sdkVersion}`,
+    );
+  }
+}
+async function loadSdkFromVendorRoot(manifest, vendorRoot) {
+  const vendorNodeModules = import_node_path4.default.join(
+    vendorRoot,
+    "node_modules",
+  );
+  installVendorResolveHook(
+    vendorRoot,
+    new Set(manifest.packages.map((pkg) => pkg.name)),
+  );
+  const ripgrep = packagesForPlatform(manifest).find((pkg) => pkg.bin);
+  const ripgrepRelPath =
+    ripgrep?.bin?.rg ?? Object.values(ripgrep?.bin ?? {})[0];
+  if (ripgrep && ripgrepRelPath) {
+    const ripgrepPath = import_node_path4.default.join(
+      vendorNodeModules,
+      ripgrep.name,
+      ripgrepRelPath,
+    );
+    if (await pathExists(ripgrepPath)) {
+      if (process.platform !== "win32")
+        await import_promises3.default.chmod(ripgrepPath, 493);
+      process.env.CURSOR_RIPGREP_PATH ??= ripgrepPath;
+    }
+  }
+  const entryPath = resolvePackageEntry(
+    vendorNodeModules,
+    CURSOR_SDK_PACKAGE_NAME,
+    ".",
+  );
+  if (!entryPath) {
+    throw new Error(
+      `Vendored Cursor SDK at ${vendorRoot} is missing or unreadable; delete the directory to reinstall`,
+    );
+  }
+  const requireFromVendor = import_node_module2.createRequire(
+    import_node_path4.default.join(
+      vendorNodeModules,
+      CURSOR_SDK_PACKAGE_NAME,
+      "package.json",
+    ),
+  );
+  return requireFromVendor(entryPath);
+}
+async function pathExists(target) {
+  try {
+    await import_promises3.default.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// cursor/src/llm/cursorProviders.ts
+var logger3 = import_internal3.Logger.get(
+  "packages/typescript/cursor/src/llm/cursorProviders.ts",
+);
+var cursorProviders = {
+  cursor: (model) => {
+    logger3.debug(`Creating Cursor LLM with model ${model.name}`);
+    const apiKey = import_internal3.Env.CURSOR_API_KEY;
+    if (apiKey)
+      logger3.debug(
+        `Cursor API Key is set: ${import_internal3.maskString(apiKey)}`,
+      );
+    return new CursorLanguageModel({
+      modelId: model.name,
+      ...(apiKey ? { apiKey } : {}),
+      ...(import_internal3.isSingleFileExecutable()
+        ? { sdkLoader: loadVendoredCursorSdk }
+        : {}),
+    });
+  },
+};
+import_internal3.LlmFactory.register(cursorProviders);
+
+//# debugId=AC468DAB1BED071964756E2164756E21
+//# sourceMappingURL=index.cjs.map