@workflow/web-shared 4.0.1-beta.9 → 4.1.0-beta.46

package/dist/api/workflow-server-actions.js

@@ -1,47 +1,379 @@
 'use server';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import { hydrateResourceIO } from '@workflow/core/observability';
-import { createWorld, start } from '@workflow/core/runtime';
-function getWorldFromEnv(envMap) {
-    for (const [key, value] of Object.entries(envMap)) {
-        if (value === undefined || value === null || value === '') {
+import { createWorld, healthCheck, resumeHook as resumeHookRuntime, start, } from '@workflow/core/runtime';
+import { getDeserializeStream, getExternalRevivers, } from '@workflow/core/serialization';
+import { WorkflowAPIError, WorkflowRunNotFoundError } from '@workflow/errors';
+import { findWorkflowDataDir } from '@workflow/utils/check-data-dir';
+import { isLegacySpecVersion, SPEC_VERSION_LEGACY, } from '@workflow/world';
+import { createVercelWorld } from '@workflow/world-vercel';
+/**
+ * Map from WORKFLOW_TARGET_WORLD value to human-readable display name
+ */
+function getBackendDisplayName(targetWorld) {
+    if (!targetWorld)
+        return 'Local';
+    switch (targetWorld) {
+        case 'local':
+            return 'Local';
+        case 'vercel':
+            return 'Vercel';
+        case '@workflow/world-postgres':
+        case 'postgres':
+            return 'PostgreSQL';
+        default:
+            // For custom worlds, try to make a readable name
+            if (targetWorld.startsWith('@')) {
+                // Extract package name without scope for display
+                const parts = targetWorld.split('/');
+                return parts[parts.length - 1] || targetWorld;
+            }
+            return targetWorld;
+    }
+}
+function getEffectiveBackendId() {
+    const targetWorld = process.env.WORKFLOW_TARGET_WORLD;
+    if (targetWorld) {
+        return targetWorld;
+    }
+    // Match @workflow/core/runtime defaulting: vercel if VERCEL_DEPLOYMENT_ID is set, else local.
+    return process.env.VERCEL_DEPLOYMENT_ID ? 'vercel' : 'local';
+}
+function getObservabilityCwd() {
+    const raw = process.env.WORKFLOW_OBSERVABILITY_CWD;
+    if (!raw) {
+        return process.cwd();
+    }
+    return path.isAbsolute(raw) ? raw : path.resolve(process.cwd(), raw);
+}
+/**
+ * Ensure local-world env is derived consistently when running `packages/web` directly.
+ *
+ * Without this, the UI may *display* a dataDir detected from WORKFLOW_OBSERVABILITY_CWD,
+ * while the actual World reads from `WORKFLOW_LOCAL_DATA_DIR` (defaulting to `.workflow-data`
+ * under the web package cwd), resulting in "no runs" even though data exists.
+ */
+async function ensureLocalWorldDataDirEnv() {
+    if (process.env.WORKFLOW_LOCAL_DATA_DIR)
+        return;
+    const cwd = getObservabilityCwd();
+    const info = await findWorkflowDataDir(cwd);
+    // Prefer a discovered workflow-data directory (e.g. `.next/workflow-data`).
+    if (info.dataDir) {
+        process.env.WORKFLOW_LOCAL_DATA_DIR = info.dataDir;
+        return;
+    }
+    // Fall back to a canonical location under the target project directory.
+    process.env.WORKFLOW_LOCAL_DATA_DIR = path.resolve(cwd, '.workflow-data');
+}
+/**
+ * Extract hostname from a database URL without exposing credentials.
+ */
+function extractHostnameFromUrl(url) {
+    if (!url)
+        return undefined;
+    try {
+        const parsed = new URL(url);
+        return parsed.hostname || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extract database name from a URL where pathname is like "/dbname".
+ * (Works for postgres/mongodb-style URLs; returns undefined when not applicable.)
+ */
+function extractDatabaseFromUrl(url) {
+    if (!url)
+        return undefined;
+    try {
+        const parsed = new URL(url);
+        const dbName = parsed.pathname?.slice(1);
+        return dbName || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Keep this list in sync with `worlds-manifest.json` env + credentialsNote.
+const WORLD_ENV_ALLOWLIST_BY_TARGET_WORLD = {
+    // Official
+    local: [
+        'WORKFLOW_TARGET_WORLD',
+        'WORKFLOW_LOCAL_DATA_DIR',
+        'WORKFLOW_MANIFEST_PATH',
+        'WORKFLOW_OBSERVABILITY_CWD',
+        'PORT',
+    ],
+    '@workflow/world-local': [
+        'WORKFLOW_TARGET_WORLD',
+        'WORKFLOW_LOCAL_DATA_DIR',
+        'WORKFLOW_MANIFEST_PATH',
+        'WORKFLOW_OBSERVABILITY_CWD',
+        'PORT',
+    ],
+    postgres: ['WORKFLOW_TARGET_WORLD', 'WORKFLOW_POSTGRES_URL'],
+    '@workflow/world-postgres': [
+        'WORKFLOW_TARGET_WORLD',
+        'WORKFLOW_POSTGRES_URL',
+    ],
+    vercel: [
+        'WORKFLOW_TARGET_WORLD',
+        'WORKFLOW_VERCEL_ENV',
+        'WORKFLOW_VERCEL_TEAM',
+        'WORKFLOW_VERCEL_PROJECT',
+        'WORKFLOW_VERCEL_AUTH_TOKEN',
+    ],
+    '@workflow/world-vercel': [
+        'WORKFLOW_TARGET_WORLD',
+        'WORKFLOW_VERCEL_ENV',
+        'WORKFLOW_VERCEL_TEAM',
+        'WORKFLOW_VERCEL_PROJECT',
+        'WORKFLOW_VERCEL_AUTH_TOKEN',
+    ],
+    // Community (from worlds-manifest.json)
+    '@workflow-worlds/starter': ['WORKFLOW_TARGET_WORLD'],
+    '@workflow-worlds/turso': [
+        'WORKFLOW_TARGET_WORLD',
+        'WORKFLOW_TURSO_DATABASE_URL',
+    ],
+    '@workflow-worlds/mongodb': [
+        'WORKFLOW_TARGET_WORLD',
+        'WORKFLOW_MONGODB_URI',
+        'WORKFLOW_MONGODB_DATABASE_NAME',
+    ],
+    '@workflow-worlds/redis': ['WORKFLOW_TARGET_WORLD', 'WORKFLOW_REDIS_URI'],
+    'workflow-world-jazz': [
+        'WORKFLOW_TARGET_WORLD',
+        // credentialsNote:
+        'JAZZ_API_KEY',
+        'JAZZ_WORKER_ACCOUNT',
+        'JAZZ_WORKER_SECRET',
+    ],
+};
+function getAllowedEnvKeysForBackend(backendId) {
+    return (WORLD_ENV_ALLOWLIST_BY_TARGET_WORLD[backendId] ?? ['WORKFLOW_TARGET_WORLD']);
+}
+// Keep this list in sync with `worlds-manifest.json` env + credentialsNote.
+//
+// IMPORTANT: This is intentionally explicit (no heuristics). We only redact values for env
+// vars that are known + whitelisted and that we *know* contain secrets/credentials.
+const WORLD_SENSITIVE_ENV_KEYS = new Set([
+    // Official
+    'WORKFLOW_POSTGRES_URL',
+    'WORKFLOW_VERCEL_AUTH_TOKEN',
+    // Community
+    'WORKFLOW_TURSO_DATABASE_URL',
+    'WORKFLOW_MONGODB_URI',
+    'WORKFLOW_REDIS_URI',
+    'JAZZ_API_KEY',
+    'JAZZ_WORKER_SECRET',
+]);
+function isSet(value) {
+    return value !== undefined && value !== null && value !== '';
+}
+function deriveDbInfoForKey(key, value) {
+    // Only attempt for URL-like strings.
+    if (!value.includes(':'))
+        return null;
+    try {
+        const parsed = new URL(value);
+        const protocol = (parsed.protocol || '').replace(':', '');
+        // file: URIs are not useful for hostname/db display
+        if (protocol === 'file')
+            return null;
+        const hostname = extractHostnameFromUrl(value);
+        const database = extractDatabaseFromUrl(value);
+        const out = {};
+        if (hostname)
+            out[`derived.${key}.hostname`] = hostname;
+        if (database)
+            out[`derived.${key}.database`] = database;
+        if (protocol)
+            out[`derived.${key}.protocol`] = protocol;
+        return Object.keys(out).length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getLocalDisplayInfo() {
+    const cwd = getObservabilityCwd();
+    const dataDirInfo = await findWorkflowDataDir(cwd);
+    const out = {
+        'local.shortName': dataDirInfo.shortName,
+        'local.projectDir': dataDirInfo.projectDir,
+    };
+    if (dataDirInfo.dataDir) {
+        out['local.dataDirPath'] = dataDirInfo.dataDir;
+    }
+    return out;
+}
+function collectAllowedEnv(allowedKeys) {
+    const publicEnv = {};
+    const sensitiveEnvKeys = [];
+    const derivedDisplayInfo = {};
+    for (const key of allowedKeys) {
+        const value = process.env[key];
+        if (!isSet(value))
+            continue;
+        if (WORLD_SENSITIVE_ENV_KEYS.has(key)) {
+            sensitiveEnvKeys.push(key);
+            const derived = deriveDbInfoForKey(key, value);
+            if (derived)
+                Object.assign(derivedDisplayInfo, derived);
             continue;
         }
-        process.env[key] = value;
+        publicEnv[key] = value;
+    }
+    return {
+        publicEnv,
+        sensitiveEnvKeys: Array.from(new Set(sensitiveEnvKeys)).sort(),
+        derivedDisplayInfo,
+    };
+}
+/**
+ * Get public configuration info that is safe to send to the client.
+ *
+ * This is the ONLY server action that intentionally exposes env-derived data,
+ * and that data is strictly whitelisted per world backend.
+ */
+export async function getPublicServerConfig() {
+    const backendId = getEffectiveBackendId();
+    const backendDisplayName = getBackendDisplayName(backendId);
+    const allowedKeys = getAllowedEnvKeysForBackend(backendId);
+    const { publicEnv, sensitiveEnvKeys, derivedDisplayInfo } = collectAllowedEnv(allowedKeys);
+    const displayInfo = { ...derivedDisplayInfo };
+    if (backendId === 'local' || backendId === '@workflow/world-local') {
+        Object.assign(displayInfo, await getLocalDisplayInfo());
+    }
+    const config = {
+        backendDisplayName,
+        backendId,
+        publicEnv,
+        sensitiveEnvKeys,
+        displayInfo: Object.keys(displayInfo).length ? displayInfo : undefined,
+    };
+    // Provide defaults for commonly expected keys without revealing extra secrets.
+    if ((backendId === 'vercel' || backendId === '@workflow/world-vercel') &&
+        !publicEnv.WORKFLOW_VERCEL_ENV) {
+        config.publicEnv.WORKFLOW_VERCEL_ENV = 'production';
     }
-    return createWorld();
+    return config;
+}
+/**
+ * Cache for World instances.
+ *
+ * IMPORTANT:
+ * - We only cache non-vercel worlds.
+ * - Cache keys are derived from **server-side** WORKFLOW_* env vars only.
+ */
+const worldCache = new Map();
+/**
+ * Get or create a World instance based on configuration.
+ *
+ * The @workflow/web UI should always pass `{}` for envMap.
+ */
+async function getWorldFromEnv(userEnvMap) {
+    const backendId = getEffectiveBackendId();
+    const isVercelWorld = ['vercel', '@workflow/world-vercel'].includes(backendId);
+    // For the vercel world specifically, we do not cache the world,
+    // and allow user-provided env, as it can be a multi-tenant environment,
+    // and we instantiate the world per-user directly to avoid having to set
+    // process.env.
+    if (isVercelWorld) {
+        return createVercelWorld({
+            token: userEnvMap.WORKFLOW_VERCEL_AUTH_TOKEN ||
+                process.env.WORKFLOW_VERCEL_AUTH_TOKEN,
+            projectConfig: {
+                environment: userEnvMap.WORKFLOW_VERCEL_ENV || process.env.WORKFLOW_VERCEL_ENV,
+                projectId: userEnvMap.WORKFLOW_VERCEL_PROJECT ||
+                    process.env.WORKFLOW_VERCEL_PROJECT,
+                teamId: userEnvMap.WORKFLOW_VERCEL_TEAM || process.env.WORKFLOW_VERCEL_TEAM,
+            },
+        });
+    }
+    // For other worlds, we intentionally do not trust or apply client-provided env,
+    // to avoid potential security risks in self-hosted scenarios.
+    // Ensure local-world reads from the same project directory the UI is inspecting.
+    if (backendId === 'local' || backendId === '@workflow/world-local') {
+        await ensureLocalWorldDataDirEnv();
+    }
+    // Cache key derived ONLY from WORKFLOW_* env vars.
+    const workflowEnvEntries = Object.entries(process.env).filter(([key]) => key.startsWith('WORKFLOW_'));
+    workflowEnvEntries.sort(([a], [b]) => a.localeCompare(b));
+    const cacheKey = JSON.stringify(Object.fromEntries(workflowEnvEntries));
+    const cachedWorld = worldCache.get(cacheKey);
+    if (cachedWorld) {
+        return cachedWorld;
+    }
+    const world = createWorld();
+    worldCache.set(cacheKey, world);
+    return world;
 }
 /**
  * Creates a structured error object from a caught error
  */
-function createServerActionError(error, operation, params) {
+function createServerActionError(error, operation, requestParams) {
     const err = error instanceof Error ? error : new Error(String(error));
-    // Determine if this is an API layer error (from the World interface)
-    // or a server layer error (from within the server action)
-    const isAPIError = err.message?.includes('fetch') ||
-        err.message?.includes('HTTP') ||
-        err.message?.includes('network');
-    const actionError = {
-        message: getUserFacingMessage(err),
-        layer: isAPIError ? 'API' : 'server',
-        cause: err.stack || err.message,
-        request: params ? { operation, params } : undefined,
+    console.error(`[web-api] ${operation} error:`, err);
+    let errorResponse;
+    if (WorkflowAPIError.is(error)) {
+        // If the World threw the error on fetch/fs.read, we add that data
+        // to the error object
+        errorResponse = {
+            message: getUserFacingErrorMessage(err, error.status),
+            layer: 'API',
+            cause: err.stack || err.message,
+            request: {
+                operation,
+                params: requestParams ?? {},
+                status: error.status,
+                url: error.url,
+                code: error.code ?? undefined,
+            },
+        };
+    }
+    else if (WorkflowRunNotFoundError.is(error)) {
+        // The World might repackage the error as a WorkflowRunNotFoundError
+        errorResponse = {
+            message: getUserFacingErrorMessage(error, 404),
+            layer: 'API',
+            cause: err.stack || err.message,
+            request: { operation, status: 404, params: requestParams ?? {} },
+        };
+    }
+    else {
+        errorResponse = {
+            message: getUserFacingErrorMessage(err),
+            layer: 'server',
+            cause: err.stack || err.message,
+            request: { status: 500, operation, params: requestParams ?? {} },
+        };
+    }
+    return {
+        success: false,
+        error: errorResponse,
     };
-    return actionError;
 }
 /**
  * Converts an error into a user-facing message
  */
-function getUserFacingMessage(error) {
+function getUserFacingErrorMessage(error, status) {
+    if (!status) {
+        return `Error creating response: ${error.message}`;
+    }
     // Check for common error patterns
-    if (error.message?.includes('403') || error.message?.includes('Forbidden')) {
+    if (status === 403 || status === 401) {
         return 'Access denied. Please check your credentials and permissions.';
     }
-    if (error.message?.includes('404') || error.message?.includes('Not Found')) {
+    if (status === 404) {
         return 'The requested resource was not found.';
     }
-    if (error.message?.includes('500') ||
-        error.message?.includes('Internal Server Error')) {
-        return 'An internal server error occurred. Please try again later.';
+    if (status === 500) {
+        return 'Error connecting to World backend, please try again later.';
     }
     if (error.message?.includes('Network') || error.message?.includes('fetch')) {
         return 'Network error. Please check your connection and try again.';
@@ -49,6 +381,12 @@ function getUserFacingMessage(error) {
     // Return the original message for other errors
     return error.message || 'An unexpected error occurred';
 }
+const toJSONCompatible = (data) => {
+    if (data && typeof data === 'object') {
+        return JSON.parse(JSON.stringify(data));
+    }
+    return data;
+};
 const hydrate = (data) => {
     try {
         return hydrateResourceIO(data);
@@ -63,6 +401,7 @@ const hydrate = (data) => {
  * @returns ServerActionResult with success=true and the data
  */
 function createResponse(data) {
+    data = toJSONCompatible(data);
     return {
         success: true,
         data,
@@ -74,7 +413,7 @@ function createResponse(data) {
 export async function fetchRuns(worldEnv, params) {
     const { cursor, sortOrder = 'desc', limit = 10, workflowName, status, } = params;
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const result = await world.runs.list({
             ...(workflowName ? { workflowName } : {}),
             ...(status ? { status: status } : {}),
@@ -88,11 +427,7 @@ export async function fetchRuns(worldEnv, params) {
         });
     }
     catch (error) {
-        console.error('Failed to fetch runs:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.runs.list', params),
-        };
+        return createServerActionError(error, 'world.runs.list', params);
     }
 }
 /**
@@ -100,20 +435,16 @@ export async function fetchRuns(worldEnv, params) {
  */
 export async function fetchRun(worldEnv, runId, resolveData = 'all') {
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const run = await world.runs.get(runId, { resolveData });
         const hydratedRun = hydrate(run);
         return createResponse(hydratedRun);
     }
     catch (error) {
-        console.error('Failed to fetch run:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.runs.get', {
-                runId,
-                resolveData,
-            }),
-        };
+        return createServerActionError(error, 'world.runs.get', {
+            runId,
+            resolveData,
+        });
     }
 }
 /**
@@ -122,27 +453,24 @@ export async function fetchRun(worldEnv, runId, resolveData = 'all') {
 export async function fetchSteps(worldEnv, runId, params) {
     const { cursor, sortOrder = 'asc', limit = 100 } = params;
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const result = await world.steps.list({
             runId,
             pagination: { cursor, limit, sortOrder },
             resolveData: 'none',
         });
         return createResponse({
+            // StepWithoutData has undefined input/output, but after hydration the structure is compatible
             data: result.data.map(hydrate),
             cursor: result.cursor ?? undefined,
             hasMore: result.hasMore,
         });
     }
     catch (error) {
-        console.error('Failed to fetch steps:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.steps.list', {
-                runId,
-                ...params,
-            }),
-        };
+        return createServerActionError(error, 'world.steps.list', {
+            runId,
+            ...params,
+        });
     }
 }
 /**
@@ -150,20 +478,17 @@ export async function fetchSteps(worldEnv, runId, params) {
  */
 export async function fetchStep(worldEnv, runId, stepId, resolveData = 'all') {
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const step = await world.steps.get(runId, stepId, { resolveData });
-        return createResponse(hydrate(step));
+        const hydratedStep = hydrate(step);
+        return createResponse(hydratedStep);
     }
     catch (error) {
-        console.error('Failed to fetch step:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.steps.get', {
-                runId,
-                stepId,
-                resolveData,
-            }),
-        };
+        return createServerActionError(error, 'world.steps.get', {
+            runId,
+            stepId,
+            resolveData,
+        });
     }
 }
 /**
@@ -172,7 +497,7 @@ export async function fetchStep(worldEnv, runId, stepId, resolveData = 'all') {
 export async function fetchEvents(worldEnv, runId, params) {
     const { cursor, sortOrder = 'asc', limit = 1000 } = params;
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const result = await world.events.list({
             runId,
             pagination: { cursor, limit, sortOrder },
@@ -185,14 +510,10 @@ export async function fetchEvents(worldEnv, runId, params) {
         });
     }
     catch (error) {
-        console.error('Failed to fetch events:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.events.list', {
-                runId,
-                ...params,
-            }),
-        };
+        return createServerActionError(error, 'world.events.list', {
+            runId,
+            ...params,
+        });
     }
 }
 /**
@@ -201,24 +522,23 @@ export async function fetchEvents(worldEnv, runId, params) {
 export async function fetchEventsByCorrelationId(worldEnv, correlationId, params) {
     const { cursor, sortOrder = 'asc', limit = 1000, withData = false } = params;
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const result = await world.events.listByCorrelationId({
             correlationId,
             pagination: { cursor, limit, sortOrder },
             resolveData: withData ? 'all' : 'none',
         });
         return createResponse({
-            data: result.data,
+            data: result.data.map(hydrate),
             cursor: result.cursor ?? undefined,
             hasMore: result.hasMore,
         });
     }
     catch (error) {
-        console.error('Failed to fetch events by correlation ID:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.events.listByCorrelationId', { correlationId, ...params }),
-        };
+        return createServerActionError(error, 'world.events.listByCorrelationId', {
+            correlationId,
+            ...params,
+        });
     }
 }
 /**
@@ -227,7 +547,7 @@ export async function fetchEventsByCorrelationId(worldEnv, correlationId, params
 export async function fetchHooks(worldEnv, params) {
     const { runId, cursor, sortOrder = 'desc', limit = 10 } = params;
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const result = await world.hooks.list({
             ...(runId ? { runId } : {}),
             pagination: { cursor, limit, sortOrder },
@@ -240,11 +560,7 @@ export async function fetchHooks(worldEnv, params) {
         });
     }
     catch (error) {
-        console.error('Failed to fetch hooks:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.hooks.list', params),
-        };
+        return createServerActionError(error, 'world.hooks.list', params);
     }
 }
 /**
@@ -252,19 +568,15 @@ export async function fetchHooks(worldEnv, params) {
  */
 export async function fetchHook(worldEnv, hookId, resolveData = 'all') {
     try {
-        const world = getWorldFromEnv(worldEnv);
+        const world = await getWorldFromEnv(worldEnv);
         const hook = await world.hooks.get(hookId, { resolveData });
         return createResponse(hydrate(hook));
     }
     catch (error) {
-        console.error('Failed to fetch hook:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.hooks.get', {
-                hookId,
-                resolveData,
-            }),
-        };
+        return createServerActionError(error, 'world.hooks.get', {
+            hookId,
+            resolveData,
+        });
     }
 }
 /**
@@ -272,16 +584,20 @@ export async function fetchHook(worldEnv, hookId, resolveData = 'all') {
  */
 export async function cancelRun(worldEnv, runId) {
     try {
-        const world = getWorldFromEnv(worldEnv);
-        await world.runs.cancel(runId);
+        const world = await getWorldFromEnv(worldEnv);
+        const run = await world.runs.get(runId, { resolveData: 'none' });
+        const compatMode = isLegacySpecVersion(run.specVersion);
+        const eventData = {
+            eventType: 'run_cancelled',
+            specVersion: run.specVersion || 1,
+        };
+        await world.events.create(runId, eventData, { v1Compat: compatMode });
         return createResponse(undefined);
     }
     catch (error) {
-        console.error('Failed to cancel run:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.runs.cancel', { runId }),
-        };
+        return createServerActionError(error, 'world.events.create', {
+            runId,
+        });
     }
 }
 /**
@@ -289,40 +605,257 @@ export async function cancelRun(worldEnv, runId) {
  *
  * This requires the ID of an existing run of which to re-use the deployment ID of.
  */
-export async function recreateRun(worldEnv, runId) {
+export async function recreateRun(worldEnv, runId, deploymentId) {
     try {
-        const world = getWorldFromEnv({ ...worldEnv });
+        const world = await getWorldFromEnv({ ...worldEnv });
         const run = await world.runs.get(runId);
+        // Get original input/output
         const hydratedRun = hydrate(run);
-        const deploymentId = run.deploymentId;
+        // Preserve original specVersion - if undefined (legacy v1), use SPEC_VERSION_LEGACY
         const newRun = await start({ workflowId: run.workflowName }, hydratedRun.input, {
-            deploymentId,
+            deploymentId: deploymentId ?? run.deploymentId,
+            world,
+            specVersion: run.specVersion ?? SPEC_VERSION_LEGACY,
         });
         return createResponse(newRun.runId);
     }
     catch (error) {
-        console.error('Failed to start run:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'recreateRun', { runId }),
-        };
+        return createServerActionError(error, 'recreateRun', { runId });
+    }
+}
+/**
+ * Re-enqueue a workflow run.
+ *
+ * This re-enqueues the workflow orchestration layer. It's a no-op unless the workflow
+ * got stuck due to an implementation issue in the World. Useful for debugging custom Worlds.
+ */
+export async function reenqueueRun(worldEnv, runId) {
+    try {
+        const world = await getWorldFromEnv({ ...worldEnv });
+        const run = await world.runs.get(runId);
+        const deploymentId = run.deploymentId;
+        await world.queue(`__wkf_workflow_${run.workflowName}`, {
+            runId,
+        }, {
+            deploymentId,
+        });
+        return createResponse(undefined);
+    }
+    catch (error) {
+        return createServerActionError(error, 'reenqueueRun', { runId });
+    }
+}
+/**
+ * Wake up a workflow run by interrupting pending sleep() calls.
+ *
+ * This finds wait_created events without matching wait_completed events,
+ * creates wait_completed events for them, and then re-enqueues the run.
+ *
+ * @param worldEnv - Environment configuration for the World
+ * @param runId - The run ID to wake up
+ * @param options - Optional settings to narrow down targeting (specific correlation IDs)
+ */
+export async function wakeUpRun(worldEnv, runId, options) {
+    try {
+        const world = await getWorldFromEnv({ ...worldEnv });
+        const run = await world.runs.get(runId);
+        const deploymentId = run.deploymentId;
+        const compatMode = isLegacySpecVersion(run.specVersion);
+        // Fetch all events for the run
+        const eventsResult = await world.events.list({
+            runId,
+            pagination: { limit: 1000 },
+            resolveData: 'none',
+        });
+        // Find wait_created events without matching wait_completed events
+        const waitCreatedEvents = eventsResult.data.filter((e) => e.eventType === 'wait_created');
+        const waitCompletedCorrelationIds = new Set(eventsResult.data
+            .filter((e) => e.eventType === 'wait_completed')
+            .map((e) => e.correlationId));
+        let pendingWaits = waitCreatedEvents.filter((e) => !waitCompletedCorrelationIds.has(e.correlationId));
+        // If specific correlation IDs are provided, filter to only those
+        if (options?.correlationIds && options.correlationIds.length > 0) {
+            const targetCorrelationIds = new Set(options.correlationIds);
+            pendingWaits = pendingWaits.filter((e) => e.correlationId && targetCorrelationIds.has(e.correlationId));
+        }
+        // Create wait_completed events for each pending wait
+        for (const waitEvent of pendingWaits) {
+            if (waitEvent.correlationId) {
+                // For v2, include specVersion in event data; for v1Compat, it's not needed
+                const eventData = compatMode
+                    ? {
+                        eventType: 'wait_completed',
+                        correlationId: waitEvent.correlationId,
+                    }
+                    : {
+                        eventType: 'wait_completed',
+                        correlationId: waitEvent.correlationId,
+                        specVersion: run.specVersion,
+                    };
+                await world.events.create(runId, eventData, { v1Compat: compatMode });
+            }
+        }
+        // Re-enqueue the run to wake it up
+        if (pendingWaits.length > 0) {
+            await world.queue(`__wkf_workflow_${run.workflowName}`, {
+                runId,
+            }, {
+                deploymentId,
+            });
+        }
+        return createResponse({ stoppedCount: pendingWaits.length });
+    }
+    catch (error) {
+        return createServerActionError(error, 'wakeUpRun', {
+            runId,
+            correlationIds: options?.correlationIds,
+        });
+    }
+}
+/**
+ * Resume a hook by sending a payload.
+ *
+ * This sends a payload to a hook identified by its token, which resumes
+ * the associated workflow run. The payload will be available as the return
+ * value of the `createHook()` call in the workflow.
+ *
+ * @param worldEnv - Environment configuration for the World
+ * @param token - The hook token
+ * @param payload - The JSON payload to send to the hook
+ */
+export async function resumeHook(worldEnv, token, payload) {
+    try {
+        // Initialize the world so resumeHookRuntime can access it
+        await getWorldFromEnv({ ...worldEnv });
+        const hook = await resumeHookRuntime(token, payload);
+        return createResponse({
+            hookId: hook.hookId,
+            runId: hook.runId,
+        });
+    }
+    catch (error) {
+        return createServerActionError(error, 'resumeHook', {
+            token,
+        });
     }
 }
 export async function readStreamServerAction(env, streamId, startIndex) {
     try {
-        const world = getWorldFromEnv(env);
+        const world = await getWorldFromEnv(env);
+        // We should probably use getRun().getReadable() instead, to make the UI
+        // more consistent with runtime behavior, and also expose a "replay" and "startIndex",
+        // feature, to allow for testing World behavior.
         const stream = await world.readFromStream(streamId, startIndex);
-        return createResponse(stream);
+        const revivers = getExternalRevivers(globalThis, [], '');
+        const transform = getDeserializeStream(revivers);
+        return stream.pipeThrough(transform);
     }
     catch (error) {
-        console.error('Failed to read stream:', error);
-        return {
-            success: false,
-            error: createServerActionError(error, 'world.readFromStream', {
-                streamId,
-                startIndex,
-            }),
-        };
+        const actionError = createServerActionError(error, 'world.readFromStream', {
+            streamId,
+            startIndex,
+        });
+        if (!actionError.success) {
+            return actionError.error;
+        }
+        // Shouldn't happen, this is just a type guard
+        throw new Error();
+    }
+}
+/**
+ * List all stream IDs for a run
+ */
+export async function fetchStreams(env, runId) {
+    try {
+        const world = await getWorldFromEnv(env);
+        const streams = await world.listStreamsByRunId(runId);
+        return createResponse(streams);
+    }
+    catch (error) {
+        return createServerActionError(error, 'world.listStreamsByRunId', {
+            runId,
+        });
+    }
+}
+/**
+ * Fetch the workflows manifest from the workflow route directory
+ * The manifest is generated at build time and contains static structure info about workflows
+ *
+ * Configuration priority:
+ * 1. WORKFLOW_MANIFEST_PATH - explicit path to the manifest file
+ * 2. Standard Next.js app router locations (app/.well-known/workflow/v1/manifest.json)
+ * 3. WORKFLOW_EMBEDDED_DATA_DIR - legacy data directory
+ */
+export async function fetchWorkflowsManifest(_worldEnv) {
+    const cwd = getObservabilityCwd();
+    // Helper to resolve path (absolute or relative to cwd)
+    const resolvePath = (p) => path.isAbsolute(p) ? p : path.join(cwd, p);
+    // Build list of paths to try, in priority order
+    const manifestPaths = [];
+    // 1. Explicit manifest path configuration (highest priority)
+    if (process.env.WORKFLOW_MANIFEST_PATH) {
+        manifestPaths.push(resolvePath(process.env.WORKFLOW_MANIFEST_PATH));
+    }
+    // 2. Standard Next.js app router locations
+    manifestPaths.push(path.join(cwd, 'app/.well-known/workflow/v1/manifest.json'), path.join(cwd, 'src/app/.well-known/workflow/v1/manifest.json'));
+    // 3. Legacy data directory locations
+    if (process.env.WORKFLOW_EMBEDDED_DATA_DIR) {
+        manifestPaths.push(path.join(resolvePath(process.env.WORKFLOW_EMBEDDED_DATA_DIR), 'manifest.json'));
+    }
+    // Try each path until we find the manifest
+    for (const manifestPath of manifestPaths) {
+        try {
+            const content = await fs.readFile(manifestPath, 'utf-8');
+            const manifest = JSON.parse(content);
+            return createResponse(manifest);
+        }
+        catch (_err) {
+            // Continue to next path
+        }
+    }
+    // If no manifest found, return an empty manifest
+    // This allows the UI to work without workflows graph data
+    return createResponse({
+        version: '1.0.0',
+        steps: {},
+        workflows: {},
+    });
+}
+/**
+ * Run a queue-based health check on a workflow endpoint.
+ *
+ * This sends a health check message through the Queue infrastructure,
+ * bypassing Vercel Deployment Protection. The endpoint processes the
+ * message and writes a response to a stream, which we then read to
+ * verify the endpoint is healthy.
+ *
+ * @param worldEnv - Environment configuration for the World
+ * @param endpoint - Which endpoint to check: 'workflow' or 'step'
+ * @param options - Optional configuration (timeout in ms)
+ */
+export async function runHealthCheck(worldEnv, endpoint, options) {
+    const startTime = Date.now();
+    try {
+        const world = await getWorldFromEnv(worldEnv);
+        const result = await healthCheck(world, endpoint, options);
+        const latencyMs = Date.now() - startTime;
+        return createResponse({
+            ...result,
+            latencyMs,
+        });
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        // For health check failures, we want to return success=true with healthy=false
+        // so the UI can display the error properly, rather than propagating the server
+        // action error. This allows the health check result to be parsed by the UI
+        // even when the endpoint is down or unreachable.
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createResponse({
+            healthy: false,
+            error: errorMessage,
+            latencyMs,
+        });
     }
 }
 //# sourceMappingURL=workflow-server-actions.js.map