@pyxmate/memory 1.1.2 → 1.2.0

package/dist/cli/pyx-mem.mjs

@@ -352,7 +352,7 @@ async function promptMasked(label) {
 `);
     return value;
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const previousEncoding = stdin.readableEncoding;
     stdin.setEncoding("utf8");
     stdin.setRawMode(true);
@@ -370,7 +370,7 @@ async function promptMasked(label) {
         if (ch === "\n" || ch === "\r") {
           cleanup();
           stdout.write("\n");
-          resolve3(buf.trim());
+          resolve4(buf.trim());
           return;
         }
         if (ch === "") {
@@ -564,6 +564,8 @@ function createReadCredentials(providerFactory) {
 }
 
 // src/mcp/proxy-server.ts
+import { readFile, stat } from "fs/promises";
+import { basename, isAbsolute, resolve } from "path";
 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";
@@ -574,108 +576,6 @@ import {
   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.2" : "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 as StdioServerTransport2 } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/mcp/prompts/index.ts
-import { z } from "zod";
-var structureGraphPrompt = {
-  name: "structure_graph",
-  description: STRUCTURE_GRAPH_PROMPT_DESC,
-  register(server) {
-    server.registerPrompt(
-      "structure_graph",
-      {
-        title: "Structure content into a knowledge graph",
-        description: STRUCTURE_GRAPH_PROMPT_DESC,
-        argsSchema: {
-          content: z.string().min(1).describe("The memory content to extract graph fields from.")
-        }
-      },
-      ({ content }) => ({
-        messages: [
-          { role: "user", content: { type: "text", text: buildGraphStructuringPrompt(content) } }
-        ]
-      })
-    );
-  }
-};
-var ALL_PROMPTS = [structureGraphPrompt];
-
-// src/mcp/tools/corrections.ts
-import { z as z3 } from "zod";
 
 // src/mcp/http-client.ts
 var DEFAULT_TIMEOUT_MS = 15e3;
@@ -781,6 +681,202 @@ function extractEnvelopeError(parsed) {
   return null;
 }
 
+// src/mcp/tools/shared.ts
+var LOCAL_UPLOAD_META_KEY = "pyx.dev/local-upload";
+
+// src/mcp/proxy-server.ts
+var REMOTE_MCP_PATH = "/mcp";
+function extractLocalUpload(meta) {
+  if (meta === null || typeof meta !== "object") return void 0;
+  const descriptor = meta[LOCAL_UPLOAD_META_KEY];
+  if (descriptor === null || typeof descriptor !== "object") return void 0;
+  const obj = descriptor;
+  if (typeof obj.pathArg !== "string" || typeof obj.endpoint !== "string" || typeof obj.fileField !== "string") {
+    return void 0;
+  }
+  if (!obj.endpoint.startsWith("/") || obj.endpoint.startsWith("//")) {
+    return void 0;
+  }
+  return obj;
+}
+async function readCappedLocalFile(rawPath, descriptor) {
+  if (typeof rawPath !== "string" || rawPath.length === 0) {
+    return {
+      ok: false,
+      result: mcpText(`\`${descriptor.pathArg}\` must be a non-empty local file path.`, true)
+    };
+  }
+  const abs = isAbsolute(rawPath) ? rawPath : resolve(rawPath);
+  try {
+    if (typeof descriptor.maxBytes === "number") {
+      const info = await stat(abs);
+      if (info.size > descriptor.maxBytes) {
+        return {
+          ok: false,
+          result: mcpText(`File too large: ${info.size} bytes > ${descriptor.maxBytes} cap.`, true)
+        };
+      }
+    }
+    return { ok: true, bytes: await readFile(abs), name: basename(abs) };
+  } catch (err) {
+    return {
+      ok: false,
+      result: mcpText(
+        `Failed to read ${abs}: ${err instanceof Error ? err.message : String(err)}.`,
+        true
+      )
+    };
+  }
+}
+function createLocalFileUploader(credentials, fetchImpl = fetch) {
+  return async (descriptor, args) => {
+    const file = await readCappedLocalFile(args[descriptor.pathArg], descriptor);
+    if (!file.ok) return file.result;
+    const http = createHttpClient(credentials, fetchImpl);
+    const res = await http.requestMultipart({
+      path: descriptor.endpoint,
+      formData: () => {
+        const form = new FormData();
+        form.set(descriptor.fileField, new File([new Uint8Array(file.bytes)], file.name));
+        for (const key of descriptor.optionalArgs ?? []) {
+          const value = args[key];
+          if (typeof value === "string" && value.length > 0) form.set(key, value);
+        }
+        return form;
+      }
+    });
+    return res.ok ? mcpJson(res.data) : res.result;
+  };
+}
+function createProxyServer(client, version, uploadLocalFile) {
+  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()
+  });
+  const localUploads = /* @__PURE__ */ new Map();
+  let listedOnce = false;
+  const refreshFromList = (result) => {
+    const tools = result.tools;
+    if (Array.isArray(tools)) {
+      listedOnce = true;
+      for (const tool of tools) {
+        const descriptor = uploadLocalFile ? extractLocalUpload(tool._meta) : void 0;
+        if (descriptor) localUploads.set(tool.name, descriptor);
+        else localUploads.delete(tool.name);
+      }
+    }
+    return result;
+  };
+  if (caps?.tools) {
+    server.setRequestHandler(
+      ListToolsRequestSchema,
+      async (req) => refreshFromList(await client.listTools(req.params))
+    );
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+      if (uploadLocalFile && !listedOnce) {
+        try {
+          refreshFromList(await client.listTools());
+        } catch {
+        }
+      }
+      const descriptor = uploadLocalFile ? localUploads.get(req.params.name) : void 0;
+      if (uploadLocalFile && descriptor) {
+        const result = await uploadLocalFile(
+          descriptor,
+          req.params.arguments ?? {}
+        );
+        return result;
+      }
+      return 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.2.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 legacy bundled server with \`pyx-mem mcp --bundled\`.`
+    );
+  }
+  try {
+    const server = createProxyServer(client, version, createLocalFileUploader(read.credentials));
+    const transport = new StdioServerTransport();
+    const closed = new Promise((resolve4) => {
+      transport.onclose = () => resolve4();
+    });
+    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 as StdioServerTransport2 } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/prompts/index.ts
+import { z } from "zod";
+var structureGraphPrompt = {
+  name: "structure_graph",
+  description: STRUCTURE_GRAPH_PROMPT_DESC,
+  register(server) {
+    server.registerPrompt(
+      "structure_graph",
+      {
+        title: "Structure content into a knowledge graph",
+        description: STRUCTURE_GRAPH_PROMPT_DESC,
+        argsSchema: {
+          content: z.string().min(1).describe("The memory content to extract graph fields from.")
+        }
+      },
+      ({ content }) => ({
+        messages: [
+          { role: "user", content: { type: "text", text: buildGraphStructuringPrompt(content) } }
+        ]
+      })
+    );
+  }
+};
+var ALL_PROMPTS = [structureGraphPrompt];
+
+// src/mcp/tools/corrections.ts
+import { z as z3 } from "zod";
+
 // src/mcp/tools/scopes.ts
 import { z as z2 } from "zod";
 var scopeShape = {
@@ -923,11 +1019,12 @@ var getMemoryTool = {
 };
 
 // src/mcp/tools/ingest.ts
-import { readFile, stat } from "fs/promises";
-import { basename, extname, isAbsolute, resolve } from "path";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { basename as basename2, extname, isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
 import { z as z6 } from "zod";
 var IMAGE_EXT = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".tiff", ".svg"]);
 var MAX_BYTES = 50 * 1024 * 1024;
