@memoraone/mcp 0.1.52 → 0.1.53

package/dist/cli.cjs

@@ -231,7 +231,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.52",
+      version: "0.1.53",
       type: "module",
       main: "dist/index.cjs",
       exports: {
@@ -13815,6 +13815,17 @@ function extractJsonRpcId(line) {
     return void 0;
   }
 }
+function extractInitializeProtocolVersion(line) {
+  try {
+    const message = JSON.parse(line.trim());
+    const version2 = message.params?.protocolVersion;
+    if (typeof version2 === "string" && version2.trim() !== "") {
+      return version2;
+    }
+  } catch {
+  }
+  return "2024-11-05";
+}
 function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
   return new Promise((resolve44, reject) => {
     const tryConnect = (attempt) => {
@@ -13949,11 +13960,19 @@ async function runBridgeProxy(options) {
       if (message.method === "initialize") {
         log("resolve binding from initialize request before daemon connect");
         const params = message.params ?? {};
-        await router.ensureDaemonForInitialize(params);
+        const sessionKind = await router.ensureDaemonForInitialize(params);
+        if (sessionKind === "setup_required") {
+          router.completeSetupRequiredInitialize(trimmed);
+          continue;
+        }
         await router.forwardInitializeToDaemon(trimmed);
         await router.replayDeferredClientMessages();
         continue;
       }
+      if (router.isSetupRequiredSession()) {
+        router.handleSetupRequiredClientLine(trimmed);
+        continue;
+      }
       if (!router.hasClientInitialize()) {
         const method = typeof message.method === "string" && message.method.trim() !== "" ? message.method : "(unknown)";
         if (message.id !== void 0 && message.id !== null) {
@@ -13976,7 +13995,7 @@ async function runBridgeProxy(options) {
     router.close();
   }
 }
-var net, readline4, import_node_child_process7, defaultLog, JSONRPC_METHOD_NOT_FOUND, BridgeDaemonRouter;
+var net, readline4, import_node_child_process7, defaultLog, JSONRPC_METHOD_NOT_FOUND, SETUP_REQUIRED_FINISH_SETUP_TOOL, BridgeDaemonRouter;
 var init_bridgeProxy = __esm({
   "src/bridgeProxy.ts"() {
     net = __toESM(require("net"), 1);
@@ -13996,6 +14015,11 @@ var init_bridgeProxy = __esm({
 `);
     };
     JSONRPC_METHOD_NOT_FOUND = -32601;
+    SETUP_REQUIRED_FINISH_SETUP_TOOL = {
+      name: "memora_finish_setup",
+      description: "Start MemoraOne Cursor plugin pairing for this workspace so the user can finish setup. Returns an authorization URL and request metadata; does not open a browser. Use when this plugin-managed session is unbound (setup required).",
+      inputSchema: { type: "object", properties: {} }
+    };
     BridgeDaemonRouter = class {
       constructor(options) {
         this.activeSocket = null;
@@ -14006,6 +14030,8 @@ var init_bridgeProxy = __esm({
         this.pendingDeferredClientLines = [];
         this.handshakeDeferredClientLines = [];
         this.clientInitializeSeen = false;
+        /** Unbound Cursor-plugin session: no daemon by design; handshake is local. */
+        this.setupRequiredSession = false;
         /** Waiters for daemon JSON-RPC responses (keyed by request id). */
         this.pendingDaemonResponseWaiters = /* @__PURE__ */ new Map();
         this.env = options.env ?? process.env;
@@ -14056,6 +14082,9 @@ var init_bridgeProxy = __esm({
       hasClientInitialize() {
         return this.clientInitializeSeen;
       }
+      isSetupRequiredSession() {
+        return this.setupRequiredSession;
+      }
       async ensureDaemonForInitialize(params) {
         logInitializeDebug(
           this.log,
@@ -14115,14 +14144,22 @@ var init_bridgeProxy = __esm({
           log: this.log
         }) : await resolveBinding();
         if (isPluginStartupSetupRequired(binding)) {
-          return;
+          this.setupRequiredSession = true;
+          this.activeBinding = null;
+          this.detachSocketReader();
+          const previousSocket = this.activeSocket;
+          this.activeSocket = null;
+          previousSocket?.destroy();
+          this.log("setup_required: no active binding; initialize will complete locally");
+          return "setup_required";
         }
+        this.setupRequiredSession = false;
         const environmentLog = binding.environment !== void 0 ? ` environment=${binding.environment}` : "";
         this.log(
           `session binding binding=${binding.repositoryBindingId} project=${binding.projectId} workspace=${binding.workspaceRoot} source=${binding.bindingSource}${environmentLog}`
         );
         if (this.activeBinding && bindingsMatch(this.activeBinding, binding) && this.activeSocket) {
-          return;
+          return "connected";
         }
         if (this.activeBinding && !bindingsMatch(this.activeBinding, binding)) {
           this.log(
@@ -14137,11 +14174,71 @@ var init_bridgeProxy = __esm({
         this.activeBinding = binding;
         await this.connectActiveDaemon();
         this.log("bridge connected");
+        return "connected";
       }
       recordClientInitialize(line) {
         this.lastInitializeLine = line;
         this.clientInitializeSeen = true;
       }
+      /**
+       * Finish Setup session: answer initialize on the bridge. Does not connect,
+       * spawn, or forward to a daemon — there is no binding by design.
+       */
+      completeSetupRequiredInitialize(line) {
+        this.recordClientInitialize(line);
+        const initId = extractJsonRpcId(line);
+        if (initId !== void 0) {
+          this.stdout.write(
+            `${JSON.stringify({
+              jsonrpc: "2.0",
+              id: initId,
+              result: {
+                protocolVersion: extractInitializeProtocolVersion(line),
+                capabilities: { tools: { listChanged: true } },
+                serverInfo: { name: "memoraone-mcp", version: "1.0.0" }
+              }
+            })}
+`
+          );
+        }
+        this.log("setup_required: initialize completed locally");
+        const deferred = this.pendingDeferredClientLines.slice();
+        this.pendingDeferredClientLines = [];
+        this.handshakeDeferredClientLines = deferred.slice();
+        for (const deferredLine of deferred) {
+          this.handleSetupRequiredClientLine(deferredLine);
+        }
+      }
+      /** Local MCP replies for a setup_required session (no daemon socket). */
+      handleSetupRequiredClientLine(line) {
+        let message;
+        try {
+          message = JSON.parse(line.trim());
+        } catch {
+          return;
+        }
+        const method = typeof message.method === "string" ? message.method : "";
+        const id = message.id;
+        if (method === "tools/list" && (typeof id === "string" || typeof id === "number")) {
+          this.stdout.write(
+            `${JSON.stringify({
+              jsonrpc: "2.0",
+              id,
+              result: { tools: [SETUP_REQUIRED_FINISH_SETUP_TOOL] }
+            })}
+`
+          );
+          return;
+        }
+        if (id === void 0 || id === null) {
+          return;
+        }
+        writePreInitializeJsonRpcError(
+          this.stdout,
+          id,
+          method.trim() !== "" ? method : "(unknown)"
+        );
+      }
       /**
        * Forward initialize to the daemon and wait for its JSON-RPC response before
        * returning. Prevents pipelined tools/call (e.g. Claude Code lazy MCP connect)
@@ -14241,6 +14338,7 @@ var init_bridgeProxy = __esm({
         this.pendingDeferredClientLines = [];
         this.handshakeDeferredClientLines = [];
         this.clientInitializeSeen = false;
+        this.setupRequiredSession = false;
         this.activeBinding = null;
         this.activeIdeType = void 0;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "type": "module",
   "main": "dist/index.cjs",
   "exports": {