@meetploy/cli 1.12.2 → 1.14.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 import { mkdir, writeFile, readFile, chmod, access } from 'fs/promises';
-import { join, dirname, relative } from 'path';
+import { join, dirname, relative, basename } from 'path';
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readFile as readFile$1, mkdirSync } from 'fs';
 import { promisify } from 'util';
 import { parse } from 'yaml';
@@ -137,15 +137,12 @@ function getCompatibilityFlags(config) {
   return [...new Set(allFlags)];
 }
 function getCompatibilityDate(config) {
-  return config.compatibility_date || DEFAULT_COMPATIBILITY_DATE;
+  return config.compatibility_date ?? DEFAULT_COMPATIBILITY_DATE;
 }
 function validateBindings(bindings, bindingType, configFile) {
   if (bindings === void 0) {
     return;
   }
-  if (typeof bindings !== "object" || bindings === null) {
-    throw new Error(`'${bindingType}' in ${configFile} must be an object`);
-  }
   for (const [bindingName, resourceName] of Object.entries(bindings)) {
     if (!BINDING_NAME_REGEX.test(bindingName)) {
       throw new Error(`Invalid ${bindingType} binding name '${bindingName}' in ${configFile}. Binding names must be uppercase with underscores (e.g., DB, USERS_DB)`);
@@ -196,6 +193,8 @@ function validatePloyConfig(config, configFile = "ploy.yaml", options = {}) {
   validatedConfig.main = validateRelativePath(config.main, "main", configFile);
   validateBindings(config.db, "db", configFile);
   validateBindings(config.queue, "queue", configFile);
+  validateBindings(config.cache, "cache", configFile);
+  validateBindings(config.state, "state", 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`);
@@ -222,9 +221,6 @@ function validatePloyConfig(config, configFile = "ploy.yaml", options = {}) {
     }
   }
   if (config.auth !== void 0) {
-    if (typeof config.auth !== "object" || config.auth === null) {
-      throw new Error(`'auth' in ${configFile} must be an object`);
-    }
     if (!config.auth.binding) {
       throw new Error(`'auth.binding' is required in ${configFile} when auth is configured`);
     }
@@ -238,7 +234,7 @@ function validatePloyConfig(config, configFile = "ploy.yaml", options = {}) {
   return validatedConfig;
 }
 async function readPloyConfig(projectDir, configPath) {
-  const configFile = configPath || "ploy.yaml";
+  const configFile = configPath ?? "ploy.yaml";
   const fullPath = join(projectDir, configFile);
   try {
     const content = await readFileAsync(fullPath, "utf-8");
@@ -253,7 +249,7 @@ async function readPloyConfig(projectDir, configPath) {
   }
 }
 function readPloyConfigSync(projectDir, configPath) {
-  const configFile = configPath || "ploy.yaml";
+  const configFile = configPath ?? "ploy.yaml";
   const fullPath = join(projectDir, configFile);
   if (!existsSync(fullPath)) {
     throw new Error(`Config file not found: ${fullPath}`);
@@ -262,7 +258,7 @@ function readPloyConfigSync(projectDir, configPath) {
   return parse(content);
 }
 async function readAndValidatePloyConfig(projectDir, configPath, validationOptions) {
-  const configFile = configPath || "ploy.yaml";
+  const configFile = configPath ?? "ploy.yaml";
   const config = await readPloyConfig(projectDir, configPath);
   if (!config) {
     return null;
@@ -270,12 +266,12 @@ async function readAndValidatePloyConfig(projectDir, configPath, validationOptio
   return validatePloyConfig(config, configFile, validationOptions);
 }
 function readAndValidatePloyConfigSync(projectDir, configPath, validationOptions) {
-  const configFile = configPath || "ploy.yaml";
+  const configFile = configPath ?? "ploy.yaml";
   const config = readPloyConfigSync(projectDir, configPath);
   return validatePloyConfig(config, configFile, validationOptions);
 }
 function hasBindings(config) {
-  return !!(config.db || config.queue || config.workflow || config.ai || config.auth);
+  return !!(config.db || config.queue || config.cache || config.state || config.workflow || config.ai || config.auth);
 }
 function getWorkerEntryPoint(projectDir, config) {
   if (config.main) {
@@ -331,6 +327,66 @@ var init_cli = __esm({
   }
 });
 
+// ../emulator/dist/runtime/cache-runtime.js
+var CACHE_RUNTIME_CODE;
+var init_cache_runtime = __esm({
+  "../emulator/dist/runtime/cache-runtime.js"() {
+    CACHE_RUNTIME_CODE = `
+interface CacheBinding {
+  get: (key: string) => Promise<string | null>;
+  set: (key: string, value: string, opts: { ttl: number }) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+}
+
+export function initializeCache(cacheName: string, serviceUrl: string): CacheBinding {
+  return {
+    async get(key: string): Promise<string | null> {
+      const response = await fetch(serviceUrl + "/cache/get", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ cacheName, key }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Cache get failed: " + errorText);
+      }
+
+      const result = await response.json();
+      return result.value ?? null;
+    },
+
+    async set(key: string, value: string, opts: { ttl: number }): Promise<void> {
+      const response = await fetch(serviceUrl + "/cache/set", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ cacheName, key, value, ttl: opts.ttl }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Cache set failed: " + errorText);
+      }
+    },
+
+    async delete(key: string): Promise<void> {
+      const response = await fetch(serviceUrl + "/cache/delete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ cacheName, key }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Cache delete failed: " + errorText);
+      }
+    },
+  };
+}
+`;
+  }
+});
+
 // ../shared/dist/d1-runtime.js
 var DB_RUNTIME_CODE, DB_RUNTIME_CODE_PRODUCTION;
 var init_d1_runtime = __esm({
@@ -716,6 +772,66 @@ export function initializeQueue<T = unknown>(queueName: string, serviceUrl: stri
   }
 });
 
+// ../emulator/dist/runtime/state-runtime.js
+var STATE_RUNTIME_CODE;
+var init_state_runtime = __esm({
+  "../emulator/dist/runtime/state-runtime.js"() {
+    STATE_RUNTIME_CODE = `
+interface StateBinding {
+  get: (key: string) => Promise<string | null>;
+  set: (key: string, value: string) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+}
+
+export function initializeState(stateName: string, serviceUrl: string): StateBinding {
+  return {
+    async get(key: string): Promise<string | null> {
+      const response = await fetch(serviceUrl + "/state/get", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ stateName, key }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("State get failed: " + errorText);
+      }
+
+      const result = await response.json();
+      return result.value ?? null;
+    },
+
+    async set(key: string, value: string): Promise<void> {
+      const response = await fetch(serviceUrl + "/state/set", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ stateName, key, value }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("State set failed: " + errorText);
+      }
+    },
+
+    async delete(key: string): Promise<void> {
+      const response = await fetch(serviceUrl + "/state/delete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ stateName, key }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("State delete failed: " + errorText);
+      }
+    },
+  };
+}
+`;
+  }
+});
+
 // ../emulator/dist/runtime/workflow-runtime.js
 var WORKFLOW_RUNTIME_CODE;
 var init_workflow_runtime = __esm({
@@ -942,6 +1058,18 @@ function generateWrapperCode(config, mockServiceUrl) {
       bindings.push(`  ${bindingName}: initializeQueue("${queueName}", "${mockServiceUrl}"),`);
     }
   }
+  if (config.cache) {
+    imports.push('import { initializeCache } from "__ploy_cache_runtime__";');
+    for (const [bindingName, cacheName] of Object.entries(config.cache)) {
+      bindings.push(`  ${bindingName}: initializeCache("${cacheName}", "${mockServiceUrl}"),`);
+    }
+  }
+  if (config.state) {
+    imports.push('import { initializeState } from "__ploy_state_runtime__";');
+    for (const [bindingName, stateName] of Object.entries(config.state)) {
+      bindings.push(`  ${bindingName}: initializeState("${stateName}", "${mockServiceUrl}"),`);
+    }
+  }
   if (config.workflow) {
     imports.push('import { initializeWorkflow, createStepContext, executeWorkflow } from "__ploy_workflow_runtime__";');
     for (const [bindingName, workflowName] of Object.entries(config.workflow)) {
@@ -1045,6 +1173,14 @@ function createRuntimePlugin(_config) {
         path: "__ploy_queue_runtime__",
         namespace: "ploy-runtime"
       }));
+      build2.onResolve({ filter: /^__ploy_cache_runtime__$/ }, () => ({
+        path: "__ploy_cache_runtime__",
+        namespace: "ploy-runtime"
+      }));
+      build2.onResolve({ filter: /^__ploy_state_runtime__$/ }, () => ({
+        path: "__ploy_state_runtime__",
+        namespace: "ploy-runtime"
+      }));
       build2.onResolve({ filter: /^__ploy_workflow_runtime__$/ }, () => ({
         path: "__ploy_workflow_runtime__",
         namespace: "ploy-runtime"
@@ -1057,6 +1193,14 @@ function createRuntimePlugin(_config) {
         contents: QUEUE_RUNTIME_CODE,
         loader: "ts"
       }));
+      build2.onLoad({ filter: /^__ploy_cache_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: CACHE_RUNTIME_CODE,
+        loader: "ts"
+      }));
+      build2.onLoad({ filter: /^__ploy_state_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: STATE_RUNTIME_CODE,
+        loader: "ts"
+      }));
       build2.onLoad({ filter: /^__ploy_workflow_runtime__$/, namespace: "ploy-runtime" }, () => ({
         contents: WORKFLOW_RUNTIME_CODE,
         loader: "ts"
@@ -1097,8 +1241,10 @@ async function bundleWorker(options) {
 var NODE_BUILTINS;
 var init_bundler = __esm({
   "../emulator/dist/bundler/bundler.js"() {
+    init_cache_runtime();
     init_db_runtime();
     init_queue_runtime();
+    init_state_runtime();
     init_workflow_runtime();
     NODE_BUILTINS = [
       "assert",
@@ -1156,9 +1302,6 @@ function log(message) {
 function success(message) {
   console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.green}[ploy]${COLORS.reset} ${message}`);
 }
