@pyxmate/memory 1.0.1 → 1.1.1

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.1" : "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.1" : "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)}
@@ -1544,22 +1627,28 @@ function indent(text) {
 // src/cli/commands/mcp-install.ts
 var VALID_SCOPES = /* @__PURE__ */ new Set(["local", "user", "project"]);
 var SERVER_NAME = "pyx-memory";
-var ENTRY = { command: "pyx-mem", args: ["mcp"] };
+function pyxMemArgs(remote) {
+  return remote ? ["mcp", "--remote"] : ["mcp"];
+}
+function mcpEntry(remote) {
+  return { command: "pyx-mem", args: pyxMemArgs(remote) };
+}
 function mcpInstallClaudeCodeCommand(opts = {}) {
   const scope = opts.scope ?? "local";
   if (!validateScope(scope)) return EXIT.USAGE;
+  const remote = opts.remote ?? false;
   const spawnSync = opts._spawnSync ?? nodeSpawnSync;
   const probe = spawnSync("claude", ["--version"], { stdio: "pipe" });
   if (probe.error || probe.status !== 0) {
-    printClaudeCodeManualInstructions(scope);
+    printClaudeCodeManualInstructions(scope, remote);
     return EXIT.OK;
   }
-  const cmd = ["mcp", "add", SERVER_NAME, "-s", scope, "--", "pyx-mem", "mcp"];
+  const cmd = ["mcp", "add", SERVER_NAME, "-s", scope, "--", "pyx-mem", ...pyxMemArgs(remote)];
   const res = spawnSync("claude", cmd, { stdio: "inherit" });
   if (res.status !== 0) {
     process.stderr.write(`\`claude ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
 `);
-    printClaudeCodeManualInstructions(scope);
+    printClaudeCodeManualInstructions(scope, remote);
     return EXIT.USAGE;
   }
   process.stdout.write(
@@ -1570,20 +1659,16 @@ To populate the knowledge graph, YOU pass entities and relationships (or triples
   );
   return EXIT.OK;
 }
-function printClaudeCodeManualInstructions(scope) {
+function printClaudeCodeManualInstructions(scope, remote) {
   process.stdout.write(
     [
       "The `claude` CLI is not on PATH, or the install command failed.",
       "",
       "Run this once Claude Code is installed:",
-      `  claude mcp add ${SERVER_NAME} -s ${scope} -- pyx-mem mcp`,
+      `  claude mcp add ${SERVER_NAME} -s ${scope} -- pyx-mem ${pyxMemArgs(remote).join(" ")}`,
       "",
       "Or add this entry manually to your Claude Code MCP config (.mcp.json):",
-      JSON.stringify(
-        { mcpServers: { [SERVER_NAME]: { command: "pyx-mem", args: ["mcp"] } } },
-        null,
-        2
-      ),
+      JSON.stringify({ mcpServers: { [SERVER_NAME]: mcpEntry(remote) } }, null, 2),
       "",
       "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
       ""
@@ -1593,19 +1678,20 @@ function printClaudeCodeManualInstructions(scope) {
 function mcpInstallCodexCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
+  const remote = opts.remote ?? false;
   const spawnSync = opts._spawnSync ?? nodeSpawnSync;
   const home = opts._homeDir ?? homedir();
   const probe = spawnSync("codex", ["--version"], { stdio: "pipe" });
   if (probe.error || probe.status !== 0) {
-    printCodexManualInstructions(home);
+    printCodexManualInstructions(home, remote);
     return EXIT.OK;
   }
-  const cmd = ["mcp", "add", SERVER_NAME, "--", "pyx-mem", "mcp"];
+  const cmd = ["mcp", "add", SERVER_NAME, "--", "pyx-mem", ...pyxMemArgs(remote)];
   const res = spawnSync("codex", cmd, { stdio: "inherit" });
   if (res.status !== 0) {
     process.stderr.write(`\`codex ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
 `);
-    printCodexManualInstructions(home);
+    printCodexManualInstructions(home, remote);
     return EXIT.USAGE;
   }
   process.stdout.write(
@@ -1615,20 +1701,20 @@ Restart Codex CLI to make the tools available. No API key was written to config.
   );
   return EXIT.OK;
 }
-function printCodexManualInstructions(home) {
+function printCodexManualInstructions(home, remote) {
   const configPath = join(home, ".codex", "config.toml");
   process.stdout.write(
     [
       "The `codex` CLI is not on PATH, or the install command failed.",
       "",
       "Run this once Codex CLI is installed:",
-      `  codex mcp add ${SERVER_NAME} -- pyx-mem mcp`,
+      `  codex mcp add ${SERVER_NAME} -- pyx-mem ${pyxMemArgs(remote).join(" ")}`,
       "",
       `Or add this section manually to ${configPath}:`,
       "",
       `[mcp_servers.${SERVER_NAME}]`,
       `command = "pyx-mem"`,
-      `args = ["mcp"]`,
+      `args = ${JSON.stringify(pyxMemArgs(remote))}`,
       "",
       "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
       ""
@@ -1640,11 +1726,12 @@ function mcpInstallCursorCommand(opts = {}) {
   if (!validateScope(scope)) return EXIT.USAGE;
   const home = opts._homeDir ?? homedir();
   const filePath = scope === "project" ? join(process.cwd(), ".cursor", "mcp.json") : join(home, ".cursor", "mcp.json");
-  return writeJsonAndReport(filePath, "Cursor");
+  return writeJsonAndReport(filePath, "Cursor", mcpEntry(opts.remote ?? false));
 }
 function mcpInstallClineCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
+  const remote = opts.remote ?? false;
   process.stdout.write(
     [
       "Cline MCP config is managed through the Cline UI in VS Code (the file",
@@ -1655,11 +1742,7 @@ function mcpInstallClineCommand(opts = {}) {
       '3. Click "MCP Servers" \u2192 "Configure MCP Servers".',
       `4. Add this entry under "mcpServers":`,
       "",
-      JSON.stringify(
-        { mcpServers: { [SERVER_NAME]: { command: "pyx-mem", args: ["mcp"] } } },
-        null,
-        2
-      ),
+      JSON.stringify({ mcpServers: { [SERVER_NAME]: mcpEntry(remote) } }, null, 2),
       "",
       "5. Save the file. Cline will reload the MCP servers automatically.",
       "",
@@ -1672,6 +1755,7 @@ function mcpInstallClineCommand(opts = {}) {
 function mcpInstallContinueCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
+  const remote = opts.remote ?? false;
   const home = opts._homeDir ?? homedir();
   const yamlPath = join(home, ".continue", "mcpServers", `${SERVER_NAME}.yaml`);
   process.stdout.write(
@@ -1690,7 +1774,7 @@ function mcpInstallContinueCommand(opts = {}) {
       `  - name: ${SERVER_NAME}`,
       `    command: pyx-mem`,
       `    args:`,
-      `      - mcp`,
+      ...pyxMemArgs(remote).map((arg) => `      - ${arg}`),
       "",
       "Continue auto-loads new YAML blocks on next chat session \u2014 no restart",
       "needed in most setups.",
@@ -1706,24 +1790,25 @@ function mcpInstallWindsurfCommand(opts = {}) {
   if (!validateScope(scope)) return EXIT.USAGE;
   const home = opts._homeDir ?? homedir();
   const filePath = join(home, ".codeium", "windsurf", "mcp_config.json");
-  return writeJsonAndReport(filePath, "Windsurf");
+  return writeJsonAndReport(filePath, "Windsurf", mcpEntry(opts.remote ?? false));
 }
 function mcpInstallGeminiCliCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
+  const remote = opts.remote ?? false;
   const spawnSync = opts._spawnSync ?? nodeSpawnSync;
   const home = opts._homeDir ?? homedir();
   const probe = spawnSync("gemini", ["--version"], { stdio: "pipe" });
   if (probe.error || probe.status !== 0) {
-    return writeJsonAndReport(geminiConfigPath(home, scope), "Gemini CLI");
+    return writeJsonAndReport(geminiConfigPath(home, scope), "Gemini CLI", mcpEntry(remote));
   }
   const geminiScope = scope === "local" ? "project" : scope;
-  const cmd = ["mcp", "add", "-s", geminiScope, SERVER_NAME, "pyx-mem", "mcp"];
+  const cmd = ["mcp", "add", "-s", geminiScope, SERVER_NAME, "pyx-mem", ...pyxMemArgs(remote)];
   const res = spawnSync("gemini", cmd, { stdio: "inherit" });
   if (res.status !== 0) {
     process.stderr.write(`\`gemini ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
 `);
-    return writeJsonAndReport(geminiConfigPath(home, scope), "Gemini CLI");
+    return writeJsonAndReport(geminiConfigPath(home, scope), "Gemini CLI", mcpEntry(remote));
   }
   process.stdout.write(
     `Installed pyx-memory MCP server in Gemini CLI (scope: ${geminiScope}).
@@ -1740,7 +1825,7 @@ function mcpInstallPiCommand(opts = {}) {
   if (!validateScope(scope)) return EXIT.USAGE;
   const home = opts._homeDir ?? homedir();
   const filePath = scope === "user" ? join(home, ".pi", "agent", "mcp.json") : join(process.cwd(), ".pi", "mcp.json");
-  return writeJsonAndReport(filePath, "Pi", {
+  return writeJsonAndReport(filePath, "Pi", mcpEntry(opts.remote ?? false), {
     prereq: "pi has no native MCP support \u2014 install the third-party adapter once:\n  pi install npm:pi-mcp-adapter"
   });
 }
@@ -1749,18 +1834,19 @@ function mcpInstallOhMyPiCommand(opts = {}) {
   if (!validateScope(scope)) return EXIT.USAGE;
   const home = opts._homeDir ?? homedir();
   const filePath = scope === "user" ? join(home, ".omp", "agent", "mcp.json") : join(process.cwd(), ".omp", "mcp.json");
-  return writeJsonAndReport(filePath, "oh-my-pi");
+  return writeJsonAndReport(filePath, "oh-my-pi", mcpEntry(opts.remote ?? false));
 }
 function mcpInstallOpenClawCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
+  const remote = opts.remote ?? false;
   const spawnSync = opts._spawnSync ?? nodeSpawnSync;
   const probe = spawnSync("openclaw", ["--version"], { stdio: "pipe" });
   if (probe.error || probe.status !== 0) {
-    printOpenClawManualInstructions();
+    printOpenClawManualInstructions(remote);
     return EXIT.OK;
   }
-  const entryJson = JSON.stringify(ENTRY);
+  const entryJson = JSON.stringify(mcpEntry(remote));
   const cmd = ["mcp", "set", SERVER_NAME, entryJson];
   const res = spawnSync("openclaw", cmd, { stdio: "inherit" });
   if (res.status !== 0) {
@@ -1768,7 +1854,7 @@ function mcpInstallOpenClawCommand(opts = {}) {
       `\`openclaw ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
 `
     );
-    printOpenClawManualInstructions();
+    printOpenClawManualInstructions(remote);
     return EXIT.USAGE;
   }
   process.stdout.write(
@@ -1778,8 +1864,9 @@ Restart OpenClaw to make the tools available. No API key was written to openclaw
   );
   return EXIT.OK;
 }
-function printOpenClawManualInstructions() {
-  const entryJson = JSON.stringify(ENTRY);
+function printOpenClawManualInstructions(remote) {
+  const entry = mcpEntry(remote);
+  const entryJson = JSON.stringify(entry);
   process.stdout.write(
     [
       "The `openclaw` CLI is not on PATH, or the install command failed.",
@@ -1790,7 +1877,7 @@ function printOpenClawManualInstructions() {
       "Or add this entry manually under `mcp.servers` in your OpenClaw config",
       "(run `openclaw config file` to print the active config path):",
       "",
-      JSON.stringify({ mcp: { servers: { [SERVER_NAME]: ENTRY } } }, null, 2),
+      JSON.stringify({ mcp: { servers: { [SERVER_NAME]: entry } } }, null, 2),
       "",
       "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
       ""
@@ -1800,18 +1887,19 @@ function printOpenClawManualInstructions() {
 function mcpInstallHermesCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
+  const remote = opts.remote ?? false;
   const spawnSync = opts._spawnSync ?? nodeSpawnSync;
   const probe = spawnSync("hermes", ["--version"], { stdio: "pipe" });
   if (probe.error || probe.status !== 0) {
-    printHermesManualInstructions();
+    printHermesManualInstructions(remote);
     return EXIT.OK;
   }
-  const cmd = ["mcp", "add", SERVER_NAME, "--command", "pyx-mem", "--args", "mcp"];
+  const cmd = ["mcp", "add", SERVER_NAME, "--command", "pyx-mem", "--args", ...pyxMemArgs(remote)];
   const res = spawnSync("hermes", cmd, { stdio: "inherit" });
   if (res.status !== 0) {
     process.stderr.write(`\`hermes ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
 `);
-    printHermesManualInstructions();
+    printHermesManualInstructions(remote);
     return EXIT.USAGE;
   }
   process.stdout.write(
@@ -1821,13 +1909,13 @@ Restart Hermes to make the tools available. No API key was written to config.yam
   );
   return EXIT.OK;
 }
-function printHermesManualInstructions() {
+function printHermesManualInstructions(remote) {
   process.stdout.write(
     [
       "The `hermes` CLI is not on PATH, or the install command failed.",
       "",
       "Run this once Hermes is installed:",
-      `  hermes mcp add ${SERVER_NAME} --command pyx-mem --args mcp`,
+      `  hermes mcp add ${SERVER_NAME} --command pyx-mem --args ${pyxMemArgs(remote).join(" ")}`,
       "",
       "Or add this block under `mcp_servers:` in your Hermes config",
       "(typically ~/.hermes/config.yaml):",
@@ -1835,7 +1923,7 @@ function printHermesManualInstructions() {
       `${SERVER_NAME}:`,
       "  command: pyx-mem",
       "  args:",
-      "    - mcp",
+      ...pyxMemArgs(remote).map((arg) => `    - ${arg}`),
       "",
       "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
       ""
@@ -1848,11 +1936,11 @@ function validateScope(scope) {
 `);
   return false;
 }
-function writeJsonAndReport(filePath, agentLabel, opts = {}) {
+function writeJsonAndReport(filePath, agentLabel, entry, opts = {}) {
   const result = mergeWriteJsonMcpEntry({
     filePath,
     serverName: SERVER_NAME,
-    entry: ENTRY
+    entry
   });
   const stream = result.exitCode === EXIT.OK ? process.stdout : process.stderr;
   stream.write(result.message);
@@ -2101,9 +2189,14 @@ 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 install <target> [--scope user|local|project]
+  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] [--remote]
                                                Install pyx-memory MCP config for your AI agent.
+                                               --remote installs the hosted thin-proxy (zero-touch
+                                               updates; key stays in the keychain) instead of the
+                                               bundled stdio server.
                                                Targets: claude-code, codex, cursor, cline, continue, windsurf, gemini-cli, pi, oh-my-pi, openclaw, hermes.
 
 Notes:
@@ -2171,7 +2264,7 @@ var INSTALL_TARGETS = {
   hermes: mcpInstallHermesCommand
 };
 var VALID_TARGETS = Object.keys(INSTALL_TARGETS);
-function runMcpInstall(target, scope) {
+function runMcpInstall(target, scope, remote) {
   if (target === void 0 || !Object.hasOwn(INSTALL_TARGETS, target)) {
     process.stderr.write(
       `Error: unknown install target \`${target ?? ""}\`. Expected: ${VALID_TARGETS.join(", ")}.
@@ -2180,14 +2273,14 @@ function runMcpInstall(target, scope) {
     return EXIT.USAGE;
   }
   const handler = INSTALL_TARGETS[target];
-  return handler({ scope });
+  return handler({ scope, remote });
 }
 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;
-    return runMcpInstall(target, scope);
+    return runMcpInstall(target, scope, parsed.flags.remote === true);
   }
   process.stderr.write(
     `Error: unknown subcommand \`mcp ${parsed.subcommand}\`. Run \`pyx-mem --help\`.

package/package.json

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