@pyxmate/memory 1.0.1 → 1.1.0

package/dist/cli/pyx-mem.mjs

@@ -563,9 +563,91 @@ function createReadCredentials(providerFactory) {
   };
 }
 
+// src/mcp/proxy-server.ts
+import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var REMOTE_MCP_PATH = "/mcp";
+function createProxyServer(client, version) {
+  const caps = client.getServerCapabilities();
+  const server = new Server(client.getServerVersion() ?? { name: "pyx-memory", version }, {
+    capabilities: {
+      // Advertise the PRESENCE of tools/prompts, but NOT their `listChanged`
+      // sub-capability: this proxy does not relay the remote's list_changed
+      // notifications, so claiming listChanged would be a capability the host
+      // could rely on but we never honor (Codex: keep the proxy transparent).
+      ...caps?.tools ? { tools: {} } : {},
+      ...caps?.prompts ? { prompts: {} } : {}
+    },
+    instructions: client.getInstructions()
+  });
+  if (caps?.tools) {
+    server.setRequestHandler(
+      ListToolsRequestSchema,
+      (req) => client.listTools(req.params)
+    );
+    server.setRequestHandler(
+      CallToolRequestSchema,
+      (req) => client.callTool(req.params)
+    );
+  }
+  if (caps?.prompts) {
+    server.setRequestHandler(
+      ListPromptsRequestSchema,
+      (req) => client.listPrompts(req.params)
+    );
+    server.setRequestHandler(
+      GetPromptRequestSchema,
+      (req) => client.getPrompt(req.params)
+    );
+  }
+  return server;
+}
+async function runMcpProxyServer(opts) {
+  const version = opts.version ?? (true ? "1.1.0" : "0.0.0-dev");
+  const read = await opts.readCredentials();
+  if (!read.ok) {
+    const text = read.result.content.map((c) => c.type === "text" ? c.text : "").join(" ").trim();
+    throw new Error(text || "pyx-memory credentials are unavailable. Run: pyx-mem login");
+  }
+  const { endpoint, apiKey } = read.credentials;
+  const url = new URL(`${endpoint.replace(/\/+$/, "")}${REMOTE_MCP_PATH}`);
+  const client = new McpClient({ name: "pyx-mem-proxy", version }, { capabilities: {} });
+  const clientTransport = new StreamableHTTPClientTransport(url, {
+    requestInit: { headers: { Authorization: `Bearer ${apiKey}` } }
+  });
+  try {
+    await client.connect(clientTransport);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Could not reach the pyx-memory remote MCP at ${url.href}: ${msg}. Verify the endpoint and key with \`pyx-mem doctor\`, or run the bundled server with \`pyx-mem mcp\`.`
+    );
+  }
+  try {
+    const server = createProxyServer(client, version);
+    const transport = new StdioServerTransport();
+    const closed = new Promise((resolve3) => {
+      transport.onclose = () => resolve3();
+    });
+    await server.connect(transport);
+    await closed;
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StdioServerTransport as StdioServerTransport2 } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/prompts/index.ts
 import { z } from "zod";
@@ -1377,7 +1459,7 @@ var ALL_TOOL_NAMES = ALL_TOOLS.map((t) => t.name);
 // src/mcp/server.ts
 async function runMcpServer(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const version = opts.version ?? (true ? "1.0.1" : "0.0.0-dev");
+  const version = opts.version ?? (true ? "1.1.0" : "0.0.0-dev");
   const server = new McpServer(
     { name: "pyx-memory", version },
     { instructions: PYX_MEMORY_INSTRUCTIONS, capabilities: { tools: {}, prompts: {} } }
@@ -1396,7 +1478,7 @@ async function runMcpServer(opts) {
   for (const prompt of ALL_PROMPTS) {
     prompt.register(server);
   }
-  const transport = new StdioServerTransport();
+  const transport = new StdioServerTransport2();
   const closed = new Promise((resolve3) => {
     transport.onclose = () => resolve3();
   });
@@ -1405,14 +1487,15 @@ async function runMcpServer(opts) {
 }
 
 // src/cli/commands/mcp.ts
-async function mcpCommand() {
+async function mcpCommand(opts = {}) {
   const readCredentials = createReadCredentials(() => getDefaultKeychain());
   const onStdinEnd = new Promise((resolve3) => {
     process.stdin.once("end", resolve3);
     process.stdin.once("close", resolve3);
   });
   try {
-    await Promise.race([runMcpServer({ readCredentials }), onStdinEnd]);
+    const run = opts.remote ? runMcpProxyServer({ readCredentials }) : runMcpServer({ readCredentials });
+    await Promise.race([run, onStdinEnd]);
     return EXIT.OK;
   } catch (err) {
     process.stderr.write(`Internal error: ${err instanceof Error ? err.message : String(err)}
@@ -2101,7 +2184,9 @@ Commands:
   logout                                       Delete stored pyx-memory credentials.
   doctor [--json]                              Diagnose keychain, credentials, backend, MCP startup.
   scaffold [--name <dir>]                      Generate Docker, env, SDK, and memory design-guide starter files.
-  mcp                                          Start stdio MCP server.
+  mcp [--remote]                               Start stdio MCP server. --remote proxies to the hosted
+                                               server so tools + instructions stay server-owned
+                                               (zero-touch updates; key stays in the keychain).
   mcp install <target> [--scope user|local|project]
                                                Install pyx-memory MCP config for your AI agent.
                                                Targets: claude-code, codex, cursor, cline, continue, windsurf, gemini-cli, pi, oh-my-pi, openclaw, hermes.
@@ -2183,7 +2268,7 @@ function runMcpInstall(target, scope) {
   return handler({ scope });
 }
 function runMcpCommand(parsed) {
-  if (parsed.subcommand === void 0) return mcpCommand();
+  if (parsed.subcommand === void 0) return mcpCommand({ remote: parsed.flags.remote === true });
   if (parsed.subcommand === "install") {
     const target = parsed.positional[0];
     const scope = typeof parsed.flags.scope === "string" ? parsed.flags.scope : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",