-function warn(message) {
-  console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.yellow}[ploy]${COLORS.reset} ${message}`);
-}
 function error(message) {
   console.error(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.red}[ploy]${COLORS.reset} ${message}`);
 }
@@ -1181,6 +1324,22 @@ var init_logger = __esm({
     };
   }
 });
+function isIgnored(filePath) {
+  const name = basename(filePath);
+  if (name.startsWith(".")) {
+    return true;
+  }
+  if (IGNORED_DIRS.has(name)) {
+    return true;
+  }
+  if (IGNORED_FILES.has(name)) {
+    return true;
+  }
+  if (name.endsWith(".log")) {
+    return true;
+  }
+  return false;
+}
 function createFileWatcher(srcDir, onRebuild) {
   let watcher = null;
   let debounceTimer = null;
@@ -1213,25 +1372,11 @@ function createFileWatcher(srcDir, onRebuild) {
       watcher = watch(srcDir, {
         persistent: true,
         ignoreInitial: true,
-        ignored: [
-          "**/node_modules/**",
-          "**/dist/**",
-          "**/.*",
-          "**/.*/**",
-          "**/coverage/**",
-          "**/build/**",
-          "**/*.log",
-          "**/pnpm-lock.yaml",
-          "**/package-lock.json",
-          "**/yarn.lock"
-        ]
+        ignored: isIgnored
       });
       watcher.on("error", (err) => {
         const error2 = err;
-        if (error2.code === "EMFILE") {
-          warn("Warning: Too many open files. Some file changes may not be detected.");
-          warn("Consider increasing your system's file descriptor limit (ulimit -n).");
-        } else {
+        if (error2.code !== "EMFILE") {
           error(`File watcher error: ${error2.message || String(err)}`);
         }
       });
@@ -1263,9 +1408,16 @@ function createFileWatcher(srcDir, onRebuild) {
     }
   };
 }
+var IGNORED_DIRS, IGNORED_FILES;
 var init_watcher = __esm({
   "../emulator/dist/bundler/watcher.js"() {
     init_logger();
+    IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", "build"]);
+    IGNORED_FILES = /* @__PURE__ */ new Set([
+      "pnpm-lock.yaml",
+      "package-lock.json",
+      "yarn.lock"
+    ]);
   }
 });
 
@@ -1587,6 +1739,40 @@ var init_auth_service = __esm({
     SESSION_TOKEN_EXPIRY = 7 * 24 * 60 * 60;
   }
 });
