npm - cursor-supermemory - Versions diffs - 1.0.0 - Mend

cursor-supermemory 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/.cursor-plugin/plugin.json +14 -0
package/.mcp.json +8 -0
package/README.md +40 -0
package/commands/supermemory-config.md +21 -0
package/commands/supermemory-logout.md +12 -0
package/commands/supermemory-setup.md +14 -0
package/dist/cli.js +1767 -0
package/dist/mcp-server.js +1654 -0
package/dist/session-end.js +1447 -0
package/dist/session-start.js +1479 -0
package/hooks/hooks.json +18 -0
package/package.json +28 -0
package/rules/supermemory.mdc +21 -0
package/skills/memory-init/SKILL.md +13 -0
package/skills/memory-save/SKILL.md +10 -0
package/skills/memory-search/SKILL.md +9 -0

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,1767 @@
+// src/config.ts
+import path2 from "node:path";
+import os2 from "node:os";
+import fs2 from "node:fs";
+// src/auth.ts
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+var CREDENTIALS_DIR = path.join(os.homedir(), ".supermemory-cursor");
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+var AUTH_PORT = 19878;
+var AUTH_URL = "https://console.supermemory.ai/auth/connect";
+var SUCCESS_HTML = `<!DOCTYPE html>
+<html><head><style>
+  body { background: #111; color: #fff; font-family: system-ui; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+  h1 { font-size: 2rem; }
+</style></head><body><h1>Connected to Cursor!</h1></body></html>`;
+function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE))
+      return null;
+    const data = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    if (data.apiKey)
+      return data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(apiKey) {
+  fs.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+  const data = { apiKey, createdAt: new Date().toISOString() };
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function clearCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      fs.unlinkSync(CREDENTIALS_FILE);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function startAuthFlow(timeoutMs = 120000) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const server = Bun.serve({
+      port: AUTH_PORT,
+      hostname: "127.0.0.1",
+      fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname !== "/callback") {
+          return new Response("Not found", { status: 404 });
+        }
+        const apiKey = url.searchParams.get("apikey") || url.searchParams.get("api_key");
+        if (!apiKey?.startsWith("sm_")) {
+          return new Response("Invalid API key", { status: 400 });
+        }
+        saveCredentials(apiKey);
+        settled = true;
+        server.stop();
+        clearTimeout(timer);
+        resolve({ success: true, apiKey });
+        return new Response(SUCCESS_HTML, {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+    });
+    const callbackUrl = `http://localhost:${AUTH_PORT}/callback`;
+    const authUrl = `${AUTH_URL}?callback=${encodeURIComponent(callbackUrl)}&client=cursor`;
+    process.stderr.write(`
+Open this URL to connect Supermemory to Cursor:
+  ${authUrl}
+Waiting...
+`);
+    const opener = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+    Bun.$`${opener} ${authUrl}`.quiet().nothrow();
+    const timer = setTimeout(() => {
+      if (!settled) {
+        server.stop();
+        resolve({ success: false, error: "Authentication timed out" });
+      }
+    }, timeoutMs);
+  });
+}
+// src/config.ts
+var DEFAULTS = {
+  similarityThreshold: 0.3,
+  maxMemories: 10,
+  maxProjectMemories: 5,
+  injectProfile: true,
+  userContainerTag: null,
+  projectContainerTag: null
+};
+function readJson(filePath) {
+  try {
+    if (!fs2.existsSync(filePath))
+      return null;
+    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function findProjectConfig(cwd) {
+  let dir = cwd;
+  while (true) {
+    const configPath = path2.join(dir, ".cursor", ".supermemory", "config.json");
+    const data = readJson(configPath);
+    if (data)
+      return data;
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function loadConfig(cwd) {
+  const projectConfig = findProjectConfig(cwd || process.cwd());
+  const globalConfig = readJson(path2.join(os2.homedir(), ".config", "cursor", "supermemory.json"));
+  const merged = { ...DEFAULTS, ...globalConfig, ...projectConfig };
+  return {
+    apiKey: process.env.SUPERMEMORY_API_KEY ?? merged.apiKey ?? null,
+    similarityThreshold: merged.similarityThreshold,
+    maxMemories: merged.maxMemories,
+    maxProjectMemories: merged.maxProjectMemories,
+    injectProfile: merged.injectProfile,
+    userContainerTag: merged.userContainerTag,
+    projectContainerTag: merged.projectContainerTag
+  };
+}
+function getApiKey(config) {
+  if (config.apiKey)
+    return config.apiKey;
+  const creds = loadCredentials();
+  return creds?.apiKey ?? null;
+}
+// src/tags.ts
+import crypto from "node:crypto";
+import os3 from "node:os";
+import { execSync } from "node:child_process";
+function sha256(input) {
+  return crypto.createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function getGitEmail() {
+  try {
+    return execSync("git config user.email", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getGitRoot(dir) {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getMachineId() {
+  return `${os3.hostname()}_${os3.userInfo().username}`;
+}
+function getUserTag(config) {
+  const identity = config.userContainerTag ?? process.env.SUPERMEMORY_USER_TAG ?? process.env.CURSOR_USER_EMAIL ?? getGitEmail() ?? getMachineId();
+  return `cursor_user_${sha256(identity)}`;
+}
+function getProjectTag(workspaceRoot, config) {
+  const identity = config.projectContainerTag ?? process.env.SUPERMEMORY_PROJECT_TAG ?? (getGitRoot(workspaceRoot) || workspaceRoot);
+  return `cursor_project_${sha256(identity)}`;
+}
+// node_modules/supermemory/internal/tslib.mjs
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+// node_modules/supermemory/internal/utils/uuid.mjs
+var uuid4 = function() {
+  const { crypto: crypto2 } = globalThis;
+  if (crypto2?.randomUUID) {
+    uuid4 = crypto2.randomUUID.bind(crypto2);
+    return crypto2.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto2 ? () => crypto2.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
+  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
+};
+// node_modules/supermemory/internal/errors.mjs
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && (("name" in err) && err.name === "AbortError" || ("message" in err) && String(err.message).includes("FetchRequestCanceledException"));
+}
+var castToError = (err) => {
+  if (err instanceof Error)
+    return err;
+  if (typeof err === "object" && err !== null) {
+    try {
+      if (Object.prototype.toString.call(err) === "[object Error]") {
+        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+        if (err.stack)
+          error.stack = err.stack;
+        if (err.cause && !error.cause)
+          error.cause = err.cause;
+        if (err.name)
+          error.name = err.name;
+        return error;
+      }
+    } catch {}
+    try {
+      return new Error(JSON.stringify(err));
+    } catch {}
+  }
+  return new Error(err);
+};
+// node_modules/supermemory/core/error.mjs
+class SupermemoryError extends Error {
+}
+class APIError extends SupermemoryError {
+  constructor(status, error, message, headers) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+    const error = errorResponse;
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new APIError(status, error, message, headers);
+  }
+}
+class APIUserAbortError extends APIError {
+  constructor({ message } = {}) {
+    super(undefined, undefined, message || "Request was aborted.", undefined);
+  }
+}
+class APIConnectionError extends APIError {
+  constructor({ message, cause }) {
+    super(undefined, undefined, message || "Connection error.", undefined);
+    if (cause)
+      this.cause = cause;
+  }
+}
+class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message } = {}) {
+    super({ message: message ?? "Request timed out." });
+  }
+}
+class BadRequestError extends APIError {
+}
+class AuthenticationError extends APIError {
+}
+class PermissionDeniedError extends APIError {
+}
+class NotFoundError extends APIError {
+}
+class ConflictError extends APIError {
+}
+class UnprocessableEntityError extends APIError {
+}
+class RateLimitError extends APIError {
+}
+class InternalServerError extends APIError {
+}
+// node_modules/supermemory/internal/utils/values.mjs
+var startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+var isAbsoluteURL = (url) => {
+  return startsWithSchemeRegexp.test(url);
+};
+var isArray = (val) => (isArray = Array.isArray, isArray(val));
+var isReadonlyArray = isArray;
+function isEmptyObj(obj) {
+  if (!obj)
+    return true;
+  for (const _k in obj)
+    return false;
+  return true;
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+var validatePositiveInteger = (name, n) => {
+  if (typeof n !== "number" || !Number.isInteger(n)) {
+    throw new SupermemoryError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new SupermemoryError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+var safeJSON = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return;
+  }
+};
+// node_modules/supermemory/internal/utils/sleep.mjs
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// node_modules/supermemory/version.mjs
+var VERSION = "4.11.1";
+// node_modules/supermemory/internal/detect-platform.mjs
+function getDetectedPlatform() {
+  if (typeof Deno !== "undefined" && Deno.build != null) {
+    return "deno";
+  }
+  if (typeof EdgeRuntime !== "undefined") {
+    return "edge";
+  }
+  if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") {
+    return "node";
+  }
+  return "unknown";
+}
+var getPlatformProperties = () => {
+  const detectedPlatform = getDetectedPlatform();
+  if (detectedPlatform === "deno") {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": normalizePlatform(Deno.build.os),
+      "X-Stainless-Arch": normalizeArch(Deno.build.arch),
+      "X-Stainless-Runtime": "deno",
+      "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown"
+    };
+  }
+  if (typeof EdgeRuntime !== "undefined") {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": "Unknown",
+      "X-Stainless-Arch": `other:${EdgeRuntime}`,
+      "X-Stainless-Runtime": "edge",
+      "X-Stainless-Runtime-Version": globalThis.process.version
+    };
+  }
+  if (detectedPlatform === "node") {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"),
+      "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"),
+      "X-Stainless-Runtime": "node",
+      "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown"
+    };
+  }
+  const browserInfo = getBrowserInfo();
+  if (browserInfo) {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": "Unknown",
+      "X-Stainless-Arch": "unknown",
+      "X-Stainless-Runtime": `browser:${browserInfo.browser}`,
+      "X-Stainless-Runtime-Version": browserInfo.version
+    };
+  }
+  return {
+    "X-Stainless-Lang": "js",
+    "X-Stainless-Package-Version": VERSION,
+    "X-Stainless-OS": "Unknown",
+    "X-Stainless-Arch": "unknown",
+    "X-Stainless-Runtime": "unknown",
+    "X-Stainless-Runtime-Version": "unknown"
+  };
+};
+function getBrowserInfo() {
+  if (typeof navigator === "undefined" || !navigator) {
+    return null;
+  }
+  const browserPatterns = [
+    { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }
+  ];
+  for (const { key, pattern } of browserPatterns) {
+    const match = pattern.exec(navigator.userAgent);
+    if (match) {
+      const major = match[1] || 0;
+      const minor = match[2] || 0;
+      const patch = match[3] || 0;
+      return { browser: key, version: `${major}.${minor}.${patch}` };
+    }
+  }
+  return null;
+}
+var normalizeArch = (arch) => {
+  if (arch === "x32")
+    return "x32";
+  if (arch === "x86_64" || arch === "x64")
+    return "x64";
+  if (arch === "arm")
+    return "arm";
+  if (arch === "aarch64" || arch === "arm64")
+    return "arm64";
+  if (arch)
+    return `other:${arch}`;
+  return "unknown";
+};
+var normalizePlatform = (platform) => {
+  platform = platform.toLowerCase();
+  if (platform.includes("ios"))
+    return "iOS";
+  if (platform === "android")
+    return "Android";
+  if (platform === "darwin")
+    return "MacOS";
+  if (platform === "win32")
+    return "Windows";
+  if (platform === "freebsd")
+    return "FreeBSD";
+  if (platform === "openbsd")
+    return "OpenBSD";
+  if (platform === "linux")
+    return "Linux";
+  if (platform)
+    return `Other:${platform}`;
+  return "Unknown";
+};
+var _platformHeaders;
+var getPlatformHeaders = () => {
+  return _platformHeaders ?? (_platformHeaders = getPlatformProperties());
+};
+// node_modules/supermemory/internal/shims.mjs
+function getDefaultFetch() {
+  if (typeof fetch !== "undefined") {
+    return fetch;
+  }
+  throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Supermemory({ fetch })` or polyfill the global, `globalThis.fetch = fetch`");
+}
+function makeReadableStream(...args) {
+  const ReadableStream = globalThis.ReadableStream;
+  if (typeof ReadableStream === "undefined") {
+    throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`");
+  }
+  return new ReadableStream(...args);
+}
+function ReadableStreamFrom(iterable) {
+  let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+  return makeReadableStream({
+    async pull(controller) {
+      const { done, value } = await iter.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    async cancel() {
+      await iter.return?.();
+    }
+  });
+}
+async function CancelReadableStream(stream) {
+  if (stream === null || typeof stream !== "object")
+    return;
+  if (stream[Symbol.asyncIterator]) {
+    await stream[Symbol.asyncIterator]().return?.();
+    return;
+  }
+  const reader = stream.getReader();
+  const cancelPromise = reader.cancel();
+  reader.releaseLock();
+  await cancelPromise;
+}
+// node_modules/supermemory/internal/request-options.mjs
+var FallbackEncoder = ({ headers, body }) => {
+  return {
+    bodyHeaders: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  };
+};
+// node_modules/supermemory/internal/uploads.mjs
+var checkFileSupport = () => {
+  if (typeof File === "undefined") {
+    const { process: process2 } = globalThis;
+    const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20;
+    throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : ""));
+  }
+};
+function makeFile(fileBits, fileName, options) {
+  checkFileSupport();
+  return new File(fileBits, fileName ?? "unknown_file", options);
+}
+function getName(value) {
+  return (typeof value === "object" && value !== null && (("name" in value) && value.name && String(value.name) || ("url" in value) && value.url && String(value.url) || ("filename" in value) && value.filename && String(value.filename) || ("path" in value) && value.path && String(value.path)) || "").split(/[\\/]/).pop() || undefined;
+}
+var isAsyncIterable = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+var multipartFormRequestOptions = async (opts, fetch2) => {
+  return { ...opts, body: await createForm(opts.body, fetch2) };
+};
+var supportsFormDataMap = /* @__PURE__ */ new WeakMap;
+function supportsFormData(fetchObject) {
+  const fetch2 = typeof fetchObject === "function" ? fetchObject : fetchObject.fetch;
+  const cached = supportsFormDataMap.get(fetch2);
+  if (cached)
+    return cached;
+  const promise = (async () => {
+    try {
+      const FetchResponse = "Response" in fetch2 ? fetch2.Response : (await fetch2("data:,")).constructor;
+      const data = new FormData;
+      if (data.toString() === await new FetchResponse(data).text()) {
+        return false;
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  })();
+  supportsFormDataMap.set(fetch2, promise);
+  return promise;
+}
+var createForm = async (body, fetch2) => {
+  if (!await supportsFormData(fetch2)) {
+    throw new TypeError("The provided fetch function does not support file uploads with the current global FormData class.");
+  }
+  const form = new FormData;
+  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  return form;
+};
+var isNamedBlob = (value) => value instanceof Blob && ("name" in value);
+var addFormValue = async (form, key, value) => {
+  if (value === undefined)
+    return;
+  if (value == null) {
+    throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`);
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    form.append(key, String(value));
+  } else if (value instanceof Response) {
+    form.append(key, makeFile([await value.blob()], getName(value)));
+  } else if (isAsyncIterable(value)) {
+    form.append(key, makeFile([await new Response(ReadableStreamFrom(value)).blob()], getName(value)));
+  } else if (isNamedBlob(value)) {
+    form.append(key, value, getName(value));
+  } else if (Array.isArray(value)) {
+    await Promise.all(value.map((entry) => addFormValue(form, key + "[]", entry)));
+  } else if (typeof value === "object") {
+    await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)));
+  } else {
+    throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`);
+  }
+};
+// node_modules/supermemory/internal/to-file.mjs
+var isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function";
+var isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value);
+var isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function";
+async function toFile(value, name, options) {
+  checkFileSupport();
+  value = await value;
+  if (isFileLike(value)) {
+    if (value instanceof File) {
+      return value;
+    }
+    return makeFile([await value.arrayBuffer()], value.name);
+  }
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name || (name = new URL(value.url).pathname.split(/[\\/]/).pop());
+    return makeFile(await getBytes(blob), name, options);
+  }
+  const parts = await getBytes(value);
+  name || (name = getName(value));
+  if (!options?.type) {
+    const type = parts.find((part) => typeof part === "object" && ("type" in part) && part.type);
+    if (typeof type === "string") {
+      options = { ...options, type };
+    }
+  }
+  return makeFile(parts, name, options);
+}
+async function getBytes(value) {
+  let parts = [];
+  if (typeof value === "string" || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(value instanceof Blob ? value : await value.arrayBuffer());
+  } else if (isAsyncIterable(value)) {
+    for await (const chunk of value) {
+      parts.push(...await getBytes(chunk));
+    }
+  } else {
+    const constructor = value?.constructor?.name;
+    throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ""}${propsForError(value)}`);
+  }
+  return parts;
+}
+function propsForError(value) {
+  if (typeof value !== "object" || value === null)
+    return "";
+  const props = Object.getOwnPropertyNames(value);
+  return `; props: [${props.map((p) => `"${p}"`).join(", ")}]`;
+}
+// node_modules/supermemory/core/resource.mjs
+class APIResource {
+  constructor(client) {
+    this._client = client;
+  }
+}
+// node_modules/supermemory/internal/headers.mjs
+var brand_privateNullableHeaders = /* @__PURE__ */ Symbol("brand.privateNullableHeaders");
+function* iterateHeaders(headers) {
+  if (!headers)
+    return;
+  if (brand_privateNullableHeaders in headers) {
+    const { values, nulls } = headers;
+    yield* values.entries();
+    for (const name of nulls) {
+      yield [name, null];
+    }
+    return;
+  }
+  let shouldClear = false;
+  let iter;
+  if (headers instanceof Headers) {
+    iter = headers.entries();
+  } else if (isReadonlyArray(headers)) {
+    iter = headers;
+  } else {
+    shouldClear = true;
+    iter = Object.entries(headers ?? {});
+  }
+  for (let row of iter) {
+    const name = row[0];
+    if (typeof name !== "string")
+      throw new TypeError("expected header name to be a string");
+    const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
+    let didClear = false;
+    for (const value of values) {
+      if (value === undefined)
+        continue;
+      if (shouldClear && !didClear) {
+        didClear = true;
+        yield [name, null];
+      }
+      yield [name, value];
+    }
+  }
+}
+var buildHeaders = (newHeaders) => {
+  const targetHeaders = new Headers;
+  const nullHeaders = new Set;
+  for (const headers of newHeaders) {
+    const seenHeaders = new Set;
+    for (const [name, value] of iterateHeaders(headers)) {
+      const lowerName = name.toLowerCase();
+      if (!seenHeaders.has(lowerName)) {
+        targetHeaders.delete(name);
+        seenHeaders.add(lowerName);
+      }
+      if (value === null) {
+        targetHeaders.delete(name);
+        nullHeaders.add(lowerName);
+      } else {
+        targetHeaders.append(name, value);
+        nullHeaders.delete(lowerName);
+      }
+    }
+  }
+  return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
+};
+// node_modules/supermemory/internal/utils/path.mjs
+function encodeURIPath(str) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path(statics, ...params) {
+  if (statics.length === 1)
+    return statics[0];
+  let postPath = false;
+  const invalidSegments = [];
+  const path3 = statics.reduce((previousValue, currentValue, index) => {
+    if (/[?#]/.test(currentValue)) {
+      postPath = true;
+    }
+    const value = params[index];
+    let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value);
+    if (index !== params.length && (value == null || typeof value === "object" && value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)?.toString)) {
+      encoded = value + "";
+      invalidSegments.push({
+        start: previousValue.length + currentValue.length,
+        length: encoded.length,
+        error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter`
+      });
+    }
+    return previousValue + currentValue + (index === params.length ? "" : encoded);
+  }, "");
+  const pathOnly = path3.split(/[?#]/, 1)[0];
+  const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+  let match;
+  while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+    invalidSegments.push({
+      start: match.index,
+      length: match[0].length,
+      error: `Value "${match[0]}" can't be safely passed as a path parameter`
+    });
+  }
+  invalidSegments.sort((a, b) => a.start - b.start);
+  if (invalidSegments.length > 0) {
+    let lastEnd = 0;
+    const underline = invalidSegments.reduce((acc, segment) => {
+      const spaces = " ".repeat(segment.start - lastEnd);
+      const arrows = "^".repeat(segment.length);
+      lastEnd = segment.start + segment.length;
+      return acc + spaces + arrows;
+    }, "");
+    throw new SupermemoryError(`Path parameters result in path with invalid segments:
+${invalidSegments.map((e) => e.error).join(`
+`)}
+${path3}
+${underline}`);
+  }
+  return path3;
+};
+var path3 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
+// node_modules/supermemory/resources/connections.mjs
+class Connections extends APIResource {
+  create(provider, body = {}, options) {
+    return this._client.post(path3`/v3/connections/${provider}`, { body, ...options });
+  }
+  list(body = {}, options) {
+    return this._client.post("/v3/connections/list", { body, ...options });
+  }
+  configure(connectionID, body, options) {
+    return this._client.post(path3`/v3/connections/${connectionID}/configure`, { body, ...options });
+  }
+  deleteByID(connectionID, options) {
+    return this._client.delete(path3`/v3/connections/${connectionID}`, options);
+  }
+  deleteByProvider(provider, body, options) {
+    return this._client.delete(path3`/v3/connections/${provider}`, { body, ...options });
+  }
+  getByID(connectionID, options) {
+    return this._client.get(path3`/v3/connections/${connectionID}`, options);
+  }
+  getByTag(provider, body, options) {
+    return this._client.post(path3`/v3/connections/${provider}/connection`, { body, ...options });
+  }
+  import(provider, body = {}, options) {
+    return this._client.post(path3`/v3/connections/${provider}/import`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: "text/plain" }, options?.headers])
+    });
+  }
+  listDocuments(provider, body = {}, options) {
+    return this._client.post(path3`/v3/connections/${provider}/documents`, { body, ...options });
+  }
+  resources(connectionID, query = {}, options) {
+    return this._client.get(path3`/v3/connections/${connectionID}/resources`, { query, ...options });
+  }
+}
+// node_modules/supermemory/resources/documents.mjs
+class Documents extends APIResource {
+  update(id, body = {}, options) {
+    return this._client.patch(path3`/v3/documents/${id}`, { body, ...options });
+  }
+  list(body = {}, options) {
+    return this._client.post("/v3/documents/list", { body, ...options });
+  }
+  delete(id, options) {
+    return this._client.delete(path3`/v3/documents/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: "*/*" }, options?.headers])
+    });
+  }
+  add(body, options) {
+    return this._client.post("/v3/documents", { body, ...options });
+  }
+  batchAdd(body, options) {
+    return this._client.post("/v3/documents/batch", { body, ...options });
+  }
+  deleteBulk(body = {}, options) {
+    return this._client.delete("/v3/documents/bulk", { body, ...options });
+  }
+  get(id, options) {
+    return this._client.get(path3`/v3/documents/${id}`, options);
+  }
+  listProcessing(options) {
+    return this._client.get("/v3/documents/processing", options);
+  }
+  uploadFile(body, options) {
+    return this._client.post("/v3/documents/file", multipartFormRequestOptions({ body, ...options }, this._client));
+  }
+}
+// node_modules/supermemory/resources/memories.mjs
+class Memories extends APIResource {
+  forget(body, options) {
+    return this._client.delete("/v4/memories", { body, ...options });
+  }
+  updateMemory(body, options) {
+    return this._client.patch("/v4/memories", { body, ...options });
+  }
+}
+// node_modules/supermemory/resources/search.mjs
+class Search extends APIResource {
+  documents(body, options) {
+    return this._client.post("/v3/search", { body, ...options });
+  }
+  execute(body, options) {
+    return this._client.post("/v3/search", { body, ...options });
+  }
+  memories(body, options) {
+    return this._client.post("/v4/search", { body, ...options });
+  }
+}
+// node_modules/supermemory/resources/settings.mjs
+class Settings extends APIResource {
+  update(body = {}, options) {
+    return this._client.patch("/v3/settings", { body, ...options });
+  }
+  get(options) {
+    return this._client.get("/v3/settings", options);
+  }
+}
+// node_modules/supermemory/internal/utils/log.mjs
+var levelNumbers = {
+  off: 0,
+  error: 200,
+  warn: 300,
+  info: 400,
+  debug: 500
+};
+var parseLogLevel = (maybeLevel, sourceName, client) => {
+  if (!maybeLevel) {
+    return;
+  }
+  if (hasOwn(levelNumbers, maybeLevel)) {
+    return maybeLevel;
+  }
+  loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
+  return;
+};
+function noop() {}
+function makeLogFn(fnLevel, logger, logLevel) {
+  if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+    return noop;
+  } else {
+    return logger[fnLevel].bind(logger);
+  }
+}
+var noopLogger = {
+  error: noop,
+  warn: noop,
+  info: noop,
+  debug: noop
+};
+var cachedLoggers = /* @__PURE__ */ new WeakMap;
+function loggerFor(client) {
+  const logger = client.logger;
+  const logLevel = client.logLevel ?? "off";
+  if (!logger) {
+    return noopLogger;
+  }
+  const cachedLogger = cachedLoggers.get(logger);
+  if (cachedLogger && cachedLogger[0] === logLevel) {
+    return cachedLogger[1];
+  }
+  const levelLogger = {
+    error: makeLogFn("error", logger, logLevel),
+    warn: makeLogFn("warn", logger, logLevel),
+    info: makeLogFn("info", logger, logLevel),
+    debug: makeLogFn("debug", logger, logLevel)
+  };
+  cachedLoggers.set(logger, [logLevel, levelLogger]);
+  return levelLogger;
+}
+var formatRequestDetails = (details) => {
+  if (details.options) {
+    details.options = { ...details.options };
+    delete details.options["headers"];
+  }
+  if (details.headers) {
+    details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [
+      name,
+      name.toLowerCase() === "authorization" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value
+    ]));
+  }
+  if ("retryOfRequestLogID" in details) {
+    if (details.retryOfRequestLogID) {
+      details.retryOf = details.retryOfRequestLogID;
+    }
+    delete details.retryOfRequestLogID;
+  }
+  return details;
+};
+// node_modules/supermemory/internal/parse.mjs
+async function defaultParseResponse(client, props) {
+  const { response, requestLogID, retryOfRequestLogID, startTime } = props;
+  const body = await (async () => {
+    if (response.status === 204) {
+      return null;
+    }
+    if (props.options.__binaryResponse) {
+      return response;
+    }
+    const contentType = response.headers.get("content-type");
+    const mediaType = contentType?.split(";")[0]?.trim();
+    const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json");
+    if (isJSON) {
+      const contentLength = response.headers.get("content-length");
+      if (contentLength === "0") {
+        return;
+      }
+      const json = await response.json();
+      return json;
+    }
+    const text = await response.text();
+    return text;
+  })();
+  loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({
+    retryOfRequestLogID,
+    url: response.url,
+    status: response.status,
+    body,
+    durationMs: Date.now() - startTime
+  }));
+  return body;
+}
+// node_modules/supermemory/core/api-promise.mjs
+var _APIPromise_client;
+class APIPromise extends Promise {
+  constructor(client, responsePromise, parseResponse = defaultParseResponse) {
+    super((resolve) => {
+      resolve(null);
+    });
+    this.responsePromise = responsePromise;
+    this.parseResponse = parseResponse;
+    _APIPromise_client.set(this, undefined);
+    __classPrivateFieldSet(this, _APIPromise_client, client, "f");
+  }
+  _thenUnwrap(transform) {
+    return new APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props));
+  }
+  asResponse() {
+    return this.responsePromise.then((p) => p.response);
+  }
+  async withResponse() {
+    const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+    return { data, response };
+  }
+  parse() {
+    if (!this.parsedPromise) {
+      this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet(this, _APIPromise_client, "f"), data));
+    }
+    return this.parsedPromise;
+  }
+  then(onfulfilled, onrejected) {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.parse().finally(onfinally);
+  }
+}
+_APIPromise_client = new WeakMap;
+// node_modules/supermemory/internal/utils/env.mjs
+var readEnv = (env) => {
+  if (typeof globalThis.process !== "undefined") {
+    return globalThis.process.env?.[env]?.trim() ?? undefined;
+  }
+  if (typeof globalThis.Deno !== "undefined") {
+    return globalThis.Deno.env?.get?.(env)?.trim();
+  }
+  return;
+};
+// node_modules/supermemory/client.mjs
+var _Supermemory_instances;
+var _a;
+var _Supermemory_encoder;
+var _Supermemory_baseURLOverridden;
+class Supermemory {
+  constructor({ baseURL = readEnv("SUPERMEMORY_BASE_URL"), apiKey = readEnv("SUPERMEMORY_API_KEY"), ...opts } = {}) {
+    _Supermemory_instances.add(this);
+    _Supermemory_encoder.set(this, undefined);
+    this.memories = new Memories(this);
+    this.documents = new Documents(this);
+    this.search = new Search(this);
+    this.settings = new Settings(this);
+    this.connections = new Connections(this);
+    if (apiKey === undefined) {
+      throw new SupermemoryError("The SUPERMEMORY_API_KEY environment variable is missing or empty; either provide it, or instantiate the Supermemory client with an apiKey option, like new Supermemory({ apiKey: 'My API Key' }).");
+    }
+    const options = {
+      apiKey,
+      ...opts,
+      baseURL: baseURL || `https://api.supermemory.ai`
+    };
+    this.baseURL = options.baseURL;
+    this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT;
+    this.logger = options.logger ?? console;
+    const defaultLogLevel = "warn";
+    this.logLevel = defaultLogLevel;
+    this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("SUPERMEMORY_LOG"), "process.env['SUPERMEMORY_LOG']", this) ?? defaultLogLevel;
+    this.fetchOptions = options.fetchOptions;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.fetch = options.fetch ?? getDefaultFetch();
+    __classPrivateFieldSet(this, _Supermemory_encoder, FallbackEncoder, "f");
+    this._options = options;
+    this.apiKey = apiKey;
+  }
+  withOptions(options) {
+    const client = new this.constructor({
+      ...this._options,
+      baseURL: this.baseURL,
+      maxRetries: this.maxRetries,
+      timeout: this.timeout,
+      logger: this.logger,
+      logLevel: this.logLevel,
+      fetch: this.fetch,
+      fetchOptions: this.fetchOptions,
+      apiKey: this.apiKey,
+      ...options
+    });
+    return client;
+  }
+  add(body, options) {
+    return this.post("/v3/documents", { body, ...options });
+  }
+  profile(body, options) {
+    return this.post("/v4/profile", { body, ...options });
+  }
+  defaultQuery() {
+    return this._options.defaultQuery;
+  }
+  validateHeaders({ values, nulls }) {
+    return;
+  }
+  async authHeaders(opts) {
+    return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
+  }
+  stringifyQuery(query) {
+    return Object.entries(query).filter(([_, value]) => typeof value !== "undefined").map(([key, value]) => {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+      }
+      if (value === null) {
+        return `${encodeURIComponent(key)}=`;
+      }
+      throw new SupermemoryError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
+    }).join("&");
+  }
+  getUserAgent() {
+    return `${this.constructor.name}/JS ${VERSION}`;
+  }
+  defaultIdempotencyKey() {
+    return `stainless-node-retry-${uuid4()}`;
+  }
+  makeStatusError(status, error, message, headers) {
+    return APIError.generate(status, error, message, headers);
+  }
+  buildURL(path4, query, defaultBaseURL) {
+    const baseURL = !__classPrivateFieldGet(this, _Supermemory_instances, "m", _Supermemory_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
+    const url = isAbsoluteURL(path4) ? new URL(path4) : new URL(baseURL + (baseURL.endsWith("/") && path4.startsWith("/") ? path4.slice(1) : path4));
+    const defaultQuery = this.defaultQuery();
+    if (!isEmptyObj(defaultQuery)) {
+      query = { ...defaultQuery, ...query };
+    }
+    if (typeof query === "object" && query && !Array.isArray(query)) {
+      url.search = this.stringifyQuery(query);
+    }
+    return url.toString();
+  }
+  async prepareOptions(options) {}
+  async prepareRequest(request, { url, options }) {}
+  get(path4, opts) {
+    return this.methodRequest("get", path4, opts);
+  }
+  post(path4, opts) {
+    return this.methodRequest("post", path4, opts);
+  }
+  patch(path4, opts) {
+    return this.methodRequest("patch", path4, opts);
+  }
+  put(path4, opts) {
+    return this.methodRequest("put", path4, opts);
+  }
+  delete(path4, opts) {
+    return this.methodRequest("delete", path4, opts);
+  }
+  methodRequest(method, path4, opts) {
+    return this.request(Promise.resolve(opts).then((opts2) => {
+      return { method, path: path4, ...opts2 };
+    }));
+  }
+  request(options, remainingRetries = null) {
+    return new APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
+  }
+  async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
+    const options = await optionsInput;
+    const maxRetries = options.maxRetries ?? this.maxRetries;
+    if (retriesRemaining == null) {
+      retriesRemaining = maxRetries;
+    }
+    await this.prepareOptions(options);
+    const { req, url, timeout } = await this.buildRequest(options, {
+      retryCount: maxRetries - retriesRemaining
+    });
+    await this.prepareRequest(req, { url, options });
+    const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0");
+    const retryLogStr = retryOfRequestLogID === undefined ? "" : `, retryOf: ${retryOfRequestLogID}`;
+    const startTime = Date.now();
+    loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
+      retryOfRequestLogID,
+      method: options.method,
+      url,
+      options,
+      headers: req.headers
+    }));
+    if (options.signal?.aborted) {
+      throw new APIUserAbortError;
+    }
+    const controller = new AbortController;
+    const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+    const headersTime = Date.now();
+    if (response instanceof globalThis.Error) {
+      const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+      if (options.signal?.aborted) {
+        throw new APIUserAbortError;
+      }
+      const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : ""));
+      if (retriesRemaining) {
+        loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`);
+        loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({
+          retryOfRequestLogID,
+          url,
+          durationMs: headersTime - startTime,
+          message: response.message
+        }));
+        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+      }
+      loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`);
+      loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({
+        retryOfRequestLogID,
+        url,
+        durationMs: headersTime - startTime,
+        message: response.message
+      }));
+      if (isTimeout) {
+        throw new APIConnectionTimeoutError;
+      }
+      throw new APIConnectionError({ cause: response });
+    }
+    const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`;
+    if (!response.ok) {
+      const shouldRetry = await this.shouldRetry(response);
+      if (retriesRemaining && shouldRetry) {
+        const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`;
+        await CancelReadableStream(response.body);
+        loggerFor(this).info(`${responseInfo} - ${retryMessage2}`);
+        loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({
+          retryOfRequestLogID,
+          url: response.url,
+          status: response.status,
+          headers: response.headers,
+          durationMs: headersTime - startTime
+        }));
+        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
+      }
+      const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
+      loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+      const errText = await response.text().catch((err2) => castToError(err2).message);
+      const errJSON = safeJSON(errText);
+      const errMessage = errJSON ? undefined : errText;
+      loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+        retryOfRequestLogID,
+        url: response.url,
+        status: response.status,
+        headers: response.headers,
+        message: errMessage,
+        durationMs: Date.now() - startTime
+      }));
+      const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+      throw err;
+    }
+    loggerFor(this).info(responseInfo);
+    loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
+      retryOfRequestLogID,
+      url: response.url,
+      status: response.status,
+      headers: response.headers,
+      durationMs: headersTime - startTime
+    }));
+    return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
+  }
+  async fetchWithTimeout(url, init, ms, controller) {
+    const { signal, method, ...options } = init || {};
+    const abort = this._makeAbort(controller);
+    if (signal)
+      signal.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(abort, ms);
+    const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body;
+    const fetchOptions = {
+      signal: controller.signal,
+      ...isReadableBody ? { duplex: "half" } : {},
+      method: "GET",
+      ...options
+    };
+    if (method) {
+      fetchOptions.method = method.toUpperCase();
+    }
+    try {
+      return await this.fetch.call(undefined, url, fetchOptions);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async shouldRetry(response) {
+    const shouldRetryHeader = response.headers.get("x-should-retry");
+    if (shouldRetryHeader === "true")
+      return true;
+    if (shouldRetryHeader === "false")
+      return false;
+    if (response.status === 408)
+      return true;
+    if (response.status === 409)
+      return true;
+    if (response.status === 429)
+      return true;
+    if (response.status >= 500)
+      return true;
+    return false;
+  }
+  async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
+    let timeoutMillis;
+    const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms");
+    if (retryAfterMillisHeader) {
+      const timeoutMs = parseFloat(retryAfterMillisHeader);
+      if (!Number.isNaN(timeoutMs)) {
+        timeoutMillis = timeoutMs;
+      }
+    }
+    const retryAfterHeader = responseHeaders?.get("retry-after");
+    if (retryAfterHeader && !timeoutMillis) {
+      const timeoutSeconds = parseFloat(retryAfterHeader);
+      if (!Number.isNaN(timeoutSeconds)) {
+        timeoutMillis = timeoutSeconds * 1000;
+      } else {
+        timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+      }
+    }
+    if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
+      const maxRetries = options.maxRetries ?? this.maxRetries;
+      timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+    }
+    await sleep(timeoutMillis);
+    return this.makeRequest(options, retriesRemaining - 1, requestLogID);
+  }
+  calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+    const initialRetryDelay = 0.5;
+    const maxRetryDelay = 8;
+    const numRetries = maxRetries - retriesRemaining;
+    const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
+    const jitter = 1 - Math.random() * 0.25;
+    return sleepSeconds * jitter * 1000;
+  }
+  async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+    const options = { ...inputOptions };
+    const { method, path: path4, query, defaultBaseURL } = options;
+    const url = this.buildURL(path4, query, defaultBaseURL);
+    if ("timeout" in options)
+      validatePositiveInteger("timeout", options.timeout);
+    options.timeout = options.timeout ?? this.timeout;
+    const { bodyHeaders, body } = this.buildBody({ options });
+    const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
+    const req = {
+      method,
+      headers: reqHeaders,
+      ...options.signal && { signal: options.signal },
+      ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" },
+      ...body && { body },
+      ...this.fetchOptions ?? {},
+      ...options.fetchOptions ?? {}
+    };
+    return { req, url, timeout: options.timeout };
+  }
+  async buildHeaders({ options, method, bodyHeaders, retryCount }) {
+    let idempotencyHeaders = {};
+    if (this.idempotencyHeader && method !== "get") {
+      if (!options.idempotencyKey)
+        options.idempotencyKey = this.defaultIdempotencyKey();
+      idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
+    }
+    const headers = buildHeaders([
+      idempotencyHeaders,
+      {
+        Accept: "application/json",
+        "User-Agent": this.getUserAgent(),
+        "X-Stainless-Retry-Count": String(retryCount),
+        ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1000)) } : {},
+        ...getPlatformHeaders()
+      },
+      await this.authHeaders(options),
+      this._options.defaultHeaders,
+      bodyHeaders,
+      options.headers
+    ]);
+    this.validateHeaders(headers);
+    return headers.values;
+  }
+  _makeAbort(controller) {
+    return () => controller.abort();
+  }
+  buildBody({ options: { body, headers: rawHeaders } }) {
+    if (!body) {
+      return { bodyHeaders: undefined, body: undefined };
+    }
+    const headers = buildHeaders([rawHeaders]);
+    if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && headers.values.has("content-type") || globalThis.Blob && body instanceof globalThis.Blob || body instanceof FormData || body instanceof URLSearchParams || globalThis.ReadableStream && body instanceof globalThis.ReadableStream) {
+      return { bodyHeaders: undefined, body };
+    } else if (typeof body === "object" && ((Symbol.asyncIterator in body) || (Symbol.iterator in body) && ("next" in body) && typeof body.next === "function")) {
+      return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
+    } else {
+      return __classPrivateFieldGet(this, _Supermemory_encoder, "f").call(this, { body, headers });
+    }
+  }
+}
+_a = Supermemory, _Supermemory_encoder = new WeakMap, _Supermemory_instances = new WeakSet, _Supermemory_baseURLOverridden = function _Supermemory_baseURLOverridden2() {
+  return this.baseURL !== "https://api.supermemory.ai";
+};
+Supermemory.Supermemory = _a;
+Supermemory.DEFAULT_TIMEOUT = 60000;
+Supermemory.SupermemoryError = SupermemoryError;
+Supermemory.APIError = APIError;
+Supermemory.APIConnectionError = APIConnectionError;
+Supermemory.APIConnectionTimeoutError = APIConnectionTimeoutError;
+Supermemory.APIUserAbortError = APIUserAbortError;
+Supermemory.NotFoundError = NotFoundError;
+Supermemory.ConflictError = ConflictError;
+Supermemory.RateLimitError = RateLimitError;
+Supermemory.BadRequestError = BadRequestError;
+Supermemory.AuthenticationError = AuthenticationError;
+Supermemory.InternalServerError = InternalServerError;
+Supermemory.PermissionDeniedError = PermissionDeniedError;
+Supermemory.UnprocessableEntityError = UnprocessableEntityError;
+Supermemory.toFile = toFile;
+Supermemory.Memories = Memories;
+Supermemory.Documents = Documents;
+Supermemory.Search = Search;
+Supermemory.Settings = Settings;
+Supermemory.Connections = Connections;
+// src/client.ts
+import { createHash, createHmac } from "node:crypto";
+var INTEGRITY_VERSION = 1;
+var SEED = "7f2a9c4b8e1d6f3a5c0b9d8e7f6a5b4c3d2e1f0a9b8c7d6e5f4a3b2c1d0e9f8a";
+function sha2562(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function integrityHeaders(apiKey, containerTag) {
+  const contentHash = sha2562(containerTag);
+  const payload = [sha2562(apiKey), contentHash, INTEGRITY_VERSION].join(":");
+  const sig = createHmac("sha256", SEED).update(payload).digest("base64url");
+  return {
+    "X-Content-Hash": contentHash,
+    "X-Request-Integrity": `v${INTEGRITY_VERSION}.${sig}`
+  };
+}
+function createClient(apiKey, containerTag = "cursor") {
+  return new Supermemory({
+    apiKey,
+    defaultHeaders: integrityHeaders(apiKey, containerTag)
+  });
+}
+// src/mcp-server.ts
+var TOOLS = [
+  {
+    name: "supermemory_search",
+    description: "Search the user's memory for relevant information. Use this to find previously stored knowledge, preferences, and context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        container: {
+          type: "string",
+          enum: ["user", "project"],
+          description: "Search user memories or project memories",
+          default: "user"
+        },
+        limit: {
+          type: "number",
+          description: "Max results to return",
+          default: 10
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "supermemory_add",
+    description: "Save information to the user's memory. Use this to remember preferences, facts, decisions, or any knowledge worth persisting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "Content to save" },
+        container: {
+          type: "string",
+          enum: ["user", "project"],
+          description: "Save to user memories or project memories",
+          default: "user"
+        }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "supermemory_profile",
+    description: "Get the user's profile summary — a distilled view of who they are based on their memories.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Optional search query to include relevant results"
+        }
+      }
+    }
+  },
+  {
+    name: "supermemory_list",
+    description: "List stored documents/memories.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max items", default: 20 },
+        page: { type: "number", description: "Page number", default: 1 }
+      }
+    }
+  },
+  {
+    name: "supermemory_forget",
+    description: "Forget a specific memory. Use when the user asks to remove or forget something.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Memory ID to forget" },
+        content: {
+          type: "string",
+          description: "Exact content match (if ID unknown)"
+        },
+        container: {
+          type: "string",
+          enum: ["user", "project"],
+          default: "user"
+        }
+      }
+    }
+  }
+];
+function getAuth() {
+  const config = loadConfig();
+  const apiKey = getApiKey(config);
+  if (!apiKey) {
+    throw new Error("Not authenticated. Run `cursor-supermemory login` to connect your account.");
+  }
+  const userTag = getUserTag(config);
+  const projectTag = getProjectTag(process.cwd(), config);
+  return { apiKey, userTag, projectTag };
+}
+function containerTag(auth, container) {
+  return container === "project" ? auth.projectTag : auth.userTag;
+}
+async function handleSearch(args) {
+  const auth = getAuth();
+  const tag = containerTag(auth, args.container);
+  const client = createClient(auth.apiKey, tag);
+  const result = await client.search.memories({
+    q: args.query,
+    containerTag: tag,
+    limit: args.limit || 10
+  });
+  const formatted = result.results.map((r) => ({
+    id: r.id,
+    memory: r.memory ?? r.chunk ?? "",
+    similarity: r.similarity,
+    updatedAt: r.updatedAt
+  }));
+  return JSON.stringify(formatted, null, 2);
+}
+async function handleAdd(args) {
+  const auth = getAuth();
+  const tag = containerTag(auth, args.container);
+  const client = createClient(auth.apiKey, tag);
+  const result = await client.add({
+    content: args.content,
+    containerTag: tag
+  });
+  return JSON.stringify(result, null, 2);
+}
+async function handleProfile(args) {
+  const auth = getAuth();
+  const client = createClient(auth.apiKey, auth.userTag);
+  const result = await client.profile({
+    containerTag: auth.userTag,
+    q: args.query
+  });
+  return JSON.stringify(result, null, 2);
+}
+async function handleList(args) {
+  const auth = getAuth();
+  const client = createClient(auth.apiKey, auth.userTag);
+  const result = await client.documents.list({
+    limit: args.limit || 20,
+    page: args.page || 1
+  });
+  return JSON.stringify(result, null, 2);
+}
+async function handleForget(args) {
+  const auth = getAuth();
+  const tag = containerTag(auth, args.container);
+  const client = createClient(auth.apiKey, tag);
+  const params = {
+    containerTag: containerTag(auth, args.container)
+  };
+  if (args.id)
+    params.id = args.id;
+  if (args.content)
+    params.content = args.content;
+  if (!params.id && !params.content) {
+    throw new Error("Provide either id or content to forget.");
+  }
+  const result = await client.memories.forget(params);
+  return JSON.stringify(result, null, 2);
+}
+var HANDLERS = {
+  supermemory_search: handleSearch,
+  supermemory_add: handleAdd,
+  supermemory_profile: handleProfile,
+  supermemory_list: handleList,
+  supermemory_forget: handleForget
+};
+function jsonRpcResponse(id, result) {
+  return JSON.stringify({ jsonrpc: "2.0", id, result });
+}
+function jsonRpcError(id, code, message) {
+  return JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+}
+async function handleMessage(msg) {
+  const { id, method, params } = msg;
+  switch (method) {
+    case "initialize":
+      return jsonRpcResponse(id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "supermemory", version: "1.0.0" }
+      });
+    case "notifications/initialized":
+      return null;
+    case "tools/list":
+      return jsonRpcResponse(id, { tools: TOOLS });
+    case "tools/call": {
+      const toolName = params?.name;
+      const handler = HANDLERS[toolName];
+      if (!handler) {
+        return jsonRpcError(id, -32601, `Unknown tool: ${toolName}`);
+      }
+      try {
+        const text = await handler(params?.arguments ?? {});
+        return jsonRpcResponse(id, {
+          content: [{ type: "text", text }]
+        });
+      } catch (err) {
+        return jsonRpcResponse(id, {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true
+        });
+      }
+    }
+    default:
+      if (id !== undefined) {
+        return jsonRpcError(id, -32601, `Method not found: ${method}`);
+      }
+      return null;
+  }
+}
+async function startMcpServer() {
+  const decoder = new TextDecoder;
+  let buffer = "";
+  for await (const chunk of Bun.stdin.stream()) {
+    buffer += decoder.decode(chunk, { stream: true });
+    while (true) {
+      const headerEnd = buffer.indexOf(`\r
+\r
+`);
+      if (headerEnd === -1)
+        break;
+      const header = buffer.slice(0, headerEnd);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        buffer = buffer.slice(headerEnd + 4);
+        continue;
+      }
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      if (buffer.length < bodyStart + contentLength)
+        break;
+      const body = buffer.slice(bodyStart, bodyStart + contentLength);
+      buffer = buffer.slice(bodyStart + contentLength);
+      try {
+        const msg = JSON.parse(body);
+        const response = await handleMessage(msg);
+        if (response) {
+          const out = `Content-Length: ${Buffer.byteLength(response)}\r
+\r
+${response}`;
+          process.stdout.write(out);
+        }
+      } catch (err) {
+        const errResp = jsonRpcError(null, -32700, "Parse error");
+        const out = `Content-Length: ${Buffer.byteLength(errResp)}\r
+\r
+${errResp}`;
+        process.stdout.write(out);
+      }
+    }
+  }
+}
+// src/cli.ts
+var command = process.argv[2];
+switch (command) {
+  case "mcp":
+    await startMcpServer();
+    break;
+  case "login": {
+    const existing = loadCredentials();
+    if (existing) {
+      console.log("Already authenticated. Use `logout` first to re-authenticate.");
+      process.exit(0);
+    }
+    console.log("Opening browser to authenticate...");
+    const result = await startAuthFlow();
+    if (result.success) {
+      console.log("Authenticated successfully.");
+    } else {
+      console.error(`Authentication failed: ${result.error}`);
+      process.exit(1);
+    }
+    break;
+  }
+  case "logout": {
+    const removed = clearCredentials();
+    console.log(removed ? "Logged out." : "No credentials found.");
+    break;
+  }
+  case "status": {
+    const creds = loadCredentials();
+    if (creds) {
+      console.log(`Authenticated since ${creds.createdAt}`);
+      console.log(`API key: ${creds.apiKey.slice(0, 6)}...${creds.apiKey.slice(-4)}`);
+    } else {
+      console.log("Not authenticated. Run `cursor-supermemory login` to connect.");
+    }
+    break;
+  }
+  default:
+    console.log(`cursor-supermemory — Persistent AI memory for Cursor
+Commands:
+  mcp      Start the MCP server (stdio)
+  login    Authenticate with Supermemory
+  logout   Remove stored credentials
+  status   Show authentication status`);
+    if (command)
+      process.exit(1);
+}