@memoraone/mcp 0.1.41 → 0.1.43

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((resolve9) => setTimeout(resolve9, retryDelayMs));
+        await new Promise((resolve10) => setTimeout(resolve10, retryDelayMs));
         continue;
       }
       throw err;
@@ -611,9 +611,10 @@ async function withLocalLock(lockName, fn, options = {}) {
 }
 
 // src/localState/localConnectClient.ts
-async function requestJson(baseUrl, method, path14, options = {}) {
+var path6 = __toESM(require("path"), 1);
+async function requestJson(baseUrl, method, path15, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const url = `${baseUrl.replace(/\/+$/, "")}${path14.startsWith("/") ? path14 : `/${path14}`}`;
+  const url = `${baseUrl.replace(/\/+$/, "")}${path15.startsWith("/") ? path15 : `/${path15}`}`;
   const res = await fetchImpl(url, {
     method,
     headers: {
@@ -719,7 +720,7 @@ async function refreshInstallationAccessToken(options) {
 
 // src/localState/bindingStore.ts
 var fs5 = __toESM(require("fs/promises"), 1);
-var path6 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 
 // src/localState/bindingRecord.ts
 var BINDING_RECORD_VERSION = 1;
@@ -949,9 +950,9 @@ var MemoraClient = class {
       ...options?.headers ?? {}
     };
   }
-  async perform(method, path14, body, options, retried = false) {
+  async perform(method, path15, body, options, retried = false) {
     const nonce = crypto2.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path14.startsWith("/") ? path14 : `/${path14}`}`;
+    const url = `${this.baseUrl}${path15.startsWith("/") ? path15 : `/${path15}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=${method} url=${url}`
@@ -975,10 +976,10 @@ var MemoraClient = class {
       if (accepted) {
         return res.text ? JSON.parse(res.text) : null;
       }
-      if ((res.status === 401 || res.status === 403) && !options?.skipAuthRefresh && !retried) {
+      if (res.status === 401 && !options?.skipAuthRefresh && !retried) {
         try {
           await this.refreshAccessToken();
-          return this.perform(method, path14, body, options, true);
+          return this.perform(method, path15, body, options, true);
         } catch (err) {
           if (err instanceof ReconnectRequiredError) {
             await this.markReconnectRequired();
@@ -986,9 +987,6 @@ var MemoraClient = class {
           throw err;
         }
       }
-      if (res.status === 401 || res.status === 403) {
-        await this.markReconnectRequired();
-      }
       const quiet = options?.quietHttpStatuses?.includes(res.status);
       if (!quiet) {
         const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
@@ -1001,33 +999,33 @@ var MemoraClient = class {
     }
     return res.text ? JSON.parse(res.text) : null;
   }
-  async post(path14, body, options) {
-    console.error(`[memoraone-mcp][info] MemoraClient.post ENTER path=${path14}`);
-    const result = await this.perform("POST", path14, body, options);
-    console.error(`[memoraone-mcp][info] MemoraClient.post EXIT path=${path14}`);
+  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}`);
     return result;
   }
-  async get(path14, options) {
-    return this.perform("GET", path14, void 0, options);
+  async get(path15, options) {
+    return this.perform("GET", path15, void 0, options);
   }
 };
 var memoraClient_default = MemoraClient;
 
 // src/projectBinding.ts
 var fs8 = __toESM(require("fs/promises"), 1);
-var path10 = __toESM(require("path"), 1);
+var path11 = __toESM(require("path"), 1);
 
 // src/localState/resolveLocalBinding.ts
 var fs7 = __toESM(require("fs/promises"), 1);
-var path9 = __toESM(require("path"), 1);
+var path10 = __toESM(require("path"), 1);
 
 // src/localState/pathIndex.ts
-var path8 = __toESM(require("path"), 1);
+var path9 = __toESM(require("path"), 1);
 
 // src/localState/rootFilesystemIdentity.ts
 var fs6 = __toESM(require("fs/promises"), 1);
 var os3 = __toESM(require("os"), 1);
-var path7 = __toESM(require("path"), 1);
+var path8 = __toESM(require("path"), 1);
 var import_node_child_process = require("child_process");
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
@@ -1091,7 +1089,7 @@ async function resolveDeviceId(platform2 = os3.platform()) {
   throw new Error(`[memoraone-mcp] Unsupported platform for device ID: ${platform2}`);
 }
 async function captureRootFilesystemIdentity(rootPath, deps = {}) {
-  const resolved = path7.resolve(rootPath);
+  const resolved = path8.resolve(rootPath);
   const platform2 = deps.platform ?? os3.platform();
   const statRoot = deps.statRoot ?? (async (p) => {
     const st2 = await fs6.stat(p);
@@ -1178,7 +1176,7 @@ async function savePathIndex(index, homeDir) {
   await writeJsonAtomic(getPathIndexPath(homeDir), next);
 }
 function lookupPathIndex(index, workspaceRoot, identity) {
-  const resolved = path8.resolve(workspaceRoot);
+  const resolved = path9.resolve(workspaceRoot);
   const byPathId = index.byPath[resolved];
   if (byPathId) {
     return { kind: "path", repositoryBindingId: assertRepositoryBindingId(byPathId) };
@@ -1204,14 +1202,14 @@ function lookupPathIndex(index, workspaceRoot, identity) {
 }
 async function upsertPathIndexEntry(options) {
   const repositoryBindingId = assertRepositoryBindingId(options.repositoryBindingId);
-  const resolved = path8.resolve(options.workspaceRoot);
+  const resolved = path9.resolve(options.workspaceRoot);
   const identityKey = filesystemIdentityKey(options.identity);
   return withLocalLock(
     "path-index",
     async () => {
       const index = await loadPathIndex(options.homeDir);
-      if (options.previousPath && path8.resolve(options.previousPath) !== resolved) {
-        delete index.byPath[path8.resolve(options.previousPath)];
+      if (options.previousPath && path9.resolve(options.previousPath) !== resolved) {
+        delete index.byPath[path9.resolve(options.previousPath)];
       }
       for (const [p, id] of Object.entries(index.byPath)) {
         if (id === repositoryBindingId && p !== resolved) {
@@ -1237,7 +1235,7 @@ function identityMatchesStored(stored, current) {
 
 // src/localState/resolveLocalBinding.ts
 async function detectLegacyM1Warning(workspaceRoot) {
-  const candidate = path9.join(path9.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
+  const candidate = path10.join(path10.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
   try {
     await fs7.access(candidate);
     return candidate;
@@ -1246,7 +1244,7 @@ async function detectLegacyM1Warning(workspaceRoot) {
   }
 }
 async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
-  const resolved = path9.resolve(workspaceRoot);
+  const resolved = path10.resolve(workspaceRoot);
   const identity = await captureRootFilesystemIdentity(resolved, options.identityDeps);
   const legacyM1WarningPath = await detectLegacyM1Warning(resolved);
   const index = await loadPathIndex(options.homeDir);
@@ -1254,7 +1252,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   if (lookup.kind === "path") {
     const record = await readBindingRecord(lookup.repositoryBindingId, options.homeDir);
     if (record && identityMatchesStored(record.filesystemIdentity, identity)) {
-      if (path9.resolve(record.workspaceRoot) !== resolved) {
+      if (path10.resolve(record.workspaceRoot) !== resolved) {
         const updated = {
           ...record,
           workspaceRoot: resolved,
@@ -1316,7 +1314,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   };
 }
 async function resolveLocalBinding(workspaceRoot, options = {}) {
-  const resolved = path9.resolve(workspaceRoot);
+  const resolved = path10.resolve(workspaceRoot);
   const { repositoryBindingId, legacyM1WarningPath } = await ensureRepositoryBindingForRoot(
     resolved,
     { ...options, createIfMissing: false }
@@ -1380,7 +1378,7 @@ function toResolvedBinding(local) {
   };
 }
 async function warnLegacyM1IfPresent(workspaceRoot) {
-  const candidate = path10.join(path10.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
+  const candidate = path11.join(path11.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
   try {
     await fs8.access(candidate);
     process.stderr.write(
@@ -1439,7 +1437,7 @@ function normalizeWorkspaceSearchRoots(workspaceRoot) {
     if (raw === void 0) continue;
     const trimmed = String(raw).trim();
     if (trimmed === "") continue;
-    const resolved = path10.resolve(trimmed);
+    const resolved = path11.resolve(trimmed);
     if (!seen.has(resolved)) {
       seen.add(resolved);
       out.push(resolved);
@@ -1450,17 +1448,17 @@ function normalizeWorkspaceSearchRoots(workspaceRoot) {
 function bindingRelevantValuesMatch(a, b) {
   const envA = a.environment ?? void 0;
   const envB = b.environment ?? void 0;
-  return a.repositoryBindingId === b.repositoryBindingId && a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path10.resolve(a.workspaceRoot) === path10.resolve(b.workspaceRoot) && (a.installationPublicId ?? void 0) === (b.installationPublicId ?? void 0) && envA === envB && a.status === b.status;
+  return a.repositoryBindingId === b.repositoryBindingId && a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path11.resolve(a.workspaceRoot) === path11.resolve(b.workspaceRoot) && (a.installationPublicId ?? void 0) === (b.installationPublicId ?? void 0) && envA === envB && a.status === b.status;
 }
-async function reconcileResolvedBindingWithDisk(cached) {
+async function reconcileResolvedBindingWithDisk(cached, options = {}) {
   const repositoryBindingId = assertRepositoryBindingId(cached.repositoryBindingId);
-  const record = await readBindingRecord(repositoryBindingId);
+  const record = await readBindingRecord(repositoryBindingId, options.homeDir);
   if (!record) {
     throw new ReconnectRequiredError(
       `[memoraone-mcp] Cached binding missing for ${repositoryBindingId}. Run: memoraone-mcp connect <code>`
     );
   }
-  const workspaceRoot = path10.resolve(record.workspaceRoot);
+  const workspaceRoot = path11.resolve(record.workspaceRoot);
   const identity = await captureRootFilesystemIdentity(workspaceRoot);
   if (!identitiesMatch(record.filesystemIdentity, identity)) {
     throw new ReconnectRequiredError(
@@ -1486,6 +1484,21 @@ async function reconcileResolvedBindingWithDisk(cached) {
   }
   return { binding: fresh, cacheRefreshed: true };
 }
+async function checkRuntimeBindingValidity(cached, options = {}) {
+  try {
+    const { binding: current } = await reconcileResolvedBindingWithDisk(cached, options);
+    if (current.status !== "connected") {
+      return { valid: false, reason: `binding status is ${current.status}` };
+    }
+    if (!bindingRelevantValuesMatch(cached, current)) {
+      return { valid: false, reason: "binding metadata changed" };
+    }
+    return { valid: true };
+  } catch (err) {
+    const reason = err instanceof Error && err.message.trim() ? err.message : String(err);
+    return { valid: false, reason };
+  }
+}
 function encodeResolvedBinding(binding) {
   const payload = {
     repositoryBindingId: binding.repositoryBindingId,
@@ -1500,7 +1513,7 @@ function encodeResolvedBinding(binding) {
 }
 
 // src/initializeBinding.ts
-var path11 = __toESM(require("path"), 1);
+var path12 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var MEMORAONE_WORKSPACE_ROOT_ENV = "MEMORAONE_WORKSPACE_ROOT";
 function getBridgeBindingResolveOptions(env2 = process.env) {
@@ -1520,8 +1533,8 @@ function getEnvWorkspaceRootCandidates() {
   const raw = process.env.WORKSPACE_FOLDER_PATHS;
   const parts = [];
   if (raw !== void 0 && raw.trim() !== "") {
-    for (const p of raw.split(path11.delimiter).map((s) => s.trim()).filter(Boolean)) {
-      parts.push(path11.resolve(p));
+    for (const p of raw.split(path12.delimiter).map((s) => s.trim()).filter(Boolean)) {
+      parts.push(path12.resolve(p));
     }
   }
   parts.push(process.cwd());
@@ -1545,7 +1558,7 @@ function extractWorkspaceRootsFromInitialize(params) {
     if (uri === void 0 || uri.trim() === "") {
       return;
     }
-    const resolved = path11.resolve(uriToPath(uri));
+    const resolved = path12.resolve(uriToPath(uri));
     if (!seen.has(resolved)) {
       seen.add(resolved);
       roots.push(resolved);
@@ -1567,7 +1580,7 @@ function getRepoScopedWorkspaceHint(env2 = process.env) {
   if (raw === void 0 || raw.trim() === "") {
     return null;
   }
-  return path11.resolve(raw.trim());
+  return path12.resolve(raw.trim());
 }
 function formatWorkspaceAmbiguityError(bindings) {
   const lines = bindings.map(
@@ -1650,8 +1663,8 @@ async function resolveBindingFromInitializeParams(params, options = {}) {
   const rootsListUris = options.rootsListUris ?? [];
   const rootsListPaths = rootsListUris.map((uri) => uriToPath(uri)).filter(Boolean);
   if (rootsListPaths.length > 1 && repoHint !== null) {
-    const hintResolved = path11.resolve(repoHint);
-    const matchingRoot = rootsListPaths.find((root) => path11.resolve(root) === hintResolved);
+    const hintResolved = path12.resolve(repoHint);
+    const matchingRoot = rootsListPaths.find((root) => path12.resolve(root) === hintResolved);
     if (!matchingRoot) {
       throw new Error(formatRepoHintNotInRootsListError(repoHint, rootsListPaths));
     }
@@ -1679,7 +1692,7 @@ async function resolveBindingFromInitializeParams(params, options = {}) {
 
 // src/bindingSidecar.ts
 var fs9 = __toESM(require("fs"), 1);
-var path12 = __toESM(require("path"), 1);
+var path13 = __toESM(require("path"), 1);
 function bindingSidecarPath(socketPath) {
   if (socketPath.endsWith(".sock")) {
     return `${socketPath.slice(0, -".sock".length)}.binding.json`;
@@ -2140,9 +2153,9 @@ function buildPersonalContextPath(parsed2) {
 }
 async function handleGetPersonalContext(client, args) {
   const parsed2 = getPersonalContextInputSchema.parse(args ?? {});
-  const path14 = buildPersonalContextPath(parsed2);
+  const path15 = buildPersonalContextPath(parsed2);
   try {
-    const result = await client.get(path14);
+    const result = await client.get(path15);
     return { ok: true, result };
   } catch (err) {
     if (err instanceof MemoraOneHttpError) {
@@ -2614,8 +2627,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 path14 = `/concepts/${encodeURIComponent(input.id)}/versions`;
-    return projectCreatedConceptVersionResponse(await client.post(path14, body));
+    const path15 = `/concepts/${encodeURIComponent(input.id)}/versions`;
+    return projectCreatedConceptVersionResponse(await client.post(path15, body));
   } catch (error) {
     rethrowToolRequestError("memora_create_concept_version", error);
   }
@@ -2650,7 +2663,7 @@ function handleBindingStatus(binding, options = {}) {
 // src/heartbeat.ts
 var crypto5 = __toESM(require("crypto"), 1);
 var fs10 = __toESM(require("fs"), 1);
-var path13 = __toESM(require("path"), 1);
+var path14 = __toESM(require("path"), 1);
 
 // src/localState/mcpSessionId.ts
 var import_node_crypto4 = require("crypto");
@@ -2683,9 +2696,9 @@ function resolvePackageVersion() {
   if (fromEnv) return fromEnv;
   const moduleDir = typeof __dirname !== "undefined" ? __dirname : void 0;
   const candidates = [
-    ...moduleDir ? [path13.join(moduleDir, "..", "package.json"), path13.join(moduleDir, "package.json")] : [],
-    path13.join(process.cwd(), "package.json"),
-    path13.join(process.cwd(), "packages", "mcp", "package.json")
+    ...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")
   ];
   for (const candidate of candidates) {
     try {
@@ -2761,19 +2774,6 @@ async function sendProjectHeartbeat(client, ctx) {
     const raw = await client.post("/v1/local-mcp/heartbeat", body, { log: false });
     return { active: parseActiveFlag(raw) };
   } catch (err) {
-    if (err instanceof ReconnectRequiredError) {
-      try {
-        const record = await readBindingRecord(ctx.repositoryBindingId);
-        if (record) {
-          await writeBindingRecord({
-            ...record,
-            status: "reconnect_required",
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      } catch {
-      }
-    }
     process.stderr.write(
       `[memoraone-mcp][info] heartbeat error (silent) ${redactSensitiveText(String(err))}
 `
@@ -2788,6 +2788,8 @@ function createDaemonHeartbeat(opts) {
   let announced = false;
   let studioActive = null;
   let starting = false;
+  let tickInFlight = false;
+  let bindingAuthorityEnded = false;
   let waitingForIdeType = false;
   const sessionId = opts.sessionId ?? generateMcpSessionId();
   const packageVersion = opts.packageVersion ?? resolvePackageVersion();
@@ -2803,6 +2805,29 @@ function createDaemonHeartbeat(opts) {
     process.stderr.write(`[memoraone-mcp][daemon-heartbeat] ${redactSensitiveText(msg)}
 `);
   });
+  const validateBinding = opts.validateBinding ?? checkRuntimeBindingValidity;
+  const endBindingAuthority = (reason) => {
+    if (bindingAuthorityEnded) return;
+    bindingAuthorityEnded = true;
+    studioActive = false;
+    runGeneration += 1;
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    log(`heartbeat authority ended: ${redactSensitiveText(reason)}`);
+  };
+  const bindingIsValid = async () => {
+    try {
+      const result = await validateBinding(opts.binding);
+      if (result.valid) return true;
+      endBindingAuthority("reason" in result ? result.reason : "binding is no longer valid");
+      return false;
+    } catch (err) {
+      endBindingAuthority(`binding validation failed: ${String(err)}`);
+      return false;
+    }
+  };
   const ensureClient = async () => {
     if (client) return client;
     const creds = await readInstallationCredentials(opts.binding.repositoryBindingId);
@@ -2853,10 +2878,17 @@ function createDaemonHeartbeat(opts) {
     }
   };
   const tick = async (generation) => {
-    if (!client || generation !== runGeneration) return;
-    const outcome = await sendProjectHeartbeat(client, ctx);
-    if (generation !== runGeneration || !interval) return;
-    applyHeartbeatOutcome(outcome);
+    if (!client || generation !== runGeneration || bindingAuthorityEnded || tickInFlight) return;
+    tickInFlight = true;
+    try {
+      if (!await bindingIsValid()) return;
+      if (generation !== runGeneration || !interval) return;
+      const outcome = await sendProjectHeartbeat(client, ctx);
+      if (generation !== runGeneration || !interval) return;
+      applyHeartbeatOutcome(outcome);
+    } finally {
+      tickInFlight = false;
+    }
   };
   const beginInterval = () => {
     if (interval) return;
@@ -2884,8 +2916,13 @@ function createDaemonHeartbeat(opts) {
       log("already starting (skipped duplicate start)");
       return;
     }
+    if (bindingAuthorityEnded) {
+      log("binding authority already ended; heartbeat will not restart");
+      return;
+    }
     starting = true;
     try {
+      if (!await bindingIsValid()) return;
       const activeClient = await ensureClient();
       if (!activeClient) return;
       const ok = await ensureAnnounced(activeClient);
@@ -3180,8 +3217,8 @@ function registerToolWithWorklog(server, runtime, sessionContext, toolName, desc
 async function main(opts = {}) {
   let bindingReadyResolve = null;
   let bindingReadyReject = null;
-  const bindingReady = new Promise((resolve9, reject) => {
-    bindingReadyResolve = resolve9;
+  const bindingReady = new Promise((resolve10, reject) => {
+    bindingReadyResolve = resolve10;
     bindingReadyReject = reject;
   });
   const devMode = Boolean(config2.devMode);
@@ -3654,10 +3691,10 @@ async function main(opts = {}) {
     console.error("[memoraone-mcp] MCP server ready");
   }
   if (opts.sessionSocket) {
-    await new Promise((resolve9) => {
+    await new Promise((resolve10) => {
       opts.sessionSocket.once("close", () => {
         shutdown("session closed", false);
-        resolve9();
+        resolve10();
       });
     });
   }