veryfront 0.0.9 → 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.8",
+  version: "0.0.10",
   nodeModulesDir: "auto",
   workspace: [
     "./examples/async-worker-redis",
@@ -3645,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();
@@ -3932,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"))) {
@@ -4037,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 = {},
@@ -4057,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);
@@ -4083,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({
@@ -4114,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}`);
       }
     }
   }
@@ -4166,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 {
@@ -5455,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";
@@ -5795,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) {
@@ -6038,7 +6214,7 @@ var DAGExecutor = class {
   /**
    * Execute a sub-workflow node
    */
-  async executeSubWorkflowNode(node, config, context, nodeStates) {
+  async executeSubWorkflowNode(node, config, context, _nodeStates) {
     const startTime = Date.now();
     let workflowDef;
     if (typeof config.workflow === "string") {
@@ -6601,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;
   }
@@ -6716,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
@@ -6731,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 */
@@ -6909,7 +7101,8 @@ var WorkflowExecutor = class _WorkflowExecutor {
       const builderContext = {
         input: context.input,
         context,
-        blobStorage: this.config.blobStorage
+        blobStorage: this.config.blobStorage,
+        blob: this.blobResolver
       };
       nodes = workflow2.steps(builderContext);
     }