skedyul 1.4.11 → 1.5.0

package/dist/config/transpileConfigMetadata.d.ts

@@ -0,0 +1 @@
+export declare function transpileConfigMetadata(configPath: string): Promise<string>;

package/dist/esm/index.mjs

@@ -2025,13 +2025,13 @@ function mergeRuntimeEnv() {
 
 // src/server/utils/http.ts
 function readRawRequestBody(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
     req.on("end", () => {
-      resolve4(body);
+      resolve5(body);
     });
     req.on("error", reject);
   });
@@ -3844,7 +3844,7 @@ function printStartupLog(config, tools, port) {
 
 // src/server/route-handlers/adapters.ts
 function fromLambdaEvent(event2) {
-  const path6 = event2.path || event2.rawPath || "/";
+  const path7 = event2.path || event2.rawPath || "/";
   const method = event2.httpMethod || event2.requestContext?.http?.method || "POST";
   const forwardedProto = event2.headers?.["x-forwarded-proto"] ?? event2.headers?.["X-Forwarded-Proto"];
   const protocol = forwardedProto ?? "https";
@@ -3852,9 +3852,9 @@ function fromLambdaEvent(event2) {
   const queryString = event2.queryStringParameters ? "?" + new URLSearchParams(
     event2.queryStringParameters
   ).toString() : "";
-  const url = `${protocol}://${host}${path6}${queryString}`;
+  const url = `${protocol}://${host}${path7}${queryString}`;
   return {
-    path: path6,
+    path: path7,
     method,
     headers: event2.headers,
     query: event2.queryStringParameters ?? {},
@@ -4404,7 +4404,7 @@ async function handleOAuthCallback(parsedBody, hooks) {
 }
 
 // src/server/handlers/webhook-handler.ts
-function parseWebhookRequest(parsedBody, method, url, path6, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
+function parseWebhookRequest(parsedBody, method, url, path7, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
   const isEnvelope = typeof parsedBody === "object" && parsedBody !== null && "env" in parsedBody && "request" in parsedBody && "context" in parsedBody;
   if (isEnvelope) {
     const envelope = parsedBody;
@@ -4458,7 +4458,7 @@ function parseWebhookRequest(parsedBody, method, url, path6, headers, query, raw
   const webhookRequest = {
     method,
     url,
-    path: path6,
+    path: path7,
     headers,
     query,
     body: parsedBody,
@@ -4907,9 +4907,9 @@ async function handleMcpBatchRoute(req, ctx) {
   }
   const perCallTimeoutMs = deadline ? Math.min(deadline, 25e3) : 25e3;
   const executeWithTimeout = async (call2, timeoutMs) => {
-    return new Promise(async (resolve4) => {
+    return new Promise(async (resolve5) => {
       const timeoutHandle = setTimeout(() => {
-        resolve4({
+        resolve5({
           id: call2.id,
           success: false,
           error: "Timeout",
@@ -4922,7 +4922,7 @@ async function handleMcpBatchRoute(req, ctx) {
         const found = findToolInRegistry(ctx.registry, toolName);
         if (!found) {
           clearTimeout(timeoutHandle);
-          resolve4({
+          resolve5({
             id: call2.id,
             success: false,
             error: `Tool "${toolName}" not found`
@@ -4940,13 +4940,13 @@ async function handleMcpBatchRoute(req, ctx) {
         clearTimeout(timeoutHandle);
         const isFailure2 = "success" in toolResult && toolResult.success === false || "error" in toolResult && toolResult.error != null;
         if (isFailure2) {
-          resolve4({
+          resolve5({
             id: call2.id,
             success: false,
             error: "error" in toolResult && toolResult.error ? typeof toolResult.error === "string" ? toolResult.error : JSON.stringify(toolResult.error) : "Tool execution failed"
           });
         } else {
-          resolve4({
+          resolve5({
             id: call2.id,
             success: true,
             result: "output" in toolResult ? toolResult.output : toolResult
@@ -4954,7 +4954,7 @@ async function handleMcpBatchRoute(req, ctx) {
         }
       } catch (err) {
         clearTimeout(timeoutHandle);
-        resolve4({
+        resolve5({
           id: call2.id,
           success: false,
           error: err instanceof Error ? err.message : String(err)
@@ -5140,21 +5140,21 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
   return {
     async listen(listenPort) {
       const finalPort = listenPort ?? port;
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve5, reject) => {
         httpServer.listen(finalPort, () => {
           printStartupLog(config, tools, finalPort);
-          resolve4();
+          resolve5();
         });
         httpServer.once("error", reject);
       });
     },
     async close() {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve5, reject) => {
         const closable = httpServer;
         closable.closeAllConnections?.();
         httpServer.close((err) => {
           if (err) reject(err);
-          else resolve4();
+          else resolve5();
         });
       });
     },
@@ -5510,49 +5510,109 @@ function defineNavigation(navigation) {
 }
 
 // src/config/loader.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os from "os";
+
+// src/config/transpileConfigMetadata.ts
+import * as esbuild from "esbuild";
 import * as fs3 from "fs";
 import * as path3 from "path";
-import * as os from "os";
+var SKEDYUL_SHIM_NAMESPACE = "skedyul-shim";
+var METADATA_STUB_NAMESPACE = "metadata-stub";
+function prepareConfigSource(content) {
+  return content.replace(/import\s*\(\s*(['"])([^'"]+)\1\s*\)/g, "Promise.resolve(null)");
+}
+function isJsonImport(importPath) {
+  return importPath.endsWith(".json");
+}
+async function transpileConfigMetadata(configPath) {
+  const absolutePath = path3.resolve(configPath);
+  const configDir = path3.dirname(absolutePath);
+  const configBasename = path3.basename(absolutePath);
+  const result = await esbuild.build({
+    absWorkingDir: configDir,
+    entryPoints: [absolutePath],
+    bundle: true,
+    format: "cjs",
+    platform: "node",
+    target: "node22",
+    write: false,
+    logLevel: "silent",
+    plugins: [
+      {
+        name: "prepare-config-entry",
+        setup(build2) {
+          build2.onLoad({ filter: new RegExp(`/${configBasename.replace(".", "\\.")}$`) }, () => ({
+            contents: prepareConfigSource(fs3.readFileSync(absolutePath, "utf-8")),
+            loader: "ts"
+          }));
+        }
+      },
+      {
+        name: "skedyul-shim",
+        setup(build2) {
+          build2.onResolve({ filter: /^skedyul$/ }, () => ({
+            path: "skedyul-shim",
+            namespace: SKEDYUL_SHIM_NAMESPACE
+          }));
+          build2.onLoad({ filter: /.*/, namespace: SKEDYUL_SHIM_NAMESPACE }, () => ({
+            contents: [
+              "function defineConfig(config) { return config; }",
+              "module.exports = { defineConfig };"
+            ].join("\n"),
+            loader: "js"
+          }));
+        }
+      },
+      {
+        name: "metadata-stub-imports",
+        setup(build2) {
+          build2.onResolve({ filter: /^\.{1,2}\// }, (args) => {
+            if (isJsonImport(args.path)) {
+              return void 0;
+            }
+            return {
+              path: args.path,
+              namespace: METADATA_STUB_NAMESPACE
+            };
+          });
+          build2.onLoad({ filter: /.*/, namespace: METADATA_STUB_NAMESPACE }, () => ({
+            contents: "module.exports = {};\n",
+            loader: "js"
+          }));
+        }
+      }
+    ]
+  });
+  if (result.errors.length > 0) {
+    throw new Error(result.errors.map((error) => error.text).join("\n"));
+  }
+  if (result.outputFiles.length === 0) {
+    throw new Error("Config transpile produced no output");
+  }
+  return result.outputFiles[0].text;
+}
+
+// src/config/loader.ts
 var CONFIG_FILE_NAMES = [
   "skedyul.config.ts",
   "skedyul.config.js",
   "skedyul.config.mjs",
   "skedyul.config.cjs"
 ];
-async function transpileTypeScript(filePath) {
-  const content = fs3.readFileSync(filePath, "utf-8");
-  const configDir = path3.dirname(path3.resolve(filePath));
-  let transpiled = content.replace(/import\s+type\s+\{[^}]+\}\s+from\s+['"][^'"]+['"]\s*;?\n?/g, "").replace(/import\s+\{\s*defineConfig\s*\}\s+from\s+['"]skedyul['"]\s*;?\n?/g, "").replace(/:\s*SkedyulConfig/g, "").replace(/export\s+default\s+/, "module.exports = ").replace(/defineConfig\s*\(\s*\{/, "{").replace(/\}\s*\)\s*;?\s*$/, "}");
-  transpiled = transpiled.replace(
-    /import\s+(\w+)\s+from\s+['"](\.[^'"]+)['"]\s*(?:with\s*\{[^}]*\})?/g,
-    (_match, varName, relativePath) => {
-      const absolutePath = path3.resolve(configDir, relativePath);
-      return `const ${varName} = require('${absolutePath.replace(/\\/g, "/")}')`;
-    }
-  );
-  transpiled = transpiled.replace(
-    /import\s+\{\s*([^}]+)\s*\}\s+from\s+['"](\.[^'"]+)['"]\s*;?\n?/g,
-    (_match, namedImports, relativePath) => {
-      const absolutePath = path3.resolve(configDir, relativePath);
-      return `const { ${namedImports.trim()} } = require('${absolutePath.replace(/\\/g, "/")}')
-`;
-    }
-  );
-  transpiled = transpiled.replace(/import\s*\(\s*['"][^'"]+['"]\s*\)/g, "null");
-  return transpiled;
-}
 async function loadConfig(configPath) {
-  const absolutePath = path3.resolve(configPath);
-  if (!fs3.existsSync(absolutePath)) {
+  const absolutePath = path4.resolve(configPath);
+  if (!fs4.existsSync(absolutePath)) {
     throw new Error(`Config file not found: ${absolutePath}`);
   }
   const isTypeScript = absolutePath.endsWith(".ts");
   try {
     if (isTypeScript) {
       try {
-        const transpiled = await transpileTypeScript(absolutePath);
-        const tempFile = path3.join(os.tmpdir(), `skedyul-config-${Date.now()}.cjs`);
-        fs3.writeFileSync(tempFile, transpiled);
+        const transpiled = await transpileConfigMetadata(absolutePath);
+        const tempFile = path4.join(os.tmpdir(), `skedyul-config-${Date.now()}.cjs`);
+        fs4.writeFileSync(tempFile, transpiled);
         try {
           const module2 = __require(tempFile);
           const config2 = module2.default || module2;
@@ -5565,7 +5625,7 @@ async function loadConfig(configPath) {
           return config2;
         } finally {
           try {
-            fs3.unlinkSync(tempFile);
+            fs4.unlinkSync(tempFile);
           } catch {
           }
         }
@@ -5605,13 +5665,13 @@ function validateConfig(config) {
 }
 
 // src/config/schema-loader.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import * as os2 from "os";
 
 // src/config/resolver.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 
 // src/config/utils.ts
 function getAllEnvKeys(config) {
@@ -5714,7 +5774,7 @@ function getApiToken() {
   const config = getConfig();
   return config.apiToken || process.env.SKEDYUL_API_TOKEN || "";
 }
-async function callRateLimitApi(path6, body) {
+async function callRateLimitApi(path7, body) {
   const baseUrl = getApiBaseUrl();
   const token2 = getApiToken();
   if (!baseUrl || !token2) {
@@ -5722,7 +5782,7 @@ async function callRateLimitApi(path6, body) {
       "SKEDYUL_API_URL and SKEDYUL_API_TOKEN are required for platform queue coordination"
     );
   }
-  const response = await fetch(`${baseUrl}/api/internal/ratelimit/${path6}`, {
+  const response = await fetch(`${baseUrl}/api/internal/ratelimit/${path7}`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token2}`,
@@ -5732,11 +5792,11 @@ async function callRateLimitApi(path6, body) {
   });
   const payload = await response.json().catch(() => null);
   if (!response.ok || payload?.success === false) {
-    const message = payload?.errors?.[0]?.message ?? `Queue coordination API ${path6} failed with status ${response.status}`;
+    const message = payload?.errors?.[0]?.message ?? `Queue coordination API ${path7} failed with status ${response.status}`;
     throw new RateLimitBackendError(message, response.status);
   }
   if (!payload?.data) {
-    throw new RateLimitBackendError(`Queue coordination API ${path6} returned empty data`);
+    throw new RateLimitBackendError(`Queue coordination API ${path7} returned empty data`);
   }
   return payload.data;
 }
@@ -5863,9 +5923,9 @@ var MemoryRateLimitBackend = class {
     if (canAcquire(state, limits)) {
       return this.grant(state, queueKey, limits);
     }
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const waiter = {
-        resolve: resolve4,
+        resolve: resolve5,
         reject,
         timer: null,
         limits
@@ -5894,7 +5954,7 @@ var MemoryRateLimitBackend = class {
           if (waiter.timer) {
             clearTimeout(waiter.timer);
           }
-          resolve4(this.grant(state, queueKey, limits));
+          resolve5(this.grant(state, queueKey, limits));
           return;
         }
         setTimeout(retry, Math.max(getMinTime(limits), 10));
@@ -6015,7 +6075,7 @@ function defaultShouldRetry(error, _attempt) {
   return false;
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
 // src/ratelimit/queued-fetch.ts
@@ -6295,16 +6355,16 @@ function evaluateTemplate(template, context) {
   const templateRegex = /\{\{\s*([^}]+)\s*\}\}/g;
   const singleMatch = template.match(/^\{\{\s*([^}]+)\s*\}\}$/);
   if (singleMatch) {
-    const path6 = singleMatch[1].trim();
-    return resolvePath(context, path6);
+    const path7 = singleMatch[1].trim();
+    return resolvePath(context, path7);
   }
-  return template.replace(templateRegex, (_, path6) => {
-    const value = resolvePath(context, path6.trim());
+  return template.replace(templateRegex, (_, path7) => {
+    const value = resolvePath(context, path7.trim());
     return value === void 0 || value === null ? "" : String(value);
   });
 }
-function resolvePath(obj, path6) {
-  const parts = path6.split(".");
+function resolvePath(obj, path7) {
+  const parts = path7.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -6325,14 +6385,14 @@ function evaluateCondition(condition, context) {
   const expression = match[1].trim();
   const eqMatch = expression.match(/^(.+?)\s*==\s*['"](.+)['"]$/);
   if (eqMatch) {
-    const [, path6, expectedValue] = eqMatch;
-    const actualValue = resolvePath(context, path6.trim());
+    const [, path7, expectedValue] = eqMatch;
+    const actualValue = resolvePath(context, path7.trim());
     return actualValue === expectedValue;
   }
   const neqMatch = expression.match(/^(.+?)\s*!=\s*['"](.+)['"]$/);
   if (neqMatch) {
-    const [, path6, expectedValue] = neqMatch;
-    const actualValue = resolvePath(context, path6.trim());
+    const [, path7, expectedValue] = neqMatch;
+    const actualValue = resolvePath(context, path7.trim());
     return actualValue !== expectedValue;
   }
   const value = resolvePath(context, expression);