opencami 1.8.9 → 1.9.0

package/dist/server/assets/{thinking-CA8PSwKJ.js → thinking-CHx4Oouj.js}

@@ -1,32 +1,32 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useState, useEffect } from "react";
-import { C as Collapsible, d as CollapsibleTrigger, e as CollapsiblePanel } from "./_sessionKey-B6iYeyCS.js";
+import { C as Collapsible, d as CollapsibleTrigger, e as CollapsiblePanel } from "./_sessionKey-Bhksr7VP.js";
 import { HugeiconsIcon } from "@hugeicons/react";
 import { ArrowDown01Icon } from "@hugeicons/core-free-icons";
-import { B as Button } from "./button-CwY2OHFj.js";
+import { B as Button } from "./button-kI8fEIZQ.js";
 import "@tanstack/react-router";
 import "@tanstack/react-query";
-import "./tooltip-DgsSPocE.js";
+import "./tooltip-DOvOrSSS.js";
 import "@base-ui/react/tooltip";
 import "motion/react";
 import "@base-ui/react/alert-dialog";
-import "./use-file-explorer-state-s7CS50ho.js";
+import "./use-file-explorer-state-E6cUvMva.js";
 import "@base-ui/react/dialog";
 import "zustand";
 import "@base-ui/react/collapsible";
 import "@base-ui/react/scroll-area";
-import "./menu-D90CDTi2.js";
+import "./menu-D8cKTpmN.js";
 import "@base-ui/react/menu";
 import "./opencami-logo-C-43FL3R.js";
-import "./markdown-DoX5Q7qh.js";
+import "./markdown-CFdYXCRQ.js";
 import "marked";
 import "react-markdown";
 import "remark-breaks";
 import "remark-gfm";
-import "./index-BEWnDAH6.js";
+import "./index-B_F4DTUu.js";
 import "zustand/middleware";
 import "react-dom";
-import "./router-BqLGFd4L.js";
+import "./router-C9JRmWMm.js";
 import "node:crypto";
 import "node:fs";
 import "node:os";

package/dist/server/assets/{tooltip-DgsSPocE.js → tooltip-DOvOrSSS.js}

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { Tooltip } from "@base-ui/react/tooltip";
-import { c as cn } from "./button-CwY2OHFj.js";
+import { c as cn } from "./button-kI8fEIZQ.js";
 const defaultChatUiState = {
   isSidebarCollapsed: false
 };

package/dist/server/assets/{use-file-explorer-state-s7CS50ho.js → use-file-explorer-state-E6cUvMva.js}

