@memoraone/mcp 0.1.47 → 0.1.49

package/dist/index.cjs

@@ -593,7 +593,7 @@ async function acquireLocalLock(lockName, options = {}) {
             `[memoraone-mcp] Failed to acquire lock ${lockName} after ${maxRetries} retries`
           );
         }
-        await new Promise((resolve10) => setTimeout(resolve10, retryDelayMs));
+        await new Promise((resolve11) => setTimeout(resolve11, retryDelayMs));
         continue;
       }
       throw err;
@@ -612,9 +612,9 @@ async function withLocalLock(lockName, fn, options = {}) {
 
 // src/localState/localConnectClient.ts
 var path6 = __toESM(require("path"), 1);
-async function requestJson(baseUrl, method, path15, options = {}) {
+async function requestJson(baseUrl, method, path16, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const url = `${baseUrl.replace(/\/+$/, "")}${path15.startsWith("/") ? path15 : `/${path15}`}`;
+  const url = `${baseUrl.replace(/\/+$/, "")}${path16.startsWith("/") ? path16 : `/${path16}`}`;
   const res = await fetchImpl(url, {
     method,
     headers: {
@@ -950,9 +950,9 @@ var MemoraClient = class {
       ...options?.headers ?? {}
     };
   }
-  async perform(method, path15, body, options, retried = false) {
+  async perform(method, path16, body, options, retried = false) {
     const nonce = crypto2.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path15.startsWith("/") ? path15 : `/${path15}`}`;
+    const url = `${this.baseUrl}${path16.startsWith("/") ? path16 : `/${path16}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=${method} url=${url}`
@@ -979,7 +979,7 @@ var MemoraClient = class {
       if (res.status === 401 && !options?.skipAuthRefresh && !retried) {
         try {
           await this.refreshAccessToken();
-          return this.perform(method, path15, body, options, true);
+          return this.perform(method, path16, body, options, true);
         } catch (err) {
           if (err instanceof ReconnectRequiredError) {
             await this.markReconnectRequired();
@@ -999,24 +999,22 @@ var MemoraClient = class {
     }
     return res.text ? JSON.parse(res.text) : null;
   }
-  async post(path15, body, options) {
-    console.error(`[memoraone-mcp][info] MemoraClient.post ENTER path=${path15}`);
-    const result = await this.perform("POST", path15, body, options);
-    console.error(`[memoraone-mcp][info] MemoraClient.post EXIT path=${path15}`);
+  async post(path16, body, options) {
+    console.error(`[memoraone-mcp][info] MemoraClient.post ENTER path=${path16}`);
+    const result = await this.perform("POST", path16, body, options);
+    console.error(`[memoraone-mcp][info] MemoraClient.post EXIT path=${path16}`);
     return result;
   }
-  async get(path15, options) {
-    return this.perform("GET", path15, void 0, options);
+  async get(path16, options) {
+    return this.perform("GET", path16, void 0, options);
   }
 };
 var memoraClient_default = MemoraClient;
 
 // src/projectBinding.ts
-var fs8 = __toESM(require("fs/promises"), 1);
 var path11 = __toESM(require("path"), 1);
 
 // src/localState/resolveLocalBinding.ts
-var fs7 = __toESM(require("fs/promises"), 1);
 var path10 = __toESM(require("path"), 1);
 
 // src/localState/pathIndex.ts
@@ -1234,19 +1232,9 @@ function identityMatchesStored(stored, current) {
 }
 
 // src/localState/resolveLocalBinding.ts
-async function detectLegacyM1Warning(workspaceRoot) {
-  const candidate = path10.join(path10.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
-  try {
-    await fs7.access(candidate);
-    return candidate;
-  } catch {
-    return void 0;
-  }
-}
 async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   const resolved = path10.resolve(workspaceRoot);
   const identity = await captureRootFilesystemIdentity(resolved, options.identityDeps);
-  const legacyM1WarningPath = await detectLegacyM1Warning(resolved);
   const index = await loadPathIndex(options.homeDir);
   const lookup = lookupPathIndex(index, resolved, identity);
   if (lookup.kind === "path") {
@@ -1270,8 +1258,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
       return {
         repositoryBindingId: record.repositoryBindingId,
         identity,
-        created: false,
-        legacyM1WarningPath
+        created: false
       };
     }
   }
@@ -1295,8 +1282,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
         repositoryBindingId: record.repositoryBindingId,
         identity,
         created: false,
-        renamedFrom: lookup.previousPath,
-        legacyM1WarningPath
+        renamedFrom: lookup.previousPath
       };
     }
   }
@@ -1309,13 +1295,36 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   return {
     repositoryBindingId,
     identity,
-    created: true,
-    legacyM1WarningPath
+    created: true
+  };
+}
+async function lookupLocalBindingIdentity(workspaceRoot, options = {}) {
+  const resolved = path10.resolve(workspaceRoot);
+  const identity = await captureRootFilesystemIdentity(resolved, options.identityDeps);
+  const index = await loadPathIndex(options.homeDir);
+  const lookup = lookupPathIndex(index, resolved, identity);
+  if (lookup.kind !== "path") {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  const record = await readBindingRecord(lookup.repositoryBindingId, options.homeDir);
+  if (!record) {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  if (path10.resolve(record.workspaceRoot) !== resolved) {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  if (!identityMatchesStored(record.filesystemIdentity, identity)) {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  return {
+    status: "resolved",
+    workspaceRoot: resolved,
+    repositoryBindingId: record.repositoryBindingId
   };
 }
 async function resolveLocalBinding(workspaceRoot, options = {}) {
   const resolved = path10.resolve(workspaceRoot);
-  const { repositoryBindingId, legacyM1WarningPath } = await ensureRepositoryBindingForRoot(
+  const { repositoryBindingId } = await ensureRepositoryBindingForRoot(
     resolved,
     { ...options, createIfMissing: false }
   );
@@ -1358,13 +1367,11 @@ async function resolveLocalBinding(workspaceRoot, options = {}) {
     installationPublicId: record.installationPublicId ?? creds.installationPublicId,
     environment: record.environment,
     bindingSource: "local-binding",
-    status: record.status,
-    legacyM1WarningPath
+    status: record.status
   };
 }
 
 // src/projectBinding.ts
-var CANONICAL_M1_FILENAME = "memoraone.m1";
 function toResolvedBinding(local) {
   return {
     repositoryBindingId: local.repositoryBindingId,
@@ -1373,23 +1380,9 @@ function toResolvedBinding(local) {
     installationPublicId: local.installationPublicId,
     environment: local.environment,
     bindingSource: "local-binding",
-    status: local.status,
-    legacyM1WarningPath: local.legacyM1WarningPath
+    status: local.status
   };
 }
-async function warnLegacyM1IfPresent(workspaceRoot) {
-  const candidate = path11.join(path11.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
-  try {
-    await fs8.access(candidate);
-    process.stderr.write(
-      `[memoraone-mcp] warning: ignoring legacy ${CANONICAL_M1_FILENAME} (not used for credentials or binding)
-`
-    );
-    return candidate;
-  } catch {
-    return void 0;
-  }
-}
 async function resolveAuthoritativeBinding(workspaceRoot, _options = {}) {
   const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
   if (candidates.length === 0) {
@@ -1399,7 +1392,6 @@ async function resolveAuthoritativeBinding(workspaceRoot, _options = {}) {
   }
   const bindings = [];
   for (const root of candidates) {
-    await warnLegacyM1IfPresent(root);
     try {
       const local = await resolveLocalBinding(root);
       bindings.push(toResolvedBinding(local));
@@ -1690,9 +1682,148 @@ async function resolveBindingFromInitializeParams(params, options = {}) {
   });
 }
 
-// src/bindingSidecar.ts
-var fs9 = __toESM(require("fs"), 1);
+// src/pluginStartupBindingWait.ts
 var path13 = __toESM(require("path"), 1);
+var MEMORAONE_PLUGIN_ENV = "MEMORAONE_PLUGIN";
+var MEMORAONE_CURSOR_PLUGIN = "cursor";
+var PLUGIN_STARTUP_BINDING_WAIT_TIMEOUT_MS = 5 * 60 * 1e3;
+var PLUGIN_STARTUP_BINDING_WAIT_INTERVAL_MS = 250;
+var UNBOUND_MESSAGE_MARKERS = [
+  "No local MemoraOne binding for this workspace",
+  "No local binding for workspace"
+];
+var CREDENTIALS_MISSING_MARKER = "Installation credentials missing";
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isUnboundPluginStartupBindingMessage(message) {
+  return UNBOUND_MESSAGE_MARKERS.some((marker) => message.includes(marker));
+}
+function isCredentialsMissingMessage(message) {
+  return message.includes(CREDENTIALS_MISSING_MARKER);
+}
+async function pendingBindingWindowOpen(isPendingBinding) {
+  if (!isPendingBinding) {
+    return false;
+  }
+  try {
+    return Boolean(await isPendingBinding());
+  } catch {
+    return false;
+  }
+}
+function shouldWaitForPluginStartupBinding(options = {}) {
+  const env2 = options.env ?? process.env;
+  if (env2[MEMORAONE_PLUGIN_ENV] !== MEMORAONE_CURSOR_PLUGIN) {
+    return false;
+  }
+  if (options.daemonBindingHint) {
+    return false;
+  }
+  return true;
+}
+function collectPluginStartupBindingRoots(options) {
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [];
+  const add = (raw) => {
+    if (raw === void 0 || raw === null || raw.trim() === "") {
+      return;
+    }
+    const resolved = path13.resolve(raw);
+    if (seen.has(resolved)) {
+      return;
+    }
+    seen.add(resolved);
+    roots.push(resolved);
+  };
+  for (const root of options.initializeRoots ?? []) {
+    add(root);
+  }
+  for (const uri of options.rootsListUris ?? []) {
+    add(uriToPath(uri));
+  }
+  add(getRepoScopedWorkspaceHint(options.env));
+  return roots;
+}
+async function hasPendingPluginStartupBinding(workspaceRoots, options = {}) {
+  for (const root of workspaceRoots) {
+    try {
+      const identity = await lookupLocalBindingIdentity(root, {
+        homeDir: options.homeDir
+      });
+      if (identity.status !== "resolved") {
+        continue;
+      }
+      const record = await readBindingRecord(
+        identity.repositoryBindingId,
+        options.homeDir
+      );
+      if (record?.status === "pending") {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+async function isRetryablePluginStartupBindingError(err, options = {}) {
+  const message = errorMessage(err);
+  if (isUnboundPluginStartupBindingMessage(message)) {
+    return true;
+  }
+  if (isCredentialsMissingMessage(message) && await pendingBindingWindowOpen(options.isPendingBinding)) {
+    return true;
+  }
+  return false;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve11) => {
+    setTimeout(resolve11, ms);
+  });
+}
+async function waitForPluginStartupBinding(resolve11, options = {}) {
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? defaultSleep;
+  const timeoutMs = options.timeoutMs ?? PLUGIN_STARTUP_BINDING_WAIT_TIMEOUT_MS;
+  const intervalMs = options.intervalMs ?? PLUGIN_STARTUP_BINDING_WAIT_INTERVAL_MS;
+  const startedAt = now();
+  let waitingLogged = false;
+  let lastError;
+  while (true) {
+    try {
+      const binding = await resolve11();
+      if (waitingLogged) {
+        options.log?.(
+          `local MemoraOne binding available after Cursor plugin pairing (${now() - startedAt}ms)`
+        );
+      }
+      return binding;
+    } catch (err) {
+      lastError = err;
+      const retryable = await isRetryablePluginStartupBindingError(err, {
+        isPendingBinding: options.isPendingBinding
+      });
+      if (!retryable) {
+        throw err;
+      }
+      if (now() - startedAt >= timeoutMs) {
+        throw lastError;
+      }
+      if (!waitingLogged) {
+        options.log?.(
+          "waiting for local MemoraOne binding after Cursor plugin pairing"
+        );
+        waitingLogged = true;
+      }
+      await sleep(intervalMs);
+    }
+  }
+}
+
+// src/bindingSidecar.ts
+var fs7 = __toESM(require("fs"), 1);
+var path14 = __toESM(require("path"), 1);
 function bindingSidecarPath(socketPath) {
   if (socketPath.endsWith(".sock")) {
     return `${socketPath.slice(0, -".sock".length)}.binding.json`;
@@ -1716,7 +1847,7 @@ function writeBindingSidecar(socketPath, binding, ideType = resolveBindingIdeTyp
   if (/["']?(accessToken|refreshToken|apiKey|clientRedeemKey|clientRefreshKey)["']?\s*:/.test(text)) {
     throw new Error("[memoraone-mcp] Refusing to write sidecar containing secrets");
   }
-  fs9.writeFileSync(bindingSidecarPath(socketPath), text, "utf8");
+  fs7.writeFileSync(bindingSidecarPath(socketPath), text, "utf8");
 }
 
 // src/bridgeClientRoots.ts
@@ -2153,9 +2284,9 @@ function buildPersonalContextPath(parsed2) {
 }
 async function handleGetPersonalContext(client, args) {
   const parsed2 = getPersonalContextInputSchema.parse(args ?? {});
-  const path15 = buildPersonalContextPath(parsed2);
+  const path16 = buildPersonalContextPath(parsed2);
   try {
-    const result = await client.get(path15);
+    const result = await client.get(path16);
     return { ok: true, result };
   } catch (err) {
     if (err instanceof MemoraOneHttpError) {
@@ -2627,8 +2758,8 @@ async function handleCreateConceptVersion(client, args) {
   if (input.tags !== void 0) body.tags = input.tags;
   if (input.parent_id !== void 0) body.parent_id = input.parent_id;
   try {
-    const path15 = `/concepts/${encodeURIComponent(input.id)}/versions`;
-    return projectCreatedConceptVersionResponse(await client.post(path15, body));
+    const path16 = `/concepts/${encodeURIComponent(input.id)}/versions`;
+    return projectCreatedConceptVersionResponse(await client.post(path16, body));
   } catch (error) {
     rethrowToolRequestError("memora_create_concept_version", error);
   }
@@ -2662,8 +2793,8 @@ function handleBindingStatus(binding, options = {}) {
 
 // src/heartbeat.ts
 var crypto5 = __toESM(require("crypto"), 1);
-var fs10 = __toESM(require("fs"), 1);
-var path14 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs"), 1);
+var path15 = __toESM(require("path"), 1);
 
 // src/localState/mcpSessionId.ts
 var import_node_crypto4 = require("crypto");
@@ -2696,13 +2827,13 @@ function resolvePackageVersion() {
   if (fromEnv) return fromEnv;
   const moduleDir = typeof __dirname !== "undefined" ? __dirname : void 0;
   const candidates = [
-    ...moduleDir ? [path14.join(moduleDir, "..", "package.json"), path14.join(moduleDir, "package.json")] : [],
-    path14.join(process.cwd(), "package.json"),
-    path14.join(process.cwd(), "packages", "mcp", "package.json")
+    ...moduleDir ? [path15.join(moduleDir, "..", "package.json"), path15.join(moduleDir, "package.json")] : [],
+    path15.join(process.cwd(), "package.json"),
+    path15.join(process.cwd(), "packages", "mcp", "package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const pkg = JSON.parse(fs10.readFileSync(candidate, "utf8"));
+      const pkg = JSON.parse(fs8.readFileSync(candidate, "utf8"));
       if (typeof pkg.version === "string" && pkg.version.trim()) {
         return pkg.version.trim();
       }
@@ -3217,8 +3348,8 @@ function registerToolWithWorklog(server, runtime, sessionContext, toolName, desc
 async function main(opts = {}) {
   let bindingReadyResolve = null;
   let bindingReadyReject = null;
-  const bindingReady = new Promise((resolve10, reject) => {
-    bindingReadyResolve = resolve10;
+  const bindingReady = new Promise((resolve11, reject) => {
+    bindingReadyResolve = resolve11;
     bindingReadyReject = reject;
   });
   const devMode = Boolean(config2.devMode);
@@ -3299,12 +3430,25 @@ async function main(opts = {}) {
         console.error("[memoraone-mcp][init-debug] Workspace resolution strategy: initialize.rootUri");
       }
     }
-    const binding = await resolveBindingFromInitializeParams(params, {
+    const resolveBinding = () => resolveBindingFromInitializeParams(params, {
       fallbackWorkspaceRoots: getEnvWorkspaceRootCandidates(),
       rootsListUris,
       rootsListAttempted,
       ...getBridgeBindingResolveOptions()
     });
+    const binding = shouldWaitForPluginStartupBinding({
+      env: process.env,
+      daemonBindingHint: opts.daemonBindingHint
+    }) ? await waitForPluginStartupBinding(resolveBinding, {
+      isPendingBinding: () => hasPendingPluginStartupBinding(
+        collectPluginStartupBindingRoots({
+          initializeRoots,
+          rootsListUris,
+          env: process.env
+        })
+      ),
+      log: (msg) => console.error(`[memoraone-mcp] ${msg}`)
+    }) : await resolveBinding();
     workspaceRoot = binding.workspaceRoot;
     return binding;
   };
@@ -3578,11 +3722,6 @@ async function main(opts = {}) {
         if (debugLog) {
           console.error("[memoraone-mcp][debug] Resolved installation credentials from OS keyring");
         }
-        if (binding.legacyM1WarningPath) {
-          console.error(
-            `[memoraone-mcp] warning: ignoring legacy memoraone.m1 at ${binding.legacyM1WarningPath}`
-          );
-        }
         const projectId = binding.projectId;
         const existing = getBoundProjectId();
         if (existing !== null && existing !== projectId) {
@@ -3691,10 +3830,10 @@ async function main(opts = {}) {
     console.error("[memoraone-mcp] MCP server ready");
   }
   if (opts.sessionSocket) {
-    await new Promise((resolve10) => {
+    await new Promise((resolve11) => {
       opts.sessionSocket.once("close", () => {
         shutdown("session closed", false);
-        resolve10();
+        resolve11();
       });
     });
   }