skedyul 0.2.139 → 0.2.142

package/dist/.build-stamp

@@ -1 +1 @@
-1770350396098
+1770543492164

package/dist/cli/commands/serve.js

@@ -41,6 +41,7 @@ const link_1 = require("../utils/link");
 const config_1 = require("../utils/config");
 const tunnel_1 = require("../utils/tunnel");
 const readline = __importStar(require("readline"));
+const z = __importStar(require("zod"));
 /**
  * Prompt the user for input
  */
@@ -95,12 +96,14 @@ async function promptInput(question, hidden = false) {
 }
 /**
  * Check if required env vars are configured, prompt if missing.
- * After collecting env vars, calls the install API to run the install workflow.
+ * Returns the env and whether the install workflow needs to run.
+ * The install workflow is deferred until the server is up and endpoint is registered,
+ * so the Temporal workflow can reach the app's /install handler.
  */
-async function ensureEnvConfigured(workplaceSubdomain, existingEnv, linkConfig, credentials) {
+async function ensureEnvConfigured(workplaceSubdomain, existingEnv) {
     const installConfig = await (0, config_1.loadInstallConfig)();
     if (!installConfig?.env) {
-        return existingEnv;
+        return { env: existingEnv, needsInstall: false };
     }
     const envFields = Object.entries(installConfig.env);
     const missingRequired = [];
@@ -111,7 +114,7 @@ async function ensureEnvConfigured(workplaceSubdomain, existingEnv, linkConfig,
         }
     }
     if (missingRequired.length === 0) {
-        return existingEnv;
+        return { env: existingEnv, needsInstall: false };
     }
     // Prompt for missing env vars
     console.log(`\n⚠ Missing required environment variables for ${workplaceSubdomain}:`);
@@ -138,20 +141,7 @@ async function ensureEnvConfigured(workplaceSubdomain, existingEnv, linkConfig,
     // Save the updated env locally
     (0, link_1.saveEnvFile)(workplaceSubdomain, newEnv);
     console.log(`\n✓ Saved to .skedyul/env/${workplaceSubdomain}.env`);
-    // Call the install API to run the install workflow with the new env vars
-    console.log(`\nRunning installation workflow...`);
-    try {
-        await (0, auth_1.callCliApi)({ serverUrl: linkConfig.serverUrl, token: credentials.token }, '/install', {
-            appVersionId: linkConfig.appVersionId,
-            env: newEnv,
-        });
-        console.log(`  ✓ Installation completed`);
-    }
-    catch (error) {
-        console.error(`  ⚠ Installation workflow failed: ${error instanceof Error ? error.message : String(error)}`);
-        console.error(`  (You can continue with local testing, but some features may not work)`);
-    }
-    return newEnv;
+    return { env: newEnv, needsInstall: true };
 }
 function printHelp() {
     console.log(`
@@ -203,6 +193,29 @@ Endpoints:
 `);
 }
 const net = __importStar(require("net"));
+/**
+ * Convert a Zod schema to a JSON Schema representation for serialization.
+ * Raw Zod instances contain internal properties (functions, symbols) that
+ * can't be stored in the database, so we convert them first.
+ */
+function safeInputSchemaToJson(schema) {
+    if (!schema)
+        return undefined;
+    // Check if it's a Zod schema (has _def property or is ZodType instance)
+    if (schema instanceof z.ZodType) {
+        try {
+            return z.toJSONSchema(schema, { unrepresentable: 'any' });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // Already a plain object (JSON Schema), return as-is
+    if (typeof schema === 'object') {
+        return schema;
+    }
+    return undefined;
+}
 const HEARTBEAT_INTERVAL_MS = 30 * 1000; // 30 seconds
 const DEFAULT_PORT = 60000;
 const MAX_PORT_ATTEMPTS = 100;
@@ -289,6 +302,7 @@ async function serveCommand(args) {
     let credentials = null;
     let tunnel = null;
     let heartbeatInterval = null;
+    let envResult = { env: {}, needsInstall: false };
     if (isLinked && workplaceSubdomain) {
         // Check authentication
         credentials = (0, auth_1.getCredentials)();
@@ -356,7 +370,8 @@ async function serveCommand(args) {
         console.log(`  AppVersion: ${linkConfig.appVersionHandle}`);
         // Load env vars for this workplace, prompt for missing required vars
         let linkedEnv = (0, link_1.loadEnvFile)(workplaceSubdomain);
-        linkedEnv = await ensureEnvConfigured(workplaceSubdomain, linkedEnv, linkConfig, credentials);
+        envResult = await ensureEnvConfigured(workplaceSubdomain, linkedEnv);
+        linkedEnv = envResult.env;
         const envCount = Object.keys(linkedEnv).length;
         if (envCount > 0) {
             console.log(`\nLoading env from .skedyul/env/${workplaceSubdomain}.env`);
@@ -380,11 +395,11 @@ async function serveCommand(args) {
     if (isLinked) {
         const appConfig = await (0, config_1.loadAppConfig)();
         const installConfig = await (0, config_1.loadInstallConfig)();
-        // Build tool list with metadata
+        // Build tool list with metadata (convert Zod schemas to JSON Schema for serialization)
         const tools = Object.entries(registry).map(([name, tool]) => ({
             name,
             description: tool.description,
-            inputSchema: tool.inputSchema,
+            inputSchema: safeInputSchemaToJson(tool.inputSchema),
         }));
         executableConfig = {
             name: appConfig?.name,
@@ -400,6 +415,18 @@ async function serveCommand(args) {
         console.log(`  Tools: ${tools.length}`);
         console.log(`  Install env: ${installConfig?.env ? Object.keys(installConfig.env).length : 0} variables`);
     }
+    // Load install handler if available
+    let installHandler;
+    try {
+        const handler = await (0, config_1.loadInstallHandler)();
+        if (handler) {
+            installHandler = handler;
+            console.log(`\n✓ Loaded install handler`);
+        }
+    }
+    catch (error) {
+        console.warn(`Could not load install handler: ${error instanceof Error ? error.message : String(error)}`);
+    }
     // Create server
     const server = (0, server_1.createSkedyulServer)({
         computeLayer: 'dedicated',
@@ -408,6 +435,7 @@ async function serveCommand(args) {
             version: serverVersion,
         },
         defaultPort: port,
+        hooks: installHandler ? { install: installHandler } : undefined,
     }, registry);
     // Start listening
     const dedicatedServer = server;
@@ -474,18 +502,52 @@ async function serveCommand(args) {
         // Register endpoint with Skedyul
         console.log(`\nRegistering endpoint with Skedyul...`);
         try {
-            await (0, auth_1.callCliApi)({ serverUrl: linkConfig.serverUrl, token: credentials.token }, '/register-endpoint', {
+            const registerUrl = `${linkConfig.serverUrl}/api/cli/register-endpoint`;
+            const registerBody = {
                 appVersionId: linkConfig.appVersionId,
                 invokeEndpoint,
                 config: executableConfig,
+            };
+            const registerResponse = await fetch(registerUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${credentials.token}`,
+                },
+                body: JSON.stringify(registerBody),
             });
-            console.log(`  ✓ Registered as invokeEndpoint for ${linkConfig.appVersionHandle}`);
-            console.log(`  ✓ Synced ${toolCount} tools to Skedyul`);
+            if (!registerResponse.ok) {
+                const responseText = await registerResponse.text();
+                console.error(`Failed to register endpoint (HTTP ${registerResponse.status}):`);
+                // Show first 500 chars of response body for debugging
+                console.error(`  Response: ${responseText.substring(0, 500)}`);
+            }
+            else {
+                console.log(`  ✓ Registered as invokeEndpoint for ${linkConfig.appVersionHandle}`);
+                console.log(`  ✓ Synced ${toolCount} tools to Skedyul`);
+            }
         }
         catch (error) {
             console.error(`Failed to register endpoint: ${error instanceof Error ? error.message : String(error)}`);
             // Continue anyway, might be a temporary issue
         }
+        // Run deferred install workflow now that the server is up and endpoint is registered.
+        // The Temporal workflow calls the app's /install handler via HTTP, so the server
+        // must be reachable first.
+        if (envResult.needsInstall) {
+            console.log(`\nRunning installation workflow...`);
+            try {
+                await (0, auth_1.callCliApi)({ serverUrl: linkConfig.serverUrl, token: credentials.token }, '/install', {
+                    appVersionId: linkConfig.appVersionId,
+                    env: envResult.env,
+                });
+                console.log(`  ✓ Installation completed`);
+            }
+            catch (error) {
+                console.error(`  ⚠ Installation workflow failed: ${error instanceof Error ? error.message : String(error)}`);
+                console.error(`  (You can continue with local testing, but some features may not work)`);
+            }
+        }
         // Start heartbeat (also syncs config on each heartbeat for hot-reload)
         const sendHeartbeat = async () => {
             try {
@@ -495,7 +557,7 @@ async function serveCommand(args) {
                 const freshTools = Object.entries(registry).map(([name, tool]) => ({
                     name,
                     description: tool.description,
-                    inputSchema: tool.inputSchema,
+                    inputSchema: safeInputSchemaToJson(tool.inputSchema),
                 }));
                 const freshConfig = {
                     name: freshAppConfig?.name,

package/dist/cli/utils/config.d.ts

@@ -28,4 +28,9 @@ export interface InstallConfigData {
     onUninstall?: string;
 }
 export declare function loadInstallConfig(projectDir?: string, debug?: boolean): Promise<InstallConfigData | null>;
+/**
+ * Find and load the install handler from the project directory.
+ * Returns the default export (install handler function) or null if not found.
+ */
+export declare function loadInstallHandler(projectDir?: string): Promise<((ctx: unknown) => Promise<unknown>) | null>;
 export declare function findRegistryPath(projectDir?: string): string | null;

package/dist/cli/utils/config.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findConfigFile = findConfigFile;
 exports.loadAppConfig = loadAppConfig;
 exports.loadInstallConfig = loadInstallConfig;
+exports.loadInstallHandler = loadInstallHandler;
 exports.findRegistryPath = findRegistryPath;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -316,6 +317,50 @@ function parseInstallConfigFromSource(content) {
     }
 }
 // ─────────────────────────────────────────────────────────────────────────────
+// Install Handler Loading
+// ─────────────────────────────────────────────────────────────────────────────
+const INSTALL_HANDLER_PATHS = [
+    // Source files (dev mode)
+    'src/install.ts',
+    'src/install.js',
+    // Compiled output (production)
+    'dist/install.js',
+    'build/install.js',
+];
+/**
+ * Find and load the install handler from the project directory.
+ * Returns the default export (install handler function) or null if not found.
+ */
+async function loadInstallHandler(projectDir) {
+    const dir = projectDir ?? process.cwd();
+    for (const handlerPath of INSTALL_HANDLER_PATHS) {
+        const fullPath = path.join(dir, handlerPath);
+        if (!fs.existsSync(fullPath)) {
+            continue;
+        }
+        try {
+            let module;
+            if (fullPath.endsWith('.ts')) {
+                // Use tsx loader for TypeScript files
+                const { loadTypeScriptFile } = await Promise.resolve().then(() => __importStar(require('../utils')));
+                module = (await loadTypeScriptFile(fullPath));
+            }
+            else {
+                module = await Promise.resolve(`${fullPath}`).then(s => __importStar(require(s)));
+            }
+            const handler = module.default;
+            if (typeof handler === 'function') {
+                return handler;
+            }
+        }
+        catch (error) {
+            console.warn(`[loadInstallHandler] Failed to load ${handlerPath}: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+    }
+    return null;
+}
+// ─────────────────────────────────────────────────────────────────────────────
 // Registry Path Detection
 // ─────────────────────────────────────────────────────────────────────────────
 // Check source files first (for dev), then compiled output

package/dist/cli/utils.d.ts

@@ -15,6 +15,10 @@ export declare function parseEnvFlags(args: string[]): Record<string, string>;
  * Load environment variables from a .env file
  */
 export declare function loadEnvFile(filePath: string): Record<string, string>;
+/**
+ * Load a TypeScript file using tsx's require hook
+ */
+export declare function loadTypeScriptFile(absolutePath: string): Promise<unknown>;
 /**
  * Load a registry from a JS/TS file
  */

package/dist/cli/utils.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseArgs = parseArgs;
 exports.parseEnvFlags = parseEnvFlags;
 exports.loadEnvFile = loadEnvFile;
+exports.loadTypeScriptFile = loadTypeScriptFile;
 exports.loadRegistry = loadRegistry;
 exports.formatJson = formatJson;
 const fs = __importStar(require("fs"));

package/dist/server.js

@@ -257,13 +257,17 @@ async function handleCoreMethod(method, params) {
     };
 }
 function buildToolMetadata(registry) {
-    return Object.values(registry).map((tool) => ({
-        name: tool.name,
-        displayName: tool.label || tool.name,
-        description: tool.description,
-        inputSchema: getJsonSchemaFromToolSchema(tool.inputSchema),
-        outputSchema: getJsonSchemaFromToolSchema(tool.outputSchema),
-    }));
+    return Object.values(registry).map((tool) => {
+        const timeout = typeof tool.timeout === 'number' && tool.timeout > 0 ? tool.timeout : 10000;
+        return {
+            name: tool.name,
+            displayName: tool.label || tool.name,
+            description: tool.description,
+            inputSchema: getJsonSchemaFromToolSchema(tool.inputSchema),
+            outputSchema: getJsonSchemaFromToolSchema(tool.outputSchema),
+            timeout, // Default to 10 seconds
+        };
+    });
 }
 function createRequestState(maxRequests, ttlExtendSeconds, runtimeLabel, toolNames) {
     let requestCount = 0;
@@ -909,8 +913,12 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                         '',
                 };
                 try {
+                    const installHook = config.hooks.install;
+                    const installHandler = typeof installHook === 'function'
+                        ? installHook
+                        : installHook.handler;
                     const result = await (0, client_1.runWithConfig)(installRequestConfig, async () => {
-                        return await config.hooks.install(installContext);
+                        return await installHandler(installContext);
                     });
                     sendJSON(res, 200, {
                         env: result.env ?? {},
@@ -973,8 +981,12 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                     apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? '',
                 };
                 try {
+                    const provisionHook = config.hooks.provision;
+                    const provisionHandler = typeof provisionHook === 'function'
+                        ? provisionHook
+                        : provisionHook.handler;
                     const result = await (0, client_1.runWithConfig)(provisionRequestConfig, async () => {
-                        return await config.hooks.provision(provisionContext);
+                        return await provisionHandler(provisionContext);
                     });
                     sendJSON(res, 200, result);
                 }
@@ -1441,8 +1453,12 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                             '',
                     };
                     try {
+                        const installHook = config.hooks.install;
+                        const installHandler = typeof installHook === 'function'
+                            ? installHook
+                            : installHook.handler;
                         const result = await (0, client_1.runWithConfig)(installRequestConfig, async () => {
-                            return await config.hooks.install(installContext);
+                            return await installHandler(installContext);
                         });
                         return createResponse(200, { env: result.env ?? {}, redirect: result.redirect }, headers);
                     }

package/dist/types.d.ts

@@ -131,6 +131,8 @@ export interface ToolDefinition<Input = unknown, Output = unknown, InputSchema e
     inputSchema: ToolSchema<InputSchema>;
     handler: ToolHandler<Input, Output>;
     outputSchema?: ToolSchema<OutputSchema>;
+    /** Timeout in milliseconds. Defaults to 10000 (10 seconds) if not specified. */
+    timeout?: number;
     [key: string]: unknown;
 }
 export interface ToolRegistryEntry {
@@ -150,6 +152,8 @@ export interface ToolMetadata {
     description: string;
     inputSchema?: Record<string, unknown>;
     outputSchema?: Record<string, unknown>;
+    /** Timeout in milliseconds. Defaults to 10000 (10 seconds) if not specified. */
+    timeout?: number;
 }
 export interface HealthStatus {
     status: 'running';
@@ -177,9 +181,17 @@ export interface CorsOptions {
  */
 export interface ServerHooks {
     /** Called during app installation to validate/normalize env and perform setup */
-    install?: InstallHandler;
+    install?: InstallHandler | {
+        handler: InstallHandler;
+        /** Timeout in milliseconds. Defaults to 60000 (1 minute) if not specified. */
+        timeout?: number;
+    };
     /** Called after app version provisioning to set up version-level resources */
-    provision?: ProvisionHandler;
+    provision?: ProvisionHandler | {
+        handler: ProvisionHandler;
+        /** Timeout in milliseconds. Defaults to 300000 (5 minutes) if not specified. */
+        timeout?: number;
+    };
 }
 export interface SkedyulServerConfig {
     computeLayer: ComputeLayer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "0.2.139",
+  "version": "0.2.142",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",