vite-plugin-kiru 0.32.0-preview.0 → 0.32.0-preview.2

package/dist/server.d.ts

@@ -14,6 +14,30 @@ export interface ServerRenderOptions {
   context: Kiru.RequestContext
 }
 
+export interface ServerActionsMap {
+  [key: string]: () => Promise<unknown>
+}
+
 export declare function renderPage(
   options: ServerRenderOptions
 ): Promise<SSRRenderResult>
+
+export type ServerActionHttpResponse =
+  | {
+      body: string
+      statusCode: 200
+    }
+  | {
+      body: null
+      statusCode: 500
+    }
+
+export interface ServerActionResponse {
+  httpResponse: ServerActionHttpResponse | null
+}
+
+export declare function getServerActionResponse(
+  request: Request
+): Promise<ServerActionResponse>
+
+export declare function getRequestContext(): Kiru.RequestContext

package/dist/server.js

@@ -1,6 +1,7 @@
 // src/server.ts
-import path2 from "node:path";
-import fs from "node:fs";
+import path3 from "node:path";
+import fs2 from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 // ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -4108,12 +4109,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path3) {
-    if (!path3) {
+  resolve(path4) {
+    if (!path4) {
       return this;
     }
-    const rootPath = this.getRootString(path3);
-    const dir = path3.substring(rootPath.length);
+    const rootPath = this.getRootString(path4);
+    const dir = path4.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -4865,8 +4866,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path3) {
-    return win32.parse(path3).root;
+  getRootString(path4) {
+    return win32.parse(path4).root;
   }
   /**
    * @internal
@@ -4912,8 +4913,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path3) {
-    return path3.startsWith("/") ? "/" : "";
+  getRootString(path4) {
+    return path4.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -4962,8 +4963,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs2 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs2);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs3 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs3);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -5002,11 +5003,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path3 = this.cwd) {
-    if (typeof path3 === "string") {
-      path3 = this.cwd.resolve(path3);
+  depth(path4 = this.cwd) {
+    if (typeof path4 === "string") {
+      path4 = this.cwd.resolve(path4);
     }
-    return path3.depth();
+    return path4.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -5493,9 +5494,9 @@ var PathScurryBase = class {
     process2();
     return results;
   }
-  chdir(path3 = this.cwd) {
+  chdir(path4 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path3 === "string" ? this.cwd.resolve(path3) : path3;
+    this.cwd = typeof path4 === "string" ? this.cwd.resolve(path4) : path4;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -5521,8 +5522,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs2) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs2 });
+  newRoot(fs3) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -5550,8 +5551,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs2) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs2 });
+  newRoot(fs3) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -5851,8 +5852,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path3, n]) => [
-      path3,
+    return [...this.store.entries()].map(([path4, n]) => [
+      path4,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -6057,9 +6058,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path3, opts) {
+  constructor(patterns, path4, opts) {
     this.patterns = patterns;
-    this.path = path3;
+    this.path = path4;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -6078,11 +6079,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path3) {
-    return this.seen.has(path3) || !!this.#ignore?.ignored?.(path3);
+  #ignored(path4) {
+    return this.seen.has(path4) || !!this.#ignore?.ignored?.(path4);
   }
-  #childrenIgnored(path3) {
-    return !!this.#ignore?.childrenIgnored?.(path3);
+  #childrenIgnored(path4) {
+    return !!this.#ignore?.childrenIgnored?.(path4);
   }
   // backpressure mechanism
   pause() {
@@ -6297,8 +6298,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path3, opts) {
-    super(patterns, path3, opts);
+  constructor(patterns, path4, opts) {
+    super(patterns, path4, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -6335,8 +6336,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path3, opts) {
-    super(patterns, path3, opts);
+  constructor(patterns, path4, opts) {
+    super(patterns, path4, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -6658,30 +6659,144 @@ function tEntries(obj) {
 }
 
 // src/virtual-modules.ts
+var VIRTUAL_ENTRY_SERVER_ID = "virtual:kiru:entry-server";
 var VIRTUAL_ENTRY_CLIENT_ID = "virtual:kiru:entry-client";
 
 // src/globals.ts
-var VITE_DEV_SERVER_INSTANCE = {
-  get current() {
-    return (
-      // @ts-ignore
-      globalThis.KIRU_VITE_DEV_SERVER_INSTANCE ?? null
+import path2 from "node:path";
+import fs from "node:fs";
+var $KIRU_SERVER_GLOBAL = Symbol.for("kiru.server.global");
+var projectRoot = process.cwd().replace(/\\/g, "/");
+var serverOutDirAbs = path2.resolve(projectRoot, "dist/server");
+var manifestPath = path2.resolve(serverOutDirAbs, "vite-manifest.json");
+var global = globalThis[$KIRU_SERVER_GLOBAL] ??= {
+  viteDevServer: null,
+  serverEntryModule: Promise.withResolvers(),
+  route: null,
+  loadedRemoteModules: /* @__PURE__ */ new Map()
+};
+async function loadRouteRemoteModule(route) {
+  const existing = global.loadedRemoteModules.get(route);
+  if (existing) return existing;
+  const {
+    config: { remotes }
+  } = await getServerEntryModule();
+  const routeEntry = remotes[route];
+  if (!routeEntry) {
+    throw new Error(`Remote functions route not found: ${route}`);
+  }
+  const promise = remotes[route].load();
+  global.loadedRemoteModules.set(route, promise);
+  return promise;
+}
+var serverEntryLoadInitialized = false;
+async function getServerEntryModule() {
+  if (process.env.NODE_ENV === "production" && !serverEntryLoadInitialized) {
+    serverEntryLoadInitialized = true;
+    loadServerEntryModuleFromBuild();
+  }
+  return global.serverEntryModule.promise;
+}
+async function loadServerEntryModuleFromBuild() {
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(
+      `Server manifest not found at ${manifestPath}. Make sure the SSR build has been completed.`
     );
-  },
-  set current(server) {
-    globalThis.KIRU_VITE_DEV_SERVER_INSTANCE = server;
   }
-};
+  const manifest = JSON.parse(
+    fs.readFileSync(manifestPath, "utf-8")
+  );
+  const virtualEntryServerModule = Object.values(manifest).find(
+    (value) => value.src === VIRTUAL_ENTRY_SERVER_ID
+  );
+  if (!virtualEntryServerModule) {
+    throw new Error(
+      "Virtual entry server module not found in manifest. Make sure the SSR build has been completed."
+    );
+  }
+  const entryServerFile = virtualEntryServerModule.file;
+  const entryServerPath = path2.resolve(serverOutDirAbs, entryServerFile);
+  if (!fs.existsSync(entryServerPath)) {
+    throw new Error(
+      `Virtual entry server module file not found at ${entryServerPath}`
+    );
+  }
+  const fileUrl = `file://${entryServerPath.replace(/\\/g, "/")}`;
+  const mod = await import(
+    /* @vite-ignore */
+    fileUrl
+  );
+  global.serverEntryModule.resolve(mod);
+}
+
+// src/token.ts
+import crypto from "crypto";
+function makeKiruContextToken(ctx, secret) {
+  const iat = Date.now();
+  const payload = {
+    iat,
+    ctx
+  };
+  if (!secret) throw new Error("secret required");
+  return createSignedTokenHmac(payload, secret);
+}
+function unwrapKiruToken(token, secret) {
+  const payload = verifySignedTokenHmac(token, secret);
+  if (!payload) return null;
+  return payload.ctx;
+}
+function createSignedTokenHmac(payload, secret) {
+  const header = { alg: "HS256", typ: "KRT" };
+  const headerB = Buffer.from(JSON.stringify(header), "utf8");
+  const payloadB = Buffer.from(JSON.stringify(payload), "utf8");
+  const signingInput = `${base64UrlEncode(headerB)}.${base64UrlEncode(
+    payloadB
+  )}`;
+  const signature = crypto.createHmac("sha256", secret).update(signingInput).digest();
+  return `${signingInput}.${base64UrlEncode(signature)}`;
+}
+function verifySignedTokenHmac(token, secret) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const [headerB64, payloadB64, sigB64] = parts;
+    const header = JSON.parse(
+      Buffer.from(headerB64, "base64").toString("utf8")
+    );
+    if (header.typ !== "KRT") return null;
+    if (header.alg !== "HS256") return null;
+    const signingInput = `${headerB64}.${payloadB64}`;
+    const expectedSig = crypto.createHmac("sha256", secret).update(signingInput).digest();
+    const sig = base64UrlDecode(sigB64);
+    if (!crypto.timingSafeEqual(expectedSig, sig)) return null;
+    const payload = JSON.parse(
+      Buffer.from(payloadB64, "base64").toString("utf8")
+    );
+    return payload;
+  } catch (e) {
+    return null;
+  }
+}
+function base64UrlEncode(buf) {
+  const b64 = Buffer.from(buf).toString("base64");
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(s) {
+  s = s.replace(/-/g, "+").replace(/_/g, "/");
+  while (s.length % 4) s += "=";
+  return Buffer.from(s, "base64");
+}
 
 // src/server.ts
-async function getClientAssets(clientOutDirAbs, manifestPath) {
+var als = new AsyncLocalStorage();
+async function getClientAssets(clientOutDirAbs, manifestPath2) {
   let clientEntry = null;
   let manifest = null;
   try {
-    const clientManifestPath = path2.resolve(clientOutDirAbs, manifestPath);
-    if (fs.existsSync(clientManifestPath)) {
+    const clientManifestPath = path3.resolve(clientOutDirAbs, manifestPath2);
+    if (fs2.existsSync(clientManifestPath)) {
       const parsedManifest = JSON.parse(
-        fs.readFileSync(clientManifestPath, "utf-8")
+        fs2.readFileSync(clientManifestPath, "utf-8")
       );
       manifest = parsedManifest;
       if (parsedManifest[VIRTUAL_ENTRY_CLIENT_ID]?.file) {
@@ -6692,7 +6807,7 @@ async function getClientAssets(clientOutDirAbs, manifestPath) {
   }
   return { clientEntry, manifest };
 }
-function collectCssForModules(manifest, moduleIds, projectRoot) {
+function collectCssForModules(manifest, moduleIds, projectRoot2) {
   if (!manifest) return "";
   const seen = /* @__PURE__ */ new Set();
   const cssFiles = /* @__PURE__ */ new Set();
@@ -6714,8 +6829,8 @@ function collectCssForModules(manifest, moduleIds, projectRoot) {
   }
   for (const moduleId of moduleIds) {
     let normalizedId = moduleId.replace(/\\/g, "/");
-    if (normalizedId.startsWith(projectRoot)) {
-      normalizedId = normalizedId.substring(projectRoot.length);
+    if (normalizedId.startsWith(projectRoot2)) {
+      normalizedId = normalizedId.substring(projectRoot2.length);
     }
     if (normalizedId.startsWith("/")) {
       normalizedId = normalizedId.substring(1);
@@ -6734,8 +6849,8 @@ function collectCssForModules(manifest, moduleIds, projectRoot) {
     }
     for (const key in manifestRef) {
       const keyNormalized = key.replace(/\\/g, "/");
-      const moduleBaseName = path2.basename(normalizedId);
-      const keyBaseName = path2.basename(keyNormalized);
+      const moduleBaseName = path3.basename(normalizedId);
+      const keyBaseName = path3.basename(keyNormalized);
       if ((keyNormalized.endsWith(normalizedId) || normalizedId.endsWith(keyNormalized)) && moduleBaseName === keyBaseName) {
         collectCss(key);
         break;
@@ -6749,9 +6864,10 @@ function collectCssForModules(manifest, moduleIds, projectRoot) {
   return "";
 }
 async function renderPage(options) {
-  const { render, documentModuleId } = await import("virtual:kiru:entry-server");
+  const { render, documentModuleId, remoteFunctionSecret } = await getServerEntryModule();
   const moduleIds = [documentModuleId];
-  const projectRoot = process.cwd().replace(/\\/g, "/");
+  const projectRoot2 = process.cwd().replace(/\\/g, "/");
+  als.enterWith(options.context);
   const { httpResponse } = await render(options.url, {
     userContext: options.context,
     registerModule(moduleId) {
@@ -6759,9 +6875,7 @@ async function renderPage(options) {
     }
   });
   if (httpResponse === null) {
-    return {
-      httpResponse: null
-    };
+    return { httpResponse: null };
   }
   const isDevelopment = process.env.NODE_ENV !== "production";
   let html = httpResponse.html;
@@ -6780,8 +6894,8 @@ async function renderPage(options) {
       }
     };
     for (const id of moduleIds) {
-      const p = path2.join(projectRoot, id).replace(/\\/g, "/");
-      const mod = VITE_DEV_SERVER_INSTANCE.current.moduleGraph.getModuleById(p);
+      const p = path3.join(projectRoot2, id).replace(/\\/g, "/");
+      const mod = global.viteDevServer.moduleGraph.getModuleById(p);
       if (!mod) {
         console.error(`Module not found: ${p}`);
         continue;
@@ -6789,24 +6903,24 @@ async function renderPage(options) {
       scan(mod);
     }
     const localModules = Array.from(importedModules).filter(
-      (m) => m.id?.startsWith(projectRoot)
+      (m) => m.id?.startsWith(projectRoot2)
     );
     const cssModules = localModules.filter((m) => m.id?.endsWith(".css"));
     if (cssModules.length) {
       const stylesheets = cssModules.map((mod) => {
-        const p = mod.id?.replace(projectRoot, "");
+        const p = mod.id?.replace(projectRoot2, "");
         return `<link rel="stylesheet" type="text/css" href="${p}?temp">`;
       });
       html = html.replace("<head>", "<head>" + stylesheets.join("\n"));
     }
   } else {
-    const clientOutDirAbs = path2.resolve(projectRoot, "dist/client");
+    const clientOutDirAbs = path3.resolve(projectRoot2, "dist/client");
     const { clientEntry, manifest } = await getClientAssets(
       clientOutDirAbs,
       "vite-manifest.json"
     );
     if (manifest) {
-      const cssLinks = collectCssForModules(manifest, moduleIds, projectRoot);
+      const cssLinks = collectCssForModules(manifest, moduleIds, projectRoot2);
       if (cssLinks) {
         html = html.replace("<head>", "<head>" + cssLinks);
       }
@@ -6821,6 +6935,14 @@ async function renderPage(options) {
     "</head>",
     `<script type="application/json" k-request-context>${contextString}</script></head>`
   );
+  const token = makeKiruContextToken(
+    options.context,
+    remoteFunctionSecret
+  );
+  html = html.replace(
+    "</head>",
+    `<script type="application/json" k-request-token>${token}</script></head>`
+  );
   return {
     httpResponse: {
       ...httpResponse,
@@ -6828,6 +6950,70 @@ async function renderPage(options) {
     }
   };
 }
+async function getServerActionResponse(request) {
+  let action;
+  let actionArgs = [];
+  let context;
+  const { searchParams } = new URL(request.url);
+  try {
+    let strToken, actionId;
+    if (request.method !== "POST" || request.headers.get("Content-Type") !== "application/json" || !(strToken = request.headers.get("x-kiru-token")) || !(actionId = searchParams.get("action"))) {
+      return { httpResponse: null };
+    }
+    const [route, actionName] = actionId.split(".");
+    await loadRouteRemoteModule(route);
+    const {
+      config: { actions },
+      remoteFunctionSecret
+    } = await getServerEntryModule();
+    const ctx = unwrapKiruToken(strToken, remoteFunctionSecret);
+    if (!ctx) {
+      return createBadActionResponse();
+    }
+    const fileActions = actions.get(route);
+    const actionFn = fileActions[actionName];
+    const args = await request.json();
+    if (typeof actionFn !== "function" || !Array.isArray(args)) {
+      return createBadActionResponse();
+    }
+    action = actionFn;
+    actionArgs = args;
+    context = ctx;
+  } catch {
+    return createBadActionResponse();
+  }
+  return new Promise(async (resolve) => {
+    als.run({ ...context }, async () => {
+      try {
+        const result = await action(...actionArgs);
+        resolve({
+          httpResponse: {
+            body: JSON.stringify(result),
+            statusCode: 200
+          }
+        });
+      } catch {
+        resolve(createBadActionResponse());
+      }
+    });
+  });
+}
+function createBadActionResponse() {
+  return {
+    httpResponse: { body: null, statusCode: 500 }
+  };
+}
+function getRequestContext() {
+  const ctx = als.getStore();
+  if (ctx === void 0) {
+    throw new Error(
+      "[vite-plugin-kiru]: Invalid `getRequestContext` invocation."
+    );
+  }
+  return ctx;
+}
 export {
+  getRequestContext,
+  getServerActionResponse,
   renderPage
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-kiru",
-  "version": "0.32.0-preview.0",
+  "version": "0.32.0-preview.2",
   "description": "",
   "main": "dist/index.js",
   "type": "module",
@@ -19,7 +19,7 @@
     }
   },
   "peerDependencies": {
-    "kiru": ">=0.54.0-preview.0"
+    "kiru": ">=0.54.0-preview.1"
   },
   "devDependencies": {
     "@types/node": "^22.17.0",
@@ -27,14 +27,15 @@
     "rollup": "^4.46.2",
     "tsx": "^4.20.3",
     "typescript": "^5.9.2",
-    "kiru-devtools-client": "^0.0.0",
     "kiru-devtools-host": "^1.0.0",
-    "kiru": "^0.54.0-preview.0"
+    "kiru-devtools-client": "^0.0.0",
+    "kiru": "^0.54.0-preview.1"
   },
   "dependencies": {
     "glob": "^12.0.0",
     "magic-string": "^0.30.17",
     "mime": "^4.1.0",
+    "minimatch": "10.1.1",
     "vite": "^7.2.2"
   },
   "scripts": {