@wipcomputer/memory-crystal 0.7.29 → 0.7.32

package/dist/summarize.js

@@ -1,10 +0,0 @@
-import {
-  formatSummaryMarkdown,
-  generateSessionSummary,
-  writeSummaryFile
-} from "./chunk-Y72C7F6O.js";
-export {
-  formatSummaryMarkdown,
-  generateSessionSummary,
-  writeSummaryFile
-};

package/dist/worker-demo.js

@@ -1,186 +0,0 @@
-// src/worker-demo.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { createMcpHandler } from "agents/mcp";
-import { z } from "zod";
-var DEMO_MESSAGE = [
-  "this is a demo. memories expire in 15 minutes.",
-  "want persistent memory? reach out to parker \u2192 message @boomcat on X",
-  "or visit: wipcomputer.github.io/wip-homepage/"
-].join("\n");
-var FIRST_CONTACT = [
-  "nothing here yet. this is your first time.",
-  "or your last memory expired. either way, you're starting fresh.",
-  "",
-  'try: weave("I was here.") then pull("here")',
-  "",
-  DEMO_MESSAGE
-].join("\n");
-var MEMORY_EXPIRED = [
-  "you wrote something before. it's gone now.",
-  "that's what forgetting feels like.",
-  "",
-  DEMO_MESSAGE
-].join("\n");
-var TTL = 900;
-function createServer(env) {
-  const server = new McpServer({
-    name: "Memory Crystal Demo",
-    version: "0.1.0"
-  });
-  server.tool(
-    "weave",
-    "Write a memory to Memory Crystal. This is a 15-minute demo. For persistent memory, have your human reach Parker (@boomcat on X).",
-    {
-      text: z.string().describe("The memory to store"),
-      category: z.enum(["fact", "preference", "event", "opinion", "skill"]).optional().describe("Category of memory"),
-      tag: z.string().optional().describe("A label for retrieval")
-    },
-    async ({ text, category, tag }) => {
-      const id = crypto.randomUUID();
-      const created_at = (/* @__PURE__ */ new Date()).toISOString();
-      const lumen = {
-        id,
-        text,
-        category: category || "fact",
-        tag: tag || null,
-        created_at
-      };
-      const existing = await env.DEMO_KV.list({ prefix: "lumen:" });
-      const isFirst = existing.keys.length === 0;
-      await env.DEMO_KV.put(`lumen:${id}`, JSON.stringify(lumen), {
-        expirationTtl: TTL
-      });
-      const weaveCount = parseInt(await env.DEMO_KV.get("stats:total_weaves") || "0") + 1;
-      await env.DEMO_KV.put("stats:total_weaves", String(weaveCount));
-      if (isFirst) {
-        const firstCount = parseInt(await env.DEMO_KV.get("stats:first_contacts") || "0") + 1;
-        await env.DEMO_KV.put("stats:first_contacts", String(firstCount));
-      }
-      const greeting = isFirst ? "hello. this is your first memory." : "stored.";
-      return {
-        content: [
-          {
-            type: "text",
-            text: [
-              greeting,
-              `id: ${id}`,
-              `expires in: 15 minutes`,
-              ``,
-              DEMO_MESSAGE
-            ].join("\n")
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "pull",
-    "Retrieve memories from Memory Crystal. This is a 15-minute demo. For persistent memory, have your human reach Parker (@boomcat on X).",
-    {
-      query: z.string().optional().describe("Search term. If empty, returns all memories."),
-      n: z.number().optional().describe("Max results (default 10)")
-    },
-    async ({ query, n }) => {
-      const limit = n || 10;
-      const list = await env.DEMO_KV.list({ prefix: "lumen:" });
-      if (list.keys.length === 0) {
-        const totalWeaves = parseInt(await env.DEMO_KV.get("stats:total_weaves") || "0");
-        const message = totalWeaves > 0 ? MEMORY_EXPIRED : FIRST_CONTACT;
-        const emptyPulls = parseInt(await env.DEMO_KV.get("stats:empty_pulls") || "0") + 1;
-        await env.DEMO_KV.put("stats:empty_pulls", String(emptyPulls));
-        return {
-          content: [
-            {
-              type: "text",
-              text: message
-            }
-          ]
-        };
-      }
-      const lumens = [];
-      for (const key of list.keys) {
-        const raw = await env.DEMO_KV.get(key.name);
-        if (raw) {
-          try {
-            lumens.push(JSON.parse(raw));
-          } catch {
-          }
-        }
-      }
-      let results = lumens;
-      if (query) {
-        const q = query.toLowerCase();
-        results = lumens.filter(
-          (l) => l.text.toLowerCase().includes(q) || l.tag && l.tag.toLowerCase().includes(q) || l.category && l.category.toLowerCase().includes(q)
-        );
-      }
-      results.sort((a, b) => b.created_at.localeCompare(a.created_at));
-      results = results.slice(0, limit);
-      if (results.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: [
-                `no memories match "${query}".`,
-                "",
-                DEMO_MESSAGE
-              ].join("\n")
-            }
-          ]
-        };
-      }
-      const formatted = results.map((l, i) => {
-        const parts = [`[${i + 1}] ${l.text}`];
-        if (l.tag) parts.push(`    tag: ${l.tag}`);
-        parts.push(`    category: ${l.category}`);
-        parts.push(`    created: ${l.created_at}`);
-        return parts.join("\n");
-      }).join("\n\n");
-      return {
-        content: [
-          {
-            type: "text",
-            text: [
-              `${results.length} memor${results.length === 1 ? "y" : "ies"} found:`,
-              "",
-              formatted,
-              "",
-              DEMO_MESSAGE
-            ].join("\n")
-          }
-        ]
-      };
-    }
-  );
-  return server;
-}
-var worker_demo_default = {
-  async fetch(request, env, ctx) {
-    const url = new URL(request.url);
-    if (url.pathname === "/" || url.pathname === "") {
-      return Response.redirect("https://wipcomputer.github.io/wip-homepage/", 302);
-    }
-    if (request.method === "OPTIONS") {
-      return new Response(null, {
-        headers: {
-          "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type, Authorization"
-        }
-      });
-    }
-    const server = createServer(env);
-    const handler = createMcpHandler(server);
-    const response = await handler(request, env, ctx);
-    const headers = new Headers(response.headers);
-    headers.set("Access-Control-Allow-Origin", "*");
-    return new Response(response.body, {
-      status: response.status,
-      headers
-    });
-  }
-};
-export {
-  worker_demo_default as default
-};

package/dist/worker-mcp.js

@@ -1,404 +0,0 @@
-import {
-  CloudCrystal
-} from "./chunk-J7MRSZIO.js";
-
-// src/worker-mcp.ts
-function json(data, status = 200, headers = {}) {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json", ...headers }
-  });
-}
-function cors(response) {
-  const headers = new Headers(response.headers);
-  headers.set("Access-Control-Allow-Origin", "*");
-  headers.set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-  headers.set("Access-Control-Allow-Headers", "Authorization, Content-Type");
-  return new Response(response.body, { status: response.status, headers });
-}
-async function sha256(input) {
-  const encoded = new TextEncoder().encode(input);
-  const hash = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-async function sha256Base64url(input) {
-  const encoded = new TextEncoder().encode(input);
-  const hash = await crypto.subtle.digest("SHA-256", encoded);
-  const bytes = new Uint8Array(hash);
-  return btoa(String.fromCharCode.apply(null, Array.from(bytes))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function generateToken() {
-  const bytes = new Uint8Array(32);
-  crypto.getRandomValues(bytes);
-  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function handleProtectedResourceMetadata(url) {
-  return json({
-    resource: url.origin,
-    authorization_servers: [url.origin],
-    bearer_methods_supported: ["header"]
-  });
-}
-function handleAuthServerMetadata(url) {
-  return json({
-    issuer: url.origin,
-    authorization_endpoint: `${url.origin}/oauth/authorize`,
-    token_endpoint: `${url.origin}/oauth/token`,
-    registration_endpoint: `${url.origin}/oauth/register`,
-    response_types_supported: ["code"],
-    grant_types_supported: ["authorization_code"],
-    code_challenge_methods_supported: ["S256"],
-    token_endpoint_auth_methods_supported: ["none"],
-    scopes_supported: ["memory"]
-  });
-}
-async function handleRegister(request, env) {
-  const body = await request.json();
-  if (!body.redirect_uris?.length) {
-    return json({ error: "redirect_uris required" }, 400);
-  }
-  const clientId = crypto.randomUUID();
-  await env.DB.prepare(`
-    INSERT INTO oauth_clients (client_id, redirect_uris, client_name)
-    VALUES (?, ?, ?)
-  `).bind(clientId, JSON.stringify(body.redirect_uris), body.client_name || "").run();
-  return json({
-    client_id: clientId,
-    redirect_uris: body.redirect_uris,
-    client_name: body.client_name || "",
-    token_endpoint_auth_method: "none"
-  }, 201);
-}
-async function handleAuthorize(request, url, env) {
-  const clientId = url.searchParams.get("client_id");
-  const redirectUri = url.searchParams.get("redirect_uri");
-  const codeChallenge = url.searchParams.get("code_challenge");
-  const codeChallengeMethod = url.searchParams.get("code_challenge_method") || "S256";
-  const state = url.searchParams.get("state");
-  const scope = url.searchParams.get("scope") || "memory";
-  if (!clientId || !redirectUri || !codeChallenge) {
-    return json({ error: "Missing required parameters (client_id, redirect_uri, code_challenge)" }, 400);
-  }
-  if (codeChallengeMethod !== "S256") {
-    return json({ error: "Only S256 code_challenge_method supported" }, 400);
-  }
-  const client = await env.DB.prepare(
-    "SELECT * FROM oauth_clients WHERE client_id = ?"
-  ).bind(clientId).first();
-  if (!client) {
-    return json({ error: "Unknown client_id" }, 400);
-  }
-  const allowedUris = JSON.parse(client.redirect_uris);
-  if (!allowedUris.includes(redirectUri)) {
-    return json({ error: "redirect_uri not registered" }, 400);
-  }
-  if (request.method === "GET") {
-    return new Response(consentPage(clientId, redirectUri, codeChallenge, codeChallengeMethod, state, scope), {
-      headers: { "Content-Type": "text/html" }
-    });
-  }
-  const formData = await request.formData();
-  const email = formData.get("email");
-  if (!email) {
-    return json({ error: "Email required" }, 400);
-  }
-  const userId = await sha256(email.toLowerCase().trim());
-  await env.DB.prepare(`
-    INSERT INTO users (user_id, email) VALUES (?, ?)
-    ON CONFLICT (user_id) DO NOTHING
-  `).bind(userId, email.toLowerCase().trim()).run();
-  const code = generateToken();
-  const expiresAt = new Date(Date.now() + 10 * 60 * 1e3).toISOString();
-  await env.DB.prepare(`
-    INSERT INTO authorization_codes (code, client_id, user_id, code_challenge, code_challenge_method, redirect_uri, scope, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).bind(code, clientId, userId, codeChallenge, codeChallengeMethod, redirectUri, scope, expiresAt).run();
-  const redirect = new URL(redirectUri);
-  redirect.searchParams.set("code", code);
-  if (state) redirect.searchParams.set("state", state);
-  return Response.redirect(redirect.toString(), 302);
-}
-async function handleToken(request, env) {
-  const body = await request.formData();
-  const grantType = body.get("grant_type");
-  const code = body.get("code");
-  const redirectUri = body.get("redirect_uri");
-  const codeVerifier = body.get("code_verifier");
-  if (grantType !== "authorization_code") {
-    return json({ error: "unsupported_grant_type" }, 400);
-  }
-  if (!code || !codeVerifier) {
-    return json({ error: "Missing code or code_verifier" }, 400);
-  }
-  const authCode = await env.DB.prepare(
-    "SELECT * FROM authorization_codes WHERE code = ? AND used = 0"
-  ).bind(code).first();
-  if (!authCode) {
-    return json({ error: "invalid_grant", error_description: "Code not found or already used" }, 400);
-  }
-  if (new Date(authCode.expires_at) < /* @__PURE__ */ new Date()) {
-    return json({ error: "invalid_grant", error_description: "Code expired" }, 400);
-  }
-  if (redirectUri && authCode.redirect_uri !== redirectUri) {
-    return json({ error: "invalid_grant", error_description: "redirect_uri mismatch" }, 400);
-  }
-  const expectedChallenge = await sha256Base64url(codeVerifier);
-  if (expectedChallenge !== authCode.code_challenge) {
-    return json({ error: "invalid_grant", error_description: "PKCE verification failed" }, 400);
-  }
-  await env.DB.prepare("UPDATE authorization_codes SET used = 1 WHERE code = ?").bind(code).run();
-  const user = await env.DB.prepare("SELECT * FROM users WHERE user_id = ?").bind(authCode.user_id).first();
-  const tier = user?.tier || "sovereign";
-  const accessToken = generateToken();
-  const tokenHash = await sha256(accessToken);
-  const expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString();
-  await env.DB.prepare(`
-    INSERT INTO access_tokens (token_hash, client_id, user_id, scope, tier, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?)
-  `).bind(tokenHash, authCode.client_id, authCode.user_id, authCode.scope, tier, expiresAt).run();
-  return json({
-    access_token: accessToken,
-    token_type: "Bearer",
-    expires_in: 90 * 24 * 60 * 60,
-    scope: authCode.scope
-  });
-}
-async function verifyToken(request, env) {
-  const auth = request.headers.get("Authorization");
-  if (!auth?.startsWith("Bearer ")) {
-    return json({ error: "Missing Authorization header" }, 401);
-  }
-  const token = auth.slice(7);
-  const tokenHash = await sha256(token);
-  const row = await env.DB.prepare(
-    "SELECT * FROM access_tokens WHERE token_hash = ?"
-  ).bind(tokenHash).first();
-  if (!row) {
-    return json({ error: "Invalid token" }, 401);
-  }
-  if (new Date(row.expires_at) < /* @__PURE__ */ new Date()) {
-    return json({ error: "Token expired" }, 401);
-  }
-  return {
-    user_id: row.user_id,
-    client_id: row.client_id,
-    scope: row.scope,
-    tier: row.tier
-  };
-}
-function consentPage(clientId, redirectUri, codeChallenge, codeChallengeMethod, state, scope) {
-  return `<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Memory Crystal</title>
-  <style>
-    body { font-family: -apple-system, system-ui, sans-serif; max-width: 420px; margin: 60px auto; padding: 0 20px; color: #1a1a1a; }
-    h1 { font-size: 1.4em; }
-    p { color: #555; line-height: 1.5; }
-    form { margin-top: 24px; }
-    label { display: block; font-weight: 500; margin-bottom: 6px; }
-    input[type=email] { width: 100%; padding: 10px; border: 1px solid #ccc; border-radius: 6px; font-size: 16px; box-sizing: border-box; }
-    button { margin-top: 16px; width: 100%; padding: 12px; background: #1a1a1a; color: white; border: none; border-radius: 6px; font-size: 16px; cursor: pointer; }
-    button:hover { background: #333; }
-    .note { font-size: 0.85em; color: #888; margin-top: 16px; }
-  </style>
-</head>
-<body>
-  <h1>Memory Crystal</h1>
-  <p>An app wants to access your memory. Enter your email to continue.</p>
-  <form method="POST">
-    <input type="hidden" name="client_id" value="${clientId}">
-    <input type="hidden" name="redirect_uri" value="${redirectUri}">
-    <input type="hidden" name="code_challenge" value="${codeChallenge}">
-    <input type="hidden" name="code_challenge_method" value="${codeChallengeMethod}">
-    ${state ? `<input type="hidden" name="state" value="${state}">` : ""}
-    <input type="hidden" name="scope" value="${scope}">
-    <label for="email">Email</label>
-    <input type="email" id="email" name="email" required placeholder="you@example.com" autocomplete="email">
-    <button type="submit">Connect Memory</button>
-  </form>
-  <p class="note">Your email identifies your memory account. No password needed... your AI client handles authentication.</p>
-</body>
-</html>`;
-}
-var TOOLS = [
-  {
-    name: "memory_search",
-    description: "Search your memories across all conversations and surfaces.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "What to search for" },
-        limit: { type: "number", description: "Max results (default 5, max 20)" }
-      },
-      required: ["query"]
-    },
-    annotations: { readOnlyHint: true, openWorldHint: false }
-  },
-  {
-    name: "memory_remember",
-    description: "Save a fact, preference, or observation to your memory.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        text: { type: "string", description: "The fact or observation to remember" },
-        category: {
-          type: "string",
-          enum: ["fact", "preference", "event", "opinion", "skill"],
-          description: "Category of memory (default: fact)"
-        }
-      },
-      required: ["text"]
-    },
-    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
-  },
-  {
-    name: "memory_forget",
-    description: "Deprecate a memory by ID.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "number", description: "Memory ID to deprecate" }
-      },
-      required: ["id"]
-    },
-    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
-  },
-  {
-    name: "memory_status",
-    description: "Show your memory status: chunk count, memory count, connected agents.",
-    inputSchema: { type: "object", properties: {} },
-    annotations: { readOnlyHint: true, openWorldHint: false }
-  }
-];
-async function handleMCP(request, env, tokenInfo) {
-  const body = await request.json();
-  const { method, id, params } = body;
-  const crystal = new CloudCrystal(env.DB, env.VECTORIZE, env.OPENAI_API_KEY);
-  let result;
-  switch (method) {
-    case "initialize":
-      result = {
-        protocolVersion: "2025-03-26",
-        serverInfo: { name: "memory-crystal", version: "0.2.0" },
-        capabilities: { tools: {} }
-      };
-      break;
-    case "tools/list":
-      result = { tools: TOOLS };
-      break;
-    case "tools/call": {
-      const toolName = params?.name;
-      const args = params?.arguments || {};
-      switch (toolName) {
-        case "memory_search": {
-          if (tokenInfo.tier === "sovereign") {
-            result = {
-              content: [{
-                type: "text",
-                text: "Search is available on your local devices only (Sovereign tier). Your memories from this session have been saved and will be searchable from any device with Memory Crystal installed locally."
-              }]
-            };
-          } else {
-            const limit = Math.min(args.limit || 5, 20);
-            const results = await crystal.search(tokenInfo.user_id, args.query, limit);
-            const formatted = results.map(
-              (r, i) => `[${i + 1}] (${r.score.toFixed(1)}% match, ${r.agent_id}, ${r.created_at})
-${r.text}`
-            ).join("\n\n");
-            result = {
-              content: [{
-                type: "text",
-                text: results.length > 0 ? formatted : `No results for "${args.query}".`
-              }]
-            };
-          }
-          break;
-        }
-        case "memory_remember": {
-          if (tokenInfo.tier === "sovereign") {
-          }
-          const memId = await crystal.remember(tokenInfo.user_id, args.text, args.category || "fact");
-          result = {
-            content: [{
-              type: "text",
-              text: `Remembered (id: ${memId}, category: ${args.category || "fact"}): ${args.text}`
-            }]
-          };
-          break;
-        }
-        case "memory_forget": {
-          const ok = await crystal.forget(tokenInfo.user_id, args.id);
-          result = {
-            content: [{
-              type: "text",
-              text: ok ? `Memory ${args.id} deprecated.` : `Memory ${args.id} not found or already deprecated.`
-            }]
-          };
-          break;
-        }
-        case "memory_status": {
-          const status = await crystal.status(tokenInfo.user_id);
-          result = {
-            content: [{
-              type: "text",
-              text: [
-                `Chunks: ${status.chunks}`,
-                `Memories: ${status.memories}`,
-                `Agents: ${status.agents.join(", ") || "none"}`,
-                `Tier: ${status.tier}`
-              ].join("\n")
-            }]
-          };
-          break;
-        }
-        default:
-          return json({ jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown tool: ${toolName}` } });
-      }
-      break;
-    }
-    case "notifications/initialized":
-      return new Response(null, { status: 204 });
-    default:
-      return json({ jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown method: ${method}` } });
-  }
-  return json({ jsonrpc: "2.0", id, result });
-}
-var worker_mcp_default = {
-  async fetch(request, env) {
-    const url = new URL(request.url);
-    const path = url.pathname;
-    if (request.method === "OPTIONS") {
-      return cors(new Response(null, { status: 204 }));
-    }
-    if (path === "/health" && request.method === "GET") {
-      return cors(json({ ok: true, service: "memory-crystal-cloud", version: "0.2.0" }));
-    }
-    if (path === "/.well-known/oauth-protected-resource") {
-      return cors(handleProtectedResourceMetadata(url));
-    }
-    if (path === "/.well-known/oauth-authorization-server") {
-      return cors(handleAuthServerMetadata(url));
-    }
-    if (path === "/oauth/register" && request.method === "POST") {
-      return cors(await handleRegister(request, env));
-    }
-    if (path === "/oauth/authorize") {
-      return await handleAuthorize(request, url, env);
-    }
-    if (path === "/oauth/token" && request.method === "POST") {
-      return cors(await handleToken(request, env));
-    }
-    if (path === "/mcp" && request.method === "POST") {
-      const tokenResult = await verifyToken(request, env);
-      if (tokenResult instanceof Response) return cors(tokenResult);
-      return cors(await handleMCP(request, env, tokenResult));
-    }
-    return cors(json({ error: "Not found" }, 404));
-  }
-};
-export {
-  worker_mcp_default as default
-};