@pastepile/mcp 0.1.0 → 0.1.1

package/README.md

@@ -16,8 +16,16 @@ so it adds no supply-chain surface of its own.
 | ------------------ | ------------------------------------------------------------------- |
 | `pastepile_save`   | Save text/code and get back a stable `url`, `slug`, and `edit_key`. |
 | `pastepile_get`    | Retrieve a paste by slug or full Pastepile URL.                     |
-| `pastepile_search` | Search the public paste corpus by keyword.                          |
-| `pastepile_list`   | List the most recent public pastes.                                 |
+| `pastepile_search` | Search your private memory (with an API key) or the public corpus.  |
+| `pastepile_list`   | List your saved pastes (with an API key) or the public feed.        |
+
+**Private memory:** when `PASTEPILE_API_KEY` is set, every paste your
+assistant saves is associated with that key, and `pastepile_search` /
+`pastepile_list` default to that private namespace (including unlisted
+pastes), searching titles, filenames, and contents. Pass `scope: "public"`
+to reach the public corpus instead. Without a key, both tools cover the
+public corpus only, and nothing is associated. One key can never see
+another key's pastes.
 
 Saved pastes default to **unlisted** (retrievable by URL, never shown in public
 listings or search) and **never expire**, so stored knowledge persists. Both are

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pastepile/mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Model Context Protocol server for Pastepile - durable, URL-addressable memory for AI coding assistants. Save and retrieve knowledge from Claude, Cursor, Windsurf, and any MCP client.",
   "type": "module",
   "license": "MIT",

package/src/server.mjs

@@ -12,7 +12,7 @@
 // returns the response object, or null for a notification that must not be
 // answered.
 
-export const VERSION = "0.1.0";
+export const VERSION = "0.1.1";
 export const PROTOCOL_VERSION = "2025-06-18";
 export const SERVER_NAME = "pastepile";
 export const DEFAULT_BASE = "https://pastepile.com";
@@ -22,9 +22,11 @@ export const INSTRUCTIONS =
   "Pastepile is durable, URL-addressable storage for AI assistants. When you " +
   "produce something worth keeping across sessions (a design, a snippet, a " +
   "log, a decision record), call pastepile_save and remember the returned " +
-  "slug or URL. Reload it later with pastepile_get. Search the public corpus " +
-  "with pastepile_search. Saved pastes default to unlisted (retrievable by " +
-  "URL, not shown in public listings or search).";
+  "slug or URL. Reload it later with pastepile_get. When an API key is " +
+  "configured, pastepile_search and pastepile_list default to YOUR private " +
+  "memory: the pastes saved with that key, including unlisted ones. Without " +
+  "a key they cover the public corpus. Saved pastes default to unlisted " +
+  "(retrievable by URL, not shown in public listings or search).";
 
 const EXPIRY_VALUES = ["10m", "1h", "1d", "1w", "1mo", "never", "burn"];
 const VISIBILITY_VALUES = ["public", "unlisted"];
