@puckeditor/cloud-client 0.7.0-canary.75c0f12c → 0.7.0

package/dist/index.js

@@ -20431,7 +20431,6 @@ var processUserTool = async ({
   const responses = [];
   for (let i = 0; i < requestTools.length; i++) {
     const { name: name20, input } = requestTools[i];
-    console.info(`[PUCK] Calling user tool "${name20}"...`);
     const tool2 = tools?.[name20];
     if (!tool2) {
       throw new Error(`An unknown tool was called: ${name20}`);
@@ -20440,7 +20439,6 @@ var processUserTool = async ({
       throw new Error(`Input was not present in tool call: ${toolCallId}`);
     }
     const output = await tool2.execute(input);
-    console.info(`[PUCK] Called user tool "${name20}" successfully`);
     responses.push({ name: name20, input, output });
   }
   const res = await fetch(`${host}/tool`, {
@@ -20492,14 +20490,13 @@ var cloudApi = async (path, body, options = {}, onChunk) => {
       "No Puck API key specified. Set the PUCK_API_KEY environment variable, or provide one to the function"
     );
   }
-  const { context, collectionId, tools = {} } = ai;
+  const { context, tools = {} } = ai;
   const res = await fetch(`${host}/${path}`, {
     headers: { "x-api-key": apiKey },
     method: "post",
     body: JSON.stringify({
       ...body,
       context,
-      collectionId,
       tools: prepareUserTools(tools)
     })
   });
@@ -20549,14 +20546,13 @@ async function generate({
   config: config2,
   pageData,
   context,
-  collectionId,
   tools,
   apiKey,
   host,
   onFinish
 }) {
   let result = null;
-  const options = { ai: { context, collectionId, tools }, apiKey, host };
+  const options = { ai: { context, tools }, apiKey, host };
   await cloudApi("generate", { prompt, config: config2, pageData }, options, (chunk) => {
     if (chunk.type === "data-page") {
       result = chunk.data;
@@ -20575,143 +20571,194 @@ init_react_import();
 // src/routes.ts
 init_react_import();
 
-// src/api/plan.ts
+// src/api/attachments.ts
 init_react_import();
-
-// ../plugin-pages/api/index.ts
-init_react_import();
-var GET = async ({
-  path,
-  versionId,
-  siteId,
-  latestVersion
-}, options) => {
-  const {
-    host = "https://cloud.puckeditor.com/api",
-    ott,
-    apiKey = getApiKey()
-  } = options;
-  if (!ott && !apiKey) {
+var DEFAULT_HOST = "https://cloud.puckeditor.com/api";
+var proxyAttachment = async (path, method, body, options) => {
+  const apiKey = options.apiKey ?? getApiKey();
+  const host = (options.host ?? DEFAULT_HOST).replace(/\/+$/, "");
+  if (!apiKey) {
     throw new Error(
       "No Puck API key specified. Set the PUCK_API_KEY environment variable, or provide one to the function"
     );
   }
-  const res = await fetch(
-    `${host}/page?path=${path}${versionId ? `&versionId=${versionId}` : ""}${latestVersion ? `&latestVersion=true` : ""}`,
-    {
-      headers: {
-        ...ott ? { "x-ott": ott } : {},
-        ...apiKey && !ott ? { "x-api-key": apiKey } : {},
-        ...siteId ? { "site-id": siteId } : {}
-      }
-    }
-  );
-  if (!res.body) {
-    throw new Error(`Puck ${res.status} (${res.statusText})`);
-  } else if (!res.ok) {
-    const body = await res.json();
-    throw new Error(
-      `Puck ${res.status} (${res.statusText}): ${body.error ?? "Unknown reason"}`
+  const response = await fetch(`${host}${path}`, {
+    method,
+    redirect: "manual",
+    headers: {
+      "x-api-key": apiKey,
+      ...body ? { "content-type": "application/json" } : {}
+    },
+    ...body ? { body: JSON.stringify(body) } : {}
+  });
+  const contentType = response.headers.get("content-type");
+  const location = response.headers.get("location");
+  const headers = new Headers();
+  if (contentType) {
+    headers.set("content-type", contentType);
+  }
+  if (location) {
+    headers.set("location", location);
+  }
+  const responseBody = response.status === 204 || response.status === 304 ? null : await response.arrayBuffer();
+  return new Response(responseBody, {
+    headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+};
+var internalError = (error45) => Response.json(
+  {
+    error: error45 instanceof Error ? error45.message : "An unexpected error occurred"
+  },
+  { status: 500 }
+);
+var createAttachments = async (context, options = {}) => {
+  try {
+    return await proxyAttachment(
+      "/chat/attachments",
+      "POST",
+      context.body,
+      options
     );
+  } catch (error45) {
+    return internalError(error45);
   }
-  return res;
 };
-
-// src/api/plan.ts
-function plan({ plan: plan2, config: config2 }, options = {}) {
-  console.info(`[PUCK] Executing plan with ${plan2.pages.length} pages...`);
-  if (!process.env.PUCK_SITE_ID) {
-    throw new Error(`Please configure the PUCK_SITE_ID environment variable`);
+var getAttachment = async (context, options = {}) => {
+  try {
+    return await proxyAttachment(
+      `/chat/attachments/${context.params.attachmentId}`,
+      "GET",
+      null,
+      options
+    );
+  } catch (error45) {
+    return internalError(error45);
   }
-  const stream = createUIMessageStream({
-    execute: async ({ writer }) => {
-      writer.write({ type: "data-plan-progress", data: {} });
-      for (let i = 0; i < plan2.pages.length; i++) {
-        const page = plan2.pages[i];
-        console.info(`[PUCK] Executing prompt "${page.pagePrompt}"...`);
-        writer.write({
-          type: "data-plan-progress",
-          data: { path: page.path, status: "processing" }
-        });
-        const existingPageRes = await GET(
-          {
-            path: page.path,
-            latestVersion: true,
-            siteId: process.env.PUCK_SITE_ID
-          },
-          {
-            host: "http://localhost:3000/api",
-            apiKey: process.env.PUCK_API_KEY
-          }
-        );
-        const existingPageJson = await existingPageRes.json();
-        const existingPageData = existingPageJson.page?.versions?.at(0)?.data ?? void 0;
-        const data = await generate({
-          prompt: page.pagePrompt,
-          config: config2,
-          context: options.ai?.context,
-          pageData: existingPageData,
-          tools: options.ai?.tools,
-          host: options.host,
-          apiKey: options.apiKey
-        });
-        console.log("data", data);
-        if (!data) {
-          throw new Error(`Could not generate ${page.path}`);
-        }
-        writer.write({
-          type: "data-plan-progress",
-          data: { path: page.path, data, status: "complete" }
-        });
-        console.info(`[PUCK] Received page data`);
-        console.info(`[PUCK] Writing to pages db...`);
-        console.log(
-          { body: { data, path: page.path, status: "draft" } },
-          {
-            host: "http://localhost:3000/api",
-            siteId: process.env.PUCK_SITE_ID,
-            apiKey: process.env.PUCK_API_KEY
-          }
-        );
-        console.info(`[PUCK] Write complete`);
-      }
-    }
-  });
-  return createUIMessageStreamResponse({ stream });
-}
+};
+var deleteAttachment = async (context, options = {}) => {
+  try {
+    return await proxyAttachment(
+      `/chat/attachments/${context.params.attachmentId}`,
+      "DELETE",
+      null,
+      options
+    );
+  } catch (error45) {
+    return internalError(error45);
+  }
+};
 
 // src/routes.ts
-var routeRegistry = {
-  "/api/puck/chat": {
-    POST: chat
-  },
-  "/api/puck/plan": {
-    POST: plan
+var utf8Decoder = new TextDecoder("utf-8", { fatal: false });
+var safeDecode3 = (pathname) => pathname.replace(/(?:%[0-9a-fA-F]{2})+/g, (run) => {
+  const bytes = run.slice(1).split("%").map((pair) => Number.parseInt(pair, 16));
+  return utf8Decoder.decode(Uint8Array.from(bytes));
+});
+var normalizePathname = (pathname) => {
+  const normalized = safeDecode3(pathname).replace(/\/+$/, "");
+  return normalized.length > 0 ? normalized : "/";
+};
+var matchRoute = (pattern, pathname) => {
+  const normalizedPattern = normalizePathname(pattern);
+  const normalizedPathname = normalizePathname(pathname);
+  const patternSegments = normalizedPattern.split("/").filter(Boolean);
+  const pathSegments = normalizedPathname.split("/").filter(Boolean);
+  if (patternSegments.length !== pathSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i += 1) {
+    const patternSegment = patternSegments[i];
+    const pathSegment = pathSegments[i];
+    if (patternSegment.startsWith(":")) {
+      params[patternSegment.slice(1)] = pathSegment;
+      continue;
+    }
+    if (patternSegment !== pathSegment) {
+      return null;
+    }
   }
+  return params;
 };
-var findRoute = (pathname, method) => {
-  return routeRegistry[pathname][method];
+var routeRegistry = [
+  {
+    pattern: "/api/puck/chat/attachments/:attachmentId",
+    methods: {
+      DELETE: deleteAttachment,
+      GET: getAttachment
+    }
+  },
+  {
+    pattern: "/api/puck/chat/attachments",
+    methods: {
+      POST: createAttachments
+    }
+  },
+  {
+    pattern: "/api/puck/chat",
+    methods: {
+      POST: ({ body }, options) => chat(body, options)
+    }
+  }
+];
+var findRouteInRegistry = (routeRegistry2, pathname, method) => {
+  for (const route of routeRegistry2) {
+    const params = matchRoute(route.pattern, pathname);
+    if (!params) {
+      continue;
+    }
+    const handler = route.methods[method];
+    if (!handler) {
+      return null;
+    }
+    return {
+      handler,
+      params
+    };
+  }
+  return null;
 };
+var findRoute = (pathname, method) => findRouteInRegistry(routeRegistry, pathname, method);
 
 // src/api/puck-handler.ts
-async function puckHandler(request, options) {
+var bodyMethods = /* @__PURE__ */ new Set(["PATCH", "POST", "PUT"]);
+var isRouteMethod = (method) => method === "DELETE" || method === "GET" || method === "POST";
+var handlePuckRequest = async (request, options, findRoute2) => {
   const cloned = request.clone();
   const url2 = new URL(cloned.url);
-  const searchParams = Object.fromEntries(url2.searchParams);
+  const query = Object.fromEntries(url2.searchParams);
   const pathname = url2.pathname;
   const method = cloned.method;
-  const route = findRoute(pathname, method);
+  if (!isRouteMethod(method)) {
+    return Response.json({ error: "Not found" }, { status: 404 });
+  }
+  const route = findRoute2(pathname, method);
   if (!route) {
     return Response.json({ error: "Not found" }, { status: 404 });
   }
   let body = null;
-  if (method === "POST" || method === "PUT" || method === "PATCH") {
+  if (bodyMethods.has(method)) {
     try {
       body = await cloned.json();
-    } catch (error45) {
+    } catch {
     }
   }
-  return route(body ?? searchParams, options);
+  return route.handler(
+    {
+      body,
+      headers: cloned.headers,
+      params: route.params,
+      pathname,
+      query,
+      request: cloned
+    },
+    options
+  );
+};
+async function puckHandler(request, options = {}) {
+  return handlePuckRequest(request, options, findRoute);
 }
 
 // src/index.ts