@memlink/cli 1.0.3 → 1.0.5

package/dist/cli/index.js

@@ -45902,24 +45902,46 @@ Memlink is a self-hosted MCP server that gives you persistent, organized memory
 ## Connection
 
 The MCP server runs at:
+
+**Streamable HTTP** (modern clients):
 \`\`\`
 http://localhost:4444/mcp?id=YOUR_MEMORY_ID
 \`\`\`
 
+**SSE** (legacy clients like OpenCode):
+\`\`\`
+http://localhost:4444/sse?id=YOUR_MEMORY_ID
+\`\`\`
+
 The memory ID is a 12-character alphanumeric string assigned when you create a memory via \`memlink init <name>\`.
 
-### MCP Config (for agent settings)
+### Streamable HTTP config
 
 \`\`\`json
 {
   "mcpServers": {
     "memlink": {
+      "type": "http",
       "url": "http://localhost:4444/mcp?id=YOUR_MEMORY_ID"
     }
   }
 }
 \`\`\`
 
+### SSE config (OpenCode)
+
+\`\`\`json
+{
+  "mcpServers": {
+    "memlink": {
+      "type": "remote",
+      "enabled": true,
+      "url": "http://localhost:4444/sse?id=YOUR_MEMORY_ID"
+    }
+  }
+}
+\`\`\`
+
 ## Session Workflow
 
 1. **Start of session** — Always call \`memory_read\` to load existing context
@@ -46002,7 +46024,7 @@ function nanoid(size = 21) {
 }
 
 // src/core/types.ts
-var MEMLINK_VERSION = "1.0.3";
+var MEMLINK_VERSION = "1.0.5";
 var DEFAULT_PORT = 4444;
 var DEFAULT_HOST = "localhost";
 var CONFIG_DIR = ".memlink";
@@ -64883,6 +64905,134 @@ class StreamableHTTPServerTransport {
   }
 }
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js
+import { randomUUID } from "node:crypto";
+import { TLSSocket } from "node:tls";
+var import_raw_body = __toESM(require_raw_body(), 1);
+var import_content_type = __toESM(require_content_type(), 1);
+import { URL as URL2 } from "node:url";
+var MAXIMUM_MESSAGE_SIZE = "4mb";
+
+class SSEServerTransport {
+  constructor(_endpoint, res, options) {
+    this._endpoint = _endpoint;
+    this.res = res;
+    this._sessionId = randomUUID();
+    this._options = options || { enableDnsRebindingProtection: false };
+  }
+  validateRequestHeaders(req) {
+    if (!this._options.enableDnsRebindingProtection) {
+      return;
+    }
+    if (this._options.allowedHosts && this._options.allowedHosts.length > 0) {
+      const hostHeader = req.headers.host;
+      if (!hostHeader || !this._options.allowedHosts.includes(hostHeader)) {
+        return `Invalid Host header: ${hostHeader}`;
+      }
+    }
+    if (this._options.allowedOrigins && this._options.allowedOrigins.length > 0) {
+      const originHeader = req.headers.origin;
+      if (originHeader && !this._options.allowedOrigins.includes(originHeader)) {
+        return `Invalid Origin header: ${originHeader}`;
+      }
+    }
+    return;
+  }
+  async start() {
+    if (this._sseResponse) {
+      throw new Error("SSEServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+    }
+    this.res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive"
+    });
+    const dummyBase = "http://localhost";
+    const endpointUrl = new URL2(this._endpoint, dummyBase);
+    endpointUrl.searchParams.set("sessionId", this._sessionId);
+    const relativeUrlWithSession = endpointUrl.pathname + endpointUrl.search + endpointUrl.hash;
+    this.res.write(`event: endpoint
+data: ${relativeUrlWithSession}
+
+`);
+    this._sseResponse = this.res;
+    this.res.on("close", () => {
+      this._sseResponse = undefined;
+      this.onclose?.();
+    });
+  }
+  async handlePostMessage(req, res, parsedBody) {
+    if (!this._sseResponse) {
+      const message = "SSE connection not established";
+      res.writeHead(500).end(message);
+      throw new Error(message);
+    }
+    const validationError = this.validateRequestHeaders(req);
+    if (validationError) {
+      res.writeHead(403).end(validationError);
+      this.onerror?.(new Error(validationError));
+      return;
+    }
+    const authInfo = req.auth;
+    const host = req.headers.host;
+    const protocol = req.socket instanceof TLSSocket ? "https" : "http";
+    const fullUrl = host && req.url ? new URL2(req.url, `${protocol}://${host}`) : undefined;
+    const requestInfo = {
+      headers: req.headers,
+      url: fullUrl
+    };
+    let body;
+    try {
+      const ct = import_content_type.default.parse(req.headers["content-type"] ?? "");
+      if (ct.type !== "application/json") {
+        throw new Error(`Unsupported content-type: ${ct.type}`);
+      }
+      body = parsedBody ?? await import_raw_body.default(req, {
+        limit: MAXIMUM_MESSAGE_SIZE,
+        encoding: ct.parameters.charset ?? "utf-8"
+      });
+    } catch (error2) {
+      res.writeHead(400).end(String(error2));
+      this.onerror?.(error2);
+      return;
+    }
+    try {
+      await this.handleMessage(typeof body === "string" ? JSON.parse(body) : body, { requestInfo, authInfo });
+    } catch {
+      res.writeHead(400).end(`Invalid message: ${body}`);
+      return;
+    }
+    res.writeHead(202).end("Accepted");
+  }
+  async handleMessage(message, extra) {
+    let parsedMessage;
+    try {
+      parsedMessage = JSONRPCMessageSchema.parse(message);
+    } catch (error2) {
+      this.onerror?.(error2);
+      throw error2;
+    }
+    this.onmessage?.(parsedMessage, extra);
+  }
+  async close() {
+    this._sseResponse?.end();
+    this._sseResponse = undefined;
+    this.onclose?.();
+  }
+  async send(message) {
+    if (!this._sseResponse) {
+      throw new Error("Not connected");
+    }
+    this._sseResponse.write(`event: message
+data: ${JSON.stringify(message)}
+
+`);
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+}
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -79161,7 +79311,7 @@ function date7(params) {
 config2(en_default4());
 // src/server/index.ts
 var loggingEnabled = false;
-function logRequest(req, memoryName, method, _params) {
+function logRequest(_req, memoryName, method, _params) {
   if (!loggingEnabled)
     return;
   const timestamp = new Date().toISOString();
@@ -79587,6 +79737,7 @@ Deleted: ${result.deleted}`
   });
   return server;
 }
+var sseSessions = new Map;
 function createApp() {
   const app = import_express.default();
   app.use(import_express.default.json({ limit: "10mb" }));
@@ -79624,6 +79775,50 @@ function createApp() {
       content: AGENT_SYSTEM_PROMPT(name)
     });
   });
+  app.get("/sse", async (req, res) => {
+    const memId = req.query.id || req.query.mem_id;
+    if (!memId) {
+      res.status(401).json({ error: "Missing memory ID. Use ?id=<memory_id>" });
+      return;
+    }
+    const memoryInfo = getMemoryById(memId);
+    if (!memoryInfo) {
+      res.status(403).json({ error: "Invalid memory ID." });
+      return;
+    }
+    const memoryId = memoryInfo.memoryId;
+    const memoryName = memoryInfo.memoryName;
+    updateUniversalMemoryLastSeen(memoryId);
+    const mcpServer = buildMcpServer(memoryId, memoryName);
+    const transport = new SSEServerTransport("/messages", res);
+    sseSessions.set(transport.sessionId, { transport, memoryId, mcpServer });
+    res.on("close", () => {
+      sseSessions.delete(transport.sessionId);
+      mcpServer.close();
+    });
+    try {
+      await mcpServer.connect(transport);
+      await transport.start();
+    } catch {
+      sseSessions.delete(transport.sessionId);
+      mcpServer.close();
+    }
+  });
+  app.post("/messages", async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId || !sseSessions.has(sessionId)) {
+      res.status(404).json({ error: "SSE session not found" });
+      return;
+    }
+    const { transport } = sseSessions.get(sessionId);
+    try {
+      await transport.handlePostMessage(req, res, req.body);
+    } catch (err2) {
+      if (!res.headersSent) {
+        res.status(500).json({ error: String(err2) });
+      }
+    }
+  });
   app.all("/mcp", async (req, res) => {
     const memId = req.query.id || req.query.mem_id;
     if (!memId) {
@@ -79787,8 +79982,11 @@ function openUrl(url2) {
 function memoryTableRow(name, id, sizeKb) {
   return [colors.white(name), colors.dim(id), colors.dim(`${sizeKb} KB`)];
 }
-function serverUrl(host, port) {
-  return `http://${host}:${port}/mcp`;
+function mcpUrl(host, port, memId) {
+  return `http://${host}:${port}/mcp?id=${memId}`;
+}
+function sseUrl(host, port, memId) {
+  return `http://${host}:${port}/sse?id=${memId}`;
 }
 var program2 = new Command;
 program2.name("memlink").description("Memlink — Universal memory for AI agents").version(MEMLINK_VERSION, "--version").addHelpText("before", logo());
@@ -79797,8 +79995,8 @@ program2.action(() => {
   const config3 = loadConfig();
   const host = envHost() || config3.serverHost || DEFAULT_HOST;
   const port = envPort() || config3.serverPort || DEFAULT_PORT;
-  const url2 = serverUrl(host, port);
-  console.log(info("Server", url2));
+  const base = `http://${host}:${port}`;
+  console.log(info("Server", base));
   let totalSize = 0;
   let totalEntries = 0;
   if (config3.universalMemories.length > 0) {
@@ -79839,7 +80037,8 @@ program2.command("serve").description("Start the Memlink MCP server").option("--
   const host = opts.host;
   if (config3.universalMemories.length > 0) {
     for (const mem of config3.universalMemories) {
-      console.log(info("URL", `http://${host}:${port}/mcp?id=${mem.memoryId}`));
+      console.log(info("MCP", mcpUrl(host, port, mem.memoryId)));
+      console.log(info("SSE", sseUrl(host, port, mem.memoryId)));
     }
   } else {
     console.log(info("no memories", "Create one with: Memlink init <name>"));
@@ -79856,12 +80055,14 @@ function initAction(name, opts) {
   const config3 = loadConfig();
   const host = envHost() || config3.serverHost || DEFAULT_HOST;
   const port = envPort() || config3.serverPort || DEFAULT_PORT;
-  const url2 = serverUrl(host, port) + `?id=${memory.memoryId}`;
+  const mcp = mcpUrl(host, port, memory.memoryId);
+  const sse = sseUrl(host, port, memory.memoryId);
   console.log(info("Name", memory.memoryName));
   console.log(info("ID", memory.memoryId));
-  console.log(info("URL", url2));
+  console.log(info("MCP", mcp));
+  console.log(info("SSE", sse));
   console.log();
-  const copied = copyToClipboard(url2);
+  const copied = copyToClipboard(mcp);
   if (copied) {
     console.log(ok("URL copied to clipboard"));
   }
@@ -79912,7 +80113,8 @@ program2.command("connect <memoryId>").description("Get MCP connection details f
   }
   const host = envHost() || config3.serverHost || DEFAULT_HOST;
   const port = envPort() || config3.serverPort || DEFAULT_PORT;
-  const url2 = serverUrl(host, port) + `?id=${memory.memoryId}`;
+  const mcp = mcpUrl(host, port, memory.memoryId);
+  const sse = sseUrl(host, port, memory.memoryId);
   const small = logoSmall();
   if (small)
     console.log(`
@@ -79920,24 +80122,41 @@ program2.command("connect <memoryId>").description("Get MCP connection details f
 `);
   console.log(info("Name", memory.memoryName));
   console.log(info("ID", memory.memoryId));
-  console.log(info("URL", url2));
+  console.log(info("MCP", mcp));
+  console.log(info("SSE", sse));
   console.log();
-  const mcpConfig = {
+  const httpConfig = {
     mcpServers: {
       memlink: {
-        url: url2
+        type: "http",
+        url: mcp
       }
     }
   };
-  console.log(subheading("MCP JSON:"));
-  const jsonStr = JSON.stringify(mcpConfig, null, 2);
+  const sseConfig = {
+    mcpServers: {
+      memlink: {
+        type: "remote",
+        enabled: true,
+        url: sse
+      }
+    }
+  };
+  console.log(subheading("Streamable HTTP (modern clients):"));
+  console.log(colors.muted("  ```json"));
+  console.log(colors.muted(JSON.stringify(httpConfig, null, 2).split(`
+`).map((l) => "  " + l).join(`
+`)));
+  console.log(colors.muted("  ```"));
+  console.log();
+  console.log(subheading("SSE (legacy clients like OpenCode):"));
   console.log(colors.muted("  ```json"));
-  console.log(colors.muted(jsonStr.split(`
+  console.log(colors.muted(JSON.stringify(sseConfig, null, 2).split(`
 `).map((l) => "  " + l).join(`
 `)));
   console.log(colors.muted("  ```"));
   console.log();
-  const copied = copyToClipboard(url2);
+  const copied = copyToClipboard(mcp);
   if (copied) {
     console.log(ok("URL copied to clipboard"));
   }

package/dist/server/index.js

@@ -56081,6 +56081,134 @@ class StreamableHTTPServerTransport {
   }
 }
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js
+import { randomUUID } from "node:crypto";
+import { TLSSocket } from "node:tls";
+var import_raw_body = __toESM(require_raw_body(), 1);
+var import_content_type = __toESM(require_content_type(), 1);
+import { URL as URL2 } from "node:url";
+var MAXIMUM_MESSAGE_SIZE = "4mb";
+
+class SSEServerTransport {
+  constructor(_endpoint, res, options) {
+    this._endpoint = _endpoint;
+    this.res = res;
+    this._sessionId = randomUUID();
+    this._options = options || { enableDnsRebindingProtection: false };
+  }
+  validateRequestHeaders(req) {
+    if (!this._options.enableDnsRebindingProtection) {
+      return;
+    }
+    if (this._options.allowedHosts && this._options.allowedHosts.length > 0) {
+      const hostHeader = req.headers.host;
+      if (!hostHeader || !this._options.allowedHosts.includes(hostHeader)) {
+        return `Invalid Host header: ${hostHeader}`;
+      }
+    }
+    if (this._options.allowedOrigins && this._options.allowedOrigins.length > 0) {
+      const originHeader = req.headers.origin;
+      if (originHeader && !this._options.allowedOrigins.includes(originHeader)) {
+        return `Invalid Origin header: ${originHeader}`;
+      }
+    }
+    return;
+  }
+  async start() {
+    if (this._sseResponse) {
+      throw new Error("SSEServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+    }
+    this.res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive"
+    });
+    const dummyBase = "http://localhost";
+    const endpointUrl = new URL2(this._endpoint, dummyBase);
+    endpointUrl.searchParams.set("sessionId", this._sessionId);
+    const relativeUrlWithSession = endpointUrl.pathname + endpointUrl.search + endpointUrl.hash;
+    this.res.write(`event: endpoint
+data: ${relativeUrlWithSession}
+
+`);
+    this._sseResponse = this.res;
+    this.res.on("close", () => {
+      this._sseResponse = undefined;
+      this.onclose?.();
+    });
+  }
+  async handlePostMessage(req, res, parsedBody) {
+    if (!this._sseResponse) {
+      const message = "SSE connection not established";
+      res.writeHead(500).end(message);
+      throw new Error(message);
+    }
+    const validationError = this.validateRequestHeaders(req);
+    if (validationError) {
+      res.writeHead(403).end(validationError);
+      this.onerror?.(new Error(validationError));
+      return;
+    }
+    const authInfo = req.auth;
+    const host = req.headers.host;
+    const protocol = req.socket instanceof TLSSocket ? "https" : "http";
+    const fullUrl = host && req.url ? new URL2(req.url, `${protocol}://${host}`) : undefined;
+    const requestInfo = {
+      headers: req.headers,
+      url: fullUrl
+    };
+    let body;
+    try {
+      const ct = import_content_type.default.parse(req.headers["content-type"] ?? "");
+      if (ct.type !== "application/json") {
+        throw new Error(`Unsupported content-type: ${ct.type}`);
+      }
+      body = parsedBody ?? await import_raw_body.default(req, {
+        limit: MAXIMUM_MESSAGE_SIZE,
+        encoding: ct.parameters.charset ?? "utf-8"
+      });
+    } catch (error2) {
+      res.writeHead(400).end(String(error2));
+      this.onerror?.(error2);
+      return;
+    }
+    try {
+      await this.handleMessage(typeof body === "string" ? JSON.parse(body) : body, { requestInfo, authInfo });
+    } catch {
+      res.writeHead(400).end(`Invalid message: ${body}`);
+      return;
+    }
+    res.writeHead(202).end("Accepted");
+  }
+  async handleMessage(message, extra) {
+    let parsedMessage;
+    try {
+      parsedMessage = JSONRPCMessageSchema.parse(message);
+    } catch (error2) {
+      this.onerror?.(error2);
+      throw error2;
+    }
+    this.onmessage?.(parsedMessage, extra);
+  }
+  async close() {
+    this._sseResponse?.end();
+    this._sseResponse = undefined;
+    this.onclose?.();
+  }
+  async send(message) {
+    if (!this._sseResponse) {
+      throw new Error("Not connected");
+    }
+    this._sseResponse.write(`event: message
+data: ${JSON.stringify(message)}
+
+`);
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+}
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -70395,7 +70523,7 @@ function nanoid4(size = 21) {
 }
 
 // src/core/types.ts
-var MEMLINK_VERSION = "1.0.3";
+var MEMLINK_VERSION = "1.0.5";
 var DEFAULT_PORT = 4444;
 var DEFAULT_HOST = "localhost";
 var CONFIG_DIR = ".memlink";
@@ -70813,7 +70941,7 @@ function bulkDeleteMemoriesByPattern(memoryId, pattern, useRegex = false) {
 
 // src/server/index.ts
 var loggingEnabled = false;
-function logRequest(req, memoryName, method, _params) {
+function logRequest(_req, memoryName, method, _params) {
   if (!loggingEnabled)
     return;
   const timestamp = new Date().toISOString();
@@ -71239,6 +71367,7 @@ Deleted: ${result.deleted}`
   });
   return server;
 }
+var sseSessions = new Map;
 function createApp() {
   const app = import_express.default();
   app.use(import_express.default.json({ limit: "10mb" }));
@@ -71276,6 +71405,50 @@ function createApp() {
       content: AGENT_SYSTEM_PROMPT(name)
     });
   });
+  app.get("/sse", async (req, res) => {
+    const memId = req.query.id || req.query.mem_id;
+    if (!memId) {
+      res.status(401).json({ error: "Missing memory ID. Use ?id=<memory_id>" });
+      return;
+    }
+    const memoryInfo = getMemoryById(memId);
+    if (!memoryInfo) {
+      res.status(403).json({ error: "Invalid memory ID." });
+      return;
+    }
+    const memoryId = memoryInfo.memoryId;
+    const memoryName = memoryInfo.memoryName;
+    updateUniversalMemoryLastSeen(memoryId);
+    const mcpServer = buildMcpServer(memoryId, memoryName);
+    const transport = new SSEServerTransport("/messages", res);
+    sseSessions.set(transport.sessionId, { transport, memoryId, mcpServer });
+    res.on("close", () => {
+      sseSessions.delete(transport.sessionId);
+      mcpServer.close();
+    });
+    try {
+      await mcpServer.connect(transport);
+      await transport.start();
+    } catch {
+      sseSessions.delete(transport.sessionId);
+      mcpServer.close();
+    }
+  });
+  app.post("/messages", async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId || !sseSessions.has(sessionId)) {
+      res.status(404).json({ error: "SSE session not found" });
+      return;
+    }
+    const { transport } = sseSessions.get(sessionId);
+    try {
+      await transport.handlePostMessage(req, res, req.body);
+    } catch (err) {
+      if (!res.headersSent) {
+        res.status(500).json({ error: String(err) });
+      }
+    }
+  });
   app.all("/mcp", async (req, res) => {
     const memId = req.query.id || req.query.mem_id;
     if (!memId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlink/cli",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Memlink — Universal memory async and organized for AI agents. Self hosted, Fast, Organized.",
   "keywords": [
     "mcp",