@meetploy/cli 1.14.1 → 1.16.0

package/dist/index.js

@@ -8,11 +8,11 @@ import { parse } from 'yaml';
 import { build } from 'esbuild';
 import { watch } from 'chokidar';
 import { randomBytes, randomUUID, createHmac, pbkdf2Sync, timingSafeEqual, createHash } from 'crypto';
+import { homedir, tmpdir } from 'os';
 import { getCookie, deleteCookie, setCookie } from 'hono/cookie';
 import { URL, fileURLToPath } from 'url';
 import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
-import { homedir, tmpdir } from 'os';
 import Database from 'better-sqlite3';
 import { spawn, exec } from 'child_process';
 import createClient from 'openapi-fetch';
@@ -183,10 +183,24 @@ function validatePloyConfig(config, configFile = "ploy.yaml", options = {}) {
   validatedConfig.out = validateRelativePath(config.out, "out", configFile);
   validatedConfig.base = validateRelativePath(config.base, "base", configFile);
   validatedConfig.main = validateRelativePath(config.main, "main", configFile);
+  if (config.env !== void 0) {
+    if (typeof config.env !== "object" || config.env === null) {
+      throw new Error(`'env' in ${configFile} must be a map of KEY: value`);
+    }
+    for (const [key, value] of Object.entries(config.env)) {
+      if (!BINDING_NAME_REGEX.test(key)) {
+        throw new Error(`Invalid env key '${key}' in ${configFile}. Env keys must be uppercase with underscores (e.g., FOO, MY_VAR)`);
+      }
+      if (typeof value !== "string") {
+        throw new Error(`Env key '${key}' in ${configFile} must have a string value`);
+      }
+    }
+  }
   validateBindings(config.db, "db", configFile);
   validateBindings(config.queue, "queue", configFile);
   validateBindings(config.cache, "cache", configFile);
   validateBindings(config.state, "state", configFile);
+  validateBindings(config.fs, "fs", configFile);
   validateBindings(config.workflow, "workflow", configFile);
   if (config.ai !== void 0 && typeof config.ai !== "boolean") {
     throw new Error(`'ai' in ${configFile} must be a boolean`);
@@ -263,7 +277,50 @@ function readAndValidatePloyConfigSync(projectDir, configPath, validationOptions
   return validatePloyConfig(config, configFile, validationOptions);
 }
 function hasBindings(config) {
-  return !!(config.db ?? config.queue ?? config.cache ?? config.state ?? config.workflow ?? config.ai ?? config.auth);
+  return !!(config.env ?? config.db ?? config.queue ?? config.cache ?? config.state ?? config.fs ?? config.workflow ?? config.ai ?? config.auth);
+}
+function parseDotEnv(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function loadDotEnvSync(projectDir) {
+  const envPath = join(projectDir, ".env");
+  if (!existsSync(envPath)) {
+    return {};
+  }
+  const content = readFileSync(envPath, "utf-8");
+  return parseDotEnv(content);
+}
+function resolveEnvVars(configEnv, dotEnv, processEnv) {
+  const result = {};
+  for (const [key, value] of Object.entries(configEnv)) {
+    if (value.startsWith("$")) {
+      const refName = value.slice(1);
+      const resolved = dotEnv[refName] ?? processEnv[refName];
+      if (resolved !== void 0) {
+        result[key] = resolved;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
 }
 function getWorkerEntryPoint(projectDir, config) {
   if (config.main) {
@@ -306,10 +363,13 @@ __export(cli_exports, {
   getWorkerEntryPoint: () => getWorkerEntryPoint,
   hasBindings: () => hasBindings,
   isPnpmWorkspace: () => isPnpmWorkspace,
+  loadDotEnvSync: () => loadDotEnvSync,
+  parseDotEnv: () => parseDotEnv,
   readAndValidatePloyConfig: () => readAndValidatePloyConfig,
   readAndValidatePloyConfigSync: () => readAndValidatePloyConfigSync,
   readPloyConfig: () => readPloyConfig,
   readPloyConfigSync: () => readPloyConfigSync,
+  resolveEnvVars: () => resolveEnvVars,
   validatePloyConfig: () => validatePloyConfig
 });
 var init_cli = __esm({
@@ -698,6 +758,124 @@ var init_db_runtime = __esm({
   }
 });
 
+// ../emulator/dist/runtime/fs-runtime.js
+var FS_RUNTIME_CODE;
+var init_fs_runtime = __esm({
+  "../emulator/dist/runtime/fs-runtime.js"() {
+    FS_RUNTIME_CODE = `
+interface FileStoragePutOptions {
+  contentType?: string;
+}
+
+interface FileStorageListOptions {
+  prefix?: string;
+  limit?: number;
+}
+
+interface FileStorageObject {
+  body: string;
+  contentType: string;
+  size: number;
+}
+
+interface FileStorageKey {
+  key: string;
+  size: number;
+  contentType: string;
+}
+
+interface FileStorageListResult {
+  keys: FileStorageKey[];
+}
+
+interface FileStorageBinding {
+  put: (key: string, value: string, options?: FileStoragePutOptions) => Promise<void>;
+  get: (key: string) => Promise<FileStorageObject | null>;
+  delete: (key: string) => Promise<void>;
+  list: (options?: FileStorageListOptions) => Promise<FileStorageListResult>;
+}
+
+export function initializeFileStorage(fsName: string, serviceUrl: string): FileStorageBinding {
+  return {
+    async put(key: string, value: string, options?: FileStoragePutOptions): Promise<void> {
+      const response = await fetch(serviceUrl + "/fs/put", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          fsName,
+          key,
+          value,
+          contentType: options?.contentType || "application/octet-stream",
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("File storage put failed: " + errorText);
+      }
+    },
+
+    async get(key: string): Promise<FileStorageObject | null> {
+      const response = await fetch(serviceUrl + "/fs/get", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ fsName, key }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("File storage get failed: " + errorText);
+      }
+
+      const result = await response.json();
+      if (result.found === false) {
+        return null;
+      }
+      return {
+        body: result.body,
+        contentType: result.contentType,
+        size: result.size,
+      };
+    },
+
+    async delete(key: string): Promise<void> {
+      const response = await fetch(serviceUrl + "/fs/delete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ fsName, key }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("File storage delete failed: " + errorText);
+      }
+    },
+
+    async list(options?: FileStorageListOptions): Promise<FileStorageListResult> {
+      const response = await fetch(serviceUrl + "/fs/list", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          fsName,
+          prefix: options?.prefix,
+          limit: options?.limit,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("File storage list failed: " + errorText);
+      }
+
+      const result = await response.json();
+      return { keys: result.keys };
+    },
+  };
+}
+`;
+  }
+});
+
 // ../emulator/dist/runtime/queue-runtime.js
 var QUEUE_RUNTIME_CODE;
 var init_queue_runtime = __esm({
@@ -1035,7 +1213,7 @@ export async function executeWorkflow<TInput, TOutput, TEnv>(
 `;
   }
 });
-function generateWrapperCode(config, mockServiceUrl) {
+function generateWrapperCode(config, mockServiceUrl, envVars) {
   const imports = [];
   const bindings = [];
   if (config.db) {
@@ -1062,6 +1240,12 @@ function generateWrapperCode(config, mockServiceUrl) {
       bindings.push(`  ${bindingName}: initializeState("${stateName}", "${mockServiceUrl}"),`);
     }
   }
+  if (config.fs) {
+    imports.push('import { initializeFileStorage } from "__ploy_fs_runtime__";');
+    for (const [bindingName, fsName] of Object.entries(config.fs)) {
+      bindings.push(`  ${bindingName}: initializeFileStorage("${fsName}", "${mockServiceUrl}"),`);
+    }
+  }
   if (config.workflow) {
     imports.push('import { initializeWorkflow, createStepContext, executeWorkflow } from "__ploy_workflow_runtime__";');
     for (const [bindingName, workflowName] of Object.entries(config.workflow)) {
@@ -1125,6 +1309,11 @@ function generateWrapperCode(config, mockServiceUrl) {
       }
     }
   }` : "";
+  const envVarsEntries = envVars && Object.keys(envVars).length > 0 ? Object.entries(envVars).map(([key, value]) => `    ${JSON.stringify(key)}: ${JSON.stringify(value)}`).join(",\n") : "";
+  const envVarsCode = envVarsEntries ? `
+    injectedEnv.vars = {
+${envVarsEntries}
+    };` : "";
   return `${imports.join("\n")}
 
 const ployBindings = {
@@ -1133,7 +1322,7 @@ ${bindings.join("\n")}
 
 export default {
   async fetch(request, env, ctx) {
-    const injectedEnv = { ...env, ...ployBindings };
+    const injectedEnv = { ...env, ...ployBindings };${envVarsCode}
     ${workflowHandlerCode}
     ${queueHandlerCode}
 
@@ -1146,7 +1335,7 @@ export default {
 
   async scheduled(event, env, ctx) {
     if (userWorker.scheduled) {
-      const injectedEnv = { ...env, ...ployBindings };
+      const injectedEnv = { ...env, ...ployBindings };${envVarsCode}
       return userWorker.scheduled(event, injectedEnv, ctx);
     }
   }
@@ -1173,6 +1362,10 @@ function createRuntimePlugin(_config) {
         path: "__ploy_state_runtime__",
         namespace: "ploy-runtime"
       }));
+      build2.onResolve({ filter: /^__ploy_fs_runtime__$/ }, () => ({
+        path: "__ploy_fs_runtime__",
+        namespace: "ploy-runtime"
+      }));
       build2.onResolve({ filter: /^__ploy_workflow_runtime__$/ }, () => ({
         path: "__ploy_workflow_runtime__",
         namespace: "ploy-runtime"
@@ -1193,6 +1386,10 @@ function createRuntimePlugin(_config) {
         contents: STATE_RUNTIME_CODE,
         loader: "ts"
       }));
+      build2.onLoad({ filter: /^__ploy_fs_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: FS_RUNTIME_CODE,
+        loader: "ts"
+      }));
       build2.onLoad({ filter: /^__ploy_workflow_runtime__$/, namespace: "ploy-runtime" }, () => ({
         contents: WORKFLOW_RUNTIME_CODE,
         loader: "ts"
@@ -1201,8 +1398,8 @@ function createRuntimePlugin(_config) {
   };
 }
 async function bundleWorker(options) {
-  const { projectDir, tempDir, entryPoint, config, mockServiceUrl } = options;
-  const wrapperCode = generateWrapperCode(config, mockServiceUrl);
+  const { projectDir, tempDir, entryPoint, config, mockServiceUrl, envVars } = options;
+  const wrapperCode = generateWrapperCode(config, mockServiceUrl, envVars);
   const wrapperPath = join(tempDir, "wrapper.ts");
   writeFileSync(wrapperPath, wrapperCode);
   const bundlePath = join(tempDir, "worker.bundle.js");
@@ -1235,6 +1432,7 @@ var init_bundler = __esm({
   "../emulator/dist/bundler/bundler.js"() {
     init_cache_runtime();
     init_db_runtime();
+    init_fs_runtime();
     init_queue_runtime();
     init_state_runtime();
     init_workflow_runtime();
@@ -1412,6 +1610,20 @@ var init_watcher = __esm({
   }
 });
 
+// ../emulator/dist/config/env.js
+function resolveEnvVars2(projectDir, config) {
+  if (!config.env) {
+    return {};
+  }
+  const dotEnv = loadDotEnvSync(projectDir);
+  return resolveEnvVars(config.env, dotEnv, process.env);
+}
+var init_env = __esm({
+  "../emulator/dist/config/env.js"() {
+    init_cli();
+  }
+});
+
 // ../emulator/dist/config/ploy-config.js
 function readPloyConfig2(projectDir, configPath) {
   const config = readPloyConfigSync(projectDir, configPath);
@@ -1481,6 +1693,34 @@ var init_workerd_config = __esm({
   "../emulator/dist/config/workerd-config.js"() {
   }
 });
+function getProjectHash(projectDir) {
+  return createHash("sha256").update(projectDir).digest("hex").slice(0, 12);
+}
+function getTempDir(projectDir) {
+  const hash = getProjectHash(projectDir);
+  return join(tmpdir(), `ploy-emulator-${hash}`);
+}
+function getDataDir(projectDir) {
+  return join(projectDir, ".ploy");
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+function ensureTempDir(projectDir) {
+  const tempDir = getTempDir(projectDir);
+  ensureDir(tempDir);
+  return tempDir;
+}
+function ensureDataDir(projectDir) {
+  const dataDir = getDataDir(projectDir);
+  ensureDir(dataDir);
+  ensureDir(join(dataDir, "db"));
+  return dataDir;
+}
+var init_paths = __esm({
+  "../emulator/dist/utils/paths.js"() {
+  }
+});
 function generateId() {
   return randomBytes(16).toString("hex");
 }
@@ -1793,6 +2033,7 @@ function createDashboardRoutes(app, dbManager2, config) {
       queue: config.queue,
       cache: config.cache,
       state: config.state,
+      fs: config.fs,
       workflow: config.workflow,
       auth: config.auth
     });
@@ -2287,6 +2528,37 @@ function createDashboardRoutes(app, dbManager2, config) {
       return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
     }
   });
+  app.get("/api/fs/:binding/entries", (c) => {
+    const binding = c.req.param("binding");
+    const fsName = config.fs?.[binding];
+    const limit = parseInt(c.req.query("limit") || "20", 10);
+    const offset = parseInt(c.req.query("offset") || "0", 10);
+    if (!fsName) {
+      return c.json({ error: "File storage binding not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const total = db.prepare(`SELECT COUNT(*) as count FROM fs_entries WHERE fs_name = ?`).get(fsName).count;
+      const entries = db.prepare(`SELECT key, size, content_type, created_at
+					 FROM fs_entries
+					 WHERE fs_name = ?
+					 ORDER BY key ASC
+					 LIMIT ? OFFSET ?`).all(fsName, limit, offset);
+      return c.json({
+        entries: entries.map((e) => ({
+          key: e.key,
+          size: e.size,
+          contentType: e.content_type,
+          createdAt: new Date(e.created_at * 1e3).toISOString()
+        })),
+        total,
+        limit,
+        offset
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
   if (hasDashboard) {
     app.get("/assets/*", (c) => {
       const path = c.req.path;
@@ -2437,6 +2709,125 @@ var init_db_service = __esm({
   "../emulator/dist/services/db-service.js"() {
   }
 });
+function createFsHandlers(db, dataDir) {
+  const fsBaseDir = join(dataDir, "fs");
+  mkdirSync(fsBaseDir, { recursive: true });
+  function getFsDir(fsName) {
+    const dir = join(fsBaseDir, fsName);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+  function encodedKeyPath(fsDir, key) {
+    return join(fsDir, encodeURIComponent(key));
+  }
+  const putHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { fsName, key, value, contentType } = body;
+      if (!fsName || !key) {
+        return c.json({ error: "Missing required fields: fsName, key, value" }, 400);
+      }
+      const fsDir = getFsDir(fsName);
+      const filePath = encodedKeyPath(fsDir, key);
+      writeFileSync(filePath, value, "utf-8");
+      const size = Buffer.byteLength(value, "utf-8");
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(`INSERT OR REPLACE INTO fs_entries (fs_name, key, content_type, size, created_at) VALUES (?, ?, ?, ?, ?)`).run(fsName, key, contentType ?? "application/octet-stream", size, now);
+      return c.json({ success: true });
+    } catch (err) {
+      error(`[fs-service] put error: ${err instanceof Error ? err.message : String(err)}`);
+      return c.json({
+        error: `put failed: ${err instanceof Error ? err.message : String(err)}`
+      }, 500);
+    }
+  };
+  const getHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { fsName, key } = body;
+      if (!fsName || !key) {
+        return c.json({ error: "Missing required fields: fsName, key" }, 400);
+      }
+      const row = db.prepare(`SELECT content_type, size FROM fs_entries WHERE fs_name = ? AND key = ?`).get(fsName, key);
+      if (!row) {
+        return c.json({ found: false });
+      }
+      const fsDir = getFsDir(fsName);
+      const filePath = encodedKeyPath(fsDir, key);
+      if (!existsSync(filePath)) {
+        db.prepare(`DELETE FROM fs_entries WHERE fs_name = ? AND key = ?`).run(fsName, key);
+        return c.json({ found: false });
+      }
+      const fileContent = readFileSync(filePath, "utf-8");
+      return c.json({
+        found: true,
+        body: fileContent,
+        contentType: row.content_type,
+        size: row.size
+      });
+    } catch (err) {
+      error(`[fs-service] get error: ${err instanceof Error ? err.message : String(err)}`);
+      return c.json({
+        error: `get failed: ${err instanceof Error ? err.message : String(err)}`
+      }, 500);
+    }
+  };
+  const deleteHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { fsName, key } = body;
+      if (!fsName || !key) {
+        return c.json({ error: "Missing required fields: fsName, key" }, 400);
+      }
+      db.prepare(`DELETE FROM fs_entries WHERE fs_name = ? AND key = ?`).run(fsName, key);
+      const fsDir = getFsDir(fsName);
+      const filePath = encodedKeyPath(fsDir, key);
+      if (existsSync(filePath)) {
+        unlinkSync(filePath);
+      }
+      return c.json({ success: true });
+    } catch (err) {
+      error(`[fs-service] delete error: ${err instanceof Error ? err.message : String(err)}`);
+      return c.json({
+        error: `delete failed: ${err instanceof Error ? err.message : String(err)}`
+      }, 500);
+    }
+  };
+  const listHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { fsName, prefix, limit } = body;
+      if (!fsName) {
+        return c.json({ error: "Missing required field: fsName" }, 400);
+      }
+      const effectiveLimit = limit ?? 1e3;
+      const keys = prefix ? db.prepare(`SELECT key, size, content_type FROM fs_entries WHERE fs_name = ? AND key LIKE ? ORDER BY key ASC LIMIT ?`).all(fsName, `${prefix}%`, effectiveLimit) : db.prepare(`SELECT key, size, content_type FROM fs_entries WHERE fs_name = ? ORDER BY key ASC LIMIT ?`).all(fsName, effectiveLimit);
+      return c.json({
+        keys: keys.map((k) => ({
+          key: k.key,
+          size: k.size,
+          contentType: k.content_type
+        }))
+      });
+    } catch (err) {
+      error(`[fs-service] list error: ${err instanceof Error ? err.message : String(err)}`);
+      return c.json({
+        error: `list failed: ${err instanceof Error ? err.message : String(err)}`
+      }, 500);
+    }
+  };
+  return {
+    putHandler,
+    getHandler,
+    deleteHandler,
+    listHandler
+  };
+}
+var init_fs_service = __esm({
+  "../emulator/dist/services/fs-service.js"() {
+    init_logger();
+  }
+});
 function createQueueHandlers(db) {
   const sendHandler = async (c) => {
     try {
@@ -2870,6 +3261,14 @@ async function startMockServer(dbManager2, config, options = {}) {
     app.post("/state/set", stateHandlers.setHandler);
     app.post("/state/delete", stateHandlers.deleteHandler);
   }
+  if (config.fs) {
+    const dataDir = getDataDir(process.cwd());
+    const fsHandlers = createFsHandlers(dbManager2.emulatorDb, dataDir);
+    app.post("/fs/put", fsHandlers.putHandler);
+    app.post("/fs/get", fsHandlers.getHandler);
+    app.post("/fs/delete", fsHandlers.deleteHandler);
+    app.post("/fs/list", fsHandlers.listHandler);
+  }
   if (config.auth) {
     const authHandlers = createAuthHandlers(dbManager2.emulatorDb);
     app.post("/auth/signup", authHandlers.signupHandler);
@@ -2901,44 +3300,18 @@ async function startMockServer(dbManager2, config, options = {}) {
 var DEFAULT_MOCK_SERVER_PORT;
 var init_mock_server = __esm({
   "../emulator/dist/services/mock-server.js"() {
+    init_paths();
     init_auth_service();
     init_cache_service();
     init_dashboard_routes();
     init_db_service();
+    init_fs_service();
     init_queue_service();
     init_state_service();
     init_workflow_service();
     DEFAULT_MOCK_SERVER_PORT = 4003;
   }
 });
-function getProjectHash(projectDir) {
-  return createHash("sha256").update(projectDir).digest("hex").slice(0, 12);
-}
-function getTempDir(projectDir) {
-  const hash = getProjectHash(projectDir);
-  return join(tmpdir(), `ploy-emulator-${hash}`);
-}
-function getDataDir(projectDir) {
-  return join(projectDir, ".ploy");
-}
-function ensureDir(dir) {
-  mkdirSync(dir, { recursive: true });
-}
-function ensureTempDir(projectDir) {
-  const tempDir = getTempDir(projectDir);
-  ensureDir(tempDir);
-  return tempDir;
-}
-function ensureDataDir(projectDir) {
-  const dataDir = getDataDir(projectDir);
-  ensureDir(dataDir);
-  ensureDir(join(dataDir, "db"));
-  return dataDir;
-}
-var init_paths = __esm({
-  "../emulator/dist/utils/paths.js"() {
-  }
-});
 function initializeDatabases(projectDir) {
   const dataDir = ensureDataDir(projectDir);
   const d1Databases = /* @__PURE__ */ new Map();
@@ -3080,6 +3453,16 @@ CREATE TABLE IF NOT EXISTS state_entries (
   value TEXT NOT NULL,
   PRIMARY KEY (state_name, key)
 );
+
+-- File storage entries table (metadata for stored files)
+CREATE TABLE IF NOT EXISTS fs_entries (
+  fs_name TEXT NOT NULL,
+  key TEXT NOT NULL,
+  content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
+  size INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  PRIMARY KEY (fs_name, key)
+);
 `;
   }
 });
@@ -3093,6 +3476,7 @@ var init_emulator = __esm({
   "../emulator/dist/emulator.js"() {
     init_bundler();
     init_watcher();
+    init_env();
     init_ploy_config2();
     init_workerd_config();
     init_mock_server();
@@ -3110,6 +3494,7 @@ var init_emulator = __esm({
       workerdProcess = null;
       fileWatcher = null;
       queueProcessor = null;
+      resolvedEnvVars = {};
       constructor(options = {}) {
         const port = options.port ?? 8787;
         this.options = {
@@ -3127,6 +3512,10 @@ var init_emulator = __esm({
         try {
           this.config = readPloyConfig2(this.projectDir, this.options.configPath);
           debug(`Loaded config: ${JSON.stringify(this.config)}`, this.options.verbose);
+          this.resolvedEnvVars = resolveEnvVars2(this.projectDir, this.config);
+          if (Object.keys(this.resolvedEnvVars).length > 0) {
+            debug(`Resolved env vars: ${Object.keys(this.resolvedEnvVars).join(", ")}`, this.options.verbose);
+          }
           this.tempDir = ensureTempDir(this.projectDir);
           ensureDataDir(this.projectDir);
           debug(`Temp dir: ${this.tempDir}`, this.options.verbose);
@@ -3174,6 +3563,9 @@ var init_emulator = __esm({
           }
           success(`Emulator running at http://${this.options.host}:${String(this.options.port)}`);
           log(`  Dashboard: http://${this.options.host}:${String(this.mockServer.port)}`);
+          if (Object.keys(this.resolvedEnvVars).length > 0) {
+            log(`  Env vars: ${Object.keys(this.resolvedEnvVars).join(", ")}`);
+          }
           if (this.config.db) {
             log(`  DB bindings: ${Object.keys(this.config.db).join(", ")}`);
           }
@@ -3183,6 +3575,9 @@ var init_emulator = __esm({
           if (this.config.cache) {
             log(`  Cache bindings: ${Object.keys(this.config.cache).join(", ")}`);
           }
+          if (this.config.fs) {
+            log(`  File Storage bindings: ${Object.keys(this.config.fs).join(", ")}`);
+          }
           if (this.config.workflow) {
             log(`  Workflow bindings: ${Object.keys(this.config.workflow).join(", ")}`);
           }
@@ -3202,7 +3597,8 @@ var init_emulator = __esm({
           tempDir: this.tempDir,
           entryPoint,
           config: this.config,
-          mockServiceUrl
+          mockServiceUrl,
+          envVars: this.resolvedEnvVars
         });
       }
       async startWorkerd(configPath) {
@@ -3228,9 +3624,7 @@ var init_emulator = __esm({
           let stderrOutput = "";
           this.workerdProcess.stdout?.on("data", (data) => {
             const output = data.toString();
-            if (this.options.verbose) {
-              process.stdout.write(output);
-            }
+            log(`[workerd stdout] ${output.trim()}`);
             if (!started && (output.includes("Listening") || output.includes("running"))) {
               started = true;
               resolve(void 0);
@@ -5166,6 +5560,12 @@ async function updateTsConfigInclude(cwd, outputPath) {
 function generateEnvType(config) {
   const imports = [];
   const properties = [];
+  if (config.env && Object.keys(config.env).length > 0) {
+    const varProps = Object.keys(config.env).map((key) => `		${key}: string;`).join("\n");
+    properties.push(`	vars: {
+${varProps}
+	};`);
+  }
   if (config.ai) {
     properties.push("	AI_URL: string;");
     properties.push("	AI_TOKEN: string;");
@@ -5241,7 +5641,7 @@ async function typesCommand(options = {}) {
     console.error("Error: ploy.yaml not found in current directory");
     process.exit(1);
   }
-  const hasBindings2 = config.ai || config.db || config.queue || config.cache || config.state || config.workflow;
+  const hasBindings2 = config.env || config.ai || config.db || config.queue || config.cache || config.state || config.workflow;
   if (!hasBindings2) {
     console.log("No bindings found in ploy.yaml. Generating empty Env.");
   }