gencow 0.1.151 → 0.1.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.151",
+  "version": "0.1.153",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {

package/server/index.js

@@ -20610,8 +20610,8 @@ var init_pdf = __esm({
         this._readCapability = Promise.withResolvers();
         this._headersCapability = Promise.withResolvers();
         const fs4 = process.getBuiltinModule("fs");
-        fs4.promises.lstat(this._url).then((stat4) => {
-          this._contentLength = stat4.size;
+        fs4.promises.lstat(this._url).then((stat5) => {
+          this._contentLength = stat5.size;
           this._setReadableStream(fs4.createReadStream(this._url));
           this._headersCapability.resolve();
         }, (error) => {
@@ -88535,14 +88535,20 @@ var DEFAULT_TIMEOUT_RESTART_THRESHOLD = 3;
 var DEFAULT_TIMEOUT_RESTART_WINDOW_MS = 6e4;
 var DEFAULT_TIMEOUT_RESTART_DELAY_MS = 250;
 var DEFAULT_TIMEOUT_RESTART_KINDS = ["query", "mutation"];
+var DEFAULT_FUNCTION_SLOW_LOG_MS = 1e4;
 var timeoutWindowStartMs = 0;
 var timeoutCountInWindow = 0;
 var timeoutRestartScheduled = false;
 var timeoutFunctionNames = [];
+var functionInvocationSequence = 0;
 function parsePositiveInteger(value, fallback) {
   const parsed = Number(value);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
+function parseNonNegativeInteger(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
 function parseRestartKinds(value) {
   if (!value?.trim()) return [...DEFAULT_TIMEOUT_RESTART_KINDS];
   const allowed = /* @__PURE__ */ new Set(["query", "mutation", "httpAction", "cron"]);
@@ -88569,6 +88575,20 @@ function resolveFunctionTimeoutRestartPolicy(env2 = process.env) {
     kinds: parseRestartKinds(env2.GENCOW_FUNCTION_TIMEOUT_RESTART_KINDS)
   };
 }
+function resolveFunctionSlowLogMs(env2 = process.env) {
+  return parseNonNegativeInteger(env2.GENCOW_FUNCTION_SLOW_LOG_MS, DEFAULT_FUNCTION_SLOW_LOG_MS);
+}
+function nextFunctionInvocationId() {
+  functionInvocationSequence = functionInvocationSequence >= Number.MAX_SAFE_INTEGER ? 1 : functionInvocationSequence + 1;
+  return `${Date.now().toString(36)}-${functionInvocationSequence}`;
+}
+function formatErrorForRuntimeLog(error) {
+  const record = error;
+  const name = typeof record?.name === "string" ? record.name : "Error";
+  const code = typeof record?.code === "string" ? ` code=${record.code}` : "";
+  const message = typeof record?.message === "string" ? record.message.replace(/\s+/g, " ").slice(0, 300) : String(error).replace(/\s+/g, " ").slice(0, 300);
+  return `name=${name}${code} message="${message}"`;
+}
 function recordFunctionTimeout(event, runtime = {}) {
   const env2 = runtime.env ?? process.env;
   const policy = resolveFunctionTimeoutRestartPolicy(env2);
@@ -88600,13 +88620,40 @@ function recordFunctionTimeout(event, runtime = {}) {
 }
 async function executeWithTimeout(fn, type, functionName, timeouts = FUNCTION_TIMEOUTS, restartRuntime) {
   const timeoutMs = timeouts[type];
+  const invocationId = nextFunctionInvocationId();
+  const startedAt = Date.now();
+  const logger2 = restartRuntime?.logger ?? console;
+  const slowLogMs = resolveFunctionSlowLogMs(restartRuntime?.env);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let timedOut = false;
+  const work = Promise.resolve().then(fn);
+  work.then(
+    () => {
+      if (!timedOut) return;
+      const elapsedMs = Date.now() - startedAt;
+      logger2.warn(
+        `[runtime] function completed after timeout id=${invocationId} type=${type} name="${functionName}" elapsedMs=${elapsedMs} timeoutMs=${timeoutMs}`
+      );
+    },
+    (error) => {
+      if (!timedOut) return;
+      const elapsedMs = Date.now() - startedAt;
+      logger2.error(
+        `[runtime] function failed after timeout id=${invocationId} type=${type} name="${functionName}" elapsedMs=${elapsedMs} timeoutMs=${timeoutMs} ${formatErrorForRuntimeLog(error)}`
+      );
+    }
+  );
   try {
-    return await Promise.race([
-      fn(),
+    const result2 = await Promise.race([
+      work,
       new Promise((_3, reject2) => {
         controller.signal.addEventListener("abort", () => {
+          timedOut = true;
+          const elapsedMs2 = Date.now() - startedAt;
+          logger2.error(
+            `[runtime] function timeout id=${invocationId} type=${type} name="${functionName}" elapsedMs=${elapsedMs2} timeoutMs=${timeoutMs}`
+          );
           recordFunctionTimeout({ type, functionName, timeoutMs }, restartRuntime);
           const error = new Error(
             `Function "${functionName}" exceeded ${timeoutMs / 1e3}s time limit. Split into smaller mutations and call them sequentially from the frontend. Limits: query 30s, mutation 30s, httpAction 5min, cron 10min.`
@@ -88616,6 +88663,22 @@ async function executeWithTimeout(fn, type, functionName, timeouts = FUNCTION_TI
         });
       })
     ]);
+    const elapsedMs = Date.now() - startedAt;
+    if (slowLogMs > 0 && elapsedMs >= slowLogMs) {
+      logger2.warn(
+        `[runtime] function slow id=${invocationId} type=${type} name="${functionName}" elapsedMs=${elapsedMs} thresholdMs=${slowLogMs}`
+      );
+    }
+    return result2;
+  } catch (error) {
+    const elapsedMs = Date.now() - startedAt;
+    const code = error?.code;
+    if (code !== "FUNCTION_TIMEOUT" && slowLogMs > 0 && elapsedMs >= slowLogMs) {
+      logger2.warn(
+        `[runtime] function slow failed id=${invocationId} type=${type} name="${functionName}" elapsedMs=${elapsedMs} thresholdMs=${slowLogMs} ${formatErrorForRuntimeLog(error)}`
+      );
+    }
+    throw error;
   } finally {
     clearTimeout(timer);
   }
@@ -92725,7 +92788,9 @@ var getNodeRouteMetricsSnapshot = mod2.getNodeRouteMetricsSnapshot;
 var resetNodeRouteMetricsForTests = mod2.resetNodeRouteMetricsForTests;
 
 // ../server/src/server-platform-static-file.ts
-import { join as join2 } from "path";
+import { extname as extname2, join as join2 } from "path";
+import { brotliCompressSync, gzipSync } from "zlib";
+import { stat } from "fs/promises";
 
 // ../server/src/static-file-routing.ts
 import { extname, isAbsolute, relative as relative2, resolve as resolve7 } from "path";
@@ -92848,6 +92913,65 @@ async function resolveStaticFileRequest(params) {
 }
 
 // ../server/src/server-platform-static-file.ts
+var compressibleStaticExtensions = /* @__PURE__ */ new Set([
+  ".css",
+  ".csv",
+  ".htm",
+  ".html",
+  ".js",
+  ".json",
+  ".mjs",
+  ".svg",
+  ".txt",
+  ".wasm",
+  ".webmanifest",
+  ".xml"
+]);
+var encodedFileCache = /* @__PURE__ */ new Map();
+var encodedFileCacheTtlMs = 10 * 60 * 1e3;
+var encodedFileCacheMaxEntries = 240;
+function acceptsEncoding(value, encoding) {
+  const tokens = value.toLowerCase().split(",").map((part) => part.trim());
+  return tokens.some((token) => {
+    if (!token.startsWith(encoding)) return false;
+    const q = token.match(/;\s*q=([0-9.]+)/)?.[1];
+    return q === void 0 || Number(q) > 0;
+  });
+}
+function requestHeader(c, name) {
+  const direct = c?.req?.header?.(name);
+  if (typeof direct === "string") return direct;
+  const fromHeaders = c?.req?.headers?.get?.(name);
+  return typeof fromHeaders === "string" ? fromHeaders : "";
+}
+function preferredStaticEncoding(acceptEncoding, filePath) {
+  if (!compressibleStaticExtensions.has(extname2(filePath).toLowerCase())) return null;
+  if (acceptsEncoding(acceptEncoding, "br")) return "br";
+  if (acceptsEncoding(acceptEncoding, "gzip")) return "gzip";
+  return null;
+}
+function pruneEncodedFileCache(now = Date.now()) {
+  for (const [key, value] of encodedFileCache) {
+    if (now - value.createdAt > encodedFileCacheTtlMs) encodedFileCache.delete(key);
+  }
+  while (encodedFileCache.size > encodedFileCacheMaxEntries) {
+    const oldest = encodedFileCache.keys().next().value;
+    if (!oldest) break;
+    encodedFileCache.delete(oldest);
+  }
+}
+async function encodedStaticFile(filePath, encoding, originalSize) {
+  const stats = await stat(filePath).catch(() => null);
+  const cacheKey = `${filePath}:${stats?.mtimeMs ?? 0}:${originalSize}:${encoding}`;
+  pruneEncodedFileCache();
+  const cached = encodedFileCache.get(cacheKey);
+  if (cached) return cached.body;
+  const input = Buffer.from(await Bun.file(filePath).arrayBuffer());
+  const output = encoding === "br" ? brotliCompressSync(input) : gzipSync(input);
+  if (output.byteLength >= input.byteLength) return null;
+  encodedFileCache.set(cacheKey, { body: output, createdAt: Date.now() });
+  return output;
+}
 async function serveStaticFile(params) {
   const staticDir = join2(params.dataDir, "static");
   const resolution = await resolveStaticFileRequest({
@@ -92862,14 +92986,23 @@ async function serveStaticFile(params) {
   const file = Bun.file(resolution.filePath);
   const fileSize = file.size;
   const requestMethod = String(params.c?.req?.method ?? "").toUpperCase();
-  if (requestMethod !== "HEAD" && Number.isSafeInteger(fileSize) && fileSize > 0) {
-    params.recordBytes?.(fileSize);
+  const encoding = preferredStaticEncoding(requestHeader(params.c, "Accept-Encoding"), resolution.filePath);
+  const encodedBody = encoding && Number.isSafeInteger(fileSize) && fileSize > 0 ? await encodedStaticFile(resolution.filePath, encoding, fileSize) : null;
+  const responseBody = encodedBody ? new Uint8Array(encodedBody) : file;
+  const responseBytes = encodedBody?.byteLength ?? fileSize;
+  if (requestMethod !== "HEAD" && Number.isSafeInteger(responseBytes) && responseBytes > 0) {
+    params.recordBytes?.(responseBytes);
   }
   const headers = new Headers({ "Cache-Control": resolution.cacheControl });
-  if (Number.isSafeInteger(fileSize) && fileSize >= 0) {
-    headers.set("Content-Length", String(fileSize));
+  if (encodedBody && encoding) {
+    headers.set("Content-Encoding", encoding);
+    headers.set("Vary", "Accept-Encoding");
   }
-  return new Response(file, {
+  if (file.type) headers.set("Content-Type", file.type);
+  if (Number.isSafeInteger(responseBytes) && responseBytes >= 0) {
+    headers.set("Content-Length", String(responseBytes));
+  }
+  return new Response(requestMethod === "HEAD" ? null : responseBody, {
     headers
   });
 }
@@ -97137,7 +97270,7 @@ import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve20 } from "path";
 
 // ../../node_modules/.pnpm/hono@4.12.18/node_modules/hono/dist/adapter/bun/serve-static.js
-import { stat } from "node:fs/promises";
+import { stat as stat2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
 
 // ../../node_modules/.pnpm/hono@4.12.18/node_modules/hono/dist/utils/compress.js
@@ -97313,7 +97446,7 @@ var serveStatic2 = (options) => {
     const isDir = async (path3) => {
       let isDir2;
       try {
-        const stats = await stat(path3);
+        const stats = await stat2(path3);
         isDir2 = stats.isDirectory();
       } catch {
       }
@@ -97761,11 +97894,11 @@ async function loadStorageMeta(params) {
   try {
     const raw2 = await fs.readFile(`${filePath}.meta`, "utf-8");
     const parsed = JSON.parse(raw2);
-    const stat4 = await fs.stat(filePath);
+    const stat5 = await fs.stat(filePath);
     const meta = {
       id: params.storageId,
       name: typeof parsed.name === "string" ? parsed.name : params.storageId,
-      size: typeof parsed.size === "number" ? parsed.size : stat4.size,
+      size: typeof parsed.size === "number" ? parsed.size : stat5.size,
       type: typeof parsed.type === "string" ? parsed.type : "application/octet-stream",
       visibility: normalizeStorageVisibility(parsed.visibility),
       path: filePath
@@ -99151,6 +99284,9 @@ function isAuthorizedCronToken(token, internalToken, cronToken) {
   if (!token) return false;
   return Boolean(internalToken) && token === internalToken || Boolean(cronToken) && token === cronToken;
 }
+function canFallbackToStableSchedulerAction(action) {
+  return action.startsWith(`${WORKFLOW_RESUME_ACTION_PREFIX}.`);
+}
 function createInternalCronRouteHandler(params) {
   const logger2 = params.logger ?? console;
   return async (c) => {
@@ -99187,7 +99323,7 @@ function createInternalCronRouteHandler(params) {
         logger2.error(`[cron] /internal/cron/${action}: failed:`, message);
         return c.json({ ok: false, error: message }, 500);
       }
-      if (hasActionTokenMap) {
+      if (hasActionTokenMap && !canFallbackToStableSchedulerAction(action)) {
         logger2.warn(`[cron] /internal/cron/${action}: action token not found`);
         return c.json({ ok: false, error: `Action "${action}" not found` }, 404);
       }
@@ -109535,13 +109671,21 @@ function sanitizePublicAuthResponsePayload(payload, fallback = "Authentication f
   return sanitized;
 }
 
-// ../server/src/auth-session-cookies.ts
+// ../server/src/auth-session-resolution.ts
 function sessionTokenToCookieHeader(sessionToken) {
   return [
     `better-auth.session_token=${sessionToken}`,
     `__Secure-better-auth.session_token=${sessionToken}`
   ].join("; ");
 }
+function decodeCookieToken(value) {
+  try {
+    const decoded = decodeURIComponent(value);
+    return decoded || null;
+  } catch {
+    return null;
+  }
+}
 function extractSessionTokenFromCookieHeader(cookieHeader) {
   return extractSessionTokensFromCookieHeader(cookieHeader)[0] ?? null;
 }
@@ -109550,7 +109694,8 @@ function extractSessionTokensFromCookieHeader(cookieHeader) {
   const pattern = /(?:^|;\s*)(?:__Secure-)?better-auth\.session_token=([^;]+)/g;
   let match2;
   while ((match2 = pattern.exec(cookieHeader)) !== null) {
-    tokens.push(decodeURIComponent(match2[1]));
+    const token = decodeCookieToken(match2[1]);
+    if (token) tokens.push(token);
   }
   return tokens;
 }
@@ -109574,6 +109719,37 @@ function sessionCreatedAtMs(session2) {
   }
   return 0;
 }
+async function resolveRequestSession(input) {
+  if (input.authorizationHeader?.startsWith("Bearer ")) {
+    const sessionToken2 = input.authorizationHeader.substring(7);
+    const session3 = await input.getSession(new Headers({ cookie: sessionTokenToCookieHeader(sessionToken2) }));
+    return { session: session3, sessionToken: sessionToken2 };
+  }
+  const cookieHeader = input.cookieHeader ?? "";
+  const sessionTokens = [...new Set(extractSessionTokensFromCookieHeader(cookieHeader))];
+  if (sessionTokens.length <= 1) {
+    const session3 = await input.getSession(buildSessionLookupHeaders(input.headers, cookieHeader));
+    return { session: session3, sessionToken: sessionTokens[0] ?? null };
+  }
+  const resolved = await Promise.all(
+    sessionTokens.map(async (sessionToken2, index) => {
+      try {
+        const session3 = await input.getSession(buildSessionLookupHeadersForToken(input.headers, sessionToken2));
+        return session3 ? { session: session3, sessionToken: sessionToken2, index } : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  const valid = resolved.filter((candidate) => candidate !== null);
+  if (valid.length === 0) return { session: null, sessionToken: null };
+  valid.sort((a, b) => {
+    const createdDelta = sessionCreatedAtMs(b.session) - sessionCreatedAtMs(a.session);
+    return createdDelta || a.index - b.index;
+  });
+  const { session: session2, sessionToken } = valid[0];
+  return { session: session2, sessionToken };
+}
 
 // ../server/src/auth-oauth-invite-reservation.ts
 import { createHash as createHash7, randomUUID as randomUUID2 } from "crypto";
@@ -110983,29 +111159,12 @@ async function issueJWT(user2) {
   return { token, expires_in: JWT_EXPIRES_IN_SEC };
 }
 async function resolveSessionFromRequest(c) {
-  const authHeader = c.req.header("Authorization");
-  if (authHeader?.startsWith("Bearer ")) {
-    const sessionToken = authHeader.substring(7);
-    const session2 = await authInstance.api.getSession({
-      headers: new Headers({ cookie: sessionTokenToCookieHeader(sessionToken) })
-    });
-    return { session: session2, sessionToken };
-  }
-  const cookieHeader = c.req.header("cookie") || "";
-  const sessionTokens = [...new Set(extractSessionTokensFromCookieHeader(cookieHeader))];
-  if (sessionTokens.length <= 1) {
-    const session2 = await authInstance.api.getSession({
-      headers: buildSessionLookupHeaders(c.req.raw.headers, cookieHeader)
-    });
-    return { session: session2, sessionToken: sessionTokens[0] ?? null };
-  }
-  const resolved = (await Promise.all(
-    sessionTokens.map(
-      (sessionToken) => authInstance.api.getSession({ headers: buildSessionLookupHeadersForToken(c.req.raw.headers, sessionToken) }).then((session2) => session2 ? { session: session2, sessionToken } : null).catch(() => null)
-    )
-  )).filter(Boolean);
-  if (resolved.length === 0) return { session: null, sessionToken: null };
-  return resolved.sort((a, b) => sessionCreatedAtMs(b.session) - sessionCreatedAtMs(a.session))[0];
+  return resolveRequestSession({
+    authorizationHeader: c.req.header("Authorization"),
+    cookieHeader: c.req.header("cookie"),
+    headers: c.req.raw.headers,
+    getSession: (headers) => authInstance.api.getSession({ headers })
+  });
 }
 async function getSessionFromRequest(c) {
   return (await resolveSessionFromRequest(c)).session;