@@ -1,6 +1,6 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Dialog } from "@base-ui/react/dialog";
-import { c as cn, B as Button } from "./button-CwY2OHFj.js";
+import { c as cn, B as Button } from "./button-kI8fEIZQ.js";
 import { create } from "zustand";
 function DialogRoot({ children, ...props }) {
   return /* @__PURE__ */ jsx(Dialog.Root, { ...props, children });

package/dist/server/server.js

@@ -184,19 +184,11 @@ function getResponse() {
   return event.res;
 }
 async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-C9chPgNH.js");
+  const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-D-5ReiD4.js");
   const startManifest = tsrStartManifest();
   const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
   rootRoute.assets = rootRoute.assets || [];
-  let script = `import('${startManifest.clientEntry}')`;
-  rootRoute.assets.push({
-    tag: "script",
-    attrs: {
-      type: "module",
-      async: true
-    },
-    children: script
-  });
+  let injectedHeadScripts;
   const manifest2 = {
     routes: Object.fromEntries(
       Object.entries(startManifest.routes).flatMap(([k, v]) => {
@@ -217,7 +209,11 @@ async function getStartManifest(matchedRoutes) {
       })
     )
   };
-  return manifest2;
+  return {
+    manifest: manifest2,
+    clientEntry: startManifest.clientEntry,
+    injectedHeadScripts
+  };
 }
 const textEncoder$1 = new TextEncoder();
 const EMPTY_PAYLOAD = new Uint8Array(0);
@@ -375,10 +371,6 @@ const handleServerAction = async ({
   context,
   serverFnId
 }) => {
-  const controller = new AbortController();
-  const signal = controller.signal;
-  const abort = () => controller.abort();
-  request.signal.addEventListener("abort", abort);
   const method = request.method;
   const methodUpper = method.toUpperCase();
   const methodLower = method.toLowerCase();
@@ -446,17 +438,17 @@ const handleServerAction = async ({
           }
           if (rawStreams.size > 0) {
             const jsonStream = new ReadableStream({
-              start(controller2) {
+              start(controller) {
                 callbacks.onParse = (value) => {
-                  controller2.enqueue(JSON.stringify(value) + "\n");
+                  controller.enqueue(JSON.stringify(value) + "\n");
                 };
                 callbacks.onDone = () => {
                   try {
-                    controller2.close();
+                    controller.close();
                   } catch {
                   }
                 };
-                callbacks.onError = (error) => controller2.error(error);
+                callbacks.onError = (error) => controller.error(error);
                 if (nonStreamingBody !== void 0) {
                   callbacks.onParse(nonStreamingBody);
                 }
@@ -476,18 +468,18 @@ const handleServerAction = async ({
             });
           }
           const stream = new ReadableStream({
-            start(controller2) {
-              callbacks.onParse = (value) => controller2.enqueue(
+            start(controller) {
+              callbacks.onParse = (value) => controller.enqueue(
                 textEncoder.encode(JSON.stringify(value) + "\n")
               );
               callbacks.onDone = () => {
                 try {
-                  controller2.close();
+                  controller.close();
                 } catch (error) {
-                  controller2.error(error);
+                  controller.error(error);
                 }
               };
-              callbacks.onError = (error) => controller2.error(error);
+              callbacks.onError = (error) => controller.error(error);
               if (nonStreamingBody !== void 0) {
                 callbacks.onParse(nonStreamingBody);
               }
@@ -539,7 +531,7 @@ const handleServerAction = async ({
               if (false) ;
             }
           }
-          return await action(params, signal);
+          return await action(params);
         }
         if (methodLower === "get") {
           const payloadParam = url.searchParams.get("payload");
@@ -549,7 +541,7 @@ const handleServerAction = async ({
           const payload2 = payloadParam ? parsePayload(JSON.parse(payloadParam)) : {};
           payload2.context = safeObjectMerge(context, payload2.context);
           payload2.method = methodUpper;
-          return await action(payload2, signal);
+          return await action(payload2);
         }
         if (methodLower !== "post") {
           throw new Error("expected POST method");
@@ -561,7 +553,7 @@ const handleServerAction = async ({
         const payload = jsonPayload ? parsePayload(jsonPayload) : {};
         payload.context = safeObjectMerge(payload.context, context);
         payload.method = methodUpper;
-        return await action(payload, signal);
+        return await action(payload);
       })();
       const unwrapped = res.result || res.error;
       if (isNotFound(res)) {
@@ -609,7 +601,6 @@ const handleServerAction = async ({
       });
     }
   })();
-  request.signal.removeEventListener("abort", abort);
   return response;
 };
 function isNotFoundResponse(error) {
@@ -622,6 +613,111 @@ function isNotFoundResponse(error) {
     }
   });
 }
+function resolveTransformConfig(transform) {
+  if (typeof transform === "string") {
+    const prefix = transform;
+    return {
+      type: "transform",
+      transformFn: ({ url }) => `${prefix}${url}`,
+      cache: true
+    };
+  }
+  if (typeof transform === "function") {
+    return {
+      type: "transform",
+      transformFn: transform,
+      cache: true
+    };
+  }
+  if ("createTransform" in transform && transform.createTransform) {
+    return {
+      type: "createTransform",
+      createTransform: transform.createTransform,
+      cache: transform.cache !== false
+    };
+  }
+  const transformFn = typeof transform.transform === "string" ? (({ url }) => `${transform.transform}${url}`) : transform.transform;
+  return {
+    type: "transform",
+    transformFn,
+    cache: transform.cache !== false
+  };
+}
+function buildClientEntryScriptTag(clientEntry, injectedHeadScripts) {
+  const clientEntryLiteral = JSON.stringify(clientEntry);
+  let script = `import(${clientEntryLiteral})`;
+  if (injectedHeadScripts) {
+    script = `${injectedHeadScripts};${script}`;
+  }
+  return {
+    tag: "script",
+    attrs: {
+      type: "module",
+      async: true
+    },
+    children: script
+  };
+}
+function transformManifestUrls(source, transformFn, opts) {
+  return (async () => {
+    const manifest2 = opts?.clone ? structuredClone(source.manifest) : source.manifest;
+    for (const route of Object.values(manifest2.routes)) {
+      if (route.preloads) {
+        route.preloads = await Promise.all(
+          route.preloads.map(
+            (url) => Promise.resolve(transformFn({ url, type: "modulepreload" }))
+          )
+        );
+      }
+      if (route.assets) {
+        for (const asset of route.assets) {
+          if (asset.tag === "link" && asset.attrs?.href) {
+            asset.attrs.href = await Promise.resolve(
+              transformFn({
+                url: asset.attrs.href,
+                type: "stylesheet"
+              })
+            );
+          }
+        }
+      }
+    }
+    const transformedClientEntry = await Promise.resolve(
+      transformFn({
+        url: source.clientEntry,
+        type: "clientEntry"
+      })
+    );
+    const rootRoute = manifest2.routes[rootRouteId];
+    if (rootRoute) {
+      rootRoute.assets = rootRoute.assets || [];
+      rootRoute.assets.push(
+        buildClientEntryScriptTag(
+          transformedClientEntry,
+          source.injectedHeadScripts
+        )
+      );
+    }
+    return manifest2;
+  })();
+}
+function buildManifestWithClientEntry(source) {
+  const scriptTag = buildClientEntryScriptTag(
+    source.clientEntry,
+    source.injectedHeadScripts
+  );
+  const baseRootRoute = source.manifest.routes[rootRouteId];
+  const routes = {
+    ...source.manifest.routes,
+    ...baseRootRoute ? {
+      [rootRouteId]: {
+        ...baseRootRoute,
+        assets: [...baseRootRoute.assets || [], scriptTag]
+      }
+    } : {}
+  };
+  return { routes };
+}
 const HEADERS = {
   TSS_SHELL: "X-TSS_SHELL"
 };
@@ -654,9 +750,10 @@ function getStartResponseHeaders(opts) {
   return headers;
 }
 let entriesPromise;
-let manifestPromise;
+let baseManifestPromise;
+let cachedFinalManifestPromise;
 async function loadEntries() {
-  const routerEntry = await import("./assets/router-BqLGFd4L.js").then((n) => n.r);
+  const routerEntry = await import("./assets/router-C9JRmWMm.js").then((n) => n.r);
   const startEntry = await import("./assets/start-HYkvq4Ni.js");
   return { startEntry, routerEntry };
 }
@@ -666,11 +763,24 @@ function getEntries() {
   }
   return entriesPromise;
 }
-function getManifest(matchedRoutes) {
-  if (!manifestPromise) {
-    manifestPromise = getStartManifest();
+function getBaseManifest(matchedRoutes) {
+  if (!baseManifestPromise) {
+    baseManifestPromise = getStartManifest();
   }
-  return manifestPromise;
+  return baseManifestPromise;
+}
+async function resolveManifest(matchedRoutes, transformFn, cache) {
+  const base = await getBaseManifest();
+  const computeFinalManifest = async () => {
+    return transformFn ? await transformManifestUrls(base, transformFn, { clone: !cache }) : buildManifestWithClientEntry(base);
+  };
+  if (!transformFn || cache) {
+    if (!cachedFinalManifestPromise) {
+      cachedFinalManifestPromise = computeFinalManifest();
+    }
+    return cachedFinalManifestPromise;
+  }
+  return computeFinalManifest();
 }
 const ROUTER_BASEPATH = "/";
 const SERVER_FN_BASE = "/_serverFn/";
@@ -744,14 +854,52 @@ function handlerToMiddleware(handler, mayDefer = false) {
     return response;
   };
 }
-function createStartHandler(cb) {
+function createStartHandler(cbOrOptions) {
+  const cb = typeof cbOrOptions === "function" ? cbOrOptions : cbOrOptions.handler;
+  const transformAssetUrlsOption = typeof cbOrOptions === "function" ? void 0 : cbOrOptions.transformAssetUrls;
+  const warmupTransformManifest = !!transformAssetUrlsOption && typeof transformAssetUrlsOption === "object" && transformAssetUrlsOption.warmup === true;
+  const resolvedTransformConfig = transformAssetUrlsOption ? resolveTransformConfig(transformAssetUrlsOption) : void 0;
+  const cache = resolvedTransformConfig ? resolvedTransformConfig.cache : true;
+  let cachedCreateTransformPromise;
+  const getTransformFn = async (opts) => {
+    if (!resolvedTransformConfig) return void 0;
+    if (resolvedTransformConfig.type === "createTransform") {
+      if (cache) {
+        if (!cachedCreateTransformPromise) {
+          cachedCreateTransformPromise = Promise.resolve(
+            resolvedTransformConfig.createTransform(opts)
+          );
+        }
+        return cachedCreateTransformPromise;
+      }
+      return resolvedTransformConfig.createTransform(opts);
+    }
+    return resolvedTransformConfig.transformFn;
+  };
+  if (warmupTransformManifest && cache && true && !cachedFinalManifestPromise) {
+    const warmupPromise = (async () => {
+      const base = await getBaseManifest();
+      const transformFn = await getTransformFn({ warmup: true });
+      return transformFn ? await transformManifestUrls(base, transformFn, { clone: false }) : buildManifestWithClientEntry(base);
+    })();
+    cachedFinalManifestPromise = warmupPromise;
+    warmupPromise.catch(() => {
+      if (cachedFinalManifestPromise === warmupPromise) {
+        cachedFinalManifestPromise = void 0;
+      }
+      cachedCreateTransformPromise = void 0;
+    });
+  }
   const startRequestResolver = async (request, requestOpts) => {
     let router = null;
     let cbWillCleanup = false;
     try {
-      const url = getNormalizedURL(request.url);
+      const { url, handledProtocolRelativeURL } = getNormalizedURL(request.url);
       const href = url.pathname + url.search + url.hash;
       const origin = getOrigin(request);
+      if (handledProtocolRelativeURL) {
+        return Response.redirect(url, 308);
+      }
       const entries = await getEntries();
       const startOptions = await entries.startEntry.startInstance?.getOptions() || {};
       const serializationAdapters = [
@@ -818,6 +966,7 @@ function createStartHandler(cb) {
         );
         const ctx2 = await executeMiddleware([...middlewares2, serverFnHandler], {
           request,
+          pathname: url.pathname,
           context: createNullProtoObject(requestOpts?.context)
         });
         return handleRedirectResponse(ctx2.response, request, getRouter);
@@ -835,7 +984,11 @@ function createStartHandler(cb) {
             { status: 500 }
           );
         }
-        const manifest2 = await getManifest(matchedRoutes);
+        const manifest2 = await resolveManifest(
+          matchedRoutes,
+          await getTransformFn({ warmup: false, request }),
+          cache
+        );
         const routerInstance = await getRouter();
         attachRouterServerSsrUtils({
           router: routerInstance,
@@ -890,7 +1043,11 @@ function createStartHandler(cb) {
       );
       const ctx = await executeMiddleware(
         [...middlewares, requestHandlerMiddleware],
-        { request, context: createNullProtoObject(requestOpts?.context) }
+        {
+          request,
+          pathname: url.pathname,
+          context: createNullProtoObject(requestOpts?.context)
+        }
       );
       return handleRedirectResponse(ctx.response, request, getRouter);
     } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencami",
-  "version": "1.8.9",
+  "version": "1.9.0",
   "type": "module",
   "description": "OpenCami - A beautiful web client for OpenClaw",
   "bin": {