veryfront 0.0.7 → 0.0.10

package/dist/ai/index.js

@@ -844,17 +844,30 @@ var GoogleProvider = class extends BaseProvider {
   }
 };
 
-// src/ai/providers/factory.ts
-function getEnv(name) {
-  if (typeof Deno !== "undefined" && Deno.env) {
-    return process.env(name);
+// src/platform/compat/process.ts
+import process from "node:process";
+
+// src/platform/compat/runtime.ts
+var isDeno = typeof Deno !== "undefined";
+var isNode = typeof globalThis.process !== "undefined" && globalThis.process?.versions?.node !== void 0;
+var isBun = typeof globalThis.Bun !== "undefined";
+var isCloudflare = typeof globalThis !== "undefined" && "caches" in globalThis && "WebSocketPair" in globalThis;
+
+// src/platform/compat/process.ts
+function cwd() {
+  if (isDeno) {
+    return process.cwd();
   }
-  const _global = globalThis;
-  if (typeof _global.process !== "undefined" && _global.process.env) {
-    return _global.process.env[name];
+  return process.cwd();
+}
+function getEnv(key) {
+  if (isDeno) {
+    return process.env(key);
   }
-  return void 0;
+  return process.env[key];
 }
+
+// src/ai/providers/factory.ts
 var ProviderRegistry = class {
   constructor() {
     this.providers = /* @__PURE__ */ new Map();
@@ -1675,7 +1688,7 @@ var BYTES_PER_MB = 1024 * 1024;
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.7",
+  version: "0.0.10",
   nodeModulesDir: "auto",
   workspace: [
     "./examples/async-worker-redis",
@@ -1804,6 +1817,7 @@ var deno_default = {
     dev: "deno run --allow-all --no-lock --unstable-net --unstable-worker-options src/cli/main.ts dev",
     build: "deno compile --allow-all --output ../../bin/veryfront src/cli/main.ts",
     "build:npm": "deno run -A scripts/build-npm.ts",
+    release: "deno run -A scripts/release.ts",
     test: "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
     "test:unit": "DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests --unstable-worker-options --unstable-net",
     "test:integration": "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
@@ -3466,6 +3480,7 @@ var DEFAULT_CONFIG2 = {
   }
 };
 var configCacheByProject = /* @__PURE__ */ new Map();
+var cacheRevision = 0;
 function validateCorsConfig(userConfig) {
   if (!userConfig || typeof userConfig !== "object") {
     return;
@@ -3542,13 +3557,18 @@ var ConfigValidationError = class extends Error {
 };
 async function loadAndMergeConfig(configPath, projectDir) {
   try {
-    const configUrl = `file://${configPath}?t=${Date.now()}`;
+    const configUrl = `file://${configPath}?t=${Date.now()}-${crypto.randomUUID()}`;
     const configModule = await import(configUrl);
     const userConfig = configModule.default || configModule;
+    if (userConfig === null || typeof userConfig !== "object" || Array.isArray(userConfig)) {
+      throw new ConfigValidationError(
+        `Expected object, received ${userConfig === null ? "null" : typeof userConfig}`
+      );
+    }
     validateCorsConfig(userConfig);
     validateConfigShape(userConfig);
     const merged = mergeConfigs(userConfig);
-    configCacheByProject.set(projectDir, merged);
+    configCacheByProject.set(projectDir, { revision: cacheRevision, config: merged });
     return merged;
   } catch (error) {
     if (error instanceof ConfigValidationError) {
@@ -3562,8 +3582,8 @@ async function loadAndMergeConfig(configPath, projectDir) {
 }
 async function getConfig(projectDir, adapter) {
   const cached = configCacheByProject.get(projectDir);
-  if (cached)
-    return cached;
+  if (cached && cached.revision === cacheRevision)
+    return cached.config;
   const configFiles = ["veryfront.config.js", "veryfront.config.ts", "veryfront.config.mjs"];
   for (const configFile of configFiles) {
     const configPath = join(projectDir, configFile);
@@ -3589,7 +3609,7 @@ async function getConfig(projectDir, adapter) {
     }
   }
   const defaultConfig = DEFAULT_CONFIG2;
-  configCacheByProject.set(projectDir, defaultConfig);
+  configCacheByProject.set(projectDir, { revision: cacheRevision, config: defaultConfig });
   return defaultConfig;
 }
 
@@ -3638,16 +3658,16 @@ function createMockAdapter() {
         files.set(path, content);
         return Promise.resolve();
       },
-      exists: async (path) => {
+      exists: (path) => {
         if (files.has(path))
-          return true;
+          return Promise.resolve(true);
         if (directories.has(path))
-          return true;
+          return Promise.resolve(true);
         for (const filePath of files.keys()) {
           if (filePath.startsWith(path + "/"))
-            return true;
+            return Promise.resolve(true);
         }
-        return false;
+        return Promise.resolve(false);
       },
       readDir: async function* (path) {
         const entries = /* @__PURE__ */ new Map();
@@ -3925,14 +3945,14 @@ async function findTypeScriptFiles(dir, context) {
         }
       }
     } else {
-      const { fs, path } = await getNodeDeps(context);
-      if (!fs || !path) {
+      const { fs: fs2, path } = await getNodeDeps(context);
+      if (!fs2 || !path) {
         return files;
       }
-      if (!fs.existsSync(dir)) {
+      if (!fs2.existsSync(dir)) {
         return files;
       }
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      const entries = fs2.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const filePath = path.join(dir, entry.name);
         if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
@@ -4030,10 +4050,165 @@ function toAISDKTools(tools) {
   return aiTools;
 }
 
+// src/platform/compat/fs.ts
+var NodeFileSystem = class {
+  constructor() {
+    this.fs = null;
+    this.os = null;
+    this.path = null;
+    this.initialized = false;
+  }
+  async ensureInitialized() {
+    if (this.initialized)
+      return;
+    if (!isNode) {
+      throw toError(createError({
+        type: "not_supported",
+        message: "Node.js fs modules not available",
+        feature: "Node.js"
+      }));
+    }
+    const [fsModule, osModule, pathModule] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:os"),
+      import("node:path")
+    ]);
+    this.fs = fsModule;
+    this.os = osModule;
+    this.path = pathModule;
+    this.initialized = true;
+  }
+  async readTextFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path, { encoding: "utf8" });
+  }
+  async readFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data, { encoding: "utf8" });
+  }
+  async writeFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data);
+  }
+  async exists(path) {
+    await this.ensureInitialized();
+    try {
+      await this.fs.access(path);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    await this.ensureInitialized();
+    const stat = await this.fs.stat(path);
+    return {
+      isFile: stat.isFile(),
+      isDirectory: stat.isDirectory(),
+      isSymlink: stat.isSymbolicLink(),
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await this.ensureInitialized();
+    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    await this.ensureInitialized();
+    const entries = await this.fs.readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile(),
+        isDirectory: entry.isDirectory()
+      };
+    }
+  }
+  async remove(path, options) {
+    await this.ensureInitialized();
+    await this.fs.rm(path, { recursive: options?.recursive ?? false, force: options?.recursive ?? false });
+  }
+  async makeTempDir(options) {
+    await this.ensureInitialized();
+    const tempDir = this.path.join(this.os.tmpdir(), `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`);
+    await this.fs.mkdir(tempDir, { recursive: true });
+    return tempDir;
+  }
+};
+var DenoFileSystem = class {
+  async readTextFile(path) {
+    return await Deno.readTextFile(path);
+  }
+  async readFile(path) {
+    return await Deno.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await Deno.writeTextFile(path, data);
+  }
+  async writeFile(path, data) {
+    await Deno.writeFile(path, data);
+  }
+  async exists(path) {
+    try {
+      await Deno.stat(path);
+      return true;
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    const stat = await Deno.stat(path);
+    return {
+      isFile: stat.isFile,
+      isDirectory: stat.isDirectory,
+      isSymlink: stat.isSymlink,
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    for await (const entry of Deno.readDir(path)) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile,
+        isDirectory: entry.isDirectory
+      };
+    }
+  }
+  async remove(path, options) {
+    await Deno.remove(path, { recursive: options?.recursive ?? false });
+  }
+  async makeTempDir(options) {
+    return await Deno.makeTempDir({ prefix: options?.prefix });
+  }
+};
+function createFileSystem() {
+  if (isDeno) {
+    return new DenoFileSystem();
+  } else {
+    return new NodeFileSystem();
+  }
+}
+
 // src/ai/utils/setup.ts
+var fs = createFileSystem();
 async function setupAI(options = {}) {
   const {
-    baseDir = detectCwd(),
+    baseDir = cwd(),
     aiDir = "ai",
     tools: manualTools = {},
     agents: manualAgents = {},
@@ -4050,7 +4225,7 @@ async function setupAI(options = {}) {
   const errors = [];
   if (manifestPath) {
     try {
-      const manifest = await loadManifest(manifestPath);
+      const manifest = await fs.readTextFile(manifestPath).then(JSON.parse);
       if (manifest.tools) {
         for (const [id, tool2] of Object.entries(manifest.tools)) {
           tools.set(id, tool2);
@@ -4076,7 +4251,7 @@ async function setupAI(options = {}) {
         }
       }
       if (verbose) {
-        console.log(`[setupAI] Loaded manifest: ${tools.size} tools, ${agents.size} agents`);
+        cliLogger.info(`[setupAI] Loaded manifest: ${tools.size} tools, ${agents.size} agents`);
       }
     } catch (error) {
       errors.push({
@@ -4107,11 +4282,11 @@ async function setupAI(options = {}) {
       }
       errors.push(...discovered.errors);
       if (verbose) {
-        console.log(`[setupAI] Discovered: ${tools.size} tools, ${agents.size} agents`);
+        cliLogger.info(`[setupAI] Discovered: ${tools.size} tools, ${agents.size} agents`);
       }
     } catch (error) {
       if (verbose) {
-        console.log(`[setupAI] Discovery skipped: ${error}`);
+        cliLogger.info(`[setupAI] Discovery skipped: ${error}`);
       }
     }
   }
@@ -4159,24 +4334,6 @@ async function setupAI(options = {}) {
   };
   return result;
 }
-function detectCwd() {
-  if (typeof Deno !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd();
-  }
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd();
-  }
-  return ".";
-}
-async function loadManifest(path) {
-  if (typeof Deno !== "undefined" && typeof Deno.readTextFile === "function") {
-    const content2 = await Deno.readTextFile(path);
-    return JSON.parse(content2);
-  }
-  const fs = await import("node:fs/promises");
-  const content = await fs.readFile(path, "utf-8");
-  return JSON.parse(content);
-}
 
 // src/ai/mcp/server.ts
 var MCPServer = class {
@@ -5448,6 +5605,23 @@ function waitForApproval(id, options = {}) {
   };
 }
 
+// src/platform/compat/path-helper.ts
+import nodePath from "node:path";
+var pathMod = null;
+var denoPathPromise = null;
+if (typeof Deno === "undefined") {
+  pathMod = nodePath;
+} else {
+  denoPathPromise = import("path").then((mod) => {
+    pathMod = mod;
+    return pathMod;
+  });
+}
+var sep = nodePath.sep;
+
+// src/ai/workflow/blob/s3-storage.ts
+import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, HeadObjectCommand, CreateBucketCommand } from "@aws-sdk/client-s3";
+
 // src/ai/workflow/backends/types.ts
 function hasLockSupport(backend) {
   return typeof backend.acquireLock === "function" && typeof backend.releaseLock === "function";
@@ -5788,6 +5962,15 @@ var MemoryBackend = class {
   }
 };
 
+// src/ai/workflow/backends/redis.ts
+var DenoRedis = void 0;
+var NodeRedis = void 0;
+if (typeof Deno !== "undefined") {
+  DenoRedis = await import("redis");
+} else {
+  NodeRedis = await import("redis");
+}
+
 // src/ai/workflow/executor/dag-executor.ts
 var DAGExecutor = class {
   constructor(config) {
@@ -5921,20 +6104,172 @@ var DAGExecutor = class {
         return await this.executeStepNode(node, context);
       case "parallel":
         return await this.executeParallelNode(node, config, context, nodeStates);
+      case "map":
+        return await this.executeMapNode(node, config, context, nodeStates);
       case "branch":
         return await this.executeBranchNode(node, config, context, nodeStates);
       case "wait":
         return await this.executeWaitNode(node, config, context);
       case "subWorkflow":
-        throw new Error(
-          `Sub-workflow execution is not yet implemented for node "${node.id}". Workaround: Flatten your workflow by inlining the sub-workflow steps directly, or use the parallel() or branch() DSL helpers to compose workflows.`
-        );
+        return await this.executeSubWorkflowNode(node, config, context, nodeStates);
       default:
         throw new Error(
-          `Unknown node type "${config.type}" for node "${node.id}". Valid types are: step, parallel, branch, wait, subWorkflow`
+          `Unknown node type "${config.type}" for node "${node.id}". Valid types are: step, parallel, map, branch, wait, subWorkflow`
         );
     }
   }
+  /**
+   * Execute a map node (dynamic fan-out)
+   */
+  async executeMapNode(node, config, context, nodeStates) {
+    const startTime = Date.now();
+    const items = typeof config.items === "function" ? await config.items(context) : config.items;
+    if (!Array.isArray(items)) {
+      throw new Error(`Map node "${node.id}" items must be an array`);
+    }
+    if (items.length === 0) {
+      const state = {
+        nodeId: node.id,
+        status: "completed",
+        output: [],
+        attempt: 1,
+        startedAt: new Date(startTime),
+        completedAt: /* @__PURE__ */ new Date()
+      };
+      return { state, contextUpdates: { [node.id]: [] }, waiting: false };
+    }
+    const childNodes = [];
+    const isWorkflowDef = (p) => !!p.steps;
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const childId = `${node.id}_${i}`;
+      let childNode;
+      if (isWorkflowDef(config.processor)) {
+        childNode = {
+          id: childId,
+          config: {
+            type: "subWorkflow",
+            workflow: config.processor,
+            input: item,
+            retry: config.retry,
+            checkpoint: false
+            // Don't checkpoint individual map items by default
+          }
+        };
+      } else {
+        const processorConfig = { ...config.processor.config };
+        if (processorConfig.type === "step") {
+          processorConfig.input = item;
+        }
+        childNode = {
+          id: childId,
+          config: processorConfig
+        };
+      }
+      childNodes.push(childNode);
+    }
+    const originalConcurrency = this.config.maxConcurrency;
+    if (config.concurrency) {
+      this.config.maxConcurrency = config.concurrency;
+    }
+    try {
+      const result = await this.execute(childNodes, {
+        id: `${node.id}_map`,
+        workflowId: "",
+        status: "running",
+        input: context.input,
+        nodeStates: {},
+        // Start fresh for map iteration
+        currentNodes: [],
+        context: { ...context },
+        // Pass copy of context so they can read global state
+        checkpoints: [],
+        pendingApprovals: [],
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      Object.assign(nodeStates, result.nodeStates);
+      const outputs = childNodes.map((child) => {
+        const childState = result.nodeStates[child.id];
+        return childState?.output;
+      });
+      const state = {
+        nodeId: node.id,
+        status: result.completed ? "completed" : result.waiting ? "running" : "failed",
+        output: outputs,
+        error: result.error,
+        attempt: 1,
+        startedAt: new Date(startTime),
+        completedAt: result.completed ? /* @__PURE__ */ new Date() : void 0
+      };
+      this.config.onNodeComplete?.(node.id, state);
+      return {
+        state,
+        contextUpdates: result.completed ? { [node.id]: outputs } : {},
+        waiting: result.waiting
+      };
+    } finally {
+      this.config.maxConcurrency = originalConcurrency;
+    }
+  }
+  /**
+   * Execute a sub-workflow node
+   */
+  async executeSubWorkflowNode(node, config, context, _nodeStates) {
+    const startTime = Date.now();
+    let workflowDef;
+    if (typeof config.workflow === "string") {
+      throw new Error("Resolving workflow by ID is not yet supported in this execution context. Pass the WorkflowDefinition object.");
+    } else {
+      workflowDef = config.workflow;
+    }
+    const input = typeof config.input === "function" ? await config.input(context) : config.input ?? context.input;
+    let steps;
+    if (typeof workflowDef.steps === "function") {
+      steps = workflowDef.steps({
+        input,
+        context
+      });
+    } else {
+      steps = workflowDef.steps;
+    }
+    const subRunId = `${node.id}_sub_${generateId()}`;
+    const result = await this.execute(steps, {
+      id: subRunId,
+      workflowId: workflowDef.id,
+      status: "running",
+      input,
+      nodeStates: {},
+      currentNodes: [],
+      context: {
+        input
+        // Subworkflow starts with fresh context scoped to its input
+        // We do NOT inherit parent context to ensure isolation, 
+        // unless explicitly passed via input.
+      },
+      checkpoints: [],
+      pendingApprovals: [],
+      createdAt: /* @__PURE__ */ new Date()
+    });
+    let finalOutput = result.context;
+    if (result.completed && config.output) {
+      finalOutput = config.output(result.context);
+    }
+    const state = {
+      nodeId: node.id,
+      status: result.completed ? "completed" : result.waiting ? "running" : "failed",
+      output: finalOutput,
+      error: result.error,
+      attempt: 1,
+      startedAt: new Date(startTime),
+      completedAt: result.completed ? /* @__PURE__ */ new Date() : void 0
+    };
+    this.config.onNodeComplete?.(node.id, state);
+    return {
+      state,
+      contextUpdates: result.completed ? { [node.id]: finalOutput } : {},
+      waiting: result.waiting
+    };
+  }
   /**
    * Execute a step node
    */
@@ -6442,7 +6777,10 @@ var StepExecutor = class {
     const resolvedTool = typeof tool2 === "string" ? this.getTool(tool2) : tool2;
     const result = await resolvedTool.execute(
       input,
-      { agentId: "workflow" }
+      {
+        agentId: "workflow",
+        blobStorage: this.config.blobStorage
+      }
     );
     return result;
   }
@@ -6557,7 +6895,10 @@ var WorkflowExecutor = class _WorkflowExecutor {
       lockDuration: _WorkflowExecutor.DEFAULT_LOCK_DURATION,
       ...config
     };
-    this.stepExecutor = new StepExecutor(this.config.stepExecutor);
+    this.stepExecutor = new StepExecutor({
+      ...this.config.stepExecutor,
+      blobStorage: this.config.blobStorage
+    });
     this.checkpointManager = new CheckpointManager({
       backend: this.config.backend,
       debug: this.config.debug
@@ -6572,6 +6913,16 @@ var WorkflowExecutor = class _WorkflowExecutor {
       onWaiting: () => {
       }
     });
+    if (this.config.blobStorage) {
+      const bs = this.config.blobStorage;
+      this.blobResolver = {
+        getText: (ref) => ref.__kind === "blob" ? bs.getText(ref.id) : Promise.resolve(null),
+        getBytes: (ref) => ref.__kind === "blob" ? bs.getBytes(ref.id) : Promise.resolve(null),
+        getStream: (ref) => ref.__kind === "blob" ? bs.getStream(ref.id) : Promise.resolve(null),
+        stat: (ref) => ref.__kind === "blob" ? bs.stat(ref.id) : Promise.resolve(null),
+        delete: (ref) => ref.__kind === "blob" ? bs.delete(ref.id) : Promise.resolve(void 0)
+      };
+    }
   }
   static {
     /** Default lock duration: 30 seconds */
@@ -6745,9 +7096,13 @@ var WorkflowExecutor = class _WorkflowExecutor {
     if (Array.isArray(workflow2.steps)) {
       nodes = workflow2.steps;
     } else {
+      if (!this.config.blobStorage) {
+      }
       const builderContext = {
         input: context.input,
-        context
+        context,
+        blobStorage: this.config.blobStorage,
+        blob: this.blobResolver
       };
       nodes = workflow2.steps(builderContext);
     }