@workflow/cli 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/lib/inspect/vercel-api.js

@@ -43,47 +43,22 @@ export async function fetchTeamInfo(teamId, authToken) {
         return null;
     }
 }
-// /**
-//  * Check if the Vercel dashboard workflows page is available
-//  */
-// export async function checkVercelDashboardAvailable(
-//   teamSlug: string,
-//   projectName: string,
-//   authToken: string
-// ): Promise<boolean> {
-//   try {
-//     const dashboardUrl = `https://vercel.com/${teamSlug}/${projectName}/ai/workflows`;
-//     logger.debug(`Checking Vercel dashboard availability: ${dashboardUrl}`);
-//     const response = await fetch(dashboardUrl, {
-//       method: 'HEAD',
-//       redirect: 'follow',
-//       headers: {
-//         Authorization: `Bearer ${authToken}`,
-//       },
-//     });
-//     // Consider 2xx and 3xx as success
-//     const isAvailable = response.status >= 200 && response.status < 400;
-//     logger.debug(
-//       `Dashboard check result: ${response.status} - ${isAvailable ? 'available' : 'not available'}`
-//     );
-//     return isAvailable;
-//   } catch (error) {
-//     logger.debug(`Error checking dashboard availability: ${error}`);
-//     return false;
-//   }
-// }
 /**
- * Get the Vercel dashboard URL for workflows
+ * Get the Vercel dashboard URL for workflows.
+ *
+ * Format: https://vercel.com/<teamSlug>/<projectSlug>/workflows/runs/<runId>?environment=<env>
+ * (the older `/observability/workflows` route is no longer used).
  */
