@meetploy/cli 1.6.0 → 1.8.0

package/dist/dev.js

@@ -1,2 +1,1065 @@
-export { initPloyForDev } from "@meetploy/emulator";
-//# sourceMappingURL=dev.js.map
+import { createRequire } from 'module';
+import 'child_process';
+import { readFile, existsSync, readFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import 'esbuild';
+import 'chokidar';
+import { promisify } from 'util';
+import { parse } from 'yaml';
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { randomUUID } from 'crypto';
+import 'os';
+import Database from 'better-sqlite3';
+
+createRequire(import.meta.url);
+promisify(readFile);
+function readPloyConfigSync(projectDir, configPath) {
+  const configFile = configPath;
+  const fullPath = join(projectDir, configFile);
+  if (!existsSync(fullPath)) {
+    throw new Error(`Config file not found: ${fullPath}`);
+  }
+  const content = readFileSync(fullPath, "utf-8");
+  return parse(content);
+}
+
+// ../emulator/dist/config/ploy-config.js
+function readPloyConfig(projectDir, configPath) {
+  const config = readPloyConfigSync(projectDir, configPath);
+  if (!config.kind) {
+    throw new Error(`Missing required field 'kind' in ${configPath}`);
+  }
+  if (config.kind !== "dynamic" && config.kind !== "worker") {
+    throw new Error(`Invalid kind '${config.kind}' in ${configPath}. Must be 'dynamic' or 'worker'`);
+  }
+  return config;
+}
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function findDashboardDistPath() {
+  const possiblePaths = [
+    join(__dirname, "..", "dashboard-dist"),
+    join(__dirname, "..", "..", "src", "dashboard-dist")
+  ];
+  for (const p of possiblePaths) {
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+  return null;
+}
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function getMimeType(filePath) {
+  const ext = filePath.substring(filePath.lastIndexOf("."));
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+function createDashboardRoutes(app, dbManager2, config) {
+  const dashboardDistPath = findDashboardDistPath();
+  const hasDashboard = dashboardDistPath !== null;
+  function getDbResourceName(bindingName) {
+    return config.db?.[bindingName] ?? null;
+  }
+  app.get("/api/config", (c) => {
+    return c.json({
+      db: config.db,
+      queue: config.queue,
+      workflow: config.workflow
+    });
+  });
+  app.post("/api/db/:binding/query", async (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    const body = await c.req.json();
+    const { query } = body;
+    if (!query) {
+      return c.json({ error: "Query is required" }, 400);
+    }
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const startTime = Date.now();
+      const stmt = db.prepare(query);
+      const isSelect = query.trim().toUpperCase().startsWith("SELECT");
+      let results = [];
+      let changes = 0;
+      if (isSelect) {
+        results = stmt.all();
+      } else {
+        const info = stmt.run();
+        changes = info.changes;
+      }
+      const duration = Date.now() - startTime;
+      return c.json({
+        results,
+        success: true,
+        meta: {
+          duration,
+          rows_read: results.length,
+          rows_written: changes
+        }
+      });
+    } catch (err) {
+      return c.json({
+        results: [],
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        meta: { duration: 0, rows_read: 0, rows_written: 0 }
+      }, 400);
+    }
+  });
+  app.get("/api/db/:binding/tables", (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const tables = db.prepare(`SELECT name FROM sqlite_master
+					 WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_litestream_%'
+					 ORDER BY name`).all();
+      return c.json({ tables });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/db/:binding/tables/:tableName", (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    const tableName = c.req.param("tableName");
+    const limit = parseInt(c.req.query("limit") || "50", 10);
+    const offset = parseInt(c.req.query("offset") || "0", 10);
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const columnsResult = db.prepare(`PRAGMA table_info("${tableName}")`).all();
+      const columns = columnsResult.map((col) => col.name);
+      const countResult = db.prepare(`SELECT COUNT(*) as count FROM "${tableName}"`).get();
+      const total = countResult.count;
+      const data = db.prepare(`SELECT * FROM "${tableName}" LIMIT ? OFFSET ?`).all(limit, offset);
+      return c.json({ data, columns, total });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/db/:binding/schema", (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const tablesResult = db.prepare(`SELECT name FROM sqlite_master
+					 WHERE type='table' AND name NOT LIKE 'sqlite_%'
+					 ORDER BY name`).all();
+      const tables = tablesResult.map((table) => {
+        const columnsResult = db.prepare(`PRAGMA table_info("${table.name}")`).all();
+        return {
+          name: table.name,
+          columns: columnsResult.map((col) => ({
+            name: col.name,
+            type: col.type,
+            notNull: col.notnull === 1,
+            primaryKey: col.pk === 1
+          }))
+        };
+      });
+      return c.json({ tables });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/queue/:binding/metrics", (c) => {
+    const binding = c.req.param("binding");
+    const queueName = config.queue?.[binding];
+    if (!queueName) {
+      return c.json({ error: "Queue not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const metrics = {
+        pending: 0,
+        processing: 0,
+        acknowledged: 0,
+        failed: 0,
+        deadLetter: 0
+      };
+      const statusCounts = db.prepare(`SELECT status, COUNT(*) as count
+					 FROM queue_messages
+					 WHERE queue_name = ?
+					 GROUP BY status`).all(queueName);
+      for (const row of statusCounts) {
+        if (row.status === "pending") {
+          metrics.pending = row.count;
+        } else if (row.status === "processing") {
+          metrics.processing = row.count;
+        } else if (row.status === "acknowledged") {
+          metrics.acknowledged = row.count;
+        } else if (row.status === "failed") {
+          metrics.failed = row.count;
+        } else if (row.status === "dead_letter") {
+          metrics.deadLetter = row.count;
+        }
+      }
+      return c.json({ metrics });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/queue/:binding/messages", (c) => {
+    const binding = c.req.param("binding");
+    const queueName = config.queue?.[binding];
+    const limit = parseInt(c.req.query("limit") || "10", 10);
+    if (!queueName) {
+      return c.json({ error: "Queue not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const messages = db.prepare(`SELECT id, status, payload, attempt, created_at
+					 FROM queue_messages
+					 WHERE queue_name = ?
+					 ORDER BY created_at DESC
+					 LIMIT ?`).all(queueName, limit);
+      return c.json({
+        messages: messages.map((m) => ({
+          id: m.id,
+          status: m.status.toUpperCase(),
+          payload: JSON.parse(m.payload),
+          attempt: m.attempt,
+          createdAt: new Date(m.created_at * 1e3).toISOString()
+        }))
+      });
+    } 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];
+    const limit = parseInt(c.req.query("limit") || "20", 10);
+    if (!workflowConfig) {
+      return c.json({ error: "Workflow not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const workflowName = workflowConfig;
+      const executions = db.prepare(`SELECT
+						e.id,
+						e.workflow_name,
+						e.status,
+						e.error,
+						e.started_at,
+						e.completed_at,
+						e.created_at,
+						(SELECT COUNT(*) FROM workflow_steps WHERE execution_id = e.id) as steps_count,
+						(SELECT COUNT(*) FROM workflow_steps WHERE execution_id = e.id AND status = 'completed') as steps_completed
+					 FROM workflow_executions e
+					 WHERE e.workflow_name = ?
+					 ORDER BY e.created_at DESC
+					 LIMIT ?`).all(workflowName, limit);
+      return c.json({
+        executions: executions.map((e) => ({
+          id: e.id,
+          status: e.status.toUpperCase(),
+          startedAt: e.started_at ? new Date(e.started_at * 1e3).toISOString() : null,
+          completedAt: e.completed_at ? new Date(e.completed_at * 1e3).toISOString() : null,
+          durationMs: e.started_at && e.completed_at ? (e.completed_at - e.started_at) * 1e3 : null,
+          stepsCount: e.steps_count,
+          stepsCompleted: e.steps_completed,
+          errorMessage: e.error,
+          createdAt: new Date(e.created_at * 1e3).toISOString()
+        }))
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/workflow/:binding/executions/:executionId", (c) => {
+    const binding = c.req.param("binding");
+    const executionId = c.req.param("executionId");
+    const workflowConfig = config.workflow?.[binding];
+    if (!workflowConfig) {
+      return c.json({ error: "Workflow not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const execution = db.prepare(`SELECT id, workflow_name, status, error, started_at, completed_at, created_at
+					 FROM workflow_executions
+					 WHERE id = ?`).get(executionId);
+      if (!execution) {
+        return c.json({ error: "Execution not found" }, 404);
+      }
+      const steps = db.prepare(`SELECT id, step_name, step_index, status, output, error, duration_ms, created_at
+					 FROM workflow_steps
+					 WHERE execution_id = ?
+					 ORDER BY step_index`).all(executionId);
+      return c.json({
+        execution: {
+          id: execution.id,
+          status: execution.status.toUpperCase(),
+          startedAt: execution.started_at ? new Date(execution.started_at * 1e3).toISOString() : null,
+          completedAt: execution.completed_at ? new Date(execution.completed_at * 1e3).toISOString() : null,
+          durationMs: execution.started_at && execution.completed_at ? (execution.completed_at - execution.started_at) * 1e3 : null,
+          stepsCount: steps.length,
+          stepsCompleted: steps.filter((s) => s.status === "completed").length,
+          errorMessage: execution.error,
+          createdAt: new Date(execution.created_at * 1e3).toISOString()
+        },
+        steps: steps.map((s) => ({
+          id: String(s.id),
+          stepName: s.step_name,
+          stepIndex: s.step_index,
+          status: s.status.toUpperCase(),
+          output: s.output ? JSON.parse(s.output) : null,
+          errorMessage: s.error,
+          durationMs: s.duration_ms,
+          createdAt: new Date(s.created_at * 1e3).toISOString()
+        }))
+      });
+    } 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;
+      const filePath = join(dashboardDistPath, path);
+      if (!existsSync(filePath)) {
+        return c.notFound();
+      }
+      const content = readFileSync(filePath);
+      const mimeType = getMimeType(filePath);
+      return new Response(content, {
+        headers: {
+          "Content-Type": mimeType,
+          "Cache-Control": "public, max-age=31536000"
+        }
+      });
+    });
+    app.get("*", (c) => {
+      if (c.req.path.startsWith("/api/") || c.req.path.startsWith("/db") || c.req.path.startsWith("/queue") || c.req.path.startsWith("/workflow")) {
+        return c.notFound();
+      }
+      const indexPath = join(dashboardDistPath, "index.html");
+      if (!existsSync(indexPath)) {
+        return c.text("Dashboard not found. Run 'pnpm build' in packages/dev-dashboard.", 404);
+      }
+      const content = readFileSync(indexPath, "utf-8");
+      return c.html(content);
+    });
+  }
+}
+
+// ../emulator/dist/services/db-service.js
+function createDbHandler(getDatabase) {
+  return async (c) => {
+    const startTime = Date.now();
+    try {
+      const body = await c.req.json();
+      const { bindingName, method, query, params, statements } = body;
+      const db = getDatabase(bindingName);
+      if (method === "prepare" && query) {
+        const stmt = db.prepare(query);
+        const isSelect = query.trim().toUpperCase().startsWith("SELECT");
+        let results;
+        let changes = 0;
+        if (isSelect) {
+          results = params?.length ? stmt.all(...params) : stmt.all();
+        } else {
+          const info = params?.length ? stmt.run(...params) : stmt.run();
+          changes = info.changes;
+          results = [];
+        }
+        const duration = Date.now() - startTime;
+        return c.json({
+          results,
+          success: true,
+          meta: {
+            duration,
+            rows_read: results.length,
+            rows_written: changes
+          }
+        });
+      }
+      if (method === "exec" && query) {
+        db.exec(query);
+        const duration = Date.now() - startTime;
+        return c.json({
+          results: [],
+          success: true,
+          meta: {
+            duration,
+            rows_read: 0,
+            rows_written: 0
+          }
+        });
+      }
+      if (method === "batch" && statements) {
+        const results = [];
+        const transaction = db.transaction(() => {
+          for (const stmt of statements) {
+            const prepared = db.prepare(stmt.query);
+            const isSelect = stmt.query.trim().toUpperCase().startsWith("SELECT");
+            if (isSelect) {
+              const rows = stmt.params?.length ? prepared.all(...stmt.params) : prepared.all();
+              results.push({
+                results: rows,
+                success: true,
+                meta: {
+                  duration: 0,
+                  rows_read: rows.length,
+                  rows_written: 0
+                }
+              });
+            } else {
+              const info = stmt.params?.length ? prepared.run(...stmt.params) : prepared.run();
+              results.push({
+                results: [],
+                success: true,
+                meta: {
+                  duration: 0,
+                  rows_read: 0,
+                  rows_written: info.changes
+                }
+              });
+            }
+          }
+        });
+        transaction();
+        return c.json(results);
+      }
+      if (method === "dump") {
+        const buffer = db.serialize();
+        return new Response(new Uint8Array(buffer), {
+          headers: {
+            "Content-Type": "application/octet-stream"
+          }
+        });
+      }
+      return c.json({ error: "Invalid method" }, 400);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  };
+}
+function createQueueHandlers(db) {
+  const sendHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { queueName, payload, delaySeconds = 0 } = body;
+      const id = randomUUID();
+      const now = Math.floor(Date.now() / 1e3);
+      const visibleAt = now + delaySeconds;
+      db.prepare(`INSERT INTO queue_messages (id, queue_name, payload, visible_at)
+				 VALUES (?, ?, ?, ?)`).run(id, queueName, JSON.stringify(payload), visibleAt);
+      return c.json({ success: true, messageId: id });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const batchSendHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { queueName, messages } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const messageIds = [];
+      const insert = db.prepare(`INSERT INTO queue_messages (id, queue_name, payload, visible_at)
+				 VALUES (?, ?, ?, ?)`);
+      const transaction = db.transaction(() => {
+        for (const msg of messages) {
+          const id = randomUUID();
+          const visibleAt = now + (msg.delaySeconds || 0);
+          insert.run(id, queueName, JSON.stringify(msg.payload), visibleAt);
+          messageIds.push(id);
+        }
+      });
+      transaction();
+      return c.json({ success: true, messageIds });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const receiveHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { queueName, maxMessages = 10, visibilityTimeoutSeconds = 30 } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const deliveryId = randomUUID();
+      const newVisibleAt = now + visibilityTimeoutSeconds;
+      const rows = db.prepare(`SELECT id, queue_name, payload, attempt
+					 FROM queue_messages
+					 WHERE queue_name = ? AND status = 'pending' AND visible_at <= ?
+					 ORDER BY visible_at ASC
+					 LIMIT ?`).all(queueName, now, maxMessages);
+      if (rows.length === 0) {
+        return c.json({ success: true, messages: [] });
+      }
+      const ids = rows.map((r) => r.id);
+      const placeholders = ids.map(() => "?").join(",");
+      db.prepare(`UPDATE queue_messages
+				 SET status = 'processing', delivery_id = ?, visible_at = ?, attempt = attempt + 1, updated_at = ?
+				 WHERE id IN (${placeholders})`).run(deliveryId, newVisibleAt, now, ...ids);
+      const messages = rows.map((row) => ({
+        id: row.id,
+        payload: JSON.parse(row.payload),
+        attempt: row.attempt + 1,
+        deliveryId
+      }));
+      return c.json({ success: true, messages });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, messages: [], error: message }, 500);
+    }
+  };
+  const ackHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { messageId, deliveryId } = body;
+      const result = db.prepare(`DELETE FROM queue_messages
+					 WHERE id = ? AND delivery_id = ?`).run(messageId, deliveryId);
+      if (result.changes === 0) {
+        return c.json({ success: false, error: "Message not found or already processed" }, 404);
+      }
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const retryHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { messageId, deliveryId } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const backoffSeconds = 5;
+      const result = db.prepare(`UPDATE queue_messages
+					 SET status = 'pending', delivery_id = NULL, visible_at = ?, updated_at = ?
+					 WHERE id = ? AND delivery_id = ?`).run(now + backoffSeconds, now, messageId, deliveryId);
+      if (result.changes === 0) {
+        return c.json({ success: false, error: "Message not found or already processed" }, 404);
+      }
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  return {
+    sendHandler,
+    batchSendHandler,
+    receiveHandler,
+    ackHandler,
+    retryHandler
+  };
+}
+function createWorkflowHandlers(db, workerUrl) {
+  const triggerHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { workflowName, input } = body;
+      const id = randomUUID();
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(`INSERT INTO workflow_executions (id, workflow_name, status, input, started_at, created_at)
+				 VALUES (?, ?, 'running', ?, ?, ?)`).run(id, workflowName, JSON.stringify(input), now, now);
+      if (workerUrl) {
+        fetch(workerUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Ploy-Workflow-Execution": "true",
+            "X-Ploy-Workflow-Name": workflowName,
+            "X-Ploy-Execution-Id": id
+          },
+          body: JSON.stringify(input)
+        }).catch(() => {
+        });
+      }
+      return c.json({ success: true, executionId: id });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const statusHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId } = body;
+      const execution = db.prepare(`SELECT id, workflow_name, status, input, output, error, started_at, completed_at, created_at
+					 FROM workflow_executions WHERE id = ?`).get(executionId);
+      if (!execution) {
+        return c.json({ success: false, error: "Execution not found" }, 404);
+      }
+      const steps = db.prepare(`SELECT step_name, step_index, status, output, error, duration_ms
+					 FROM workflow_steps WHERE execution_id = ? ORDER BY step_index`).all(executionId);
+      return c.json({
+        success: true,
+        execution: {
+          id: execution.id,
+          workflowName: execution.workflow_name,
+          status: execution.status,
+          input: execution.input ? JSON.parse(execution.input) : null,
+          output: execution.output ? JSON.parse(execution.output) : null,
+          error: execution.error,
+          startedAt: execution.started_at ? new Date(execution.started_at * 1e3).toISOString() : null,
+          completedAt: execution.completed_at ? new Date(execution.completed_at * 1e3).toISOString() : null,
+          steps: steps.map((s) => ({
+            stepName: s.step_name,
+            stepIndex: s.step_index,
+            status: s.status,
+            output: s.output ? JSON.parse(s.output) : null,
+            error: s.error,
+            durationMs: s.duration_ms
+          }))
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const cancelHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const result = db.prepare(`UPDATE workflow_executions
+					 SET status = 'cancelled', completed_at = ?
+					 WHERE id = ? AND status IN ('pending', 'running')`).run(now, executionId);
+      if (result.changes === 0) {
+        return c.json({ success: false, error: "Execution not found or already completed" }, 404);
+      }
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const stepStartHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, stepName, stepIndex } = body;
+      const existing = db.prepare(`SELECT status, output FROM workflow_steps
+					 WHERE execution_id = ? AND step_name = ? AND step_index = ?`).get(executionId, stepName, stepIndex);
+      if (existing && existing.status === "completed") {
+        return c.json({
+          success: true,
+          alreadyCompleted: true,
+          output: existing.output ? JSON.parse(existing.output) : null
+        });
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      if (existing) {
+        db.prepare(`UPDATE workflow_steps SET status = 'running' WHERE execution_id = ? AND step_name = ?`).run(executionId, stepName);
+      } else {
+        db.prepare(`INSERT INTO workflow_steps (execution_id, step_name, step_index, status, created_at)
+					 VALUES (?, ?, ?, 'running', ?)`).run(executionId, stepName, stepIndex, now);
+      }
+      return c.json({ success: true, alreadyCompleted: false });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const stepCompleteHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, stepName, output, durationMs } = body;
+      db.prepare(`UPDATE workflow_steps
+				 SET status = 'completed', output = ?, duration_ms = ?
+				 WHERE execution_id = ? AND step_name = ?`).run(JSON.stringify(output), durationMs, executionId, stepName);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const stepFailHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, stepName, error: error2, durationMs } = body;
+      db.prepare(`UPDATE workflow_steps
+				 SET status = 'failed', error = ?, duration_ms = ?
+				 WHERE execution_id = ? AND step_name = ?`).run(error2, durationMs, executionId, stepName);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const completeHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, output } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(`UPDATE workflow_executions
+				 SET status = 'completed', output = ?, completed_at = ?
+				 WHERE id = ?`).run(JSON.stringify(output), now, executionId);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const failHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, error: error2 } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(`UPDATE workflow_executions
+				 SET status = 'failed', error = ?, completed_at = ?
+				 WHERE id = ?`).run(error2, now, executionId);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  return {
+    triggerHandler,
+    statusHandler,
+    cancelHandler,
+    stepStartHandler,
+    stepCompleteHandler,
+    stepFailHandler,
+    completeHandler,
+    failHandler
+  };
+}
+
+// ../emulator/dist/services/mock-server.js
+var DEFAULT_MOCK_SERVER_PORT = 4003;
+async function startMockServer(dbManager2, config, options = {}) {
+  const app = new Hono();
+  if (config.db) {
+    const dbHandler = createDbHandler(dbManager2.getD1Database);
+    app.post("/db", dbHandler);
+  }
+  if (config.queue) {
+    const queueHandlers = createQueueHandlers(dbManager2.emulatorDb);
+    app.post("/queue/send", queueHandlers.sendHandler);
+    app.post("/queue/batch-send", queueHandlers.batchSendHandler);
+    app.post("/queue/receive", queueHandlers.receiveHandler);
+    app.post("/queue/ack", queueHandlers.ackHandler);
+    app.post("/queue/retry", queueHandlers.retryHandler);
+  }
+  if (config.workflow) {
+    const workflowHandlers = createWorkflowHandlers(dbManager2.emulatorDb, options.workerUrl);
+    app.post("/workflow/trigger", workflowHandlers.triggerHandler);
+    app.post("/workflow/status", workflowHandlers.statusHandler);
+    app.post("/workflow/cancel", workflowHandlers.cancelHandler);
+    app.post("/workflow/step/start", workflowHandlers.stepStartHandler);
+    app.post("/workflow/step/complete", workflowHandlers.stepCompleteHandler);
+    app.post("/workflow/step/fail", workflowHandlers.stepFailHandler);
+    app.post("/workflow/complete", workflowHandlers.completeHandler);
+    app.post("/workflow/fail", workflowHandlers.failHandler);
+  }
+  app.get("/health", (c) => c.json({ status: "ok" }));
+  if (options.dashboardEnabled !== false) {
+    createDashboardRoutes(app, dbManager2, config);
+  }
+  const serverPort = options.port ?? DEFAULT_MOCK_SERVER_PORT;
+  return await new Promise((resolve) => {
+    const server = serve({
+      fetch: app.fetch,
+      port: serverPort
+    }, (info) => {
+      resolve({
+        port: info.port,
+        close: () => new Promise((res) => {
+          server.close(() => res());
+        })
+      });
+    });
+  });
+}
+function getDataDir(projectDir) {
+  return join(projectDir, ".ploy");
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+function ensureDataDir(projectDir) {
+  const dataDir = getDataDir(projectDir);
+  ensureDir(dataDir);
+  ensureDir(join(dataDir, "db"));
+  return dataDir;
+}
+var EMULATOR_SCHEMA = `
+-- Queue messages table
+CREATE TABLE IF NOT EXISTS queue_messages (
+  id TEXT PRIMARY KEY,
+  queue_name TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  status TEXT DEFAULT 'pending',
+  attempt INTEGER DEFAULT 0,
+  delivery_id TEXT,
+  visible_at INTEGER NOT NULL,
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_queue_messages_status
+  ON queue_messages(queue_name, status, visible_at);
+
+-- Workflow executions table
+CREATE TABLE IF NOT EXISTS workflow_executions (
+  id TEXT PRIMARY KEY,
+  workflow_name TEXT NOT NULL,
+  status TEXT DEFAULT 'pending',
+  input TEXT,
+  output TEXT,
+  error TEXT,
+  started_at INTEGER,
+  completed_at INTEGER,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_workflow_executions_status
+  ON workflow_executions(workflow_name, status);
+
+-- Workflow steps table
+CREATE TABLE IF NOT EXISTS workflow_steps (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  execution_id TEXT NOT NULL,
+  step_name TEXT NOT NULL,
+  step_index INTEGER NOT NULL,
+  status TEXT DEFAULT 'pending',
+  output TEXT,
+  error TEXT,
+  duration_ms INTEGER,
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  FOREIGN KEY (execution_id) REFERENCES workflow_executions(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_workflow_steps_execution
+  ON workflow_steps(execution_id, step_index);
+`;
+function initializeDatabases(projectDir) {
+  const dataDir = ensureDataDir(projectDir);
+  const d1Databases = /* @__PURE__ */ new Map();
+  const emulatorDb = new Database(join(dataDir, "emulator.db"));
+  emulatorDb.pragma("journal_mode = WAL");
+  emulatorDb.exec(EMULATOR_SCHEMA);
+  function getD1Database(bindingName) {
+    let db = d1Databases.get(bindingName);
+    if (!db) {
+      db = new Database(join(dataDir, "db", `${bindingName}.db`));
+      db.pragma("journal_mode = WAL");
+      d1Databases.set(bindingName, db);
+    }
+    return db;
+  }
+  function close() {
+    emulatorDb.close();
+    for (const db of d1Databases.values()) {
+      db.close();
+    }
+    d1Databases.clear();
+  }
+  return {
+    emulatorDb,
+    getD1Database,
+    close
+  };
+}
+
+// ../emulator/dist/nextjs-dev.js
+var PLOY_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("__ploy-context__");
+function createDevD1(databaseId, apiUrl) {
+  return {
+    async dump() {
+      const response = await fetch(`${apiUrl}/db`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          databaseId,
+          method: "dump"
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`DB dump failed: ${await response.text()}`);
+      }
+      return await response.arrayBuffer();
+    },
+    prepare(query) {
+      let boundParams = [];
+      const stmt = {
+        bind(...values) {
+          boundParams = values;
+          return stmt;
+        },
+        async run() {
+          const response = await fetch(`${apiUrl}/db`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              databaseId,
+              method: "prepare",
+              query,
+              params: boundParams
+            })
+          });
+          if (!response.ok) {
+            throw new Error(`DB query failed: ${await response.text()}`);
+          }
+          return await response.json();
+        },
+        async all() {
+          return await stmt.run();
+        },
+        async first(colName) {
+          const result = await stmt.run();
+          if (result.results.length === 0) {
+            return null;
+          }
+          const firstRow = result.results[0];
+          if (colName) {
+            return firstRow[colName] ?? null;
+          }
+          return firstRow;
+        },
+        async raw() {
+          const result = await stmt.run();
+          if (result.results.length === 0) {
+            return [];
+          }
+          const keys = Object.keys(result.results[0]);
+          return result.results.map((row) => keys.map((k) => row[k]));
+        }
+      };
+      return stmt;
+    },
+    async exec(query) {
+      const response = await fetch(`${apiUrl}/db`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          databaseId,
+          method: "exec",
+          query
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`DB exec failed: ${await response.text()}`);
+      }
+      return await response.json();
+    },
+    async batch(statements) {
+      const stmts = statements.map((s) => {
+        const data = s.__db_data;
+        return data || s;
+      });
+      const response = await fetch(`${apiUrl}/db`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          databaseId,
+          method: "batch",
+          statements: stmts
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`DB batch failed: ${await response.text()}`);
+      }
+      return await response.json();
+    }
+  };
+}
+var mockServer = null;
+var dbManager = null;
+async function initPloyForDev(config) {
+  if (process.env.NODE_ENV !== "development") {
+    return;
+  }
+  if (globalThis.__PLOY_DEV_INITIALIZED__) {
+    return;
+  }
+  globalThis.__PLOY_DEV_INITIALIZED__ = true;
+  const configPath = config?.configPath || "./ploy.yaml";
+  const projectDir = process.cwd();
+  let ployConfig;
+  try {
+    ployConfig = readPloyConfig(projectDir, configPath);
+  } catch {
+    if (config?.bindings?.db) {
+      ployConfig = { db: config.bindings.db };
+    } else {
+      return;
+    }
+  }
+  if (config?.bindings?.db) {
+    ployConfig = { ...ployConfig, db: config.bindings.db };
+  }
+  if (!ployConfig.db || Object.keys(ployConfig.db).length === 0) {
+    return;
+  }
+  ensureDataDir(projectDir);
+  dbManager = initializeDatabases(projectDir);
+  mockServer = await startMockServer(dbManager, ployConfig, {});
+  const apiUrl = `http://localhost:${mockServer.port}`;
+  const env = {};
+  for (const [bindingName, databaseId] of Object.entries(ployConfig.db)) {
+    env[bindingName] = createDevD1(databaseId, apiUrl);
+  }
+  const context = {
+    env,
+    cf: void 0,
+    ctx: void 0
+  };
+  globalThis.__PLOY_DEV_CONTEXT__ = context;
+  Object.defineProperty(globalThis, PLOY_CONTEXT_SYMBOL, {
+    get() {
+      return context;
+    },
+    configurable: true
+  });
+  const bindingNames = Object.keys(env);
+  console.log(`[Ploy] Development context initialized with bindings: ${bindingNames.join(", ")}`);
+  console.log(`[Ploy] Mock server running at ${apiUrl}`);
+  const cleanup = async () => {
+    if (mockServer) {
+      await mockServer.close();
+      mockServer = null;
+    }
+    if (dbManager) {
+      dbManager.close();
+      dbManager = null;
+    }
+  };
+  process.on("exit", () => {
+    if (dbManager) {
+      dbManager.close();
+    }
+  });
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+}
+
+export { initPloyForDev };