@wipcomputer/memory-crystal 0.7.32 → 0.7.34-alpha.1

package/dist/worker-mcp.js

@@ -0,0 +1,404 @@
+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
+};

package/dist/worker.js

@@ -0,0 +1,137 @@
+// src/worker.ts
+function authenticate(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 tokenMap = {};
+  if (env.AUTH_TOKEN_CC_AIR) tokenMap[env.AUTH_TOKEN_CC_AIR] = "cc-air";
+  if (env.AUTH_TOKEN_CC_MINI) tokenMap[env.AUTH_TOKEN_CC_MINI] = "cc-mini";
+  if (env.AUTH_TOKEN_LESA) tokenMap[env.AUTH_TOKEN_LESA] = "lesa-mini";
+  const agentId = tokenMap[token];
+  if (!agentId) {
+    return json({ error: "Invalid token" }, 403);
+  }
+  return { agentId };
+}
+var VALID_CHANNELS = ["conversations", "mirror", "commands", "files", "chatgpt", "chatgpt-attachments"];
+function isValidChannel(channel) {
+  return VALID_CHANNELS.includes(channel);
+}
+async function handleDrop(request, env, agentId, channel) {
+  if (!isValidChannel(channel)) {
+    return json({ error: `Invalid channel: ${channel}. Valid: ${VALID_CHANNELS.join(", ")}` }, 400);
+  }
+  const body = await request.arrayBuffer();
+  if (body.byteLength === 0) {
+    return json({ error: "Empty payload" }, 400);
+  }
+  if (body.byteLength > 100 * 1024 * 1024) {
+    return json({ error: "Payload too large (max 100MB)" }, 413);
+  }
+  const id = crypto.randomUUID();
+  const key = `${channel}/${id}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await env.RELAY.put(key, body, {
+    customMetadata: {
+      agent_id: agentId,
+      dropped_at: now,
+      size: String(body.byteLength)
+    }
+  });
+  return json({ ok: true, id, channel, size: body.byteLength, dropped_at: now });
+}
+async function handlePickupList(env, channel) {
+  if (!isValidChannel(channel)) {
+    return json({ error: `Invalid channel: ${channel}` }, 400);
+  }
+  const listed = await env.RELAY.list({ prefix: `${channel}/` });
+  const blobs = listed.objects.map((obj) => ({
+    id: obj.key.split("/")[1],
+    size: obj.size,
+    dropped_at: obj.customMetadata?.dropped_at || obj.uploaded.toISOString(),
+    agent_id: obj.customMetadata?.agent_id || "unknown"
+  }));
+  return json({ channel, count: blobs.length, blobs });
+}
+async function handlePickup(env, channel, id) {
+  if (!isValidChannel(channel)) {
+    return json({ error: `Invalid channel: ${channel}` }, 400);
+  }
+  const key = `${channel}/${id}`;
+  const obj = await env.RELAY.get(key);
+  if (!obj) {
+    return json({ error: "Blob not found (already picked up or expired)" }, 404);
+  }
+  return new Response(obj.body, {
+    headers: {
+      "Content-Type": "application/octet-stream",
+      "X-Agent-Id": obj.customMetadata?.agent_id || "unknown",
+      "X-Dropped-At": obj.customMetadata?.dropped_at || ""
+    }
+  });
+}
+async function handleConfirm(env, channel, id) {
+  if (!isValidChannel(channel)) {
+    return json({ error: `Invalid channel: ${channel}` }, 400);
+  }
+  const key = `${channel}/${id}`;
+  const obj = await env.RELAY.head(key);
+  if (!obj) {
+    return json({ error: "Blob not found (already confirmed or expired)" }, 404);
+  }
+  await env.RELAY.delete(key);
+  return json({ ok: true, deleted: key });
+}
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+var worker_default = {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts[0] === "health" && request.method === "GET") {
+      return json({ ok: true, service: "memory-crystal-relay", mode: "ephemeral" });
+    }
+    const authResult = authenticate(request, env);
+    if (authResult instanceof Response) return authResult;
+    const { agentId } = authResult;
+    try {
+      if (parts[0] === "drop" && parts[1] && request.method === "POST") {
+        return handleDrop(request, env, agentId, parts[1]);
+      }
+      if (parts[0] === "pickup" && parts[1] && request.method === "GET") {
+        if (parts[2]) {
+          return handlePickup(env, parts[1], parts[2]);
+        }
+        return handlePickupList(env, parts[1]);
+      }
+      if (parts[0] === "confirm" && parts[1] && parts[2] && request.method === "DELETE") {
+        return handleConfirm(env, parts[1], parts[2]);
+      }
+      return json({ error: "Not found" }, 404);
+    } catch (err) {
+      return json({ error: err.message || "Internal error" }, 500);
+    }
+  },
+  // Scheduled cleanup: delete blobs older than 24h (TTL safety net)
+  async scheduled(event, env) {
+    const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+    for (const channel of VALID_CHANNELS) {
+      const listed = await env.RELAY.list({ prefix: `${channel}/` });
+      for (const obj of listed.objects) {
+        const droppedAt = obj.customMetadata?.dropped_at;
+        if (droppedAt && new Date(droppedAt).getTime() < cutoff) {
+          await env.RELAY.delete(obj.key);
+        }
+      }
+    }
+  }
+};
+export {
+  worker_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/memory-crystal",
-  "version": "0.7.32",
+  "version": "0.7.34-alpha.1",
   "description": "Sovereign memory system — local-first with ephemeral encrypted relay. Your memory, your machine, your rules.",
   "repository": {
     "type": "git",
@@ -17,7 +17,21 @@
     "crystal": "dist/cli.js",
     "crystal-mcp": "dist/mcp-server.js"
   },
+  "files": [
+    "dist/",
+    "scripts/",
+    "skills/",
+    "migrations/",
+    "cloud/",
+    "openclaw.plugin.json",
+    "SKILL.md",
+    "TECHNICAL.md",
+    "README.md",
+    "LICENSE",
+    "CLA.md"
+  ],
   "scripts": {
+    "prepublishOnly": "npm run build",
     "build": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist && tsup src/worker.ts --format esm --outDir dist --no-dts && cp scripts/crystal-capture.sh scripts/ldm-backup.sh dist/",
     "build:local": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist",
     "build:worker": "tsup src/worker.ts --format esm --outDir dist --no-dts",

package/.env.example

@@ -1,20 +0,0 @@
-# Memory Crystal — Environment Config
-# Copy to ~/.openclaw/memory-crystal/.env and fill in your keys.
-# Or skip this and use 1Password (keys auto-resolve from "Agent Secrets" vault).
-
-# Embedding provider: openai (default), ollama, or google
-# CRYSTAL_EMBEDDING_PROVIDER=openai
-
-# OpenAI (required if provider is openai)
-OPENAI_API_KEY=sk-...
-
-# Google (required if provider is google)
-# GOOGLE_API_KEY=AIza...
-
-# Ollama (only if provider is ollama — runs locally, no key needed)
-# CRYSTAL_OLLAMA_HOST=http://localhost:11434
-# CRYSTAL_OLLAMA_MODEL=nomic-embed-text
-
-# Cloud mirror (Phase 2)
-# CRYSTAL_REMOTE_URL=https://memory-crystal.your-worker.workers.dev
-# CRYSTAL_REMOTE_TOKEN=your-token

package/.publish-skill.json

@@ -1 +0,0 @@
-{ "name": "wip-memory-crystal" }