+var INGEST_ENDPOINT = "/api/memory/ingest/file";
 var inputShape3 = {
   path: z6.string().min(1).describe(
     "Local file path readable by the pyx-mem process. Uploaded as multipart `file`. Images require `description`; documents auto-extract text."
@@ -946,6 +1043,17 @@ var ingestMemoryFileTool = {
     inputSchema: inputShape3,
     annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true }
   },
+  // `path` is a host-local file. On the remote `/mcp` route the server cannot
+  // read it, so this descriptor lets the local proxy bridge the upload (read
+  // bytes here, multipart-POST to the declared endpoint). The bundled handler
+  // below ignores it. Field names map 1:1 to the multipart form built below.
+  localUpload: {
+    pathArg: "path",
+    endpoint: INGEST_ENDPOINT,
+    fileField: "file",
+    optionalArgs: ["description", "namespaceId"],
+    maxBytes: MAX_BYTES
+  },
   handler: (deps) => async (raw) => {
     const args = raw;
     const ext = extname(args.path).toLowerCase();
@@ -956,14 +1064,14 @@ var ingestMemoryFileTool = {
         true
       );
     }
-    const abs = isAbsolute(args.path) ? args.path : resolve(args.path);
+    const abs = isAbsolute2(args.path) ? args.path : resolve2(args.path);
     let bytes;
     try {
-      const info = await stat(abs);
+      const info = await stat2(abs);
       if (info.size > MAX_BYTES) {
         return mcpText(`File too large: ${info.size} bytes > 50MB cap.`, true);
       }
-      bytes = await readFile(abs);
+      bytes = await readFile2(abs);
     } catch (err) {
       return mcpText(
         `Failed to read ${abs}: ${err instanceof Error ? err.message : String(err)}.`,
@@ -974,11 +1082,11 @@ var ingestMemoryFileTool = {
     if (!creds.ok) return creds.result;
     const http = createHttpClient(creds.credentials, deps.fetchImpl);
     const res = await http.requestMultipart({
-      path: "/api/memory/ingest/file",
+      path: INGEST_ENDPOINT,
       scope: args,
       formData: () => {
         const form = new FormData();
-        const file = new File([new Uint8Array(bytes)], basename(abs));
+        const file = new File([new Uint8Array(bytes)], basename2(abs));
         form.set("file", file);
         if (args.description) form.set("description", args.description);
         if (args.namespaceId) form.set("namespaceId", args.namespaceId);
@@ -1459,7 +1567,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.1.2" : "0.0.0-dev");
+  const version = opts.version ?? (true ? "1.2.0" : "0.0.0-dev");
   const server = new McpServer(
     { name: "pyx-memory", version },
     { instructions: PYX_MEMORY_INSTRUCTIONS, capabilities: { tools: {}, prompts: {} } }
@@ -1479,8 +1587,8 @@ async function runMcpServer(opts) {
     prompt.register(server);
   }
   const transport = new StdioServerTransport2();
-  const closed = new Promise((resolve3) => {
-    transport.onclose = () => resolve3();
+  const closed = new Promise((resolve4) => {
+    transport.onclose = () => resolve4();
   });
   await server.connect(transport);
   await closed;
@@ -1489,12 +1597,12 @@ async function runMcpServer(opts) {
 // src/cli/commands/mcp.ts
 async function mcpCommand(opts = {}) {
   const readCredentials = createReadCredentials(() => getDefaultKeychain());
-  const onStdinEnd = new Promise((resolve3) => {
-    process.stdin.once("end", resolve3);
-    process.stdin.once("close", resolve3);
+  const onStdinEnd = new Promise((resolve4) => {
+    process.stdin.once("end", resolve4);
+    process.stdin.once("close", resolve4);
   });
   try {
-    const run = opts.remote ? runMcpProxyServer({ readCredentials }) : runMcpServer({ readCredentials });
+    const run = opts.bundled ? runMcpServer({ readCredentials }) : runMcpProxyServer({ readCredentials });
     await Promise.race([run, onStdinEnd]);
     return EXIT.OK;
   } catch (err) {
@@ -1503,6 +1611,14 @@ async function mcpCommand(opts = {}) {
     return EXIT.USAGE;
   }
 }
+function resolveMcpMode(flags) {
+  const remote = flags.remote === true;
+  const bundled = flags.bundled === true;
+  if (remote && bundled) {
+    return { ok: false, error: "`--remote` and `--bundled` are mutually exclusive." };
+  }
+  return { ok: true, bundled, implicit: !remote && !bundled };
+}
 
 // src/cli/commands/mcp-install.ts
 import { spawnSync as nodeSpawnSync } from "child_process";
@@ -1959,7 +2075,7 @@ function writeJsonAndReport(filePath, agentLabel, entry, opts = {}) {
 
 // src/cli/commands/scaffold.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename2, join as join2, resolve as resolve2 } from "path";
+import { basename as basename3, join as join2, resolve as resolve3 } from "path";
 var SERVER_IMAGE = "ghcr.io/pyx-corp/pyx-memory-v1:latest";
 var DOCKER_COMPOSE = `services:
   pyx-memory:
@@ -2082,8 +2198,8 @@ function resolveTarget(args) {
     process.stderr.write("Error: --name requires a non-empty directory name.\n");
     return null;
   }
-  const targetDir = trimmedName ? resolve2(cwd, trimmedName) : cwd;
-  const appName = trimmedName || basename2(resolve2(cwd));
+  const targetDir = trimmedName ? resolve3(cwd, trimmedName) : cwd;
+  const appName = trimmedName || basename3(resolve3(cwd));
   return { targetDir, appName };
 }
 function buildFiles(targetDir, appName) {
@@ -2109,7 +2225,7 @@ function scaffoldCommand(args = {}) {
   const created = [];
   const skipped = [];
   for (const file of buildFiles(target.targetDir, target.appName)) {
-    const relativePath = basename2(file.path);
+    const relativePath = basename3(file.path);
     if (existsSync2(file.path)) {
       skipped.push(relativePath);
       continue;
@@ -2189,9 +2305,11 @@ 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 [--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 [--bundled]                              Start the stdio MCP server. Default connects to the
+                                               hosted server so tools + instructions stay
+                                               server-owned (zero-touch updates; key stays in the
+                                               keychain). --bundled runs the legacy in-package server
+                                               (offline / version-pinned / host-local file ingest).
   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
@@ -2276,7 +2394,23 @@ function runMcpInstall(target, scope, remote) {
   return handler({ scope, remote });
 }
 function runMcpCommand(parsed) {
-  if (parsed.subcommand === void 0) return mcpCommand({ remote: parsed.flags.remote === true });
+  if (parsed.subcommand === void 0) {
+    const resolved = resolveMcpMode({
+      remote: parsed.flags.remote === true,
+      bundled: parsed.flags.bundled === true
+    });
+    if (!resolved.ok) {
+      process.stderr.write(`Error: ${resolved.error}
+`);
+      return EXIT.USAGE;
+    }
+    if (resolved.implicit) {
+      process.stderr.write(
+        "pyx-memory: `pyx-mem mcp` now connects to the hosted server (zero-touch \u2014 tools and instructions stay server-owned). Pass `--bundled` for the legacy in-package server.\n"
+      );
+    }
+    return mcpCommand({ bundled: resolved.bundled });
+  }
   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.1.2",
+  "version": "1.2.0",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",