veryfront 0.1.21 → 0.1.23

package/src/src/studio/bridge-template.ts

@@ -490,7 +490,7 @@ export function generateStudioBridgeScript(options: StudioBridgeOptions): string
 
     html2canvasPromise = new Promise((resolve, reject) => {
       const script = document.createElement('script');
-      script.src = 'https://cdn.jsdelivr.net/npm/html2canvas@1.4.1/dist/html2canvas.min.js';
+      script.src = 'https://cdn.jsdelivr.net/npm/html2canvas-pro@2.0.0/dist/html2canvas-pro.min.js';
       script.onload = () => {
         html2canvasLoaded = true;
         resolve();
@@ -528,7 +528,8 @@ export function generateStudioBridgeScript(options: StudioBridgeOptions): string
         await new Promise(r => setTimeout(r, 100));
       }
 
-      const canvas = await window.html2canvas(document.body, canvasOptions);
+      const html2canvasFn = window.html2canvas.default || window.html2canvas;
+      const canvas = await html2canvasFn(document.body, canvasOptions);
       const dataUrl = canvas.toDataURL('image/png', quality);
 
       window.scrollTo(0, originalScrollY);

package/src/src/task/discovery.ts

@@ -0,0 +1,228 @@
+/**
+ * Task Discovery
+ *
+ * Discovers task definitions from user's project `tasks/` directory.
+ * Follows the same patterns as workflow-discovery.ts.
+ *
+ * Scans:
+ * - tasks/*.ts - task definition files
+ * - tasks/**\/*.ts - nested task files
+ *
+ * Task files should export a task definition:
+ * ```typescript
+ * export default {
+ *   name: "Sync external data",
+ *   run: async (ctx) => {
+ *     console.log("Syncing data...")
+ *     return { synced: 42 }
+ *   }
+ * }
+ * ```
+ */
+
+import { join } from "../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { logger as baseLogger } from "../utils/index.js";
+import type { RuntimeAdapter } from "../platform/index.js";
+import type { VeryfrontConfig } from "../config/index.js";
+import { collectFiles } from "../utils/file-discovery.js";
+import { loadHandlerModule } from "../routing/api/module-loader/loader.js";
+import type { TaskDefinition } from "./types.js";
+import { isTaskDefinition } from "./types.js";
+
+const logger = baseLogger.component("task-discovery");
+
+/**
+ * Discovered task info
+ */
+export interface DiscoveredTask {
+  /** Task ID derived from file path (e.g., "sync-data" from tasks/sync-data.ts) */
+  id: string;
+
+  /** Human-readable name from task definition */
+  name: string;
+
+  /** File path where the task is defined */
+  filePath: string;
+
+  /** Export name (e.g., "default" or named export) */
+  exportName: string;
+
+  /** The task definition */
+  definition: TaskDefinition;
+}
+
+/**
+ * Options for task discovery
+ */
+export interface TaskDiscoveryOptions {
+  /** Project directory */
+  projectDir: string;
+
+  /** Runtime adapter for filesystem operations */
+  adapter: RuntimeAdapter;
+
+  /** Veryfront config (for import maps, etc.) */
+  config?: VeryfrontConfig;
+
+  /** Base directory for tasks (default: "tasks") */
+  tasksDir?: string;
+
+  /** Enable debug logging */
+  debug?: boolean;
+}
+
+/**
+ * Result of task discovery
+ */
+export interface TaskDiscoveryResult {
+  /** All discovered tasks */
+  tasks: DiscoveredTask[];
+
+  /** Errors encountered during discovery */
+  errors: Array<{ filePath: string; error: string }>;
+}
+
+/**
+ * Derive task ID from file path (e.g., "tasks/sync-data.ts" → "sync-data")
+ */
+export function deriveTaskId(filePath: string, tasksDir: string): string {
+  // Remove the tasks dir prefix and extension
+  let relative = filePath;
+  const dirPrefix = tasksDir.endsWith("/") ? tasksDir : `${tasksDir}/`;
+  if (relative.startsWith(dirPrefix)) {
+    relative = relative.slice(dirPrefix.length);
+  }
+  // Remove extension
+  return relative.replace(/\.(ts|tsx|js|jsx)$/, "");
+}
+
+/**
+ * Discover all tasks in a project
+ */
+export async function discoverTasks(
+  options: TaskDiscoveryOptions,
+): Promise<TaskDiscoveryResult> {
+  const {
+    projectDir,
+    adapter,
+    config,
+    tasksDir = "tasks",
+    debug = false,
+  } = options;
+
+  const tasks: DiscoveredTask[] = [];
+  const errors: Array<{ filePath: string; error: string }> = [];
+
+  const fsType = config?.fs?.type ?? "local";
+  const useRelativePaths = fsType === "github" || fsType === "veryfront-api";
+  const baseDir = useRelativePaths ? tasksDir : join(projectDir, tasksDir);
+
+  if (debug) {
+    logger.info(`Scanning ${baseDir} for tasks`);
+  }
+
+  try {
+    const dirExists = await adapter.fs.exists(baseDir);
+    if (!dirExists) {
+      if (debug) {
+        logger.info(`No tasks directory found at ${baseDir}`);
+      }
+      return { tasks, errors };
+    }
+
+    const files = await collectFiles({
+      baseDir,
+      extensions: [".ts", ".tsx", ".js", ".jsx"],
+      recursive: true,
+      ignorePatterns: ["node_modules", ".git", "__tests__", "*.test.*", "*.spec.*"],
+      adapter,
+    });
+
+    if (debug) {
+      logger.info(`Found ${files.length} potential task files`);
+    }
+
+    for (const file of files) {
+      try {
+        const module = await loadHandlerModule({
+          projectDir,
+          modulePath: file.path,
+          adapter,
+          config,
+        });
+
+        if (!module) continue;
+
+        // Prefer default export (aligned with discovery-engine behaviour)
+        const defaultExport = (module as Record<string, unknown>).default;
+        if (isTaskDefinition(defaultExport)) {
+          const id = deriveTaskId(file.path, baseDir);
+          tasks.push({
+            id,
+            name: defaultExport.name || id,
+            filePath: file.path,
+            exportName: "default",
+            definition: defaultExport,
+          });
+
+          if (debug) {
+            logger.info(`Found task "${id}" in ${file.path} (export: default)`);
+          }
+        } else {
+          // Fallback: check named exports
+          for (const [exportName, value] of Object.entries(module)) {
+            if (exportName === "default") continue;
+            if (isTaskDefinition(value)) {
+              const id = deriveTaskId(file.path, baseDir);
+              tasks.push({
+                id,
+                name: value.name || id,
+                filePath: file.path,
+                exportName,
+                definition: value,
+              });
+
+              if (debug) {
+                logger.info(`Found task "${id}" in ${file.path} (export: ${exportName})`);
+              }
+              break; // Only take the first valid named export per file
+            }
+          }
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        errors.push({ filePath: file.path, error: errorMsg });
+
+        if (debug) {
+          logger.warn(`Failed to load ${file.path}: ${errorMsg}`);
+        }
+      }
+    }
+
+    if (debug) {
+      logger.info(`Discovered ${tasks.length} tasks`);
+    }
+
+    return { tasks, errors };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`Task discovery failed: ${errorMsg}`);
+    errors.push({ filePath: baseDir, error: errorMsg });
+    return { tasks, errors };
+  }
+}
+
+/**
+ * Find a specific task by ID
+ *
+ * TODO: Optimise by short-circuiting discovery once the target task is found
+ * instead of discovering all tasks first. This is consistent with the workflow
+ * pattern but could be improved for large projects with many task files.
+ */
+export async function findTaskById(
+  taskId: string,
+  options: TaskDiscoveryOptions,
+): Promise<DiscoveredTask | null> {
+  const { tasks } = await discoverTasks(options);
+  return tasks.find((t) => t.id === taskId) ?? null;
+}

package/src/src/task/runner.ts

@@ -0,0 +1,94 @@
+/**
+ * Task Runner
+ *
+ * Executes a discovered task by calling its run() function
+ * with the appropriate context.
+ */
+import * as dntShim from "../../_dnt.shims.js";
+
+
+import { logger as baseLogger } from "../utils/index.js";
+import type { DiscoveredTask } from "./discovery.js";
+import type { TaskContext } from "./types.js";
+
+const logger = baseLogger.component("task-runner");
+
+/**
+ * Options for running a task
+ */
+export interface RunTaskOptions {
+  /** The discovered task to run */
+  task: DiscoveredTask;
+
+  /** Additional config to pass to the task */
+  config?: Record<string, unknown>;
+
+  /** Project ID (for cloud context) */
+  projectId?: string;
+
+  /** If set, only these env var names are passed to the task. */
+  envAllowlist?: string[];
+
+  /** Enable debug logging */
+  debug?: boolean;
+}
+
+/**
+ * Result of running a task
+ */
+export interface TaskRunResult {
+  /** Whether the task completed successfully */
+  success: boolean;
+
+  /** Return value from the task's run() */
+  result?: unknown;
+
+  /** Error if the task failed */
+  error?: string;
+
+  /** Execution duration in milliseconds */
+  durationMs: number;
+}
+
+/**
+ * Run a task with the given options
+ */
+export async function runTask(options: RunTaskOptions): Promise<TaskRunResult> {
+  const { task, config = {}, projectId, envAllowlist, debug = false } = options;
+  const start = Date.now();
+
+  if (debug) {
+    logger.info(`Running task "${task.id}" (${task.name})`);
+  }
+
+  const env: Record<string, string> = { ...dntShim.Deno.env.toObject() };
+  if (envAllowlist) {
+    for (const k of Object.keys(env)) {
+      if (!envAllowlist.includes(k)) delete env[k];
+    }
+  }
+
+  const ctx: TaskContext = {
+    env,
+    config,
+    projectId,
+  };
+
+  try {
+    const result = await task.definition.run(ctx);
+    const durationMs = Date.now() - start;
+
+    if (debug) {
+      logger.info(`Task "${task.id}" completed in ${durationMs}ms`);
+    }
+
+    return { success: true, result, durationMs };
+  } catch (error) {
+    const durationMs = Date.now() - start;
+    const errorMsg = error instanceof Error ? error.message : String(error);
+
+    logger.error(`Task "${task.id}" failed: ${errorMsg}`);
+
+    return { success: false, error: errorMsg, durationMs };
+  }
+}

package/src/src/task/types.ts

@@ -0,0 +1,40 @@
+/**
+ * Task Types
+ *
+ * Type definitions for the task execution system.
+ * Tasks are user-defined functions in `tasks/` that can run
+ * locally via `veryfront task <name>` or in the cloud as Jobs/CronJobs.
+ */
+
+/**
+ * Context passed to task run() function
+ */
+export interface TaskContext {
+  /** Environment variables */
+  env: Record<string, string>;
+  /** Job config (when run as a cloud job) */
+  config: Record<string, unknown>;
+  /** Project ID (when run as a cloud job) */
+  projectId?: string;
+}
+
+/**
+ * Task definition exported from a tasks/ file
+ */
+export interface TaskDefinition {
+  /** Human-readable name */
+  name?: string;
+  /** Task description */
+  description?: string;
+  /** The function to execute */
+  run: (ctx: TaskContext) => Promise<unknown> | unknown;
+}
+
+/**
+ * Type guard: checks if a value looks like a TaskDefinition
+ */
+export function isTaskDefinition(value: unknown): value is TaskDefinition {
+  if (!value || typeof value !== "object") return false;
+  const obj = value as Record<string, unknown>;
+  return typeof obj.run === "function";
+}

package/src/src/transforms/mdx/esm-module-loader/jsx/runtime-loader.ts

@@ -7,7 +7,7 @@ export interface JSXRuntime {
 
 export async function loadJSXRuntime(): Promise<JSXRuntime> {
   // deno-lint-ignore no-explicit-any
-  const runtime = (await import("../../../../../deps/esm.sh/react@19.1.1/jsx-dev-runtime.js")) as any;
+  const runtime = (await import("react/jsx-dev-runtime")) as any;
 
   return {
     Fragment: runtime.Fragment,

package/esm/deps/esm.sh/react@19.1.1/jsx-dev-runtime.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/esm/deps/esm.sh/react@19.1.1/jsx-dev-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx-dev-runtime.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react@19.1.1/jsx-dev-runtime.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react@19.1.1/jsx-dev-runtime.js

@@ -1,3 +0,0 @@
-/* esm.sh - react@19.1.1/jsx-dev-runtime */
-export * from "react/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/jsx-dev-runtime.development.mjs";
-export { default } from "react/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/jsx-dev-runtime.development.mjs";

package/src/deps/esm.sh/@types/react@19.1.17/global.d.ts

@@ -1,165 +0,0 @@
-/*
-React projects that don't include the DOM library need these interfaces to compile.
-React Native applications use React, but there is no DOM available. The JavaScript runtime
-is ES6/ES2015 only. These definitions allow such projects to compile with only `--lib ES6`.
-
-Warning: all of these interfaces are empty. If you want type definitions for various properties
-(such as HTMLInputElement.prototype.value), you need to add `--lib DOM` (via command line or tsconfig.json).
-*/
-
-interface Event {}
-interface AnimationEvent extends Event {}
-interface ClipboardEvent extends Event {}
-interface CompositionEvent extends Event {}
-interface DragEvent extends Event {}
-interface FocusEvent extends Event {}
-interface InputEvent extends Event {}
-interface KeyboardEvent extends Event {}
-interface MouseEvent extends Event {}
-interface TouchEvent extends Event {}
-interface PointerEvent extends Event {}
-interface ToggleEvent extends Event {}
-interface TransitionEvent extends Event {}
-interface UIEvent extends Event {}
-interface WheelEvent extends Event {}
-
-interface EventTarget {}
-interface Document {}
-interface DataTransfer {}
-interface StyleMedia {}
-
-interface Element {}
-interface DocumentFragment {}
-
-interface HTMLElement extends Element {}
-interface HTMLAnchorElement extends HTMLElement {}
-interface HTMLAreaElement extends HTMLElement {}
-interface HTMLAudioElement extends HTMLElement {}
-interface HTMLBaseElement extends HTMLElement {}
-interface HTMLBodyElement extends HTMLElement {}
-interface HTMLBRElement extends HTMLElement {}
-interface HTMLButtonElement extends HTMLElement {}
-interface HTMLCanvasElement extends HTMLElement {}
-interface HTMLDataElement extends HTMLElement {}
-interface HTMLDataListElement extends HTMLElement {}
-interface HTMLDetailsElement extends HTMLElement {}
-interface HTMLDialogElement extends HTMLElement {}
-interface HTMLDivElement extends HTMLElement {}
-interface HTMLDListElement extends HTMLElement {}
-interface HTMLEmbedElement extends HTMLElement {}
-interface HTMLFieldSetElement extends HTMLElement {}
-interface HTMLFormElement extends HTMLElement {}
-interface HTMLHeadingElement extends HTMLElement {}
-interface HTMLHeadElement extends HTMLElement {}
-interface HTMLHRElement extends HTMLElement {}
-interface HTMLHtmlElement extends HTMLElement {}
-interface HTMLIFrameElement extends HTMLElement {}
-interface HTMLImageElement extends HTMLElement {}
-interface HTMLInputElement extends HTMLElement {}
-interface HTMLModElement extends HTMLElement {}
-interface HTMLLabelElement extends HTMLElement {}
-interface HTMLLegendElement extends HTMLElement {}
-interface HTMLLIElement extends HTMLElement {}
-interface HTMLLinkElement extends HTMLElement {}
-interface HTMLMapElement extends HTMLElement {}
-interface HTMLMetaElement extends HTMLElement {}
-interface HTMLMeterElement extends HTMLElement {}
-interface HTMLObjectElement extends HTMLElement {}
-interface HTMLOListElement extends HTMLElement {}
-interface HTMLOptGroupElement extends HTMLElement {}
-interface HTMLOptionElement extends HTMLElement {}
-interface HTMLOutputElement extends HTMLElement {}
-interface HTMLParagraphElement extends HTMLElement {}
-interface HTMLParamElement extends HTMLElement {}
-interface HTMLPreElement extends HTMLElement {}
-interface HTMLProgressElement extends HTMLElement {}
-interface HTMLQuoteElement extends HTMLElement {}
-interface HTMLSlotElement extends HTMLElement {}
-interface HTMLScriptElement extends HTMLElement {}
-interface HTMLSelectElement extends HTMLElement {}
-interface HTMLSourceElement extends HTMLElement {}
-interface HTMLSpanElement extends HTMLElement {}
-interface HTMLStyleElement extends HTMLElement {}
-interface HTMLTableElement extends HTMLElement {}
-interface HTMLTableColElement extends HTMLElement {}
-interface HTMLTableDataCellElement extends HTMLElement {}
-interface HTMLTableHeaderCellElement extends HTMLElement {}
-interface HTMLTableRowElement extends HTMLElement {}
-interface HTMLTableSectionElement extends HTMLElement {}
-interface HTMLTemplateElement extends HTMLElement {}
-interface HTMLTextAreaElement extends HTMLElement {}
-interface HTMLTimeElement extends HTMLElement {}
-interface HTMLTitleElement extends HTMLElement {}
-interface HTMLTrackElement extends HTMLElement {}
-interface HTMLUListElement extends HTMLElement {}
-interface HTMLVideoElement extends HTMLElement {}
-interface HTMLWebViewElement extends HTMLElement {}
-
-interface SVGElement extends Element {}
-interface SVGSVGElement extends SVGElement {}
-interface SVGCircleElement extends SVGElement {}
-interface SVGClipPathElement extends SVGElement {}
-interface SVGDefsElement extends SVGElement {}
-interface SVGDescElement extends SVGElement {}
-interface SVGEllipseElement extends SVGElement {}
-interface SVGFEBlendElement extends SVGElement {}
-interface SVGFEColorMatrixElement extends SVGElement {}
-interface SVGFEComponentTransferElement extends SVGElement {}
-interface SVGFECompositeElement extends SVGElement {}
-interface SVGFEConvolveMatrixElement extends SVGElement {}
-interface SVGFEDiffuseLightingElement extends SVGElement {}
-interface SVGFEDisplacementMapElement extends SVGElement {}
-interface SVGFEDistantLightElement extends SVGElement {}
-interface SVGFEDropShadowElement extends SVGElement {}
-interface SVGFEFloodElement extends SVGElement {}
-interface SVGFEFuncAElement extends SVGElement {}
-interface SVGFEFuncBElement extends SVGElement {}
-interface SVGFEFuncGElement extends SVGElement {}
-interface SVGFEFuncRElement extends SVGElement {}
-interface SVGFEGaussianBlurElement extends SVGElement {}
-interface SVGFEImageElement extends SVGElement {}
-interface SVGFEMergeElement extends SVGElement {}
-interface SVGFEMergeNodeElement extends SVGElement {}
-interface SVGFEMorphologyElement extends SVGElement {}
-interface SVGFEOffsetElement extends SVGElement {}
-interface SVGFEPointLightElement extends SVGElement {}
-interface SVGFESpecularLightingElement extends SVGElement {}
-interface SVGFESpotLightElement extends SVGElement {}
-interface SVGFETileElement extends SVGElement {}
-interface SVGFETurbulenceElement extends SVGElement {}
-interface SVGFilterElement extends SVGElement {}
-interface SVGForeignObjectElement extends SVGElement {}
-interface SVGGElement extends SVGElement {}
-interface SVGImageElement extends SVGElement {}
-interface SVGLineElement extends SVGElement {}
-interface SVGLinearGradientElement extends SVGElement {}
-interface SVGMarkerElement extends SVGElement {}
-interface SVGMaskElement extends SVGElement {}
-interface SVGMetadataElement extends SVGElement {}
-interface SVGPathElement extends SVGElement {}
-interface SVGPatternElement extends SVGElement {}
-interface SVGPolygonElement extends SVGElement {}
-interface SVGPolylineElement extends SVGElement {}
-interface SVGRadialGradientElement extends SVGElement {}
-interface SVGRectElement extends SVGElement {}
-interface SVGSetElement extends SVGElement {}
-interface SVGStopElement extends SVGElement {}
-interface SVGSwitchElement extends SVGElement {}
-interface SVGSymbolElement extends SVGElement {}
-interface SVGTextElement extends SVGElement {}
-interface SVGTextPathElement extends SVGElement {}
-interface SVGTSpanElement extends SVGElement {}
-interface SVGUseElement extends SVGElement {}
-interface SVGViewElement extends SVGElement {}
-
-interface FormData {}
-interface Text {}
-interface TouchList {}
-interface WebGLRenderingContext {}
-interface WebGL2RenderingContext {}
-
-interface TrustedHTML {}
-
-interface Blob {}
-interface MediaStream {}
-interface MediaSource {}