@@ -101,16 +103,26 @@ export const TOOLS = [
   {
     name: "pastepile_search",
     description:
-      "Search public Pastepile pastes by keyword and get back matching " +
-      "titles, previews, and URLs. This searches the global public corpus of " +
-      "listed pastes, not a private per-user store. Use it to find existing " +
-      "public snippets or reference material before writing from scratch.",
+      "Search Pastepile pastes by keyword and get back matching titles, " +
+      "previews, and URLs. With an API key configured this defaults to " +
+      'scope "mine": YOUR private memory, the pastes saved with that key ' +
+      "(titles, filenames, and contents, including unlisted pastes). Use " +
+      'scope "public" to search the global public corpus instead. Without ' +
+      "a key only the public scope is available.",
     inputSchema: {
       type: "object",
       properties: {
         query: {
           type: "string",
-          description: "Keywords to match against public paste titles and content. Required.",
+          description: "Keywords to match against paste titles and content. Required.",
+        },
+        scope: {
+          type: "string",
+          enum: ["mine", "public"],
+          description:
+            '"mine" searches pastes saved with the configured API key ' +
+            '(default when a key is set); "public" searches the public ' +
+            "corpus (default without a key).",
         },
         limit: {
           type: "integer",
@@ -126,12 +138,21 @@ export const TOOLS = [
   {
     name: "pastepile_list",
     description:
-      "List the most recent public Pastepile pastes. Returns slugs, titles, " +
-      "and URLs. Use this to browse what has been shared publicly; for " +
-      "targeted lookups use pastepile_search instead.",
+      "List recent Pastepile pastes. With an API key configured this " +
+      'defaults to scope "mine": YOUR saved pastes, newest first, including ' +
+      'unlisted ones. Use scope "public" for the public feed. For targeted ' +
+      "lookups use pastepile_search instead.",
     inputSchema: {
       type: "object",
       properties: {
+        scope: {
+          type: "string",
+          enum: ["mine", "public"],
+          description:
+            '"mine" lists pastes saved with the configured API key (default ' +
+            'when a key is set); "public" lists the public feed (default ' +
+            "without a key).",
+        },
         limit: {
           type: "integer",
           minimum: 1,
@@ -225,19 +246,43 @@ async function toolSave(deps, args) {
   if (typeof args.title === "string" && args.title.length > 0) body.title = args.title;
   if (typeof args.language === "string" && args.language.length > 0) body.language = args.language;
 
-  const res = await apiFetch(deps, "POST", "/api/public/pastes", body);
-  const data = await readJson(res);
+  let res = await apiFetch(deps, "POST", "/api/public/pastes", body);
+  let data = await readJson(res);
+  let effectiveExpiry = expiry;
+  let expiryNote = null;
+  // The API reserves no-expiry for pro/enterprise API keys. When our default
+  // ("never") hits that gate on a free key, fall back to the longest allowed
+  // expiry instead of failing the save, and say so honestly in the result.
+  // An EXPLICIT expiry argument is never overridden.
+  if (
+    !res.ok &&
+    args.expiry === undefined &&
+    deps.apiKey &&
+    data &&
+    data.error &&
+    /no-expiry/i.test(String(data.error.message || ""))
+  ) {
+    effectiveExpiry = "1mo";
+    res = await apiFetch(deps, "POST", "/api/public/pastes", { ...body, expiry: effectiveExpiry });
+    data = await readJson(res);
+    expiryNote =
+      "This API key's plan does not allow never-expiring pastes, so the paste " +
+      'was stored with expiry "1mo" instead. Pass expiry explicitly to choose, ' +
+      "or upgrade the key for permanent storage.";
+  }
   if (!res.ok || !data) throw apiError(res, data);
-  return {
+  const result = {
     saved: true,
     url: data.url,
     slug: data.slug,
     raw_url: data.raw_url,
     edit_key: data.edit_key,
     visibility,
-    expiry,
+    expiry: effectiveExpiry,
     note: "Retain edit_key to update or delete this paste later; it is shown only once.",
   };
+  if (expiryNote) result.expiry_note = expiryNote;
+  return result;
 }
 
 async function toolGet(deps, args) {
@@ -258,7 +303,7 @@ async function toolGet(deps, args) {
 }
 
 function pickListItem(item) {
-  return {
+  const out = {
     slug: item.slug,
     title: item.title,
     language: item.language,
@@ -268,33 +313,58 @@ function pickListItem(item) {
     url: item.url,
     raw_url: item.raw_url,
   };
+  // Present only on scope=mine results.
+  if (item.visibility !== undefined) out.visibility = item.visibility;
+  if (item.expires_at !== undefined) out.expires_at = item.expires_at;
+  return out;
+}
+
+// Private memory ("mine") is the default whenever a key is configured; the
+// public corpus is the default (and only option) without one.
+function resolveScope(deps, args) {
+  const scope = args.scope === undefined ? (deps.apiKey ? "mine" : "public") : args.scope;
+  if (scope !== "mine" && scope !== "public") {
+    throw new ToolError('Invalid scope. Use "mine" or "public".');
+  }
+  if (scope === "mine" && !deps.apiKey) {
+    throw new ToolError(
+      'scope "mine" requires an API key. Set PASTEPILE_API_KEY in the MCP server config.',
+    );
+  }
+  return scope;
 }
 
 async function toolSearch(deps, args) {
   if (typeof args.query !== "string" || args.query.trim().length === 0) {
     throw new ToolError("`query` is required and must be a non-empty string.");
   }
+  const scope = resolveScope(deps, args);
   const limit = clampLimit(args.limit);
   const qs = new URLSearchParams({ search: args.query.slice(0, 80), limit: String(limit) });
+  if (scope === "mine") qs.set("scope", "mine");
   const res = await apiFetch(deps, "GET", `/api/public/pastes?${qs.toString()}`);
   const data = await readJson(res);
   if (!res.ok || !data) throw apiError(res, data);
   const items = Array.isArray(data.items) ? data.items : [];
   return {
     query: args.query,
+    scope,
     total: typeof data.total === "number" ? data.total : items.length,
     results: items.map(pickListItem),
   };
 }
 
 async function toolList(deps, args) {
+  const scope = resolveScope(deps, args);
   const limit = clampLimit(args.limit);
   const qs = new URLSearchParams({ limit: String(limit) });
+  if (scope === "mine") qs.set("scope", "mine");
   const res = await apiFetch(deps, "GET", `/api/public/pastes?${qs.toString()}`);
   const data = await readJson(res);
   if (!res.ok || !data) throw apiError(res, data);
   const items = Array.isArray(data.items) ? data.items : [];
   return {
+    scope,
     total: typeof data.total === "number" ? data.total : items.length,
     results: items.map(pickListItem),
   };