devflare 0.0.0 → 1.0.0-next.0

package/dist/index-m2q41jwa.js

@@ -0,0 +1,462 @@
+import {
+  BinaryFlags,
+  BinaryKind,
+  base64Decode,
+  base64Encode,
+  decodeBinaryFrame,
+  deserializeValue,
+  encodeBinaryFrame,
+  parseJsonMsg,
+  serializeValue,
+  stringifyJsonMsg
+} from "./index-pf5s73n9.js";
+
+// src/bridge/server.ts
+var server_default = {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    if (request.headers.get("Upgrade") === "websocket") {
+      return handleWebSocket(request, env, ctx);
+    }
+    if (url.pathname.startsWith("/_devflare/transfer/")) {
+      return handleHttpTransfer(request, env, url);
+    }
+    if (url.pathname === "/_devflare/health") {
+      return new Response(JSON.stringify({ ok: true, bindings: Object.keys(env) }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Devflare Bridge Gateway", { status: 200 });
+  }
+};
+async function handleWebSocket(request, env, ctx) {
+  const { 0: client, 1: server } = new WebSocketPair;
+  const activeStreams = new Map;
+  const wsProxies = new Map;
+  const incomingStreams = new Map;
+  server.accept();
+  server.addEventListener("message", async (event) => {
+    try {
+      if (typeof event.data === "string") {
+        await handleJsonMessage(event.data, server, env, ctx, activeStreams, wsProxies, incomingStreams);
+      } else if (event.data instanceof ArrayBuffer) {
+        handleBinaryMessage(new Uint8Array(event.data), server, wsProxies, incomingStreams);
+      }
+    } catch {}
+  });
+  server.addEventListener("close", () => {
+    for (const [_sid, stream] of activeStreams) {
+      stream.reader.cancel();
+    }
+    activeStreams.clear();
+    for (const [_wid, proxy] of wsProxies) {
+      proxy.doWs.close();
+    }
+    wsProxies.clear();
+  });
+  return new Response(null, { status: 101, webSocket: client });
+}
+async function handleJsonMessage(data, ws, env, ctx, activeStreams, wsProxies, incomingStreams) {
+  const msg = parseJsonMsg(data);
+  switch (msg.t) {
+    case "rpc.call":
+      await handleRpcCall(msg, ws, env, ctx, activeStreams, incomingStreams);
+      break;
+    case "stream.pull":
+      await handleStreamPull(msg, ws, activeStreams);
+      break;
+    case "stream.open":
+      handleStreamOpen(msg, incomingStreams);
+      break;
+    case "stream.end":
+      handleStreamEnd(msg, incomingStreams);
+      break;
+    case "stream.abort":
+      handleStreamAbort(msg, incomingStreams);
+      break;
+    case "ws.open":
+      await handleWsOpen(msg, ws, env, wsProxies);
+      break;
+    case "ws.close":
+      handleWsClose(msg, wsProxies);
+      break;
+  }
+}
+async function handleRpcCall(msg, ws, env, ctx, activeStreams, incomingStreams) {
+  try {
+    const getStream = (sid) => incomingStreams.get(sid)?.stream ?? null;
+    const params = deserializeValue(msg.params, getStream);
+    const result = await executeRpcMethod(msg.method, params, env, ctx);
+    const { value: serializedResult, streams } = await serializeValue(result);
+    for (const streamRef of streams) {
+      activeStreams.set(streamRef.sid, {
+        reader: streamRef.stream.getReader(),
+        seq: 0
+      });
+    }
+    const response = {
+      t: "rpc.ok",
+      id: msg.id,
+      result: serializedResult
+    };
+    ws.send(stringifyJsonMsg(response));
+  } catch (error) {
+    const response = {
+      t: "rpc.err",
+      id: msg.id,
+      error: {
+        code: error.code ?? "INTERNAL_ERROR",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+    ws.send(stringifyJsonMsg(response));
+  }
+}
+async function executeRpcMethod(method, params, env, ctx) {
+  const parts = method.split(".");
+  if (parts.length < 2) {
+    throw new Error(`Invalid method format: ${method}`);
+  }
+  const bindingName = parts[0];
+  const operation = parts.slice(1).join(".");
+  const binding = env[bindingName];
+  if (!binding) {
+    throw new Error(`Binding not found: ${bindingName}`);
+  }
+  switch (operation) {
+    case "get":
+      return binding.get(params[0], params[1]);
+    case "put":
+      return binding.put(params[0], params[1], params[2]);
+    case "delete":
+      return binding.delete(params[0]);
+    case "list":
+      return binding.list(params[0]);
+    case "getWithMetadata":
+      return binding.getWithMetadata(params[0], params[1]);
+    case "head":
+      return serializeR2Object(await binding.head(params[0]));
+    case "r2.get":
+      return serializeR2ObjectBody(await binding.get(params[0], params[1]));
+    case "r2.put":
+      return binding.put(params[0], params[1], params[2]);
+    case "r2.delete":
+      return binding.delete(params[0]);
+    case "r2.list":
+      return binding.list(params[0]);
+    case "prepare":
+      return serializeD1Statement(binding.prepare(params[0]));
+    case "batch":
+      return binding.batch(params[0]);
+    case "exec":
+      return binding.exec(params[0]);
+    case "dump":
+      return binding.dump();
+    case "stmt.bind":
+      return { __type: "D1Statement", sql: params[0], bindings: params.slice(1) };
+    case "stmt.first":
+      return executeD1Statement(binding, params[0], params.slice(1), "first", params[params.length - 1]);
+    case "stmt.all":
+      return executeD1Statement(binding, params[0], params.slice(1), "all");
+    case "stmt.run":
+      return executeD1Statement(binding, params[0], params.slice(1), "run");
+    case "stmt.raw":
+      return executeD1Statement(binding, params[0], params.slice(1), "raw", params[params.length - 1]);
+    case "idFromName":
+      return serializeDOId(binding.idFromName(params[0]));
+    case "idFromString":
+      return serializeDOId(binding.idFromString(params[0]));
+    case "newUniqueId":
+      return serializeDOId(binding.newUniqueId(params[0]));
+    case "get":
+      const doId = deserializeDOId(params[0], binding);
+      const stub = binding.get(doId);
+      return { __type: "DOStub", binding: bindingName, id: params[0] };
+    case "stub.fetch":
+      return executeDoFetch(env, params[0], params[1], params[2]);
+    case "stub.rpc":
+      return executeDoRpc(env, params[0], params[1], params[2], params[3]);
+    case "send":
+      return binding.send(params[0], params[1]);
+    case "sendBatch":
+      return binding.sendBatch(params[0], params[1]);
+    case "run":
+      if (typeof binding.run === "function") {
+        return binding.run(params[0], params[1]);
+      }
+      break;
+    default:
+      throw new Error(`Unknown operation: ${method}`);
+  }
+}
+function serializeR2Object(obj) {
+  if (!obj)
+    return null;
+  return {
+    __type: "R2Object",
+    key: obj.key,
+    version: obj.version,
+    size: obj.size,
+    etag: obj.etag,
+    httpEtag: obj.httpEtag,
+    checksums: obj.checksums,
+    uploaded: obj.uploaded?.toISOString(),
+    httpMetadata: obj.httpMetadata,
+    customMetadata: obj.customMetadata,
+    range: obj.range,
+    storageClass: obj.storageClass
+  };
+}
+async function serializeR2ObjectBody(obj) {
+  if (!obj)
+    return null;
+  const hasBody = "body" in obj || "arrayBuffer" in obj;
+  if (!hasBody) {
+    return serializeR2Object(obj);
+  }
+  const body = obj;
+  const arrayBuffer = await body.arrayBuffer();
+  const bodyData = base64Encode(new Uint8Array(arrayBuffer));
+  return {
+    __type: "R2ObjectBody",
+    key: body.key,
+    version: body.version,
+    size: body.size,
+    etag: body.etag,
+    httpEtag: body.httpEtag,
+    checksums: body.checksums,
+    uploaded: body.uploaded?.toISOString(),
+    httpMetadata: body.httpMetadata,
+    customMetadata: body.customMetadata,
+    range: body.range,
+    storageClass: body.storageClass,
+    bodyData
+  };
+}
+function serializeD1Statement(stmt) {
+  return { __type: "D1Statement" };
+}
+async function executeD1Statement(db, sql, bindings, mode, extra) {
+  let stmt = db.prepare(sql);
+  if (bindings.length > 0) {
+    stmt = stmt.bind(...bindings);
+  }
+  switch (mode) {
+    case "first":
+      return typeof extra === "string" ? stmt.first(extra) : stmt.first();
+    case "all":
+      return stmt.all();
+    case "run":
+      return stmt.run();
+    case "raw":
+      return stmt.raw(extra);
+  }
+}
+function serializeDOId(id) {
+  return { __type: "DOId", hex: id.toString() };
+}
+function deserializeDOId(serialized, ns) {
+  if (serialized.__type === "DOId") {
+    return ns.idFromString(serialized.hex);
+  }
+  throw new Error("Invalid DOId format");
+}
+async function executeDoFetch(env, bindingName, idSerialized, requestSerialized) {
+  const binding = env[bindingName];
+  const id = deserializeDOId(idSerialized, binding);
+  const stub = binding.get(id);
+  const bodyBytes = requestSerialized.body?.type === "bytes" ? base64Decode(requestSerialized.body.data) : undefined;
+  const bodyBuffer = bodyBytes ? bodyBytes.buffer.slice(bodyBytes.byteOffset, bodyBytes.byteOffset + bodyBytes.byteLength) : undefined;
+  const request = new Request(requestSerialized.url, {
+    method: requestSerialized.method,
+    headers: requestSerialized.headers,
+    body: bodyBuffer
+  });
+  return stub.fetch(request);
+}
+async function executeDoRpc(env, bindingName, idSerialized, methodName, args) {
+  const binding = env[bindingName];
+  const id = deserializeDOId(idSerialized, binding);
+  const stub = binding.get(id);
+  const response = await stub.fetch(new Request("http://do/_rpc", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ method: methodName, params: args })
+  }));
+  const result = await response.json();
+  if (!result.ok) {
+    throw new Error(result.error?.message ?? "DO RPC failed");
+  }
+  return result.result;
+}
+async function handleStreamPull(msg, ws, activeStreams) {
+  const stream = activeStreams.get(msg.sid);
+  if (!stream)
+    return;
+  let sent = 0;
+  const maxBytes = msg.creditBytes;
+  try {
+    while (sent < maxBytes) {
+      const { done, value } = await stream.reader.read();
+      if (done) {
+        ws.send(stringifyJsonMsg({ t: "stream.end", sid: msg.sid }));
+        activeStreams.delete(msg.sid);
+        break;
+      }
+      if (value) {
+        const frame = encodeBinaryFrame(BinaryKind.StreamChunk, msg.sid, stream.seq++, 0, value);
+        ws.send(frame);
+        sent += value.byteLength;
+      }
+    }
+  } catch (error) {
+    ws.send(stringifyJsonMsg({
+      t: "stream.abort",
+      sid: msg.sid,
+      error: String(error)
+    }));
+    activeStreams.delete(msg.sid);
+  }
+}
+function handleStreamOpen(msg, incomingStreams) {
+  let controller;
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  incomingStreams.set(msg.sid, { controller, stream });
+}
+function handleStreamEnd(msg, incomingStreams) {
+  const stream = incomingStreams.get(msg.sid);
+  if (stream) {
+    stream.controller.close();
+    incomingStreams.delete(msg.sid);
+  }
+}
+function handleStreamAbort(msg, incomingStreams) {
+  const stream = incomingStreams.get(msg.sid);
+  if (stream) {
+    stream.controller.error(new Error(msg.error ?? "Stream aborted"));
+    incomingStreams.delete(msg.sid);
+  }
+}
+function handleBinaryMessage(frame, ws, wsProxies, incomingStreams) {
+  const decoded = decodeBinaryFrame(frame);
+  switch (decoded.kind) {
+    case BinaryKind.StreamChunk:
+      const stream = incomingStreams.get(decoded.id);
+      if (stream) {
+        stream.controller.enqueue(decoded.payload);
+      }
+      break;
+    case BinaryKind.WsData:
+      const proxy = wsProxies.get(decoded.id);
+      if (proxy) {
+        const isText = (decoded.flags & BinaryFlags.TEXT) !== 0;
+        if (isText) {
+          proxy.doWs.send(new TextDecoder().decode(decoded.payload));
+        } else {
+          proxy.doWs.send(decoded.payload);
+        }
+      }
+      break;
+  }
+}
+async function handleWsOpen(msg, ws, env, wsProxies) {
+  try {
+    const binding = env[msg.target.binding];
+    const id = binding.idFromString(msg.target.id);
+    const stub = binding.get(id);
+    const headers = new Headers(msg.target.headers ?? []);
+    headers.set("Upgrade", "websocket");
+    const request = new Request(msg.target.url, {
+      method: "GET",
+      headers
+    });
+    const response = await stub.fetch(request);
+    const doWs = response.webSocket;
+    if (!doWs) {
+      ws.send(stringifyJsonMsg({
+        t: "rpc.err",
+        id: `ws_${msg.wid}`,
+        error: { code: "WS_UPGRADE_FAILED", message: "DO did not return WebSocket" }
+      }));
+      return;
+    }
+    doWs.accept();
+    const proxy = {
+      doWs,
+      clientWid: msg.wid
+    };
+    wsProxies.set(msg.wid, proxy);
+    doWs.addEventListener("message", (event) => {
+      const isText = typeof event.data === "string";
+      const payload = isText ? new TextEncoder().encode(event.data) : new Uint8Array(event.data);
+      const flags = isText ? BinaryFlags.TEXT : 0;
+      const frame = encodeBinaryFrame(BinaryKind.WsData, msg.wid, 0, flags, payload);
+      ws.send(frame);
+    });
+    doWs.addEventListener("close", (event) => {
+      ws.send(stringifyJsonMsg({
+        t: "ws.close",
+        wid: msg.wid,
+        code: event.code,
+        reason: event.reason
+      }));
+      wsProxies.delete(msg.wid);
+    });
+    ws.send(stringifyJsonMsg({ t: "ws.opened", wid: msg.wid }));
+  } catch (error) {
+    ws.send(stringifyJsonMsg({
+      t: "rpc.err",
+      id: `ws_${msg.wid}`,
+      error: {
+        code: "WS_OPEN_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    }));
+  }
+}
+function handleWsClose(msg, wsProxies) {
+  const proxy = wsProxies.get(msg.wid);
+  if (proxy) {
+    proxy.doWs.close(msg.code, msg.reason);
+    wsProxies.delete(msg.wid);
+  }
+}
+async function handleHttpTransfer(request, env, url) {
+  const transferId = url.pathname.split("/").pop();
+  if (request.method === "PUT" || request.method === "POST") {
+    const [binding, ...keyParts] = (transferId ?? "").split(":");
+    const key = keyParts.join(":");
+    const bucket = env[binding];
+    if (!bucket) {
+      return new Response("Binding not found", { status: 404 });
+    }
+    const result = await bucket.put(key, request.body);
+    return new Response(JSON.stringify(result), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  if (request.method === "GET") {
+    const [binding, ...keyParts] = (transferId ?? "").split(":");
+    const key = keyParts.join(":");
+    const bucket = env[binding];
+    if (!bucket) {
+      return new Response("Binding not found", { status: 404 });
+    }
+    const object = await bucket.get(key);
+    if (!object) {
+      return new Response("Object not found", { status: 404 });
+    }
+    return new Response(object.body, {
+      headers: {
+        "Content-Type": object.httpMetadata?.contentType ?? "application/octet-stream",
+        "Content-Length": String(object.size)
+      }
+    });
+  }
+  return new Response("Method not allowed", { status: 405 });
+}
+export { server_default };

package/dist/index-n7rs26ft.js

@@ -0,0 +1,77 @@
+import {
+  canProceedWithTest,
+  clearGlobalDefaultAccountId,
+  getAccountById,
+  getAccountSummary,
+  getAccounts,
+  getAllServiceStatus,
+  getAllUsageSummaries,
+  getApiToken,
+  getEffectiveAccountId,
+  getGlobalDefaultAccountId,
+  getLimits,
+  getPrimaryAccount,
+  getServiceStatus,
+  getUsage,
+  getUsageSummary,
+  getWorkspaceAccountId,
+  getWranglerAuth,
+  hasService,
+  hasWranglerConfig,
+  isAuthenticated,
+  isWithinLimits,
+  listAIModels,
+  listD1Databases,
+  listKVNamespaces,
+  listR2Buckets,
+  listVectorizeIndexes,
+  listWorkers,
+  recordTestUsage,
+  recordUsage,
+  resetUsage,
+  setGlobalDefaultAccountId,
+  setLimits,
+  setLimitsEnabled,
+  setWorkspaceAccountId,
+  shouldSkip
+} from "./index-tfyxa77h.js";
+
+// src/cloudflare/index.ts
+var account = {
+  isAuthenticated,
+  hasWranglerConfig,
+  getApiToken,
+  getWranglerAuth,
+  getAccounts,
+  getPrimaryAccount,
+  getAccountById,
+  getAccountSummary,
+  workers: listWorkers,
+  kv: listKVNamespaces,
+  d1: listD1Databases,
+  r2: listR2Buckets,
+  vectorize: listVectorizeIndexes,
+  ai: listAIModels,
+  getServiceStatus,
+  getAllServiceStatus,
+  hasService,
+  getUsage,
+  recordUsage,
+  resetUsage,
+  getAllUsageSummaries,
+  getUsageSummary,
+  getLimits,
+  setLimits,
+  setLimitsEnabled,
+  isWithinLimits,
+  canProceedWithTest,
+  recordTestUsage,
+  shouldSkip,
+  getGlobalDefaultAccountId,
+  setGlobalDefaultAccountId,
+  getWorkspaceAccountId,
+  setWorkspaceAccountId,
+  getEffectiveAccountId,
+  clearGlobalDefaultAccountId
+};
+export { account };