@wipcomputer/memory-crystal 0.7.30 → 0.7.32

package/dist/worker.js

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