-export function getVercelDashboardUrl(teamSlug, projectName, resource, id) {
-    let url = `https://vercel.com/${teamSlug}/${projectName}/observability/workflows`;
+export function getVercelDashboardUrl(teamSlug, projectName, resource, id, environment = 'production') {
+    const base = `https://vercel.com/${teamSlug}/${projectName}/workflows`;
+    const env = `environment=${environment}`;
     // Add resource-specific path segments
     if (resource === 'run' && id) {
-        url += `/runs/${id}?environment=production`;
+        return `${base}/runs/${id}?${env}`;
     }
-    else if (id) {
-        url += `?${resource}Id=${id}`;
+    if (id) {
+        return `${base}?${resource}Id=${id}&${env}`;
     }
-    return url;
+    return `${base}?${env}`;
 }
-//# sourceMappingURL=vercel-api.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/inspect/vercel-api.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vercel-api.test.d.ts.map

package/dist/lib/inspect/vercel-api.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-api.test.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/vercel-api.test.ts"],"names":[],"mappings":""}

package/dist/lib/inspect/vercel-api.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { getVercelDashboardUrl } from './vercel-api.js';
+describe('getVercelDashboardUrl', () => {
+    it('builds a run deep link with the default (production) environment', () => {
+        expect(getVercelDashboardUrl('my-team', 'my-project', 'run', 'wrun_123')).toBe('https://vercel.com/my-team/my-project/workflows/runs/wrun_123?environment=production');
+    });
+    it('respects the preview environment', () => {
+        expect(getVercelDashboardUrl('my-team', 'my-project', 'run', 'wrun_123', 'preview')).toBe('https://vercel.com/my-team/my-project/workflows/runs/wrun_123?environment=preview');
+    });
+    it('never emits the legacy /observability segment', () => {
+        const url = getVercelDashboardUrl('my-team', 'my-project', 'run', 'wrun_123', 'preview');
+        expect(url).not.toContain('/observability');
+    });
+    it('builds an overview link when no id is provided', () => {
+        expect(getVercelDashboardUrl('my-team', 'my-project', 'run')).toBe('https://vercel.com/my-team/my-project/workflows?environment=production');
+    });
+    it('builds a resource-query link for non-run resources', () => {
+        expect(getVercelDashboardUrl('my-team', 'my-project', 'step', 'step_456', 'preview')).toBe('https://vercel.com/my-team/my-project/workflows?stepId=step_456&environment=preview');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/inspect/vercel-link.js

@@ -272,4 +272,4 @@ export async function getRepoLink(cwd) {
         return undefined;
     }
 }
-//# sourceMappingURL=vercel-link.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vercel-link.js","sourceRoot":"","sources":["../../../src/lib/inspect/vercel-link.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This file was copied from @vercel/vercel/packages/cli/src/util/projects/link.ts\n * and adapted to work without importing most of the vercel CLI code.\n *\n * It strips:\n * - Network requests for validating whether the org/user/team/project exists\n * - Some vercel-specific environment variable checks and inference\n *   that we're not supporting for Workflow CLI for now\n */\n\nimport { execSync } from 'node:child_process';\nimport fs, { statSync } from 'node:fs';\nimport { lstat } from 'node:fs/promises';\nimport { homedir } from 'node:os';\nimport { join, normalize, posix, relative } from 'node:path';\nimport util from 'node:util';\nimport { promisify } from 'util';\nimport { logger } from '../config/log.js';\n\nconst home = homedir();\n\ninterface RepoProjectConfig {\n  id: string;\n  name: string;\n  directory: string;\n  /** Per-project orgId — added in vercel/vercel#14967. Prefer this over root-level orgId. */\n  orgId?: string;\n}\n\ninterface RepoProjectsConfig {\n  /** Legacy root-level orgId — older Vercel CLI versions put orgId here. */\n  orgId?: string;\n  remoteName: string;\n  projects: RepoProjectConfig[];\n}\n\ninterface RepoLink {\n  rootPath: string;\n  repoConfigPath: string;\n  repoConfig?: RepoProjectsConfig;\n}\n\nexport interface ProjectLink {\n  /**\n   * ID of the Vercel Project.\n   */\n  projectId: string;\n  /**\n   * User or Team ID of the owner of the Vercel Project.\n   */\n  orgId: string;\n  /**\n   * When linked as a repository, contains the absolute path\n   * to the root directory of the repository.\n   */\n  repoRoot?: string;\n  /**\n   * When linked as a repository, contains the relative path\n   * to the selected project root directory.\n   */\n  projectRootDirectory?: string;\n  /**\n   * Name of the Vercel Project.\n   */\n  projectName?: string;\n}\n\nconst readFile = promisify(fs.readFile);\n\nexport const VERCEL_DIR = '.vercel';\nexport const VERCEL_DIR_FALLBACK = '.now';\nexport const VERCEL_DIR_PROJECT = 'project.json';\nexport const VERCEL_DIR_REPO = 'repo.json';\n\nconst isDirectory = (dir: string) => {\n  try {\n    return statSync(dir).isDirectory();\n  } catch (err) {\n    logger.debug(`${dir} is not a directory: ${err}`);\n    return false;\n  }\n};\n\n/**\n * A type guard for `try...catch` errors.\n * @deprecated use `require('node:util').types.isNativeError(error)` instead\n */\nexport const isError = (error: unknown): error is Error => {\n  return util.types.isNativeError(error);\n};\n\nexport const isErrnoException = (\n  error: unknown\n): error is NodeJS.ErrnoException => {\n  return isError(error) && 'code' in error;\n};\n\nexport const isOneOfErrNoExceptions = (error: unknown, codes: string[]) => {\n  return (\n    isErrnoException(error) &&\n    'code' in error &&\n    error.code &&\n    codes.includes(error.code)\n  );\n};\n\n/**\n * Returns the `<cwd>/.vercel` directory for the current project\n * with a fallback to <cwd>/.now` if it exists.\n *\n * Throws an error if *both* `.vercel` and `.now` directories exist.\n */\nexport function getVercelDirectory(cwd: string): string {\n  logger.debug(`Getting vercel directory for ${cwd}`);\n  const possibleDirs = [join(cwd, VERCEL_DIR), join(cwd, VERCEL_DIR_FALLBACK)];\n  logger.debug(`Possible vercel directories: ${possibleDirs.join(', ')}`);\n  const existingDirs = possibleDirs.filter((d) => isDirectory(d));\n  if (existingDirs.length > 1) {\n    throw new Error(\n      'CONFLICTING_CONFIG_DIRECTORIES: Both `.vercel` and `.now` directories exist. Please remove the `.now` directory.'\n    );\n  }\n  return existingDirs[0] || possibleDirs[0];\n}\n\nexport async function getProjectLink(\n  path: string\n): Promise<ProjectLink | null> {\n  return (\n    (await getProjectLinkFromRepoLink(path)) ||\n    (await getLinkFromDir(getVercelDirectory(path)))\n  );\n}\n\n/**\n * Convert Windows separators to Unix separators.\n */\nexport function normalizeOsPath(p: string): string {\n  const isWin = process.platform === 'win32';\n  return isWin ? p.replace(/\\\\/g, '/') : p;\n}\n\nfunction sortByDirectory(\n  a: { directory: string },\n  b: { directory: string }\n): number {\n  const aParts = a.directory.split('/');\n  const bParts = b.directory.split('/');\n  return bParts.length - aParts.length;\n}\n\n/**\n * Finds the matching Projects from an array of Project links\n * where the provided relative path is within the Project's\n * root directory.\n */\nexport function findProjectsFromPath(\n  projects: RepoProjectConfig[],\n  path: string\n): RepoProjectConfig[] {\n  logger.debug(\n    `Finding projects ${JSON.stringify(projects)} from path ${path}`\n  );\n  const normalizedPath = normalizeOsPath(path);\n  const matches = projects\n    .slice()\n    .sort(sortByDirectory)\n    .filter((project) => {\n      if (project.directory === '.') {\n        // Project has no \"Root Directory\" setting, so any path is valid\n        return true;\n      }\n      return (\n        normalizedPath === project.directory ||\n        normalizedPath.startsWith(`${project.directory}/`)\n      );\n    });\n  // If there are multiple matches, we only want the most relevant\n  // selections (with the deepest directory depth), so pick the first\n  // one and filter on those matches.\n  const firstMatch = matches[0];\n  return matches.filter((match) => match.directory === firstMatch.directory);\n}\n\nasync function getProjectLinkFromRepoLink(\n  path: string\n): Promise<ProjectLink | null> {\n  const repoLink = await getRepoLink(path);\n  if (!repoLink?.repoConfig) {\n    logger.debug('No repo link found');\n    return null;\n  }\n  logger.debug('Repo link', JSON.stringify(repoLink));\n  const projects = findProjectsFromPath(\n    repoLink.repoConfig.projects,\n    relative(repoLink.rootPath, path)\n  );\n  logger.debug(`Found matching repo projects: ${JSON.stringify(projects)}`);\n  if (projects.length === 1) {\n    const project = projects[0];\n    // Prefer per-project orgId (vercel/vercel#14967), fall back to\n    // root-level orgId for older Vercel CLI versions.\n    const orgId = project.orgId ?? repoLink.repoConfig?.orgId;\n    if (!orgId) {\n      logger.debug('No orgId found in repo link project or root config');\n      return null;\n    }\n    return {\n      repoRoot: repoLink.rootPath,\n      orgId,\n      projectId: project.id,\n      projectName: project.name,\n      projectRootDirectory: project.directory,\n    };\n  } else if (projects.length > 1) {\n    throw new Error('Multiple projects found');\n  }\n  return null;\n}\n\nexport async function getLinkFromDir(\n  vercelDir: string\n): Promise<ProjectLink | null> {\n  logger.debug(`Getting link from dir ${vercelDir}`);\n  try {\n    const json = await readFile(join(vercelDir, VERCEL_DIR_PROJECT), 'utf8');\n    const link: ProjectLink = JSON.parse(json);\n\n    if (!link || !link.projectId || !link.orgId) {\n      throw new Error(\n        `Project Settings are invalid. To link your project again, remove the ${vercelDir} directory.`\n      );\n    }\n\n    return link;\n  } catch (err: unknown) {\n    // link file does not exists, project is not linked\n    if (isOneOfErrNoExceptions(err, ['ENOENT', 'ENOTDIR'])) {\n      return null;\n    }\n\n    // link file can't be read\n    if (isError(err) && err.name === 'SyntaxError') {\n      throw new Error(\n        `Project Settings could not be retrieved. To link your project again, remove the ${vercelDir} directory.`\n      );\n    }\n\n    throw err;\n  }\n}\n\nexport function* traverseUpDirectories({\n  start,\n  base,\n  maxDepth = 10,\n}: {\n  start: string;\n  base?: string;\n  maxDepth?: number;\n}) {\n  let current: string | undefined = normalize(start);\n  const normalizedRoot = base ? normalize(base) : undefined;\n  let depth = 0;\n  while (current) {\n    yield current;\n    if (current === normalizedRoot) break;\n    // Go up one directory\n    const next = join(current, '..');\n    current = next === current ? undefined : next;\n    depth++;\n    if (depth > maxDepth) {\n      logger.debug(`Max traversal depth of ${maxDepth} reached`);\n      break;\n    }\n  }\n}\n\n/**\n * Given a `start` directory, traverses up the directory hierarchy until\n * the nearest `.git/config` file is found. Returns the directory where\n * the Git config was found, or `undefined` when no Git repo was found.\n */\nexport async function findRepoRoot(\n  cwd: string,\n  start: string\n): Promise<string | undefined> {\n  const REPO_JSON_PATH = join(VERCEL_DIR, VERCEL_DIR_REPO);\n  /**\n   * If the current repo is a git submodule or git worktree '.git' is a file\n   * with a pointer to the \"parent\" git repository instead of a directory.\n   */\n  const GIT_PATH = isGitWorktreeOrSubmodule(cwd)\n    ? posix.normalize('.git')\n    : posix.normalize('.git/config');\n\n  for (const current of traverseUpDirectories({ start })) {\n    if (current === home) {\n      // Sometimes the $HOME directory is set up as a Git repo\n      // (for dotfiles, etc.). In this case it's safe to say that\n      // this isn't the repo we're looking for. Bail.\n      logger.debug('Arrived at home directory');\n      break;\n    }\n\n    // if `.vercel/repo.json` exists (already linked),\n    // then consider this the repo root\n    const repoConfigPath = join(current, REPO_JSON_PATH);\n    let stat = await lstat(repoConfigPath).catch((err) => {\n      if (err.code !== 'ENOENT') throw err;\n    });\n    if (stat) {\n      logger.debug(\n        `Found repo config \"${REPO_JSON_PATH}\" - detected \"${current}\" as repo root`\n      );\n      return current;\n    }\n\n    // if `.git/config` exists (unlinked),\n    // then consider this the repo root\n    const gitConfigPath = join(current, GIT_PATH);\n    stat = await lstat(gitConfigPath).catch((err) => {\n      if (err.code !== 'ENOENT') throw err;\n    });\n    if (stat) {\n      logger.debug(\n        `Found git config \"${GIT_PATH}\" - detected \"${current}\" as repo root`\n      );\n      return current;\n    }\n  }\n\n  logger.debug('Aborting search for repo root');\n}\n\nfunction getGitDirectory(cwd: string): string | null {\n  try {\n    const gitConfigPath = execSync('git rev-parse --git-dir', {\n      cwd,\n      encoding: 'utf8',\n      stdio: ['ignore', 'pipe', 'ignore'],\n    });\n\n    return gitConfigPath;\n  } catch (err: unknown) {\n    if (err instanceof Error) {\n      logger.debug(`Failed to get git directory: ${err.message}`);\n    }\n    return null;\n  }\n}\n\nexport function isGitWorktreeOrSubmodule(cwd: string): boolean {\n  const gitDir = getGitDirectory(cwd);\n\n  if (gitDir === null) {\n    return false;\n  }\n\n  const isGitWorktree = gitDir.includes('.git/worktrees/');\n  const isGitSubmodule = gitDir.includes('.git/modules/');\n\n  return isGitWorktree || isGitSubmodule;\n}\n\n/**\n * Given a directory path `cwd`, finds the root of the Git repository\n * and returns the parsed `.vercel/repo.json` file if the repository\n * has already been linked.\n */\nexport async function getRepoLink(cwd: string): Promise<RepoLink | undefined> {\n  // Determine where the root of the repo is\n  logger.debug(`Getting repo link for ${cwd}`);\n  const rootPath = await findRepoRoot(cwd, './');\n  if (!rootPath) {\n    logger.debug('getRepoLink: No repo root found');\n    return undefined;\n  }\n\n  // Read the `repo.json`, if this repo has already been linked\n  const repoConfigPath = join(rootPath, VERCEL_DIR, VERCEL_DIR_REPO);\n  logger.debug(`getRepoLink: Reading repo config path \"${repoConfigPath}\"`);\n  try {\n    const file = await readFile(repoConfigPath, 'utf8');\n    const repoConfig: RepoProjectsConfig = JSON.parse(file);\n    return { rootPath, repoConfig, repoConfigPath };\n  } catch (err) {\n    logger.debug(`Failed to parse ${repoConfigPath}: ${err}`);\n    return undefined;\n  }\n}\n"]}

package/dist/lib/inspect/web.d.ts

@@ -1,4 +1,11 @@
 export declare const getHostUrl: (webPort: number) => string;
+/**
+ * Build a URL for opening the local web UI.
+ *
+ * The web UI reads world configuration from server-side environment variables.
+ * Query params are only used for deep-linking to specific resources (resource/id, runId, etc.)
+ */
+export declare function buildWebUIUrl(hostUrl: string, resource: string, id: string | undefined, flags: Record<string, any>): string;
 /**
  * Launch the web UI with the specified configuration.
  * This starts the server (if not running), opens the browser, then keeps the server running.
@@ -7,4 +14,21 @@ export declare const getHostUrl: (webPort: number) => string;
  * The web UI reads these from process.env on the server side, not from query params.
  */
 export declare function launchWebUI(resource: string, id: string | undefined, flags: Record<string, any>, _cliVersion: string): Promise<void>;
+/**
+ * Build the deep-link URL for a resource without any side effects (no server,
+ * no browser). Picks the Vercel dashboard for a Vercel backend (unless
+ * `--localUi`), otherwise the local web UI deep link.
+ *
+ * Assumes env vars have already been resolved (e.g. via `setupCliWorld`).
+ */
+export declare function buildDeepLinkUrl(resource: string, id: string | undefined, flags: Record<string, any>): string;
+/**
+ * Resolve and print a shareable deep-link URL to stdout, then return — without
+ * opening a browser or starting the local web server. Intended for scripting
+ * and agents that need the link rather than a rendered dashboard.
+ *
+ * Human-readable chatter (the startup box, info/debug logs) is routed to stderr
+ * so stdout contains only the URL (or `{ "url": "..." }` with `--json`).
+ */
+export declare function printDeepLink(resource: string, id: string | undefined, flags: Record<string, any>, version: string): Promise<void>;
 //# sourceMappingURL=web.d.ts.map

package/dist/lib/inspect/web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/web.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,WAAkC,CAAC;AAqE7E;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAsGf"}
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/web.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,WAAkC,CAAC;AAsF7E;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,MAAM,CAmBR;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CA4If;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,MAAM,CAyBR;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAef"}

package/dist/lib/inspect/web.js

@@ -2,9 +2,54 @@ import chalk from 'chalk';
 import open from 'open';
 import { logger } from '../config/log.js';
 import { getEnvVars } from './env.js';
+import { setupCliWorld } from './setup.js';
 import { getVercelDashboardUrl } from './vercel-api.js';
 export const getHostUrl = (webPort) => `http://localhost:${webPort}`;
 let httpServer = null;
+/**
+ * Find embedded dashboards (e.g. a framework integration serving `/_workflow`)
+ * that are currently live for this project. Reads the best-effort registry and
+ * health-checks each entry, since stale entries are expected (a SIGKILL'd dev
+ * server can't clean up). Returns [] on any error — coordination is optional.
+ */
+async function findLiveEmbeddedDashboards() {
+    let entries;
+    try {
+        const { readDashboardRegistry } = await import('@workflow/web/registry');
+        entries = readDashboardRegistry();
+    }
+    catch {
+        return [];
+    }
+    const live = [];
+    for (const entry of entries) {
+        if (!entry?.url)
+            continue;
+        // Best-effort PID liveness check (same-host dev servers).
+        if (typeof entry.pid === 'number') {
+            try {
+                process.kill(entry.pid, 0);
+            }
+            catch {
+                continue; // process gone
+            }
+        }
+        try {
+            const res = await fetch(entry.url, {
+                method: 'HEAD',
+                redirect: 'manual',
+                signal: AbortSignal.timeout(1500),
+            });
+            // Any non-5xx response means something is serving that route.
+            if (res.status < 500)
+                live.push(entry);
+        }
+        catch {
+            // unreachable — treat as dead
+        }
+    }
+    return live;
+}
 /**
  * Check if a server is already listening on the given URL.
  */
@@ -43,7 +88,7 @@ async function startWebServer(webPort) {
  * The web UI reads world configuration from server-side environment variables.
  * Query params are only used for deep-linking to specific resources (resource/id, runId, etc.)
  */
-function buildWebUIUrl(hostUrl, resource, id, flags) {
+export function buildWebUIUrl(hostUrl, resource, id, flags) {
     const params = new URLSearchParams();
     // Deep-linking params
     params.set('resource', resource);
@@ -83,7 +128,7 @@ export async function launchWebUI(resource, id, flags, _cliVersion) {
     }
     if (isVercelBackend && teamSlug && projectName && !useLocalUi) {
         logger.debug(`Checking Vercel dashboard availability for team: ${teamSlug}, project: ${projectName}`);
-        const dashboardUrl = getVercelDashboardUrl(teamSlug, projectName, resource, id);
+        const dashboardUrl = getVercelDashboardUrl(teamSlug, projectName, resource, id, envVars.WORKFLOW_VERCEL_ENV || 'production');
         if (disableBrowserOpen) {
             logger.info(chalk.cyan(`Vercel dashboard URL: ${dashboardUrl}`));
             logger.info(chalk.cyan('(Browser auto-open disabled)'));
@@ -100,6 +145,37 @@ export async function launchWebUI(resource, id, flags, _cliVersion) {
             return;
         }
     }
+    // Defer to an already-running embedded dashboard (e.g. a framework
+    // integration serving `/_workflow`) unless the user forces a standalone
+    // server. Avoids spinning up a redundant UI on :3456 when one is already up.
+    if (!flags.standalone) {
+        const live = await findLiveEmbeddedDashboards();
+        if (live.length === 1) {
+            const target = buildWebUIUrl(live[0].url, resource, id, flags);
+            logger.info(chalk.green(`An embedded workflow dashboard is already running at ${live[0].url}`));
+            if (disableBrowserOpen) {
+                logger.info(chalk.cyan(`Open it at: ${target}`));
+                return;
+            }
+            logger.info(chalk.cyan(`Opening ${target}`));
+            try {
+                await open(target);
+            }
+            catch (error) {
+                logger.error(`Failed to open browser: ${error}`);
+                logger.info(`Please open the link manually: ${target}`);
+            }
+            return;
+        }
+        if (live.length > 1) {
+            logger.info('Embedded workflow dashboards are already running at:');
+            for (const entry of live) {
+                logger.info(chalk.cyan(`  - ${entry.url}`));
+            }
+            logger.info('Open the one you want, or pass --standalone to start a separate web UI.');
+            return;
+        }
+    }
     // Fall back to local web UI
     const webPort = flags.webPort ?? 3456;
     const hostUrl = getHostUrl(webPort);
@@ -146,4 +222,47 @@ export async function launchWebUI(resource, id, flags, _cliVersion) {
         });
     }
 }
-//# sourceMappingURL=web.js.map
+/**
+ * Build the deep-link URL for a resource without any side effects (no server,
+ * no browser). Picks the Vercel dashboard for a Vercel backend (unless
+ * `--localUi`), otherwise the local web UI deep link.
+ *
+ * Assumes env vars have already been resolved (e.g. via `setupCliWorld`).
+ */
+export function buildDeepLinkUrl(resource, id, flags) {
+    const envVars = getEnvVars();
+    const vercelBackendNames = ['vercel', '@workflow/world-vercel'];
+    const isVercelBackend = vercelBackendNames.includes(envVars.WORKFLOW_TARGET_WORLD);
+    const teamSlug = envVars.WORKFLOW_VERCEL_TEAM;
+    const projectName = envVars.WORKFLOW_VERCEL_PROJECT_NAME || envVars.WORKFLOW_VERCEL_PROJECT;
+    // Use the Vercel dashboard when targeting Vercel (and not forced local).
+    if (isVercelBackend && !flags.localUi && teamSlug && projectName) {
+        return getVercelDashboardUrl(teamSlug, projectName, resource, id, envVars.WORKFLOW_VERCEL_ENV || 'production');
+    }
+    // Fall back to the local web UI deep link.
+    const webPort = flags.webPort ?? 3456;
+    return buildWebUIUrl(getHostUrl(webPort), resource, id, flags);
+}
+/**
+ * Resolve and print a shareable deep-link URL to stdout, then return — without
+ * opening a browser or starting the local web server. Intended for scripting
+ * and agents that need the link rather than a rendered dashboard.
+ *
+ * Human-readable chatter (the startup box, info/debug logs) is routed to stderr
+ * so stdout contains only the URL (or `{ "url": "..." }` with `--json`).
+ */
+export async function printDeepLink(resource, id, flags, version) {
+    const wantsJson = Boolean(flags.json);
+    // Force JSON logging mode during setup so the startup box and any info/debug
+    // logs go to stderr, keeping stdout clean for the URL. We print the URL
+    // ourselves below, respecting the user's actual `--json` choice.
+    await setupCliWorld({ ...flags, json: true }, version, true);
+    const url = buildDeepLinkUrl(resource, id, flags);
+    if (wantsJson) {
+        process.stdout.write(`${JSON.stringify({ url }, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${url}\n`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web.js","sourceRoot":"","sources":["../../../src/lib/inspect/web.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Server } from 'node:http';\nimport chalk from 'chalk';\nimport open from 'open';\nimport { logger } from '../config/log.js';\nimport { getEnvVars } from './env.js';\nimport { setupCliWorld } from './setup.js';\nimport { getVercelDashboardUrl } from './vercel-api.js';\n\nexport const getHostUrl = (webPort: number) => `http://localhost:${webPort}`;\n\nlet httpServer: Server | null = null;\n\ninterface DashboardRegistryEntry {\n  url: string;\n  basename: string;\n  world: string;\n  pid: number;\n  startedAt: string;\n}\n\n/**\n * Find embedded dashboards (e.g. a framework integration serving `/_workflow`)\n * that are currently live for this project. Reads the best-effort registry and\n * health-checks each entry, since stale entries are expected (a SIGKILL'd dev\n * server can't clean up). Returns [] on any error — coordination is optional.\n */\nasync function findLiveEmbeddedDashboards(): Promise<DashboardRegistryEntry[]> {\n  let entries: DashboardRegistryEntry[];\n  try {\n    const { readDashboardRegistry } = await import('@workflow/web/registry');\n    entries = readDashboardRegistry() as DashboardRegistryEntry[];\n  } catch {\n    return [];\n  }\n\n  const live: DashboardRegistryEntry[] = [];\n  for (const entry of entries) {\n    if (!entry?.url) continue;\n    // Best-effort PID liveness check (same-host dev servers).\n    if (typeof entry.pid === 'number') {\n      try {\n        process.kill(entry.pid, 0);\n      } catch {\n        continue; // process gone\n      }\n    }\n    try {\n      const res = await fetch(entry.url, {\n        method: 'HEAD',\n        redirect: 'manual',\n        signal: AbortSignal.timeout(1500),\n      });\n      // Any non-5xx response means something is serving that route.\n      if (res.status < 500) live.push(entry);\n    } catch {\n      // unreachable — treat as dead\n    }\n  }\n  return live;\n}\n\n/**\n * Check if a server is already listening on the given URL.\n */\nasync function isServerRunning(hostUrl: string): Promise<boolean> {\n  try {\n    const response = await fetch(hostUrl, { method: 'HEAD' });\n    return response.ok;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Start the @workflow/web server in the current process.\n */\nasync function startWebServer(webPort: number): Promise<boolean> {\n  if (await isServerRunning(getHostUrl(webPort))) {\n    logger.debug('Server is already running');\n    return true;\n  }\n\n  try {\n    logger.info('Starting web UI server...');\n    const { startServer } = await import('@workflow/web/server');\n    httpServer = await startServer(webPort);\n    logger.success(chalk.green(`Web UI server started on port ${webPort}`));\n    return true;\n  } catch (error) {\n    logger.error(`Failed to start server: ${error}`);\n    return false;\n  }\n}\n\n/**\n * Build a URL for opening the local web UI.\n *\n * The web UI reads world configuration from server-side environment variables.\n * Query params are only used for deep-linking to specific resources (resource/id, runId, etc.)\n */\nexport function buildWebUIUrl(\n  hostUrl: string,\n  resource: string,\n  id: string | undefined,\n  flags: Record<string, any>\n): string {\n  const params = new URLSearchParams();\n\n  // Deep-linking params\n  params.set('resource', resource);\n  if (id) {\n    params.set('id', id);\n  }\n\n  // Optional deep-linking to specific run/step/hook\n  for (const flagName of ['runId', 'stepId', 'hookId'] as const) {\n    const value = flags[flagName];\n    if (value !== undefined && value !== '' && value !== false) {\n      params.set(flagName, String(value));\n    }\n  }\n\n  const queryString = params.toString();\n  return queryString ? `${hostUrl}?${queryString}` : hostUrl;\n}\n\n/**\n * Launch the web UI with the specified configuration.\n * This starts the server (if not running), opens the browser, then keeps the server running.\n *\n * World configuration is passed to the web server via environment variables.\n * The web UI reads these from process.env on the server side, not from query params.\n */\nexport async function launchWebUI(\n  resource: string,\n  id: string | undefined,\n  flags: Record<string, any>,\n  _cliVersion: string\n): Promise<void> {\n  const envVars = getEnvVars();\n\n  // Check if browser opening is disabled via flag or environment variable\n  const disableBrowserOpen = flags.noBrowser;\n\n  // Check if we should try to use the Vercel dashboard\n  const vercelBackendNames = ['vercel', '@workflow/world-vercel'];\n  const isVercelBackend = vercelBackendNames.includes(\n    envVars.WORKFLOW_TARGET_WORLD\n  );\n  const teamSlug = envVars.WORKFLOW_VERCEL_TEAM;\n  const projectName =\n    envVars.WORKFLOW_VERCEL_PROJECT_NAME || envVars.WORKFLOW_VERCEL_PROJECT;\n\n  // Check if user wants local UI via flag or environment variable\n  const useLocalUi = flags.localUi;\n\n  if (!useLocalUi && isVercelBackend) {\n    logger.info(\n      'If you do not want to use the Vercel dashboard, use the --localUi flag or set WORKFLOW_LOCAL_UI=1 in your environment variables.'\n    );\n  }\n  if (isVercelBackend && teamSlug && projectName && !useLocalUi) {\n    logger.debug(\n      `Checking Vercel dashboard availability for team: ${teamSlug}, project: ${projectName}`\n    );\n\n    const dashboardUrl = getVercelDashboardUrl(\n      teamSlug,\n      projectName,\n      resource,\n      id,\n      envVars.WORKFLOW_VERCEL_ENV || 'production'\n    );\n\n    if (disableBrowserOpen) {\n      logger.info(chalk.cyan(`Vercel dashboard URL: ${dashboardUrl}`));\n      logger.info(chalk.cyan('(Browser auto-open disabled)'));\n      return;\n    }\n\n    logger.info(\n      chalk.green(`Opening Vercel dashboard for workflows at: ${dashboardUrl}`)\n    );\n    try {\n      await open(dashboardUrl);\n      return; // Exit early since we opened the dashboard\n    } catch (error) {\n      logger.error(`Failed to open browser: ${error}`);\n      logger.info(`Please open the link manually.`);\n      return;\n    }\n  }\n\n  // Defer to an already-running embedded dashboard (e.g. a framework\n  // integration serving `/_workflow`) unless the user forces a standalone\n  // server. Avoids spinning up a redundant UI on :3456 when one is already up.\n  if (!flags.standalone) {\n    const live = await findLiveEmbeddedDashboards();\n    if (live.length === 1) {\n      const target = buildWebUIUrl(live[0].url, resource, id, flags);\n      logger.info(\n        chalk.green(\n          `An embedded workflow dashboard is already running at ${live[0].url}`\n        )\n      );\n      if (disableBrowserOpen) {\n        logger.info(chalk.cyan(`Open it at: ${target}`));\n        return;\n      }\n      logger.info(chalk.cyan(`Opening ${target}`));\n      try {\n        await open(target);\n      } catch (error) {\n        logger.error(`Failed to open browser: ${error}`);\n        logger.info(`Please open the link manually: ${target}`);\n      }\n      return;\n    }\n    if (live.length > 1) {\n      logger.info('Embedded workflow dashboards are already running at:');\n      for (const entry of live) {\n        logger.info(chalk.cyan(`  - ${entry.url}`));\n      }\n      logger.info(\n        'Open the one you want, or pass --standalone to start a separate web UI.'\n      );\n      return;\n    }\n  }\n\n  // Fall back to local web UI\n  const webPort = flags.webPort ?? 3456;\n  const hostUrl = getHostUrl(webPort);\n  const url = buildWebUIUrl(hostUrl, resource, id, flags);\n\n  // Check if server is already running\n  const alreadyRunning = await isServerRunning(hostUrl);\n\n  if (alreadyRunning) {\n    logger.info(\n      chalk.cyan(`Web UI server is already running on port ${webPort}.`)\n    );\n  } else {\n    // Start the server\n    const started = await startWebServer(webPort);\n    if (!started) {\n      logger.error('Failed to start web UI server');\n      return;\n    }\n  }\n\n  // Open browser\n  if (disableBrowserOpen) {\n    logger.info(chalk.cyan(`Web UI available at: ${url}`));\n    logger.info(chalk.cyan('(Browser auto-open disabled)'));\n  } else {\n    logger.info(chalk.cyan(`Opening browser to: ${url}`));\n    try {\n      await open(url);\n    } catch (error) {\n      logger.error(`Failed to open browser: ${error}`);\n      logger.info(`Please open the link manually.`);\n    }\n  }\n\n  // If we started the server, keep the process running\n  if (!alreadyRunning && httpServer) {\n    logger.info(chalk.cyan('Press Ctrl+C to stop the web UI server and exit'));\n\n    // Keep the CLI process alive while the server is running\n    await new Promise<void>((resolve) => {\n      if (httpServer) {\n        httpServer.on('close', () => resolve());\n      } else {\n        resolve();\n      }\n    });\n  }\n}\n\n/**\n * Build the deep-link URL for a resource without any side effects (no server,\n * no browser). Picks the Vercel dashboard for a Vercel backend (unless\n * `--localUi`), otherwise the local web UI deep link.\n *\n * Assumes env vars have already been resolved (e.g. via `setupCliWorld`).\n */\nexport function buildDeepLinkUrl(\n  resource: string,\n  id: string | undefined,\n  flags: Record<string, any>\n): string {\n  const envVars = getEnvVars();\n\n  const vercelBackendNames = ['vercel', '@workflow/world-vercel'];\n  const isVercelBackend = vercelBackendNames.includes(\n    envVars.WORKFLOW_TARGET_WORLD\n  );\n  const teamSlug = envVars.WORKFLOW_VERCEL_TEAM;\n  const projectName =\n    envVars.WORKFLOW_VERCEL_PROJECT_NAME || envVars.WORKFLOW_VERCEL_PROJECT;\n\n  // Use the Vercel dashboard when targeting Vercel (and not forced local).\n  if (isVercelBackend && !flags.localUi && teamSlug && projectName) {\n    return getVercelDashboardUrl(\n      teamSlug,\n      projectName,\n      resource,\n      id,\n      envVars.WORKFLOW_VERCEL_ENV || 'production'\n    );\n  }\n\n  // Fall back to the local web UI deep link.\n  const webPort = flags.webPort ?? 3456;\n  return buildWebUIUrl(getHostUrl(webPort), resource, id, flags);\n}\n\n/**\n * Resolve and print a shareable deep-link URL to stdout, then return — without\n * opening a browser or starting the local web server. Intended for scripting\n * and agents that need the link rather than a rendered dashboard.\n *\n * Human-readable chatter (the startup box, info/debug logs) is routed to stderr\n * so stdout contains only the URL (or `{ \"url\": \"...\" }` with `--json`).\n */\nexport async function printDeepLink(\n  resource: string,\n  id: string | undefined,\n  flags: Record<string, any>,\n  version: string\n): Promise<void> {\n  const wantsJson = Boolean(flags.json);\n\n  // Force JSON logging mode during setup so the startup box and any info/debug\n  // logs go to stderr, keeping stdout clean for the URL. We print the URL\n  // ourselves below, respecting the user's actual `--json` choice.\n  await setupCliWorld({ ...flags, json: true } as any, version, true);\n\n  const url = buildDeepLinkUrl(resource, id, flags);\n\n  if (wantsJson) {\n    process.stdout.write(`${JSON.stringify({ url }, null, 2)}\\n`);\n  } else {\n    process.stdout.write(`${url}\\n`);\n  }\n}\n"]}

package/dist/lib/update-check.js

@@ -239,4 +239,4 @@ export async function checkForUpdateCached(currentVersion) {
     }
     return result;
 }
-//# sourceMappingURL=update-check.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-check.js","sourceRoot":"","sources":["../../src/lib/update-check.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdir, readFile, writeFile } from 'node:fs/promises';\nimport { dirname, join } from 'node:path';\nimport XDGAppPaths from 'xdg-app-paths';\nimport { logger } from './config/log.js';\n\n// Constants\nconst PACKAGE_NAME = '@workflow/cli';\nconst NPM_REGISTRY = 'https://registry.npmjs.org';\nconst CACHE_DURATION_MS = 3 * 24 * 60 * 60 * 1000; // 3 days\nconst REQUEST_TIMEOUT_MS = 5000;\nconst VERSION_CHECK_CACHE_FILENAME = 'version-check.json';\n\n// Get XDG-compliant cache directory for workflow\nconst getXDGAppPaths = (app: string) => {\n  return (\n    XDGAppPaths as unknown as (app: string) => { dataDirs: () => string[] }\n  )(app);\n};\n\n/**\n * Get the cache file path for version checks.\n */\nexport function getVersionCheckCacheFile(): string {\n  const dirs = getXDGAppPaths('workflow').dataDirs();\n  return join(dirs[0], VERSION_CHECK_CACHE_FILENAME);\n}\n\ninterface VersionCheckResult {\n  currentVersion: string;\n  latestVersion?: string;\n  needsUpdate: boolean;\n}\n\ninterface CachedVersionData {\n  currentVersion: string;\n  latestVersion: string;\n  timestamp: number;\n}\n\n/**\n * Compare two semver versions including pre-release tags\n * Returns true if version a is greater than version b\n */\nfunction compareVersions(a: string, b: string): boolean {\n  const parseVersion = (v: string) => {\n    const [base, prerelease] = v.split('-');\n    const parts = base.split('.').map(Number);\n    return { parts, prerelease };\n  };\n\n  const comparePrerelease = (\n    pre1: string | undefined,\n    pre2: string | undefined\n  ): number => {\n    if (!pre1 && !pre2) return 0; // both no prerelease\n    if (!pre1 && pre2) return 1; // no prerelease > prerelease\n    if (pre1 && !pre2) return -1; // prerelease < no prerelease\n    if (typeof pre1 !== 'string' || typeof pre2 !== 'string') return 0;\n\n    // Both have prerelease - compare them properly\n    const parts1 = pre1.split('.');\n    const parts2 = pre2.split('.');\n\n    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {\n      const p1 = parts1[i];\n      const p2 = parts2[i];\n\n      // If one side is missing, it's less than the other\n      if (p1 === undefined) return -1;\n      if (p2 === undefined) return 1;\n\n      // Try to parse as numbers for numeric comparison\n      const num1 = Number(p1);\n      const num2 = Number(p2);\n      const isNum1 = !Number.isNaN(num1) && p1 !== '';\n      const isNum2 = !Number.isNaN(num2) && p2 !== '';\n\n      if (isNum1 && isNum2) {\n        // Both are numbers - compare numerically\n        if (num1 > num2) return 1;\n        if (num1 < num2) return -1;\n      } else {\n        // At least one is non-numeric - compare as strings\n        if (p1 > p2) return 1;\n        if (p1 < p2) return -1;\n      }\n    }\n\n    return 0; // equal\n  };\n\n  const versionA = parseVersion(a);\n  const versionB = parseVersion(b);\n\n  // Compare major, minor, patch\n  for (let i = 0; i < 3; i++) {\n    if (versionA.parts[i] > versionB.parts[i]) return true;\n    if (versionA.parts[i] < versionB.parts[i]) return false;\n  }\n\n  // If versions are equal up to patch level, check prerelease\n  // No prerelease is considered greater than prerelease\n  const preResult = comparePrerelease(versionA.prerelease, versionB.prerelease);\n  return preResult > 0;\n}\n\n/**\n * Fetch the latest version from npm registry\n */\nasync function fetchLatestVersion(\n  currentVersion: string\n): Promise<string | null> {\n  try {\n    const controller = new AbortController();\n    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);\n\n    const url = `${NPM_REGISTRY}/${PACKAGE_NAME}`;\n    logger.debug(`Checking for updates at ${url}`);\n\n    const response = await fetch(url, {\n      headers: {\n        Accept: 'application/json',\n      },\n      signal: controller.signal,\n    });\n\n    clearTimeout(timeoutId);\n\n    if (!response.ok) {\n      logger.debug(\n        `Failed to fetch package info: ${response.status} ${response.statusText}`\n      );\n      return null;\n    }\n\n    const data = (await response.json()) as {\n      'dist-tags': { [tag: string]: string };\n    };\n\n    const latestVersion = data['dist-tags']['latest'];\n    if (!latestVersion) {\n      logger.debug('No latest version found in registry');\n      return null;\n    }\n\n    logger.debug(`Current: ${currentVersion}, Latest: ${latestVersion}`);\n    return latestVersion;\n  } catch (error) {\n    if (error instanceof Error && error.name === 'AbortError') {\n      logger.debug('Version check timed out after 5 seconds');\n    } else {\n      logger.debug(`Error fetching version: ${error}`);\n    }\n    return null;\n  }\n}\n\n/**\n * Check if there's a new version available\n * Returns the current and latest version if an update is available\n */\nexport async function checkForUpdate(\n  currentVersion: string\n): Promise<VersionCheckResult> {\n  const latestVersion = await fetchLatestVersion(currentVersion);\n\n  if (!latestVersion) {\n    return {\n      currentVersion,\n      needsUpdate: false,\n    };\n  }\n\n  // Don't suggest prerelease updates to users on stable versions\n  const currentIsStable = !currentVersion.includes('-');\n  const latestIsPrerelease = latestVersion.includes('-');\n  const needsUpdate =\n    !(currentIsStable && latestIsPrerelease) &&\n    compareVersions(latestVersion, currentVersion);\n\n  return {\n    currentVersion,\n    latestVersion,\n    needsUpdate,\n  };\n}\n\n/**\n * Read cached version data from file\n */\nasync function readCache(cacheFile: string): Promise<CachedVersionData | null> {\n  try {\n    const content = await readFile(cacheFile, 'utf-8');\n    const data = JSON.parse(content) as CachedVersionData;\n    return data;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Write version data to cache file\n */\nasync function writeCache(\n  cacheFile: string,\n  data: CachedVersionData\n): Promise<void> {\n  try {\n    await mkdir(dirname(cacheFile), { recursive: true });\n    await writeFile(cacheFile, JSON.stringify(data, null, 2));\n  } catch (error) {\n    logger.debug(`Failed to write version cache: ${error}`);\n  }\n}\n\n/**\n * Check if cache is still valid\n */\nasync function isCacheValid(\n  cacheFile: string,\n  currentVersion: string\n): Promise<boolean> {\n  try {\n    const cached = await readCache(cacheFile);\n    if (!cached) return false;\n\n    // Cache is invalid if version changed\n    if (cached.currentVersion !== currentVersion) {\n      logger.debug('Version changed, cache invalidated');\n      return false;\n    }\n\n    // Check if cache is still fresh\n    const now = Date.now();\n    const age = now - cached.timestamp;\n    const isValid = age < CACHE_DURATION_MS;\n\n    if (!isValid) {\n      logger.debug(\n        `Cache expired (age: ${Math.floor(age / 1000 / 60)} minutes)`\n      );\n    }\n\n    return isValid;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check for updates with filesystem caching\n * Cache is valid unless the local version changes\n *\n * Set WORKFLOW_NO_UPDATE_CHECK=1 to skip the update check entirely.\n */\nexport async function checkForUpdateCached(\n  currentVersion: string\n): Promise<VersionCheckResult> {\n  if (process.env.WORKFLOW_NO_UPDATE_CHECK === '1') {\n    logger.debug('Skipping update check (WORKFLOW_NO_UPDATE_CHECK=1)');\n    return { currentVersion, needsUpdate: false };\n  }\n\n  const cacheFile = getVersionCheckCacheFile();\n\n  // Check if cache is valid\n  if (await isCacheValid(cacheFile, currentVersion)) {\n    logger.debug('Using cached version check result');\n    const cached = await readCache(cacheFile);\n    if (cached) {\n      // Don't suggest prerelease updates to users on stable versions\n      const currentIsStable = !cached.currentVersion.includes('-');\n      const latestIsPrerelease = cached.latestVersion.includes('-');\n      return {\n        currentVersion: cached.currentVersion,\n        latestVersion: cached.latestVersion,\n        needsUpdate:\n          !(currentIsStable && latestIsPrerelease) &&\n          compareVersions(cached.latestVersion, cached.currentVersion),\n      };\n    }\n  }\n\n  // Perform fresh check\n  logger.debug('Performing fresh version check');\n  const result = await checkForUpdate(currentVersion);\n\n  // Cache the result if we got a latest version\n  if (result.latestVersion) {\n    await writeCache(cacheFile, {\n      currentVersion: result.currentVersion,\n      latestVersion: result.latestVersion,\n      timestamp: Date.now(),\n    });\n  }\n\n  return result;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/cli",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.41",
   "description": "Command-line interface for Workflow SDK",
   "type": "module",
   "bin": {
@@ -31,10 +31,11 @@
   },
   "devDependencies": {
     "@types/node": "22.19.0",
+    "typescript": "^6.0.3",
     "@workflow/tsconfig": "5.0.0-beta.0"
   },
   "dependencies": {
-    "@oclif/core": "4.8.1",
+    "@oclif/core": "4.11.4",
     "@oclif/plugin-help": "6.2.37",
     "@swc/core": "1.15.3",
     "@vercel/cli-auth": "0.0.1",
@@ -46,24 +47,24 @@
     "dotenv": "^17.3.1",
     "easy-table": "1.2.0",
     "enhanced-resolve": "5.19.0",
-    "esbuild": "^0.27.3",
+    "esbuild": "^0.28.1",
     "find-up": "7.0.0",
     "mixpart": "0.0.4",
     "open": "10.2.0",
     "ora": "8.2.0",
     "terminal-link": "5.0.0",
-    "tinyglobby": "0.2.15",
+    "tinyglobby": "0.2.17",
     "xdg-app-paths": "5.1.0",
-    "zod": "4.3.6",
-    "@workflow/builders": "5.0.0-beta.4",
-    "@workflow/swc-plugin": "5.0.0-beta.3",
-    "@workflow/utils": "5.0.0-beta.1",
-    "@workflow/errors": "5.0.0-beta.1",
-    "@workflow/core": "5.0.0-beta.4",
-    "@workflow/web": "5.0.0-beta.4",
-    "@workflow/world": "5.0.0-beta.1",
-    "@workflow/world-local": "5.0.0-beta.3",
-    "@workflow/world-vercel": "5.0.0-beta.3"
+    "zod": "~4.3.6",
+    "@workflow/builders": "5.0.0-beta.41",
+    "@workflow/core": "5.0.0-beta.41",
+    "@workflow/errors": "5.0.0-beta.16",
+    "@workflow/swc-plugin": "5.0.0-beta.5",
+    "@workflow/utils": "5.0.0-beta.8",
+    "@workflow/web": "5.0.0-beta.41",
+    "@workflow/world": "5.0.0-beta.26",
+    "@workflow/world-local": "5.0.0-beta.35",
+    "@workflow/world-vercel": "5.0.0-beta.37"
   },
   "scripts": {
     "build": "tsc && chmod +x bin/run.js",

package/dist/base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.js","sourceRoot":"","sources":["../src/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAElD,KAAK,UAAU,WAAW,CAAC,MAA0B;IACnD,IACE,CAAC,MAAM,CAAC,QAAQ;QAChB,MAAM,CAAC,SAAS;QAChB,MAAM,CAAC,MAAM;QACb,MAAM,CAAC,aAAa;QACpB,MAAM,CAAC,gBAAgB,EACvB,CAAC;QACD,OAAO;IACT,CAAC;IAED,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;QAClC,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC9B,IAAI,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,GAAG,EAAE;gBACpB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBAC7B,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC7B,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,OAAgB,WAAY,SAAQ,OAAO;IAC/C,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;IAE7B;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,GAAsB;QAClC,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,QAAQ,EAAE,CAAC;YAC/B,MAAM,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;QACxB,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,IAAI,CACP,0BAA0B,QAAQ,YAAY,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAC5F,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACzB,qEAAqE;QACrE,wEAAwE;QACxE,yEAAyE;QACzE,qEAAqE;QACrE,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC;YAC3B,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC;SAC5B,CAAC,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IAES,OAAO,CAAC,OAAe;QAC/B,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACpB,CAAC;IAES,OAAO,CAAC,OAAe;QAC/B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrB,CAAC;IAES,QAAQ,CAAC,OAAe;QAChC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACtB,CAAC","sourcesContent":["import { Command } from '@oclif/core';\nimport { getWorld } from '@workflow/core/runtime';\n\nasync function flushStream(stream: NodeJS.WriteStream): Promise<void> {\n  if (\n    !stream.writable ||\n    stream.destroyed ||\n    stream.closed ||\n    stream.writableEnded ||\n    stream.writableFinished\n  ) {\n    return;\n  }\n\n  await new Promise<void>((resolve) => {\n    const onError = () => resolve();\n    stream.once('error', onError);\n    try {\n      stream.write('', () => {\n        stream.off('error', onError);\n        resolve();\n      });\n    } catch {\n      stream.off('error', onError);\n      resolve();\n    }\n  });\n}\n\nexport abstract class BaseCommand extends Command {\n  static enableJsonFlag = true;\n\n  /**\n   * Called by oclif after `run()` completes (or throws).\n   * Closes the cached World instance so the process can exit cleanly\n   * without relying on `process.exit()`.\n   */\n  async finally(err: Error | undefined): Promise<void> {\n    try {\n      const world = await getWorld();\n      await world.close?.();\n    } catch (closeErr) {\n      this.warn(\n        `Failed to close world: ${closeErr instanceof Error ? closeErr.message : String(closeErr)}`\n      );\n    }\n    await super.finally(err);\n    // Force exit. World.close() cleaned up database connections and HTTP\n    // agents, but third-party libraries (oclif update checker, postgres.js)\n    // may leave timers or sockets that prevent the event loop from draining.\n    // This is safe because all business logic and cleanup has completed.\n    await Promise.all([\n      flushStream(process.stdout),\n      flushStream(process.stderr),\n    ]);\n    process.exit(err ? 1 : (process.exitCode ?? 0));\n  }\n\n  protected logInfo(message: string): void {\n    this.log(message);\n  }\n\n  protected logWarn(message: string): void {\n    this.warn(message);\n  }\n\n  protected logError(message: string): void {\n    this.error(message);\n  }\n}\n"]}

package/dist/commands/build.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build.js","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from '@oclif/core';\nimport {\n  StandaloneBuilder,\n  VercelBuildOutputAPIBuilder,\n} from '@workflow/builders';\nimport { BaseCommand } from '../base.js';\nimport { type BuildTarget, isValidBuildTarget } from '../lib/config/types.js';\nimport { getWorkflowConfig } from '../lib/config/workflow-config.js';\n\nexport default class Build extends BaseCommand {\n  static description = 'Build workflow bundles for deployment';\n\n  static examples = [\n    '$ workflow build',\n    '$ workflow build --target vercel-build-output-api',\n    '$ workflow build standalone',\n  ];\n\n  static flags = {\n    target: Flags.string({\n      char: 't',\n      description: 'build target',\n      options: ['standalone', 'vercel-build-output-api'],\n      default: 'standalone',\n    }),\n    'workflow-manifest': Flags.string({\n      char: 'm',\n      description: 'output location for workflow manifest',\n      default: '',\n    }),\n  };\n\n  static args = {\n    target: Args.string({\n      description: 'build target (deprecated, use --target flag)',\n      required: false,\n    }),\n  };\n\n  public async run(): Promise<void> {\n    const { args, flags } = await this.parse(Build);\n\n    // Get build target from flag or arg (with flag taking precedence)\n    let buildTarget: string = flags.target;\n    if (args.target && !flags.target) {\n      buildTarget = args.target;\n      this.logWarn(\n        'Using positional argument for target is deprecated. Use --target flag instead.'\n      );\n    }\n\n    if (\n      flags['workflow-manifest'] &&\n      !flags['workflow-manifest'].match(/\\.(json|js|cjs|mjs)$/)\n    ) {\n      throw new Error(\n        `Invalid --workflow-manifest provided, must end in .json or .js. Received: ${flags['workflow-manifest']}`\n      );\n    }\n\n    // Validate build target\n    if (!isValidBuildTarget(buildTarget)) {\n      this.logWarn(\n        `Invalid target \"${buildTarget}\". Using default \"standalone\".`\n      );\n      this.logWarn('Valid targets: standalone, vercel-build-output-api');\n      buildTarget = 'standalone';\n    }\n\n    this.logInfo(`Using target: ${buildTarget}`);\n\n    const config = getWorkflowConfig({\n      buildTarget: buildTarget as BuildTarget,\n      workflowManifest: flags['workflow-manifest'],\n    });\n\n    try {\n      // Build using appropriate builder\n      if (config.buildTarget === 'standalone') {\n        this.logInfo('Building with StandaloneBuilder');\n        const builder = new StandaloneBuilder(config);\n        await builder.build();\n      } else if (config.buildTarget === 'vercel-build-output-api') {\n        this.logInfo('Building with VercelBuildOutputAPIBuilder');\n        const builder = new VercelBuildOutputAPIBuilder(config);\n        await builder.build();\n      } else {\n        this.error(`Unknown build target: ${config.buildTarget}`);\n      }\n\n      this.logInfo('Build completed successfully!');\n    } catch (error) {\n      this.error(\n        `Build failed: ${\n          error instanceof Error ? error.message : String(error)\n        }`\n      );\n    }\n  }\n}\n"]}

package/dist/commands/cancel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cancel.js","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"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","sourcesContent":["import readline from 'node:readline';\nimport { Args, Flags } from '@oclif/core';\nimport { cancelRun } from '@workflow/core/runtime';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport chalk from 'chalk';\nimport Table from 'easy-table';\nimport { BaseCommand } from '../base.js';\nimport { LOGGING_CONFIG, logger } from '../lib/config/log.js';\nimport { cliFlags } from '../lib/inspect/flags.js';\nimport { setupCliWorld } from '../lib/inspect/setup.js';\n\nexport default class Cancel extends BaseCommand {\n  static description =\n    'Cancel a workflow run, or bulk-cancel runs by status/name';\n\n  static aliases = ['c'];\n\n  static examples = [\n    '$ workflow cancel <run-id>',\n    '$ workflow cancel --status=running',\n    '$ workflow cancel --status=running --workflowName=myWorkflow',\n    '$ workflow cancel --status=running -y',\n  ];\n\n  async catch(error: any) {\n    if (LOGGING_CONFIG.VERBOSE_MODE) {\n      console.error(error);\n    }\n    throw error;\n  }\n\n  static args = {\n    runId: Args.string({\n      description: 'ID of the run to cancel (omit for bulk mode with filters)',\n      required: false,\n    }),\n  } as const;\n\n  static flags = {\n    ...cliFlags,\n    status: Flags.string({\n      description: 'Filter runs by status for bulk cancel',\n      required: false,\n      options: ['running', 'completed', 'failed', 'cancelled', 'pending'],\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--status',\n    }),\n    workflowName: Flags.string({\n      description: 'Filter runs by workflow name for bulk cancel',\n      required: false,\n      char: 'n',\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-n, --workflowName',\n    }),\n    limit: Flags.integer({\n      description: 'Max runs to cancel in bulk mode',\n      required: false,\n      default: 50,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--limit',\n      helpValue: 'NUMBER',\n    }),\n    confirm: Flags.boolean({\n      description: 'Skip interactive confirmation prompt',\n      required: false,\n      char: 'y',\n      default: false,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-y, --confirm',\n    }),\n  };\n\n  public async run(): Promise<void> {\n    const { flags, args } = await this.parse(Cancel);\n\n    const world = await setupCliWorld(flags, this.config.version);\n    if (!world) {\n      throw new Error(\n        'Failed to connect to backend. Check your configuration.'\n      );\n    }\n\n    // Single-run cancel (existing behavior)\n    if (args.runId) {\n      await cancelRun(world, args.runId);\n      logger.log(chalk.green(`Cancelled run ${args.runId}`));\n      return;\n    }\n\n    // Bulk mode requires at least one filter\n    if (!flags.status && !flags.workflowName) {\n      logger.error(\n        'Provide a run ID or use --status/--workflowName to bulk cancel.\\n' +\n          'Examples:\\n' +\n          '  workflow cancel <run-id>\\n' +\n          '  workflow cancel --status=running\\n' +\n          '  workflow cancel --status=running --workflowName=myWorkflow'\n      );\n      process.exit(1);\n    }\n\n    // Fetch matching runs\n    const runs = await world.runs.list({\n      status: flags.status as any,\n      workflowName: flags.workflowName,\n      pagination: { limit: flags.limit || 50 },\n      resolveData: 'none',\n    });\n\n    if (runs.data.length === 0) {\n      logger.warn('No matching runs found.');\n      return;\n    }\n\n    // Display what will be cancelled\n    const table = new Table();\n    for (const run of runs.data) {\n      const shortName =\n        parseWorkflowName(run.workflowName)?.shortName || run.workflowName;\n      table.cell('runId', run.runId);\n      table.cell('workflow', chalk.blueBright(shortName));\n      table.cell('status', run.status);\n      table.cell(\n        'startedAt',\n        run.startedAt ? new Date(run.startedAt).toISOString() : '-'\n      );\n      table.newRow();\n    }\n    logger.log(`\\nFound ${chalk.bold(runs.data.length)} runs to cancel:\\n`);\n    logger.log(table.toString());\n\n    if (runs.hasMore) {\n      logger.warn(\n        `More runs match these filters. Increase --limit (currently ${flags.limit || 50}) or re-run to cancel additional runs.`\n      );\n    }\n\n    // Confirm unless --confirm/-y\n    if (!flags.confirm) {\n      const confirmed = await promptConfirm(\n        `Cancel ${runs.data.length} run${runs.data.length === 1 ? '' : 's'}?`\n      );\n      if (!confirmed) {\n        logger.log('Aborted.');\n        return;\n      }\n    }\n\n    // Cancel each run with progress\n    let cancelled = 0;\n    let failed = 0;\n    for (const run of runs.data) {\n      try {\n        await cancelRun(world, run.runId);\n        cancelled++;\n        logger.log(\n          chalk.green(`  ✓ ${run.runId}`) +\n            chalk.gray(` (${cancelled}/${runs.data.length})`)\n        );\n      } catch (err: any) {\n        failed++;\n        logger.warn(`  ✗ ${run.runId}: ${err.message || String(err)}`);\n      }\n    }\n\n    logger.log(\n      `\\nDone: ${chalk.green(`${cancelled} cancelled`)}${failed > 0 ? `, ${chalk.red(`${failed} failed`)}` : ''}`\n    );\n  }\n}\n\nasync function promptConfirm(message: string): Promise<boolean> {\n  // Non-TTY: abort since user cannot confirm interactively (use -y/--confirm to skip prompt)\n  if (!process.stdin.isTTY) {\n    return false;\n  }\n\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise<boolean>((resolve) => {\n    rl.question(`${message} [y/N] `, (answer) => {\n      rl.close();\n      resolve(answer.trim().toLowerCase() === 'y');\n    });\n  });\n}\n"]}

package/dist/commands/dev.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev.js","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,MAAM,CAAC,OAAO,OAAO,GAAI,SAAQ,WAAW;IAC1C,MAAM,CAAC,WAAW,GAChB,2DAA2D,CAAC;IAE9D,MAAM,CAAC,QAAQ,GAAG,CAAC,gBAAgB,EAAE,4BAA4B,CAAC,CAAC;IAEnE,MAAM,CAAC,KAAK,GAAG;QACb,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC;YAClB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,2BAA2B;YACxC,OAAO,EAAE,IAAI;SACd,CAAC;QACF,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;YACnB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,8BAA8B;YAC3C,OAAO,EAAE,CAAC,YAAY,EAAE,yBAAyB,CAAC;YAClD,OAAO,EAAE,YAAY;SACtB,CAAC;KACH,CAAC;IAEK,KAAK,CAAC,GAAG;QACd,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAExC,IAAI,CAAC,OAAO,CAAC,uCAAuC,CAAC,CAAC;QACtD,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,OAAO,CAAC,4BAA4B,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,0CAA0C,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,CAAC,uCAAuC,CAAC,CAAC;QACtD,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,OAAO,CAAC,8BAA8B,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,CAAC,iBAAiB,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;QAC9C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,OAAO,CAAC,gDAAgD,CAAC,CAAC;IACjE,CAAC","sourcesContent":["import { Flags } from '@oclif/core';\nimport { BaseCommand } from '../base.js';\n\nexport default class Dev extends BaseCommand {\n  static description =\n    'Start development server with file watching (Coming soon)';\n\n  static examples = ['$ workflow dev', '$ workflow dev --port 3001'];\n\n  static flags = {\n    port: Flags.integer({\n      char: 'p',\n      description: 'port to run dev server on',\n      default: 3000,\n    }),\n    target: Flags.string({\n      char: 't',\n      description: 'build target for development',\n      options: ['standalone', 'vercel-build-output-api'],\n      default: 'standalone',\n    }),\n  };\n\n  public async run(): Promise<void> {\n    const { flags } = await this.parse(Dev);\n\n    this.logInfo('🚧 Development server is coming soon!');\n    this.logInfo('');\n    this.logInfo('This command will provide:');\n    this.logInfo('• File watching');\n    this.logInfo('• Development server for local workflows');\n    this.logInfo('• Better error messages and debugging');\n    this.logInfo('');\n    this.logInfo(`Configured to run on port: ${flags.port}`);\n    this.logInfo(`Build target: ${flags.target}`);\n    this.logInfo('');\n    this.logInfo('For now, use: workflow build --target <target>');\n  }\n}\n"]}