+
+// ../emulator/dist/services/cache-service.js
+function createCacheHandlers(db) {
+  const getHandler = async (c) => {
+    const body = await c.req.json();
+    const { cacheName, key } = body;
+    const now = Math.floor(Date.now() / 1e3);
+    const row = db.prepare(`SELECT value FROM cache_entries WHERE cache_name = ? AND key = ? AND expires_at > ?`).get(cacheName, key, now);
+    return c.json({ value: row?.value ?? null });
+  };
+  const setHandler = async (c) => {
+    const body = await c.req.json();
+    const { cacheName, key, value, ttl } = body;
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + ttl;
+    db.prepare(`INSERT OR REPLACE INTO cache_entries (cache_name, key, value, expires_at) VALUES (?, ?, ?, ?)`).run(cacheName, key, value, expiresAt);
+    return c.json({ success: true });
+  };
+  const deleteHandler = async (c) => {
+    const body = await c.req.json();
+    const { cacheName, key } = body;
+    db.prepare(`DELETE FROM cache_entries WHERE cache_name = ? AND key = ?`).run(cacheName, key);
+    return c.json({ success: true });
+  };
+  return {
+    getHandler,
+    setHandler,
+    deleteHandler
+  };
+}
+var init_cache_service = __esm({
+  "../emulator/dist/services/cache-service.js"() {
+  }
+});
 function findDashboardDistPath() {
   const possiblePaths = [
     join(__dirname, "dashboard-dist"),
@@ -1614,6 +1800,8 @@ function createDashboardRoutes(app, dbManager2, config) {
     return c.json({
       db: config.db,
       queue: config.queue,
+      cache: config.cache,
+      state: config.state,
       workflow: config.workflow,
       auth: config.auth
     });
@@ -1954,6 +2142,71 @@ function createDashboardRoutes(app, dbManager2, config) {
       return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
     }
   });
+  app.get("/api/cache/:binding/entries", (c) => {
+    const binding = c.req.param("binding");
+    const cacheName = config.cache?.[binding];
+    const limit = parseInt(c.req.query("limit") || "20", 10);
+    const offset = parseInt(c.req.query("offset") || "0", 10);
+    const now = Math.floor(Date.now() / 1e3);
+    if (!cacheName) {
+      return c.json({ error: "Cache binding not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const total = db.prepare(`SELECT COUNT(*) as count FROM cache_entries
+						 WHERE cache_name = ? AND expires_at > ?`).get(cacheName, now).count;
+      const entries = db.prepare(`SELECT key, value, expires_at
+					 FROM cache_entries
+					 WHERE cache_name = ? AND expires_at > ?
+					 ORDER BY key ASC
+					 LIMIT ? OFFSET ?`).all(cacheName, now, limit, offset);
+      return c.json({
+        entries: entries.map((e) => ({
+          key: e.key,
+          value: e.value,
+          ttlSeconds: Math.max(0, e.expires_at - now),
+          expiresAt: new Date(e.expires_at * 1e3).toISOString()
+        })),
+        total,
+        limit,
+        offset
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/state/:binding/entries", (c) => {
+    const binding = c.req.param("binding");
+    const stateName = config.state?.[binding];
+    const limit = parseInt(c.req.query("limit") || "20", 10);
+    const offset = parseInt(c.req.query("offset") || "0", 10);
+    const search = c.req.query("search") || "";
+    if (!stateName) {
+      return c.json({ error: "State binding not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const fetchLimit = limit + 1;
+      const entries = search ? db.prepare(`SELECT key, value
+						 FROM state_entries
+						 WHERE state_name = ? AND key LIKE ?
+						 ORDER BY key ASC
+						 LIMIT ? OFFSET ?`).all(stateName, `%${search}%`, fetchLimit, offset) : db.prepare(`SELECT key, value
+					 FROM state_entries
+					 WHERE state_name = ?
+					 ORDER BY key ASC
+					 LIMIT ? OFFSET ?`).all(stateName, fetchLimit, offset);
+      const hasMore = entries.length > limit;
+      return c.json({
+        entries: entries.slice(0, limit),
+        hasMore,
+        limit,
+        offset
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
   app.get("/api/workflow/:binding/executions", (c) => {
     const binding = c.req.param("binding");
     const workflowConfig = config.workflow?.[binding];
@@ -2381,6 +2634,37 @@ var init_queue_service = __esm({
   "../emulator/dist/services/queue-service.js"() {
   }
 });
+
+// ../emulator/dist/services/state-service.js
+function createStateHandlers(db) {
+  const getHandler = async (c) => {
+    const body = await c.req.json();
+    const { stateName, key } = body;
+    const row = db.prepare(`SELECT value FROM state_entries WHERE state_name = ? AND key = ?`).get(stateName, key);
+    return c.json({ value: row?.value ?? null });
+  };
+  const setHandler = async (c) => {
+    const body = await c.req.json();
+    const { stateName, key, value } = body;
+    db.prepare(`INSERT OR REPLACE INTO state_entries (state_name, key, value) VALUES (?, ?, ?)`).run(stateName, key, value);
+    return c.json({ success: true });
+  };
+  const deleteHandler = async (c) => {
+    const body = await c.req.json();
+    const { stateName, key } = body;
+    db.prepare(`DELETE FROM state_entries WHERE state_name = ? AND key = ?`).run(stateName, key);
+    return c.json({ success: true });
+  };
+  return {
+    getHandler,
+    setHandler,
+    deleteHandler
+  };
+}
+var init_state_service = __esm({
+  "../emulator/dist/services/state-service.js"() {
+  }
+});
 function createWorkflowHandlers(db, workerUrl) {
   const triggerHandler = async (c) => {
     try {
@@ -2583,6 +2867,18 @@ async function startMockServer(dbManager2, config, options = {}) {
     app.post("/workflow/complete", workflowHandlers.completeHandler);
     app.post("/workflow/fail", workflowHandlers.failHandler);
   }
+  if (config.cache) {
+    const cacheHandlers = createCacheHandlers(dbManager2.emulatorDb);
+    app.post("/cache/get", cacheHandlers.getHandler);
+    app.post("/cache/set", cacheHandlers.setHandler);
+    app.post("/cache/delete", cacheHandlers.deleteHandler);
+  }
+  if (config.state) {
+    const stateHandlers = createStateHandlers(dbManager2.emulatorDb);
+    app.post("/state/get", stateHandlers.getHandler);
+    app.post("/state/set", stateHandlers.setHandler);
+    app.post("/state/delete", stateHandlers.deleteHandler);
+  }
   if (config.auth) {
     const authHandlers = createAuthHandlers(dbManager2.emulatorDb);
     app.post("/auth/signup", authHandlers.signupHandler);
@@ -2603,7 +2899,9 @@ async function startMockServer(dbManager2, config, options = {}) {
       resolve({
         port: info.port,
         close: () => new Promise((res) => {
-          server.close(() => res());
+          server.close(() => {
+            res();
+          });
         })
       });
     });
@@ -2613,9 +2911,11 @@ var DEFAULT_MOCK_SERVER_PORT;
 var init_mock_server = __esm({
   "../emulator/dist/services/mock-server.js"() {
     init_auth_service();
+    init_cache_service();
     init_dashboard_routes();
     init_db_service();
     init_queue_service();
+    init_state_service();
     init_workflow_service();
     DEFAULT_MOCK_SERVER_PORT = 4003;
   }
@@ -2772,6 +3072,23 @@ CREATE TABLE IF NOT EXISTS auth_settings (
 
 -- Insert default settings if not exists
 INSERT OR IGNORE INTO auth_settings (id) VALUES (1);
+
+-- Cache entries table
+CREATE TABLE IF NOT EXISTS cache_entries (
+  cache_name TEXT NOT NULL,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  expires_at INTEGER NOT NULL,
+  PRIMARY KEY (cache_name, key)
+);
+
+-- State entries table (durable key-value store, no expiry)
+CREATE TABLE IF NOT EXISTS state_entries (
+  state_name TEXT NOT NULL,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (state_name, key)
+);
 `;
   }
 });
@@ -2872,6 +3189,9 @@ var init_emulator = __esm({
           if (this.config.queue) {
             log(`  Queue bindings: ${Object.keys(this.config.queue).join(", ")}`);
           }
+          if (this.config.cache) {
+            log(`  Cache bindings: ${Object.keys(this.config.cache).join(", ")}`);
+          }
           if (this.config.workflow) {
             log(`  Workflow bindings: ${Object.keys(this.config.workflow).join(", ")}`);
           }
@@ -2902,7 +3222,7 @@ var init_emulator = __esm({
         const workerdBin = this.findWorkerdBinary();
         log(`[ploy] Using workerd binary: ${workerdBin}`);
         debug(`Starting workerd: ${workerdBin} ${args2.join(" ")}`, this.options.verbose);
-        return await new Promise((resolve, reject) => {
+        await new Promise((resolve, reject) => {
           const workerdBinDir = dirname(workerdBin);
           this.workerdProcess = spawn(workerdBin, args2, {
             cwd: this.tempDir,
@@ -2922,7 +3242,7 @@ var init_emulator = __esm({
             }
             if (!started && (output.includes("Listening") || output.includes("running"))) {
               started = true;
-              resolve();
+              resolve(void 0);
             }
           });
           this.workerdProcess.stderr?.on("data", (data) => {
@@ -2936,7 +3256,7 @@ var init_emulator = __esm({
             }
             if (!started && output.includes("Listening")) {
               started = true;
-              resolve();
+              resolve(void 0);
             }
           });
           this.workerdProcess.on("error", (err) => {
@@ -2959,7 +3279,7 @@ var init_emulator = __esm({
           setTimeout(() => {
             if (!started) {
               started = true;
-              resolve();
+              resolve(void 0);
             }
           }, 2e3);
         });
@@ -4516,7 +4836,7 @@ function createCallbackServer(expectedState, apiUrl) {
 					</html>
 				`);
         server?.close();
-        reject(err);
+        reject(err instanceof Error ? err : new Error(String(err)));
       }
     });
     server.on("error", (err) => {
@@ -4856,6 +5176,18 @@ function generateEnvType(config) {
       properties.push(`	${bindingName}: QueueBinding;`);
     }
   }
+  if (config.cache) {
+    imports.push("CacheBinding");
+    for (const bindingName of Object.keys(config.cache)) {
+      properties.push(`	${bindingName}: CacheBinding;`);
+    }
+  }
+  if (config.state) {
+    imports.push("StateBinding");
+    for (const bindingName of Object.keys(config.state)) {
+      properties.push(`	${bindingName}: StateBinding;`);
+    }
+  }
   if (config.workflow) {
     imports.push("WorkflowBinding");
     for (const bindingName of Object.keys(config.workflow)) {
@@ -4903,7 +5235,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.workflow;
+  const hasBindings2 = 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.");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@meetploy/cli",
-	"version": "1.12.2",
+	"version": "1.14.0",
 	"private": false,
 	"repository": {
 		"type": "git",