@meetploy/cli 1.6.0 → 1.8.0

package/dist/index.js

@@ -1,184 +1,4332 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { buildCommand, parseBuildArgs } from "./commands/build.js";
-import { typesCommand, parseTypesArgs } from "./commands/types.js";
-const args = process.argv.slice(2);
-const command = args[0];
-if (!command) {
-    console.error("Usage: ploy <command>");
-    console.error("\nAvailable commands:");
-    console.error("  build  Build your Ploy project");
-    console.error("  dev    Start development server");
-    console.error("  types  Generate TypeScript types from ploy.yaml");
-    process.exit(1);
-}
-function parseDevArgs(args) {
-    const options = {
-        port: undefined,
-        host: undefined,
-        config: undefined,
-        watch: true,
-        verbose: false,
-        dashboardPort: undefined,
-    };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === "-p" || arg === "--port") {
-            const value = args[++i];
-            if (value) {
-                options.port = parseInt(value, 10);
-            }
+import { createRequire } from 'module';
+import { mkdir, writeFile, readFile, chmod, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { existsSync, readFileSync, readFile as readFile$1, mkdirSync, writeFileSync } from 'fs';
+import { promisify } from 'util';
+import { parse } from 'yaml';
+import { build } from 'esbuild';
+import { watch } from 'chokidar';
+import { URL, fileURLToPath } from 'url';
+import { randomBytes, randomUUID, createHash } from 'crypto';
+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';
+import { createServer } from 'http';
+
+createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+async function isPnpmWorkspace(projectDir) {
+  try {
+    await access(join(projectDir, "pnpm-workspace.yaml"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getAddDevDependencyCommand(packageManager, packages, isPnpmWorkspace2 = false) {
+  const packageList = packages.join(" ");
+  switch (packageManager) {
+    case "npm":
+      return `npm install --save-dev ${packageList}`;
+    case "yarn":
+      return `yarn add -D ${packageList}`;
+    case "pnpm":
+      return isPnpmWorkspace2 ? `pnpm add -w -D ${packageList}` : `pnpm add -D ${packageList}`;
+  }
+}
+function getRunCommand(packageManager, command2) {
+  switch (packageManager) {
+    case "npm":
+      return `npx ${command2}`;
+    case "yarn":
+      return `yarn ${command2}`;
+    case "pnpm":
+      return `pnpm ${command2}`;
+  }
+}
+var init_package_manager = __esm({
+  "../tools/dist/package-manager.js"() {
+  }
+});
+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)`);
+    }
+    if (typeof resourceName !== "string") {
+      throw new Error(`${bindingType} binding '${bindingName}' in ${configFile} must have a string value`);
+    }
+    if (!RESOURCE_NAME_REGEX.test(resourceName)) {
+      throw new Error(`Invalid ${bindingType} resource name '${resourceName}' for binding '${bindingName}' in ${configFile}. Resource names must be lowercase with underscores (e.g., default, users_db)`);
+    }
+  }
+}
+function validateRelativePath(path, fieldName, configFile) {
+  if (path === void 0) {
+    return void 0;
+  }
+  if (typeof path !== "string") {
+    throw new Error(`'${fieldName}' in ${configFile} must be a string`);
+  }
+  const normalized = path.replace(/\/+$/, "");
+  if (normalized.startsWith("/")) {
+    throw new Error(`'${fieldName}' in ${configFile} must be a relative path, not absolute`);
+  }
+  if (normalized.includes("..")) {
+    throw new Error(`'${fieldName}' in ${configFile} cannot contain path traversal (..)`);
+  }
+  return normalized;
+}
+function validatePloyConfig(config, configFile = "ploy.yaml", options = {}) {
+  const { requireKind = false, requireBuildForStatic = true, allowedKinds = ["nextjs", "static", "dynamic", "worker"] } = options;
+  const validatedConfig = { ...config };
+  if (requireKind && !config.kind) {
+    throw new Error(`Missing required field 'kind' in ${configFile}`);
+  }
+  if (config.kind !== void 0) {
+    if (!allowedKinds.includes(config.kind)) {
+      throw new Error(`Invalid kind '${config.kind}' in ${configFile}. Must be one of: ${allowedKinds.join(", ")}`);
+    }
+  }
+  if (requireBuildForStatic && config.kind === "static" && !config.build) {
+    throw new Error(`Build command is required when kind is 'static' in ${configFile}`);
+  }
+  if (config.build !== void 0 && typeof config.build !== "string") {
+    throw new Error(`'build' in ${configFile} must be a string`);
+  }
+  validatedConfig.out = validateRelativePath(config.out, "out", configFile);
+  validatedConfig.base = validateRelativePath(config.base, "base", configFile);
+  validatedConfig.main = validateRelativePath(config.main, "main", configFile);
+  validateBindings(config.db, "db", configFile);
+  validateBindings(config.queue, "queue", 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`);
+  }
+  if (config.monorepo !== void 0 && typeof config.monorepo !== "boolean") {
+    throw new Error(`'monorepo' in ${configFile} must be a boolean`);
+  }
+  return validatedConfig;
+}
+async function readPloyConfig(projectDir, configPath) {
+  const configFile = configPath || "ploy.yaml";
+  const fullPath = join(projectDir, configFile);
+  try {
+    const content = await readFileAsync(fullPath, "utf-8");
+    return parse(content);
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "code" in error2) {
+      if (error2.code === "ENOENT") {
+        return null;
+      }
+    }
+    throw error2;
+  }
+}
+function readPloyConfigSync(projectDir, configPath) {
+  const configFile = configPath || "ploy.yaml";
+  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);
+}
+async function readAndValidatePloyConfig(projectDir, configPath, validationOptions) {
+  const configFile = configPath || "ploy.yaml";
+  const config = await readPloyConfig(projectDir, configPath);
+  if (!config) {
+    return null;
+  }
+  return validatePloyConfig(config, configFile, validationOptions);
+}
+function readAndValidatePloyConfigSync(projectDir, configPath, validationOptions) {
+  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);
+}
+function getWorkerEntryPoint(projectDir, config) {
+  if (config.main) {
+    return join(projectDir, config.main);
+  }
+  const defaultPaths = [
+    join(projectDir, "index.ts"),
+    join(projectDir, "index.js"),
+    join(projectDir, "src", "index.ts"),
+    join(projectDir, "src", "index.js")
+  ];
+  for (const path of defaultPaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  throw new Error("Could not find worker entry point. Specify 'main' in ploy.yaml");
+}
+var readFileAsync, BINDING_NAME_REGEX, RESOURCE_NAME_REGEX;
+var init_ploy_config = __esm({
+  "../tools/dist/ploy-config.js"() {
+    readFileAsync = promisify(readFile$1);
+    BINDING_NAME_REGEX = /^[A-Z][A-Z0-9_]*$/;
+    RESOURCE_NAME_REGEX = /^[a-z][a-z0-9_]*$/;
+  }
+});
+
+// ../tools/dist/cli.js
+var cli_exports = {};
+__export(cli_exports, {
+  getAddDevDependencyCommand: () => getAddDevDependencyCommand,
+  getRunCommand: () => getRunCommand,
+  getWorkerEntryPoint: () => getWorkerEntryPoint,
+  hasBindings: () => hasBindings,
+  isPnpmWorkspace: () => isPnpmWorkspace,
+  readAndValidatePloyConfig: () => readAndValidatePloyConfig,
+  readAndValidatePloyConfigSync: () => readAndValidatePloyConfigSync,
+  readPloyConfig: () => readPloyConfig,
+  readPloyConfigSync: () => readPloyConfigSync,
+  validatePloyConfig: () => validatePloyConfig
+});
+var init_cli = __esm({
+  "../tools/dist/cli.js"() {
+    init_package_manager();
+    init_ploy_config();
+  }
+});
+
+// ../shared/dist/d1-runtime.js
+var DB_RUNTIME_CODE, DB_RUNTIME_CODE_PRODUCTION;
+var init_d1_runtime = __esm({
+  "../shared/dist/d1-runtime.js"() {
+    DB_RUNTIME_CODE = `
+interface DBResult {
+  results: unknown[];
+  success: boolean;
+  meta: {
+    duration: number;
+    rows_read: number;
+    rows_written: number;
+  };
+}
+
+interface DBPreparedStatement {
+  bind: (...values: unknown[]) => DBPreparedStatement;
+  run: () => Promise<DBResult>;
+  all: () => Promise<DBResult>;
+  first: (colName?: string) => Promise<unknown | null>;
+  raw: (options?: { columnNames?: boolean }) => Promise<unknown[][]>;
+}
+
+interface DBDatabase {
+  prepare: (query: string) => DBPreparedStatement;
+  dump: () => Promise<ArrayBuffer>;
+  batch: (statements: DBPreparedStatement[]) => Promise<DBResult[]>;
+  exec: (query: string) => Promise<DBResult>;
+}
+
+export function initializeDB(bindingName: string, serviceUrl: string): DBDatabase {
+  return {
+    prepare(query: string): DBPreparedStatement {
+      let boundParams: unknown[] = [];
+
+      const stmt: DBPreparedStatement = {
+        bind(...values: unknown[]) {
+          boundParams = values;
+          return this;
+        },
+
+        async run(): Promise<DBResult> {
+          const response = await fetch(serviceUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              bindingName,
+              method: "prepare",
+              query,
+              params: boundParams,
+            }),
+          });
+
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error("DB query failed: " + errorText);
+          }
+
+          return await response.json();
+        },
+
+        async all(): Promise<DBResult> {
+          return await this.run();
+        },
+
+        async first(colName?: string): Promise<unknown | null> {
+          const result = await this.run();
+          if (result.results.length === 0) {
+            return null;
+          }
+
+          const firstRow = result.results[0] as Record<string, unknown>;
+          if (colName) {
+            return firstRow[colName] ?? null;
+          }
+          return firstRow;
+        },
+
+        async raw(options?: { columnNames?: boolean }): Promise<unknown[][]> {
+          const result = await this.run();
+          const rows = result.results as Record<string, unknown>[];
+
+          if (rows.length === 0) {
+            return [];
+          }
+
+          const keys = Object.keys(rows[0]);
+          const arrayRows = rows.map((row) => keys.map((key) => row[key]));
+
+          if (options?.columnNames) {
+            return [keys, ...arrayRows];
+          }
+
+          return arrayRows;
+        },
+      };
+
+      return stmt;
+    },
+
+    async dump(): Promise<ArrayBuffer> {
+      const response = await fetch(serviceUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          bindingName,
+          method: "dump",
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error("DB dump failed: " + response.statusText);
+      }
+
+      return await response.arrayBuffer();
+    },
+
+    async batch(statements: DBPreparedStatement[]): Promise<DBResult[]> {
+      const results: DBResult[] = [];
+      for (const stmt of statements) {
+        results.push(await stmt.run());
+      }
+      return results;
+    },
+
+    async exec(query: string): Promise<DBResult> {
+      const response = await fetch(serviceUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          bindingName,
+          method: "exec",
+          query,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error("DB exec failed: " + response.statusText);
+      }
+
+      return await response.json();
+    },
+  };
+}
+`;
+    DB_RUNTIME_CODE_PRODUCTION = `export function initializeDB(databaseId, organizationId, serviceUrl) {
+	return {
+		prepare(query) {
+			let boundParams = [];
+			return {
+				bind(...values) {
+					boundParams = values;
+					return this;
+				},
+				async run() {
+					const response = await fetch(serviceUrl, {
+						method: "POST",
+						headers: { "Content-Type": "application/json" },
+						body: JSON.stringify({
+							databaseId,
+							organizationId,
+							method: "prepare",
+							query,
+							params: boundParams,
+						}),
+					});
+					if (!response.ok) {
+						const errorText = await response.text();
+						throw new Error(\`DB query failed: \${errorText}\`);
+					}
+					return await response.json();
+				},
+				async all() {
+					return await this.run();
+				},
+				async first(colName) {
+					const result = await this.run();
+					if (result.results.length === 0) {
+						return null;
+					}
+					const firstRow = result.results[0];
+					if (colName) {
+						return firstRow[colName] ?? null;
+					}
+					return firstRow;
+				},
+				async raw(options) {
+					const result = await this.run();
+					const rows = result.results;
+					if (rows.length === 0) {
+						return [];
+					}
+					const keys = Object.keys(rows[0]);
+					const arrayRows = rows.map((row) => keys.map((key) => row[key]));
+					if (options?.columnNames) {
+						return [keys, ...arrayRows];
+					}
+					return arrayRows;
+				},
+			};
+		},
+		async dump() {
+			const response = await fetch(serviceUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					databaseId,
+					organizationId,
+					method: "dump",
+				}),
+			});
+			if (!response.ok) {
+				throw new Error(\`DB dump failed: \${response.statusText}\`);
+			}
+			return await response.arrayBuffer();
+		},
+		async batch(statements) {
+			const stmts = [];
+			for (const stmt of statements) {
+				const stmtData = stmt.__db_data;
+				if (stmtData) {
+					stmts.push(stmtData);
+				}
+			}
+			const response = await fetch(serviceUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					databaseId,
+					organizationId,
+					method: "batch",
+					statements: stmts,
+				}),
+			});
+			if (!response.ok) {
+				throw new Error(\`DB batch failed: \${response.statusText}\`);
+			}
+			return await response.json();
+		},
+		async exec(query) {
+			const response = await fetch(serviceUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					databaseId,
+					organizationId,
+					method: "exec",
+					query,
+				}),
+			});
+			if (!response.ok) {
+				throw new Error(\`DB exec failed: \${response.statusText}\`);
+			}
+			return await response.json();
+		},
+	};
+}`;
+  }
+});
+
+// ../shared/dist/error.js
+var init_error = __esm({
+  "../shared/dist/error.js"() {
+  }
+});
+
+// ../shared/dist/health-check.js
+var init_health_check = __esm({
+  "../shared/dist/health-check.js"() {
+  }
+});
+
+// ../shared/dist/trace-event.js
+var init_trace_event = __esm({
+  "../shared/dist/trace-event.js"() {
+  }
+});
+
+// ../shared/dist/url-validation.js
+var init_url_validation = __esm({
+  "../shared/dist/url-validation.js"() {
+  }
+});
+
+// ../shared/dist/index.js
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    init_d1_runtime();
+    init_error();
+    init_health_check();
+    init_trace_event();
+    init_url_validation();
+  }
+});
+
+// ../emulator/dist/runtime/db-runtime.js
+var init_db_runtime = __esm({
+  "../emulator/dist/runtime/db-runtime.js"() {
+    init_dist();
+  }
+});
+
+// ../emulator/dist/runtime/queue-runtime.js
+var QUEUE_RUNTIME_CODE;
+var init_queue_runtime = __esm({
+  "../emulator/dist/runtime/queue-runtime.js"() {
+    QUEUE_RUNTIME_CODE = `
+interface QueueSendResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+interface QueueBatchSendResult {
+  success: boolean;
+  messageIds?: string[];
+  error?: string;
+}
+
+interface Queue<T = unknown> {
+  send: (payload: T, options?: { delaySeconds?: number }) => Promise<QueueSendResult>;
+  sendBatch: (messages: Array<{ payload: T; delaySeconds?: number }>) => Promise<QueueBatchSendResult>;
+}
+
+export function initializeQueue<T = unknown>(queueName: string, serviceUrl: string): Queue<T> {
+  return {
+    async send(payload: T, options?: { delaySeconds?: number }): Promise<QueueSendResult> {
+      const response = await fetch(serviceUrl + "/queue/send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          queueName,
+          payload,
+          delaySeconds: options?.delaySeconds,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return { success: false, error: "Queue send failed: " + errorText };
+      }
+
+      return await response.json();
+    },
+
+    async sendBatch(messages: Array<{ payload: T; delaySeconds?: number }>): Promise<QueueBatchSendResult> {
+      const response = await fetch(serviceUrl + "/queue/batch-send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          queueName,
+          messages,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return { success: false, error: "Queue batch send failed: " + errorText };
+      }
+
+      return await response.json();
+    },
+  };
+}
+`;
+  }
+});
+
+// ../emulator/dist/runtime/workflow-runtime.js
+var WORKFLOW_RUNTIME_CODE;
+var init_workflow_runtime = __esm({
+  "../emulator/dist/runtime/workflow-runtime.js"() {
+    WORKFLOW_RUNTIME_CODE = `
+interface WorkflowExecution {
+  id: string;
+  status: "pending" | "running" | "completed" | "failed" | "cancelled";
+  result?: unknown;
+  error?: string;
+}
+
+interface Workflow<TInput = unknown> {
+  trigger: (input: TInput) => Promise<{ executionId: string }>;
+  getExecution: (executionId: string) => Promise<WorkflowExecution>;
+  cancel: (executionId: string) => Promise<void>;
+}
+
+export function initializeWorkflow<TInput = unknown>(
+  workflowName: string,
+  serviceUrl: string
+): Workflow<TInput> {
+  return {
+    async trigger(input: TInput): Promise<{ executionId: string }> {
+      const response = await fetch(serviceUrl + "/workflow/trigger", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ workflowName, input }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Workflow trigger failed: " + errorText);
+      }
+
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "Workflow trigger failed");
+      }
+
+      return { executionId: result.executionId };
+    },
+
+    async getExecution(executionId: string): Promise<WorkflowExecution> {
+      const response = await fetch(serviceUrl + "/workflow/status", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Workflow status failed: " + errorText);
+      }
+
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "Workflow status failed");
+      }
+
+      const exec = result.execution;
+      return {
+        id: exec.id,
+        status: exec.status,
+        result: exec.output,
+        error: exec.error,
+      };
+    },
+
+    async cancel(executionId: string): Promise<void> {
+      const response = await fetch(serviceUrl + "/workflow/cancel", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Workflow cancel failed: " + errorText);
+      }
+
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "Workflow cancel failed");
+      }
+    },
+  };
+}
+
+interface WorkflowStepContext {
+  run: <T>(stepName: string, fn: () => T | Promise<T>, options?: { retries?: number }) => Promise<T>;
+  sleep: (durationMs: number) => Promise<void>;
+}
+
+interface WorkflowContext<TInput = unknown, TEnv = unknown> {
+  input: TInput;
+  env: TEnv;
+  step: WorkflowStepContext;
+}
+
+export function createStepContext(executionId: string, serviceUrl: string): WorkflowStepContext {
+  let stepIndex = 0;
+
+  return {
+    async run<T>(stepName: string, fn: () => T | Promise<T>, options?: { retries?: number }): Promise<T> {
+      const currentStepIndex = stepIndex++;
+      const maxRetries = options?.retries ?? 0;
+
+      const startResponse = await fetch(serviceUrl + "/workflow/step/start", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, stepIndex: currentStepIndex }),
+      });
+
+      if (!startResponse.ok) {
+        const errorText = await startResponse.text();
+        throw new Error("Failed to start step: " + errorText);
+      }
+
+      const startResult = await startResponse.json();
+
+      if (startResult.alreadyCompleted) {
+        return startResult.output as T;
+      }
+
+      const startTime = Date.now();
+      let lastError: Error | null = null;
+
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          const result = await fn();
+          const durationMs = Date.now() - startTime;
+
+          await fetch(serviceUrl + "/workflow/step/complete", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ executionId, stepName, output: result, durationMs }),
+          });
+
+          return result;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (attempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, Math.min(1000 * Math.pow(2, attempt), 30000)));
+          }
         }
-        else if (arg === "-h" || arg === "--host") {
-            options.host = args[++i];
+      }
+
+      const durationMs = Date.now() - startTime;
+      await fetch(serviceUrl + "/workflow/step/fail", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, error: lastError?.message || "Step execution failed", durationMs }),
+      });
+
+      throw lastError;
+    },
+
+    async sleep(durationMs: number): Promise<void> {
+      const stepName = "__sleep_" + stepIndex++;
+
+      await fetch(serviceUrl + "/workflow/step/start", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, stepIndex: stepIndex - 1 }),
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, durationMs));
+
+      await fetch(serviceUrl + "/workflow/step/complete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, output: { sleptMs: durationMs }, durationMs }),
+      });
+    },
+  };
+}
+
+export async function executeWorkflow<TInput, TOutput, TEnv>(
+  executionId: string,
+  workflowFn: (context: WorkflowContext<TInput, TEnv>) => Promise<TOutput>,
+  input: TInput,
+  env: TEnv,
+  serviceUrl: string
+): Promise<TOutput> {
+  const step = createStepContext(executionId, serviceUrl);
+  const context: WorkflowContext<TInput, TEnv> = { input, env, step };
+
+  try {
+    const output = await workflowFn(context);
+
+    await fetch(serviceUrl + "/workflow/complete", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ executionId, output }),
+    });
+
+    return output;
+  } catch (error) {
+    await fetch(serviceUrl + "/workflow/fail", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ executionId, error: error instanceof Error ? error.message : String(error) }),
+    });
+
+    throw error;
+  }
+}
+`;
+  }
+});
+function generateWrapperCode(config, mockServiceUrl) {
+  const imports = [];
+  const bindings = [];
+  if (config.db) {
+    imports.push('import { initializeDB } from "__ploy_db_runtime__";');
+    for (const [bindingName, dbName] of Object.entries(config.db)) {
+      bindings.push(`  ${bindingName}: initializeDB("${dbName}", "${mockServiceUrl}/db"),`);
+    }
+  }
+  if (config.queue) {
+    imports.push('import { initializeQueue } from "__ploy_queue_runtime__";');
+    for (const [bindingName, queueName] of Object.entries(config.queue)) {
+      bindings.push(`  ${bindingName}: initializeQueue("${queueName}", "${mockServiceUrl}"),`);
+    }
+  }
+  if (config.workflow) {
+    imports.push('import { initializeWorkflow, createStepContext, executeWorkflow } from "__ploy_workflow_runtime__";');
+    for (const [bindingName, workflowName] of Object.entries(config.workflow)) {
+      bindings.push(`  ${bindingName}: initializeWorkflow("${workflowName}", "${mockServiceUrl}"),`);
+    }
+  }
+  imports.push('import userWorker from "__ploy_user_worker__";');
+  const workflowHandlerCode = config.workflow ? `
+  // Handle workflow execution requests
+  if (request.headers.get("X-Ploy-Workflow-Execution") === "true") {
+    const workflowName = request.headers.get("X-Ploy-Workflow-Name");
+    const executionId = request.headers.get("X-Ploy-Execution-Id");
+
+    if (workflowName && executionId && userWorker.workflows && userWorker.workflows[workflowName]) {
+      const input = await request.json();
+      try {
+        await executeWorkflow(
+          executionId,
+          userWorker.workflows[workflowName],
+          input,
+          injectedEnv,
+          "${mockServiceUrl}"
+        );
+        return new Response(JSON.stringify({ success: true }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ success: false, error: String(error) }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+  }` : "";
+  const queueHandlerCode = config.queue ? `
+  // Handle queue message delivery
+  if (request.headers.get("X-Ploy-Queue-Delivery") === "true") {
+    const queueName = request.headers.get("X-Ploy-Queue-Name");
+    const messageId = request.headers.get("X-Ploy-Message-Id");
+    const deliveryId = request.headers.get("X-Ploy-Delivery-Id");
+    const attempt = parseInt(request.headers.get("X-Ploy-Message-Attempt") || "1", 10);
+
+    if (queueName && messageId && userWorker.message) {
+      const payload = await request.json();
+      try {
+        await userWorker.message({
+          id: messageId,
+          queueName,
+          payload,
+          attempt,
+          timestamp: Date.now()
+        }, injectedEnv, ctx);
+        return new Response(JSON.stringify({ success: true }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ success: false, error: String(error) }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+  }` : "";
+  return `${imports.join("\n")}
+
+const ployBindings = {
+${bindings.join("\n")}
+};
+
+export default {
+  async fetch(request, env, ctx) {
+    const injectedEnv = { ...env, ...ployBindings };
+    ${workflowHandlerCode}
+    ${queueHandlerCode}
+
+    if (userWorker.fetch) {
+      return userWorker.fetch(request, injectedEnv, ctx);
+    }
+
+    return new Response("Worker has no fetch handler", { status: 500 });
+  },
+
+  async scheduled(event, env, ctx) {
+    if (userWorker.scheduled) {
+      const injectedEnv = { ...env, ...ployBindings };
+      return userWorker.scheduled(event, injectedEnv, ctx);
+    }
+  }
+};
+`;
+}
+function createRuntimePlugin(_config) {
+  return {
+    name: "ploy-runtime",
+    setup(build2) {
+      build2.onResolve({ filter: /^__ploy_db_runtime__$/ }, () => ({
+        path: "__ploy_db_runtime__",
+        namespace: "ploy-runtime"
+      }));
+      build2.onResolve({ filter: /^__ploy_queue_runtime__$/ }, () => ({
+        path: "__ploy_queue_runtime__",
+        namespace: "ploy-runtime"
+      }));
+      build2.onResolve({ filter: /^__ploy_workflow_runtime__$/ }, () => ({
+        path: "__ploy_workflow_runtime__",
+        namespace: "ploy-runtime"
+      }));
+      build2.onLoad({ filter: /^__ploy_db_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: DB_RUNTIME_CODE,
+        loader: "ts"
+      }));
+      build2.onLoad({ filter: /^__ploy_queue_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: QUEUE_RUNTIME_CODE,
+        loader: "ts"
+      }));
+      build2.onLoad({ filter: /^__ploy_workflow_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: WORKFLOW_RUNTIME_CODE,
+        loader: "ts"
+      }));
+    }
+  };
+}
+async function bundleWorker(options) {
+  const { projectDir, tempDir, entryPoint, config, mockServiceUrl } = options;
+  const wrapperCode = generateWrapperCode(config, mockServiceUrl);
+  const wrapperPath = join(tempDir, "wrapper.ts");
+  writeFileSync(wrapperPath, wrapperCode);
+  const bundlePath = join(tempDir, "worker.bundle.js");
+  const buildOptions = {
+    entryPoints: [wrapperPath],
+    bundle: true,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    outfile: bundlePath,
+    minify: false,
+    sourcemap: false,
+    external: ["cloudflare:*"],
+    alias: {
+      __ploy_user_worker__: entryPoint
+    },
+    plugins: [createRuntimePlugin()],
+    absWorkingDir: projectDir,
+    logLevel: "warning"
+  };
+  await build(buildOptions);
+  return bundlePath;
+}
+var init_bundler = __esm({
+  "../emulator/dist/bundler/bundler.js"() {
+    init_db_runtime();
+    init_queue_runtime();
+    init_workflow_runtime();
+  }
+});
+function createFileWatcher(srcDir, onRebuild) {
+  let watcher = null;
+  let debounceTimer = null;
+  let isRebuilding = false;
+  function shouldRebuild(filePath) {
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"];
+    return extensions.some((ext) => filePath.endsWith(ext));
+  }
+  function scheduleRebuild() {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(async () => {
+      if (isRebuilding) {
+        return;
+      }
+      isRebuilding = true;
+      try {
+        await onRebuild();
+      } finally {
+        isRebuilding = false;
+      }
+    }, 100);
+  }
+  return {
+    start() {
+      if (watcher) {
+        return;
+      }
+      watcher = watch(srcDir, {
+        persistent: true,
+        ignoreInitial: true,
+        ignored: ["**/node_modules/**", "**/dist/**", "**/.ploy/**", "**/.*"]
+      });
+      watcher.on("change", (filePath) => {
+        if (shouldRebuild(filePath)) {
+          scheduleRebuild();
         }
-        else if (arg === "-c" || arg === "--config") {
-            options.config = args[++i];
+      });
+      watcher.on("add", (filePath) => {
+        if (shouldRebuild(filePath)) {
+          scheduleRebuild();
         }
-        else if (arg === "--no-watch") {
-            options.watch = false;
+      });
+      watcher.on("unlink", (filePath) => {
+        if (shouldRebuild(filePath)) {
+          scheduleRebuild();
         }
-        else if (arg === "-v" || arg === "--verbose") {
-            options.verbose = true;
+      });
+    },
+    stop() {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      if (watcher) {
+        watcher.close();
+        watcher = null;
+      }
+    }
+  };
+}
+var init_watcher = __esm({
+  "../emulator/dist/bundler/watcher.js"() {
+  }
+});
+
+// ../emulator/dist/config/ploy-config.js
+function readPloyConfig2(projectDir, configPath) {
+  const config = readPloyConfigSync(projectDir, configPath);
+  if (!config.kind) {
+    throw new Error(`Missing required field 'kind' in ${configPath || "ploy.yaml"}`);
+  }
+  if (config.kind !== "dynamic" && config.kind !== "worker") {
+    throw new Error(`Invalid kind '${config.kind}' in ${configPath || "ploy.yaml"}. Must be 'dynamic' or 'worker'`);
+  }
+  return config;
+}
+function getWorkerEntryPoint2(projectDir, config) {
+  return getWorkerEntryPoint(projectDir, config);
+}
+var init_ploy_config2 = __esm({
+  "../emulator/dist/config/ploy-config.js"() {
+    init_cli();
+  }
+});
+function generateWorkerdConfig(options) {
+  const { port, mockServicePort } = options;
+  const services = [
+    '(name = "main", worker = .worker)',
+    `(name = "mock", external = (address = "localhost:${mockServicePort}", http = ()))`,
+    '(name = "internet", network = (allow = ["public", "private", "local"], tlsOptions = (trustBrowserCas = true)))'
+  ];
+  const bindings = [
+    '(name = "mock", service = "mock")',
+    '(name = "internet", service = "internet")'
+  ];
+  const configContent = `using Workerd = import "/workerd/workerd.capnp";
+
+const config :Workerd.Config = (
+  services = [
+    ${services.join(",\n    ")}
+  ],
+  sockets = [
+    (name = "http", address = "*:${port}", http = (), service = "main")
+  ]
+);
+
+const worker :Workerd.Worker = (
+  modules = [
+    (name = "worker.js", esModule = embed "worker.bundle.js")
+  ],
+  compatibilityDate = "2025-09-15",
+  compatibilityFlags = [
+    "experimental",
+    "nodejs_compat",
+    "nodejs_als"
+  ],
+  globalOutbound = "internet",
+  bindings = [
+    ${bindings.join(",\n    ")}
+  ]
+);
+`;
+  return configContent;
+}
+function writeWorkerdConfig(options) {
+  const configContent = generateWorkerdConfig(options);
+  const configPath = join(options.tempDir, "workerd.capnp");
+  writeFileSync(configPath, configContent);
+  return configPath;
+}
+var init_workerd_config = __esm({
+  "../emulator/dist/config/workerd-config.js"() {
+  }
+});
+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;
+}
+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
         }
-        else if (arg === "--dashboard-port") {
-            const value = args[++i];
-            if (value) {
-                options.dashboardPort = parseInt(value, 10);
-            }
+      });
+    } 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);
     }
-    return options;
+    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);
+    });
+  }
 }
-async function isNextJsProject(projectDir, configPath) {
-    const { readPloyConfig } = await import("@meetploy/tools");
+var __filename, __dirname, MIME_TYPES;
+var init_dashboard_routes = __esm({
+  "../emulator/dist/services/dashboard-routes.js"() {
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    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"
+    };
+  }
+});
+
+// ../emulator/dist/services/db-service.js
+function createDbHandler(getDatabase) {
+  return async (c) => {
+    const startTime = Date.now();
     try {
-        const config = await readPloyConfig(projectDir, configPath);
-        if (config?.kind === "nextjs") {
-            return true;
+      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);
     }
-    catch {
+  };
+}
+var init_db_service = __esm({
+  "../emulator/dist/services/db-service.js"() {
+  }
+});
+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 nextConfigFiles = [
-        "next.config.ts",
-        "next.config.js",
-        "next.config.mts",
-        "next.config.mjs",
-    ];
-    for (const file of nextConfigFiles) {
-        if (existsSync(join(projectDir, file))) {
-            return true;
+  };
+  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);
     }
-    return false;
+  };
+  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 findNextBinary(projectDir) {
-    const possiblePaths = [
-        join(projectDir, "node_modules", ".bin", "next"),
-        "npx next",
-    ];
-    for (const p of possiblePaths) {
-        if (p.includes("npx") || existsSync(p)) {
-            return p;
+function createQueueProcessor(db, queueBindings, workerUrl) {
+  let interval = null;
+  async function processQueues() {
+    for (const [bindingName, queueName] of Object.entries(queueBindings)) {
+      await processQueue(bindingName, queueName);
+    }
+  }
+  async function processQueue(bindingName, queueName) {
+    const now = Math.floor(Date.now() / 1e3);
+    const deliveryId = randomUUID();
+    const visibilityTimeout = 30;
+    const rows = db.prepare(`SELECT id, payload, attempt
+				 FROM queue_messages
+				 WHERE queue_name = ? AND status = 'pending' AND visible_at <= ?
+				 LIMIT 10`).all(queueName, now);
+    if (rows.length === 0) {
+      return;
+    }
+    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, now + visibilityTimeout, now, ...ids);
+    for (const row of rows) {
+      try {
+        const response = await fetch(workerUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Ploy-Queue-Delivery": "true",
+            "X-Ploy-Queue-Name": queueName,
+            "X-Ploy-Queue-Binding": bindingName,
+            "X-Ploy-Message-Id": row.id,
+            "X-Ploy-Delivery-Id": deliveryId,
+            "X-Ploy-Message-Attempt": String(row.attempt + 1)
+          },
+          body: row.payload
+        });
+        if (response.ok) {
+          db.prepare(`DELETE FROM queue_messages WHERE id = ?`).run(row.id);
+        } else {
+          db.prepare(`UPDATE queue_messages
+						 SET status = 'pending', delivery_id = NULL, visible_at = ?, updated_at = ?
+						 WHERE id = ?`).run(now + 5, now, row.id);
         }
+      } catch {
+        db.prepare(`UPDATE queue_messages
+					 SET status = 'pending', delivery_id = NULL, visible_at = ?, updated_at = ?
+					 WHERE id = ?`).run(now + 5, now, row.id);
+      }
     }
-    return "npx next";
+  }
+  return {
+    start() {
+      if (interval) {
+        return;
+      }
+      interval = setInterval(() => {
+        processQueues().catch(() => {
+        });
+      }, 1e3);
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+    }
+  };
 }
-async function startNextJsDev(options) {
-    const projectDir = process.cwd();
-    const nextPort = options.port ?? 3000;
-    const dashboardPort = options.dashboardPort ?? nextPort + 1000;
-    const { startDevDashboard } = await import("@meetploy/emulator");
-    const dashboard = await startDevDashboard({
-        configPath: options.config,
-        port: dashboardPort,
-        verbose: options.verbose,
-    });
-    console.log(`\n  Ploy Dashboard: http://${options.host ?? "localhost"}:${dashboard.port}`);
-    const nextBin = findNextBinary(projectDir);
-    const nextArgs = ["dev", "-p", String(nextPort)];
-    if (options.host) {
-        nextArgs.push("-H", options.host);
-    }
-    console.log(`  Starting Next.js dev server...`);
-    let nextProcess;
-    if (nextBin.includes("npx")) {
-        nextProcess = spawn("npx", ["next", ...nextArgs], {
-            cwd: projectDir,
-            stdio: "inherit",
-            shell: true,
-            env: {
-                ...process.env,
-                PLOY_MOCK_SERVER_URL: `http://localhost:${dashboard.port}`,
-            },
+var init_queue_service = __esm({
+  "../emulator/dist/services/queue-service.js"() {
+  }
+});
+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);
     }
-    else {
-        nextProcess = spawn(nextBin, nextArgs, {
-            cwd: projectDir,
-            stdio: "inherit",
+  };
+  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
+  };
+}
+var init_workflow_service = __esm({
+  "../emulator/dist/services/workflow-service.js"() {
+  }
+});
+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());
+        })
+      });
+    });
+  });
+}
+var DEFAULT_MOCK_SERVER_PORT;
+var init_mock_server = __esm({
+  "../emulator/dist/services/mock-server.js"() {
+    init_dashboard_routes();
+    init_db_service();
+    init_queue_service();
+    init_workflow_service();
+    DEFAULT_MOCK_SERVER_PORT = 4003;
+  }
+});
+
+// ../emulator/dist/utils/logger.js
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+function log(message) {
+  console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.cyan}[ploy]${COLORS.reset} ${message}`);
+}
+function success(message) {
+  console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.green}[ploy]${COLORS.reset} ${message}`);
+}
+function error(message) {
+  console.error(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.red}[ploy]${COLORS.reset} ${message}`);
+}
+function debug(message, verbose) {
+  if (verbose) {
+    console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.magenta}[ploy:debug]${COLORS.reset} ${message}`);
+  }
+}
+var COLORS;
+var init_logger = __esm({
+  "../emulator/dist/utils/logger.js"() {
+    COLORS = {
+      reset: "\x1B[0m",
+      dim: "\x1B[2m",
+      cyan: "\x1B[36m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      red: "\x1B[31m",
+      magenta: "\x1B[35m"
+    };
+  }
+});
+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();
+  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
+  };
+}
+var EMULATOR_SCHEMA;
+var init_sqlite = __esm({
+  "../emulator/dist/utils/sqlite.js"() {
+    init_paths();
+    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);
+`;
+  }
+});
+async function startEmulator(options = {}) {
+  const emulator = new EmulatorServer(options);
+  await emulator.start();
+  return emulator;
+}
+var EmulatorServer;
+var init_emulator = __esm({
+  "../emulator/dist/emulator.js"() {
+    init_bundler();
+    init_watcher();
+    init_ploy_config2();
+    init_workerd_config();
+    init_mock_server();
+    init_queue_service();
+    init_logger();
+    init_paths();
+    init_sqlite();
+    EmulatorServer = class {
+      options;
+      projectDir;
+      tempDir = "";
+      config = null;
+      dbManager = null;
+      mockServer = null;
+      workerdProcess = null;
+      fileWatcher = null;
+      queueProcessor = null;
+      constructor(options = {}) {
+        const port = options.port ?? 8787;
+        this.options = {
+          port,
+          host: options.host ?? "localhost",
+          configPath: options.configPath ?? "ploy.yaml",
+          watch: options.watch ?? true,
+          verbose: options.verbose ?? false,
+          dashboardPort: options.dashboardPort ?? port + 1e3
+        };
+        this.projectDir = process.cwd();
+      }
+      async start() {
+        log("Starting Ploy emulator...");
+        try {
+          this.config = readPloyConfig2(this.projectDir, this.options.configPath);
+          debug(`Loaded config: ${JSON.stringify(this.config)}`, this.options.verbose);
+          this.tempDir = ensureTempDir(this.projectDir);
+          ensureDataDir(this.projectDir);
+          debug(`Temp dir: ${this.tempDir}`, this.options.verbose);
+          this.dbManager = initializeDatabases(this.projectDir);
+          debug("Initialized databases", this.options.verbose);
+          const workerUrl = `http://${this.options.host}:${this.options.port}`;
+          const dashboardPort = this.options.dashboardPort;
+          this.mockServer = await startMockServer(this.dbManager, this.config, {
+            workerUrl,
+            port: dashboardPort,
+            dashboardEnabled: true
+          });
+          debug(`Mock server started on port ${this.mockServer.port}`, this.options.verbose);
+          const mockServiceUrl = `http://localhost:${this.mockServer.port}`;
+          const entryPoint = getWorkerEntryPoint2(this.projectDir, this.config);
+          debug(`Entry point: ${entryPoint}`, this.options.verbose);
+          await this.bundle(entryPoint, mockServiceUrl);
+          const workerdConfigPath = writeWorkerdConfig({
+            tempDir: this.tempDir,
+            bundlePath: join(this.tempDir, "worker.bundle.js"),
+            port: this.options.port,
+            mockServicePort: this.mockServer.port,
+            config: this.config
+          });
+          await this.startWorkerd(workerdConfigPath);
+          if (this.options.watch) {
+            const srcDir = this.getSrcDir();
+            this.fileWatcher = createFileWatcher(srcDir, async () => {
+              log("Changes detected, rebuilding...");
+              try {
+                await this.bundle(entryPoint, mockServiceUrl);
+                success("Rebuild complete");
+              } catch (err) {
+                error(`Rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+            });
+            this.fileWatcher.start();
+            debug(`Watching ${srcDir} for changes`, this.options.verbose);
+          }
+          if (this.config.queue) {
+            const workerUrl2 = `http://${this.options.host}:${this.options.port}`;
+            this.queueProcessor = createQueueProcessor(this.dbManager.emulatorDb, this.config.queue, workerUrl2);
+            this.queueProcessor.start();
+            debug("Queue processor started", this.options.verbose);
+          }
+          success(`Emulator running at http://${this.options.host}:${this.options.port}`);
+          log(`  Dashboard: http://${this.options.host}:${this.mockServer.port}`);
+          if (this.config.db) {
+            log(`  DB bindings: ${Object.keys(this.config.db).join(", ")}`);
+          }
+          if (this.config.queue) {
+            log(`  Queue bindings: ${Object.keys(this.config.queue).join(", ")}`);
+          }
+          if (this.config.workflow) {
+            log(`  Workflow bindings: ${Object.keys(this.config.workflow).join(", ")}`);
+          }
+          this.setupSignalHandlers();
+        } catch (err) {
+          error(`Failed to start emulator: ${err instanceof Error ? err.message : String(err)}`);
+          await this.stop();
+          throw err;
+        }
+      }
+      async bundle(entryPoint, mockServiceUrl) {
+        if (!this.config) {
+          throw new Error("Config not loaded");
+        }
+        await bundleWorker({
+          projectDir: this.projectDir,
+          tempDir: this.tempDir,
+          entryPoint,
+          config: this.config,
+          mockServiceUrl
+        });
+      }
+      async startWorkerd(configPath) {
+        const args2 = ["serve", "--experimental", "--verbose", configPath];
+        if (this.options.watch) {
+          args2.push("--watch");
+        }
+        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) => {
+          const workerdBinDir = dirname(workerdBin);
+          this.workerdProcess = spawn(workerdBin, args2, {
+            cwd: this.tempDir,
+            stdio: ["pipe", "pipe", "pipe"],
             shell: true,
             env: {
-                ...process.env,
-                PLOY_MOCK_SERVER_URL: `http://localhost:${dashboard.port}`,
-            },
+              ...process.env,
+              PATH: `${workerdBinDir}:${process.env.PATH || ""}`
+            }
+          });
+          let started = false;
+          let stderrOutput = "";
+          this.workerdProcess.stdout?.on("data", (data) => {
+            const output = data.toString();
+            if (this.options.verbose) {
+              process.stdout.write(output);
+            }
+            if (!started && (output.includes("Listening") || output.includes("running"))) {
+              started = true;
+              resolve();
+            }
+          });
+          this.workerdProcess.stderr?.on("data", (data) => {
+            const output = data.toString();
+            stderrOutput += output;
+            log(`[workerd stderr] ${output.trim()}`);
+            if (output.includes("error") || output.includes("Error")) {
+              error(output.trim());
+            } else if (this.options.verbose) {
+              process.stderr.write(output);
+            }
+            if (!started && output.includes("Listening")) {
+              started = true;
+              resolve();
+            }
+          });
+          this.workerdProcess.on("error", (err) => {
+            error(`workerd error: ${err.message}`);
+            if (!started) {
+              reject(err);
+            }
+          });
+          this.workerdProcess.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+              error(`workerd exited with code ${code}`);
+              if (stderrOutput) {
+                error(`workerd stderr: ${stderrOutput.trim()}`);
+              }
+            }
+            if (!started) {
+              reject(new Error(`workerd exited with code ${code}`));
+            }
+          });
+          setTimeout(() => {
+            if (!started) {
+              started = true;
+              resolve();
+            }
+          }, 2e3);
         });
-    }
-    const cleanup = async () => {
-        console.log("\nShutting down...");
-        nextProcess.kill("SIGTERM");
-        await dashboard.close();
-        process.exit(0);
+      }
+      findWorkerdBinary() {
+        const __filename2 = fileURLToPath(import.meta.url);
+        const __dirname2 = dirname(__filename2);
+        const emulatorPkgDir = join(__dirname2, "..");
+        const possiblePaths = [
+          join(emulatorPkgDir, "node_modules", ".bin", "workerd"),
+          join(this.projectDir, "node_modules", ".bin", "workerd"),
+          "workerd"
+        ];
+        for (const p of possiblePaths) {
+          if (p === "workerd" || existsSync(p)) {
+            return p;
+          }
+        }
+        return "workerd";
+      }
+      getSrcDir() {
+        const possibleDirs = [join(this.projectDir, "src"), this.projectDir];
+        for (const dir of possibleDirs) {
+          if (existsSync(dir)) {
+            return dir;
+          }
+        }
+        return this.projectDir;
+      }
+      setupSignalHandlers() {
+        const handler = async () => {
+          log("\nShutting down...");
+          await this.stop();
+          process.exit(0);
+        };
+        process.on("SIGINT", handler);
+        process.on("SIGTERM", handler);
+      }
+      async stop() {
+        if (this.queueProcessor) {
+          this.queueProcessor.stop();
+          this.queueProcessor = null;
+        }
+        if (this.fileWatcher) {
+          this.fileWatcher.stop();
+          this.fileWatcher = null;
+        }
+        if (this.workerdProcess) {
+          this.workerdProcess.kill("SIGTERM");
+          this.workerdProcess = null;
+        }
+        if (this.mockServer) {
+          await this.mockServer.close();
+          this.mockServer = null;
+        }
+        if (this.dbManager) {
+          this.dbManager.close();
+          this.dbManager = null;
+        }
+        log("Emulator stopped");
+      }
     };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    nextProcess.on("exit", async (code) => {
-        await dashboard.close();
-        process.exit(code ?? 0);
+  }
+});
+
+// ../emulator/dist/nextjs-dev.js
+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();
+    }
+  };
+}
+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 = readPloyConfig2(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);
+  });
+}
+var PLOY_CONTEXT_SYMBOL, mockServer, dbManager;
+var init_nextjs_dev = __esm({
+  "../emulator/dist/nextjs-dev.js"() {
+    init_ploy_config2();
+    init_mock_server();
+    init_paths();
+    init_sqlite();
+    PLOY_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("__ploy-context__");
+    mockServer = null;
+    dbManager = null;
+  }
+});
+
+// ../emulator/dist/dev-dashboard.js
+async function startDevDashboard(options = {}) {
+  const projectDir = process.cwd();
+  const configPath = options.configPath ?? "ploy.yaml";
+  const port = options.port ?? 4e3;
+  const verbose = options.verbose ?? false;
+  log("Starting Ploy development dashboard...");
+  let config;
+  try {
+    config = readPloyConfig2(projectDir, configPath);
+  } catch {
+    config = {};
+  }
+  debug(`Loaded config: ${JSON.stringify(config)}`, verbose);
+  ensureDataDir(projectDir);
+  const dbManager2 = initializeDatabases(projectDir);
+  debug("Initialized databases", verbose);
+  const mockServer2 = await startMockServer(dbManager2, config, {
+    port,
+    dashboardEnabled: true
+  });
+  debug(`Mock server started on port ${mockServer2.port}`, verbose);
+  if (config.db) {
+    log(`  DB bindings: ${Object.keys(config.db).join(", ")}`);
+  }
+  if (config.queue) {
+    log(`  Queue bindings: ${Object.keys(config.queue).join(", ")}`);
+  }
+  if (config.workflow) {
+    log(`  Workflow bindings: ${Object.keys(config.workflow).join(", ")}`);
+  }
+  return {
+    port: mockServer2.port,
+    close: async () => {
+      await mockServer2.close();
+      dbManager2.close();
+      log("Dashboard stopped");
+    }
+  };
+}
+var init_dev_dashboard = __esm({
+  "../emulator/dist/dev-dashboard.js"() {
+    init_ploy_config2();
+    init_mock_server();
+    init_logger();
+    init_paths();
+    init_sqlite();
+  }
+});
+
+// ../emulator/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  DB_RUNTIME_CODE: () => DB_RUNTIME_CODE,
+  DB_RUNTIME_CODE_PRODUCTION: () => DB_RUNTIME_CODE_PRODUCTION,
+  EmulatorServer: () => EmulatorServer,
+  initPloyForDev: () => initPloyForDev,
+  startDevDashboard: () => startDevDashboard,
+  startEmulator: () => startEmulator
+});
+var init_dist2 = __esm({
+  "../emulator/dist/index.js"() {
+    init_emulator();
+    init_nextjs_dev();
+    init_dev_dashboard();
+    init_db_runtime();
+  }
+});
+var CONFIG_DIR = join(homedir(), ".ploy");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function getConfigFile() {
+  return CONFIG_FILE;
+}
+async function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+  }
+}
+async function readConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) {
+      return {};
+    }
+    const content = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (error2) {
+    console.warn(`Warning: Could not read config file: ${error2}`);
+    return {};
+  }
+}
+async function writeConfig(config) {
+  await ensureConfigDir();
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await chmod(CONFIG_FILE, 384);
+}
+async function updateConfig(updates) {
+  const config = await readConfig();
+  const newConfig = { ...config, ...updates };
+  await writeConfig(newConfig);
+  return newConfig;
+}
+async function getAuthToken() {
+  const envToken = process.env.PLOY_API_TOKEN || process.env.PLOY_API_KEY;
+  if (envToken) {
+    return envToken;
+  }
+  const config = await readConfig();
+  if (config.auth?.accessToken) {
+    if (config.auth.expiresAt) {
+      const expiresAt = new Date(config.auth.expiresAt);
+      if (expiresAt <= /* @__PURE__ */ new Date()) {
+        console.warn(
+          "Warning: Stored access token has expired. Please run 'ploy auth login' again."
+        );
+        await clearAuthToken();
+        return void 0;
+      }
+    }
+    return config.auth.accessToken;
+  }
+  return void 0;
+}
+async function setAuthToken(accessToken, expiresInSeconds) {
+  const auth = {
+    accessToken
+  };
+  if (expiresInSeconds) {
+    const expiresAt = new Date(Date.now() + expiresInSeconds * 1e3);
+    auth.expiresAt = expiresAt.toISOString();
+  }
+  await updateConfig({ auth });
+}
+async function clearAuthToken() {
+  const config = await readConfig();
+  delete config.auth;
+  await writeConfig(config);
+}
+async function getApiUrl() {
+  if (process.env.PLOY_API_URL) {
+    return process.env.PLOY_API_URL;
+  }
+  const config = await readConfig();
+  if (config.apiUrl) {
+    return config.apiUrl;
+  }
+  return "https://api.meetploy.com";
+}
+
+// src/lib/api-client.ts
+var ApiClientError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiClientError";
+  }
+};
+async function requireAuthToken() {
+  const token = await getAuthToken();
+  if (!token) {
+    console.error("Error: Authentication required");
+    console.error("");
+    console.error("Please authenticate using one of the following methods:");
+    console.error("");
+    console.error("  1. Run 'ploy auth login' to authenticate via browser");
+    console.error("");
+    console.error("  2. Set an environment variable:");
+    console.error("     PLOY_API_TOKEN - Your Ploy API token");
+    console.error("     PLOY_API_KEY   - Your Ploy API key");
+    console.error("");
+    process.exit(1);
+  }
+  return token;
+}
+var clientInstance = null;
+async function getClient() {
+  if (!clientInstance) {
+    const baseUrl = await getApiUrl();
+    const token = await requireAuthToken();
+    clientInstance = createClient({
+      baseUrl,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": "ploy-cli/1.0.0"
+      }
     });
+  }
+  return clientInstance;
 }
-if (command === "dev") {
-    const options = parseDevArgs(args.slice(1));
-    const projectDir = process.cwd();
-    const isNextJs = await isNextJsProject(projectDir, options.config);
-    if (isNextJs) {
-        await startNextJsDev({
-            port: options.port,
-            host: options.host,
-            config: options.config,
-            verbose: options.verbose,
-            dashboardPort: options.dashboardPort,
-        });
+async function getApiClient() {
+  return await getClient();
+}
+
+// src/commands/api/db.ts
+function printDbHelp() {
+  console.log("Usage: ploy api db <action> [options]");
+  console.log("");
+  console.log("Database operations via the Ploy API");
+  console.log("");
+  console.log("Actions:");
+  console.log("  tables <database>      List tables in a database");
+  console.log("  analytics <database>   View database analytics");
+  console.log("  list                   List all databases (requires --org)");
+  console.log("");
+  console.log("Options:");
+  console.log(
+    "  --org <id>             Organization ID (required for most actions)"
+  );
+  console.log("  --project <id>         Project ID (optional filter for list)");
+  console.log(
+    "  --period <period>      Analytics period: 24h, 7d, 30d (default: 24h)"
+  );
+  console.log("  --limit <n>            Limit number of results (default: 20)");
+  console.log(
+    "  --schema               Show table schema details (for tables action)"
+  );
+  console.log("  -h, --help             Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy api db tables my-database --org org123");
+  console.log("  ploy api db tables my-database --org org123 --schema");
+  console.log("  ploy api db analytics my-database --org org123");
+  console.log("  ploy api db analytics my-database --org org123 --period 7d");
+  console.log("  ploy api db list --org org123");
+}
+function parseDbArgs(args2) {
+  const options = {};
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printDbHelp();
+    process.exit(0);
+  }
+  options.action = args2[0];
+  if (args2[1] && !args2[1].startsWith("-")) {
+    options.databaseName = args2[1];
+  }
+  for (let i = 1; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--org") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --org requires a value");
+        process.exit(1);
+      }
+      options.orgId = nextArg;
+      i++;
+    } else if (arg === "--project") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --project requires a value");
+        process.exit(1);
+      }
+      options.projectId = nextArg;
+      i++;
+    } else if (arg === "--period") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --period requires a value");
+        process.exit(1);
+      }
+      const validPeriods = ["24h", "7d", "30d"];
+      if (!validPeriods.includes(nextArg)) {
+        console.error(
+          `Error: Invalid period. Valid options: ${validPeriods.join(", ")}`
+        );
+        process.exit(1);
+      }
+      options.period = nextArg;
+      i++;
+    } else if (arg === "--limit") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --limit requires a number");
+        process.exit(1);
+      }
+      const limit = parseInt(nextArg, 10);
+      if (Number.isNaN(limit)) {
+        console.error("Error: --limit must be a valid number");
+        process.exit(1);
+      }
+      options.limit = limit;
+      i++;
+    } else if (arg === "--schema") {
+      options.showSchema = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printDbHelp();
+      process.exit(0);
     }
-    else {
-        const { startEmulator } = await import("@meetploy/emulator");
-        await startEmulator({
-            port: options.port,
-            host: options.host,
-            configPath: options.config,
-            watch: options.watch,
-            verbose: options.verbose,
-            dashboardPort: options.dashboardPort,
-        });
+  }
+  return options;
+}
+async function listTables(options) {
+  const { databaseName, orgId, showSchema } = options;
+  if (!databaseName) {
+    console.error("Error: Database name/ID is required");
+    console.error("");
+    console.error("Usage: ploy api db tables <database>");
+    process.exit(1);
+  }
+  if (!orgId) {
+    console.error("Error: --org is required for database operations");
+    console.error("");
+    console.error("Usage: ploy api db tables <database> --org <org-id>");
+    process.exit(1);
+  }
+  console.log(`Fetching tables for database: ${databaseName}...`);
+  console.log("");
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/projects/org/{orgId}/db/{databaseId}/tables",
+      {
+        params: { path: { orgId, databaseId: databaseName } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch tables",
+        response?.status || 500
+      );
+    }
+    const tablesResult = data;
+    if (!tablesResult.tables || tablesResult.tables.length === 0) {
+      console.log("No tables found in this database.");
+      return;
+    }
+    console.log("Tables");
+    console.log("======");
+    console.log("");
+    if (showSchema) {
+      const {
+        data: schemaData,
+        error: schemaError,
+        response: schemaResponse
+      } = await client.GET("/projects/org/{orgId}/db/{databaseId}/schema", {
+        params: { path: { orgId, databaseId: databaseName } }
+      });
+      if (schemaError || !schemaData) {
+        throw new ApiClientError(
+          schemaError?.message || "Failed to fetch schema",
+          schemaResponse?.status || 500
+        );
+      }
+      const schemaResult = schemaData;
+      for (const table of schemaResult.tables) {
+        console.log(`Table: ${table.name}`);
+        console.log("-".repeat(40));
+        console.log(
+          "  " + "COLUMN".padEnd(20) + "TYPE".padEnd(15) + "NULLABLE".padEnd(10) + "PK"
+        );
+        console.log("  " + "-".repeat(50));
+        for (const col of table.columns) {
+          const nullable = col.notNull ? "NO" : "YES";
+          const pk = col.primaryKey ? "YES" : "";
+          console.log(
+            "  " + col.name.padEnd(20) + col.type.padEnd(15) + nullable.padEnd(10) + pk
+          );
+        }
+        console.log("");
+      }
+    } else {
+      console.log("NAME".padEnd(30) + "ROWS".padEnd(12) + "SIZE");
+      console.log("-".repeat(55));
+      for (const table of tablesResult.tables) {
+        console.log(table.name.padEnd(30) + "-".padEnd(12) + "-");
+      }
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error(
+          "The database was not found. Check the database name/ID."
+        );
+      }
+    } else {
+      throw error2;
     }
+    process.exit(1);
+  }
+}
+async function viewAnalytics(options) {
+  const { databaseName, orgId, period = "24h", limit = 10 } = options;
+  if (!databaseName) {
+    console.error("Error: Database name/ID is required");
+    console.error("");
+    console.error("Usage: ploy api db analytics <database>");
+    process.exit(1);
+  }
+  if (!orgId) {
+    console.error("Error: --org is required for database operations");
+    console.error("");
+    console.error("Usage: ploy api db analytics <database> --org <org-id>");
+    process.exit(1);
+  }
+  console.log(
+    `Fetching analytics for database: ${databaseName} (${period})...`
+  );
+  console.log("");
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/projects/org/{orgId}/db/{databaseId}/insights",
+      {
+        params: {
+          path: { orgId, databaseId: databaseName },
+          query: {
+            timeRange: period,
+            limit: limit.toString()
+          }
+        }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch analytics",
+        response?.status || 500
+      );
+    }
+    const insightsResult = data;
+    console.log("Database Analytics");
+    console.log("==================");
+    console.log("");
+    console.log(`  Period:            ${insightsResult.timeRange}`);
+    console.log(
+      `  Total Queries:     ${insightsResult.summary.totalQueries.toLocaleString()}`
+    );
+    console.log(
+      `  Total Rows Read:   ${insightsResult.summary.totalRowsRead.toLocaleString()}`
+    );
+    console.log(
+      `  Total Rows Written: ${insightsResult.summary.totalRowsWritten.toLocaleString()}`
+    );
+    const avgDuration = insightsResult.summary.totalQueries > 0 ? insightsResult.summary.totalDurationMs / insightsResult.summary.totalQueries : 0;
+    console.log(`  Avg Query Duration: ${avgDuration.toFixed(2)}ms`);
+    console.log("");
+    if (insightsResult.topQueries && insightsResult.topQueries.length > 0) {
+      console.log("Top Queries by Total Duration");
+      console.log("-----------------------------");
+      console.log("");
+      for (let i = 0; i < insightsResult.topQueries.length; i++) {
+        const insight = insightsResult.topQueries[i];
+        console.log(`${i + 1}. ${truncateQuery(insight.queryText, 60)}`);
+        console.log(`   Calls: ${insight.totalCalls.toLocaleString()}`);
+        console.log(`   Avg Duration: ${insight.avgDurationMs.toFixed(2)}ms`);
+        console.log(
+          `   Total Duration: ${insight.totalDurationMs.toFixed(2)}ms`
+        );
+        console.log(`   Rows Read: ${insight.totalRowsRead.toLocaleString()}`);
+        console.log(
+          `   Rows Written: ${insight.totalRowsWritten.toLocaleString()}`
+        );
+        console.log("");
+      }
+    }
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error(
+          "The database was not found. Check the database name/ID."
+        );
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+async function listDatabases(options) {
+  if (!options.orgId) {
+    console.error("Error: --org is required for listing databases");
+    console.error("");
+    console.error("Usage: ploy api db list --org <org-id>");
+    process.exit(1);
+  }
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/orgs/{id}/databases",
+      {
+        params: {
+          path: { id: options.orgId },
+          query: options.projectId ? { projectId: options.projectId } : void 0
+        }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to list databases",
+        response?.status || 500
+      );
+    }
+    const databases = data.databases;
+    if (!databases || databases.length === 0) {
+      console.log("No databases found.");
+      return;
+    }
+    console.log("");
+    console.log("Databases");
+    console.log("=========");
+    console.log("");
+    console.log(
+      "ID".padEnd(26) + "NAME".padEnd(25) + "REGION".padEnd(15) + "CREATED"
+    );
+    console.log("-".repeat(80));
+    for (const db of databases) {
+      const id = db.id.substring(0, Math.min(24, db.id.length));
+      const name = db.name.substring(0, Math.min(23, db.name.length)).padEnd(25);
+      const region = (db.region || "-").padEnd(15);
+      const created = db.createdAt ? new Date(db.createdAt).toLocaleDateString() : "-";
+      console.log(`${id}  ${name}${region}${created}`);
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+function truncateQuery(query, maxLength) {
+  const normalized = query.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return normalized.substring(0, maxLength - 3) + "...";
+}
+async function dbCommand(options) {
+  const { action } = options;
+  if (!action) {
+    printDbHelp();
+    process.exit(1);
+  }
+  switch (action) {
+    case "tables":
+      await listTables(options);
+      break;
+    case "analytics":
+      await viewAnalytics(options);
+      break;
+    case "list":
+      await listDatabases(options);
+      break;
+    case "-h":
+    case "--help":
+      printDbHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown action: ${action}`);
+      console.error("");
+      console.error("Available actions: tables, analytics, list");
+      console.error("");
+      console.error("Run 'ploy api db --help' for more information");
+      process.exit(1);
+  }
+}
+
+// src/commands/api/deployment.ts
+function printDeploymentHelp() {
+  console.log("Usage: ploy api deployment <action> [options]");
+  console.log("");
+  console.log("Manage deployments via the Ploy API");
+  console.log("");
+  console.log("Actions:");
+  console.log("  retry <id>   Retry a failed deployment");
+  console.log("  logs <id>    View deployment build logs");
+  console.log("  view <id>    View deployment details");
+  console.log("  list         List deployments (requires --project)");
+  console.log("");
+  console.log("Options:");
+  console.log("  --branch <name>     Filter by branch name (for view/list)");
+  console.log("  --commit <sha>      Filter by commit SHA (for view)");
+  console.log("  --project <id>      Project ID (required for list)");
+  console.log("  --limit <n>         Limit number of results (default: 20)");
+  console.log("  -h, --help          Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy api deployment retry abc123");
+  console.log("  ploy api deployment logs abc123");
+  console.log("  ploy api deployment view abc123");
+  console.log("  ploy api deployment view abc123 --branch main");
+  console.log("  ploy api deployment list --project proj123");
 }
-else if (command === "types") {
-    const options = parseTypesArgs(args.slice(1));
-    await typesCommand(options);
+function parseDeploymentArgs(args2) {
+  const options = {};
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printDeploymentHelp();
+    process.exit(0);
+  }
+  options.action = args2[0];
+  if (args2[1] && !args2[1].startsWith("-")) {
+    options.deploymentId = args2[1];
+  }
+  for (let i = 1; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--branch") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --branch requires a value");
+        process.exit(1);
+      }
+      options.branch = nextArg;
+      i++;
+    } else if (arg === "--commit") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --commit requires a value");
+        process.exit(1);
+      }
+      options.commitSha = nextArg;
+      i++;
+    } else if (arg === "--project") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --project requires a value");
+        process.exit(1);
+      }
+      options.projectId = nextArg;
+      i++;
+    } else if (arg === "--limit") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --limit requires a number");
+        process.exit(1);
+      }
+      const limit = parseInt(nextArg, 10);
+      if (Number.isNaN(limit)) {
+        console.error("Error: --limit requires a valid number");
+        process.exit(1);
+      }
+      options.limit = limit;
+      i++;
+    } else if (arg === "-f" || arg === "--follow") {
+      options.follow = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printDeploymentHelp();
+      process.exit(0);
+    }
+  }
+  return options;
 }
-else if (command === "build") {
-    const options = parseBuildArgs(args.slice(1));
-    await buildCommand(options);
+async function retryDeployment(deploymentId) {
+  console.log(`Retrying deployment ${deploymentId}...`);
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.POST(
+      "/deployments/{deploymentId}/retry",
+      {
+        params: { path: { deploymentId } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to retry deployment",
+        response?.status || 500
+      );
+    }
+    const retryResult = data;
+    console.log("");
+    console.log("Deployment retry initiated successfully");
+    console.log("");
+    console.log(`  New Deployment ID: ${retryResult.newDeploymentId}`);
+    console.log(`  Message: ${retryResult.message}`);
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error("The deployment was not found. Check the deployment ID.");
+      } else if (error2.status === 400) {
+        console.error(
+          "The deployment cannot be retried (may not be in a failed state)."
+        );
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
 }
-else {
-    console.error(`Unknown command: ${command}`);
-    console.error("\nAvailable commands:");
-    console.error("  build  Build your Ploy project");
-    console.error("  dev    Start development server");
-    console.error("  types  Generate TypeScript types from ploy.yaml");
+async function viewDeploymentLogs(deploymentId, _options) {
+  console.log(`Fetching logs for deployment ${deploymentId}...`);
+  console.log("");
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/deployments/{deploymentId}/logs",
+      {
+        params: { path: { deploymentId } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch logs",
+        response?.status || 500
+      );
+    }
+    const logsResult = data;
+    if (!logsResult.logs || logsResult.logs.length === 0) {
+      console.log("No logs available for this deployment.");
+      return;
+    }
+    for (const log2 of logsResult.logs) {
+      const timestamp2 = new Date(log2.createdAt).toLocaleTimeString();
+      const level = log2.level.toUpperCase().padEnd(5);
+      const prefix = log2.command ? `[${log2.command}] ` : "";
+      console.log(`${timestamp2} ${level} ${prefix}${log2.message}`);
+    }
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error("The deployment was not found. Check the deployment ID.");
+      }
+    } else {
+      throw error2;
+    }
     process.exit(1);
+  }
+}
+async function viewDeployment(deploymentId, _options) {
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/deployments/{deploymentId}",
+      {
+        params: { path: { deploymentId } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch deployment",
+        response?.status || 500
+      );
+    }
+    const deployment = data.deployment;
+    console.log("");
+    console.log("Deployment Details");
+    console.log("==================");
+    console.log("");
+    console.log(`  ID:          ${deployment.id}`);
+    console.log(`  Status:      ${formatStatus(deployment.status)}`);
+    if (deployment.project) {
+      console.log(`  Project:     ${deployment.project.name}`);
+    }
+    if (deployment.repository) {
+      console.log(`  Repository:  ${deployment.repository.fullName}`);
+    }
+    if (deployment.branch) {
+      console.log(`  Branch:      ${deployment.branch}`);
+    }
+    if (deployment.commitSha) {
+      const commitDisplay = deployment.commitSha.length >= 8 ? deployment.commitSha.substring(0, 8) : deployment.commitSha;
+      console.log(`  Commit:      ${commitDisplay}`);
+    }
+    if (deployment.commitMessage) {
+      console.log(`  Message:     ${deployment.commitMessage}`);
+    }
+    if (deployment.url) {
+      console.log(`  URL:         ${deployment.url}`);
+    }
+    console.log(
+      `  Created:     ${new Date(deployment.createdAt).toLocaleString()}`
+    );
+    console.log(
+      `  Updated:     ${new Date(deployment.updatedAt).toLocaleString()}`
+    );
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error("The deployment was not found. Check the deployment ID.");
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+async function listDeployments(options) {
+  if (!options.projectId) {
+    console.error("Error: --project is required for listing deployments");
+    console.error("");
+    console.error("Usage: ploy api deployment list --project <project-id>");
+    process.exit(1);
+  }
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET("/deployments", {
+      params: {
+        query: {
+          projectId: options.projectId,
+          branch: options.branch,
+          limit: options.limit?.toString() || "20"
+        }
+      }
+    });
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to list deployments",
+        response?.status || 500
+      );
+    }
+    const deployments = data.deployments;
+    if (!deployments || deployments.length === 0) {
+      console.log("No deployments found.");
+      return;
+    }
+    console.log("");
+    console.log("Deployments");
+    console.log("===========");
+    console.log("");
+    console.log(
+      "ID".padEnd(12) + "STATUS".padEnd(12) + "BRANCH".padEnd(20) + "COMMIT".padEnd(10) + "CREATED"
+    );
+    console.log("-".repeat(70));
+    for (const d of deployments) {
+      const id = d.id.substring(0, Math.min(10, d.id.length));
+      const status = d.status.padEnd(10);
+      const branchSource = d.branch || "-";
+      const branch = branchSource.substring(0, Math.min(18, branchSource.length)).padEnd(20);
+      const commit = d.commitSha ? d.commitSha.substring(0, Math.min(8, d.commitSha.length)) : "-";
+      const created = new Date(d.createdAt).toLocaleDateString();
+      console.log(`${id}  ${status}  ${branch}${commit.padEnd(10)}${created}`);
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+function formatStatus(status) {
+  if (!process.stdout.isTTY) {
+    return status;
+  }
+  const statusColors = {
+    success: "\x1B[32msuccess\x1B[0m",
+    // green
+    failure: "\x1B[31mfailure\x1B[0m",
+    // red
+    pending: "\x1B[33mpending\x1B[0m",
+    // yellow
+    building: "\x1B[34mbuilding\x1B[0m",
+    // blue
+    syncing: "\x1B[36msyncing\x1B[0m",
+    // cyan
+    uploading: "\x1B[36muploading\x1B[0m",
+    // cyan
+    timeout: "\x1B[31mtimeout\x1B[0m"
+    // red
+  };
+  return statusColors[status] || status;
+}
+async function deploymentCommand(options) {
+  const { action, deploymentId } = options;
+  if (!action) {
+    printDeploymentHelp();
+    process.exit(1);
+  }
+  switch (action) {
+    case "retry":
+      if (!deploymentId) {
+        console.error("Error: Deployment ID is required");
+        console.error("");
+        console.error("Usage: ploy api deployment retry <deployment-id>");
+        process.exit(1);
+      }
+      await retryDeployment(deploymentId);
+      break;
+    case "logs":
+      if (!deploymentId) {
+        console.error("Error: Deployment ID is required");
+        console.error("");
+        console.error("Usage: ploy api deployment logs <deployment-id>");
+        process.exit(1);
+      }
+      await viewDeploymentLogs(deploymentId);
+      break;
+    case "view":
+      if (!deploymentId) {
+        console.error("Error: Deployment ID is required");
+        console.error("");
+        console.error("Usage: ploy api deployment view <deployment-id>");
+        process.exit(1);
+      }
+      await viewDeployment(deploymentId);
+      break;
+    case "list":
+      await listDeployments(options);
+      break;
+    case "-h":
+    case "--help":
+      printDeploymentHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown action: ${action}`);
+      console.error("");
+      console.error("Available actions: retry, logs, view, list");
+      console.error("");
+      console.error("Run 'ploy api deployment --help' for more information");
+      process.exit(1);
+  }
+}
+
+// src/commands/api/index.ts
+function printApiHelp() {
+  console.log("Usage: ploy api <subcommand> [options]");
+  console.log("");
+  console.log("Interact with the Ploy API from the command line");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  deployment  Manage deployments (retry, logs, view)");
+  console.log("  db          Database operations (tables, analytics)");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show this help message");
+  console.log("");
+  console.log("Authentication:");
+  console.log(
+    "  Run 'ploy auth login' to authenticate via browser (recommended)"
+  );
+  console.log("");
+  console.log("  Or set environment variables:");
+  console.log("    PLOY_API_TOKEN  Your Ploy API token");
+  console.log(
+    "    PLOY_API_URL    API base URL (default: https://api.meetploy.com)"
+  );
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy api deployment retry abc123");
+  console.log("  ploy api deployment logs abc123");
+  console.log("  ploy api deployment view abc123 --branch main");
+  console.log("  ploy api db tables my-database");
+  console.log("  ploy api db analytics my-database");
+  console.log("");
+  console.log(
+    "Run 'ploy api <subcommand> --help' for subcommand-specific help"
+  );
+}
+function parseApiArgs(args2) {
+  const options = {
+    subArgs: []
+  };
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printApiHelp();
+    process.exit(0);
+  }
+  options.subcommand = args2[0];
+  options.subArgs = args2.slice(1);
+  return options;
+}
+async function apiCommand(options) {
+  const { subcommand, subArgs } = options;
+  if (!subcommand) {
+    printApiHelp();
+    process.exit(1);
+  }
+  switch (subcommand) {
+    case "deployment":
+    case "deploy": {
+      const deploymentOptions = parseDeploymentArgs(subArgs);
+      await deploymentCommand(deploymentOptions);
+      break;
+    }
+    case "db":
+    case "database": {
+      const dbOptions = parseDbArgs(subArgs);
+      await dbCommand(dbOptions);
+      break;
+    }
+    case "-h":
+    case "--help":
+      printApiHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.error("");
+      console.error("Available subcommands:");
+      console.error("  deployment  Manage deployments");
+      console.error("  db          Database operations");
+      console.error("");
+      console.error("Run 'ploy api --help' for more information");
+      process.exit(1);
+  }
+}
+var OAUTH_CLIENT_ID = "ploy-cli";
+var CALLBACK_PORT = 9876;
+var CALLBACK_HOST = "127.0.0.1";
+function printLoginHelp() {
+  console.log("Usage: ploy login [options]");
+  console.log("");
+  console.log("Authenticate with the Ploy API via browser");
+  console.log("");
+  console.log("Options:");
+  console.log(
+    "  --api-url <url>  API base URL (default: https://api.meetploy.com)"
+  );
+  console.log("  -h, --help       Show this help message");
+  console.log("");
+  console.log("This command will:");
+  console.log("  1. Open your browser to authenticate");
+  console.log("  2. Store the access token in ~/.ploy/config.json");
+  console.log("");
+  console.log("Environment Variables:");
+  console.log("  PLOY_API_URL     API base URL (alternative to --api-url)");
+}
+function parseLoginArgs(args2) {
+  const options = {};
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--api-url") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --api-url requires a value");
+        process.exit(1);
+      }
+      options.apiUrl = nextArg;
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      printLoginHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  let command2;
+  if (platform === "darwin") {
+    command2 = `open "${url}"`;
+  } else if (platform === "win32") {
+    command2 = `start "" "${url}"`;
+  } else {
+    command2 = `xdg-open "${url}"`;
+  }
+  exec(command2, (error2) => {
+    if (error2) {
+      console.log("");
+      console.log("Could not open browser automatically.");
+      console.log("Please open the following URL manually:");
+      console.log("");
+      console.log(`  ${url}`);
+      console.log("");
+    }
+  });
+}
+function generateState() {
+  return randomBytes(16).toString("hex");
+}
+async function exchangeCodeForToken(apiUrl, code, redirectUri) {
+  const tokenUrl = `${apiUrl}/oauth/token`;
+  const response = await fetch(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri,
+      client_id: OAUTH_CLIENT_ID
+      // Note: client_secret may not be needed for public clients
+    })
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`Token exchange failed: ${response.status} - ${errorBody}`);
+  }
+  return await response.json();
+}
+function createCallbackServer(expectedState, apiUrl) {
+  let server = null;
+  let resolveListening;
+  let rejectListening;
+  const waitForListening = new Promise((resolve, reject) => {
+    resolveListening = resolve;
+    rejectListening = reject;
+  });
+  const tokenPromise = new Promise((resolve, reject) => {
+    const timeout = setTimeout(
+      () => {
+        if (server) {
+          server.close();
+        }
+        reject(
+          new Error("Login timeout - no response received within 5 minutes")
+        );
+      },
+      5 * 60 * 1e3
+    );
+    server = createServer(async (req, res) => {
+      const reqUrl = new URL(
+        req.url || "/",
+        `http://${CALLBACK_HOST}:${CALLBACK_PORT}`
+      );
+      if (reqUrl.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = reqUrl.searchParams.get("code");
+      const state = reqUrl.searchParams.get("state");
+      const error2 = reqUrl.searchParams.get("error");
+      const errorDescription = reqUrl.searchParams.get("error_description");
+      if (error2) {
+        clearTimeout(timeout);
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>Error: ${error2}</p>
+							<p>${errorDescription || ""}</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(new Error(`OAuth error: ${error2} - ${errorDescription || ""}`));
+        return;
+      }
+      if (!code) {
+        clearTimeout(timeout);
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>No authorization code received.</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(new Error("No authorization code received"));
+        return;
+      }
+      if (state !== expectedState) {
+        clearTimeout(timeout);
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>State mismatch - possible CSRF attack.</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(new Error("State mismatch - possible CSRF attack"));
+        return;
+      }
+      try {
+        const redirectUri = `http://${CALLBACK_HOST}:${CALLBACK_PORT}/callback`;
+        const tokenResponse = await exchangeCodeForToken(
+          apiUrl,
+          code,
+          redirectUri
+        );
+        clearTimeout(timeout);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Successful</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Successful!</h1>
+							<p>You have been authenticated with Ploy.</p>
+							<p>You can close this window and return to your terminal.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        resolve(tokenResponse);
+      } catch (err) {
+        clearTimeout(timeout);
+        res.writeHead(500, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>Failed to exchange authorization code for token.</p>
+							<p>${err instanceof Error ? err.message : "Unknown error"}</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(err);
+      }
+    });
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      if (err.code === "EADDRINUSE") {
+        const portError = new Error(
+          `Port ${CALLBACK_PORT} is already in use. Please close any other process using this port and try again.`
+        );
+        reject(portError);
+        rejectListening(portError);
+      } else {
+        const serverError = new Error(
+          `Failed to start callback server: ${err.message}`
+        );
+        reject(serverError);
+        rejectListening(serverError);
+      }
+    });
+    server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+      resolveListening();
+    });
+  });
+  return { tokenPromise, waitForListening };
+}
+async function loginCommand(options = {}) {
+  const apiUrl = options.apiUrl || await getApiUrl();
+  const state = generateState();
+  const redirectUri = `http://${CALLBACK_HOST}:${CALLBACK_PORT}/callback`;
+  console.log("Starting login flow...");
+  console.log("");
+  const authUrl = new URL(`${apiUrl}/oauth/authorize`);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", OAUTH_CLIENT_ID);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("scope", "openid profile email");
+  const { tokenPromise, waitForListening } = createCallbackServer(
+    state,
+    apiUrl
+  );
+  try {
+    await waitForListening;
+  } catch (error2) {
+    console.error(
+      `Error: ${error2 instanceof Error ? error2.message : "Failed to start server"}`
+    );
+    process.exit(1);
+  }
+  console.log("Opening browser for authentication...");
+  openBrowser(authUrl.toString());
+  console.log("");
+  console.log("Waiting for authentication...");
+  console.log("(Press Ctrl+C to cancel)");
+  console.log("");
+  try {
+    const tokenResponse = await tokenPromise;
+    await setAuthToken(tokenResponse.access_token, tokenResponse.expires_in);
+    console.log("Login successful!");
+    console.log("");
+    console.log(`Credentials saved to: ${getConfigFile()}`);
+    console.log("");
+    console.log("You can now use 'ploy api' commands.");
+    process.exit(0);
+  } catch (error2) {
+    console.error("");
+    console.error(
+      `Login failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/auth/logout.ts
+function printLogoutHelp() {
+  console.log("Usage: ploy logout [options]");
+  console.log("");
+  console.log("Log out from the Ploy API");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show this help message");
+  console.log("");
+  console.log(
+    "This command removes stored credentials from ~/.ploy/config.json"
+  );
+}
+function parseLogoutArgs(args2) {
+  for (const arg of args2) {
+    if (arg === "-h" || arg === "--help") {
+      printLogoutHelp();
+      process.exit(0);
+    }
+  }
+}
+async function logoutCommand() {
+  const config = await readConfig();
+  if (!config.auth?.accessToken) {
+    console.log("You are not logged in.");
+    return;
+  }
+  await clearAuthToken();
+  console.log("Logged out successfully.");
+  console.log("");
+  console.log(`Credentials removed from: ${getConfigFile()}`);
+}
+
+// src/commands/auth/index.ts
+function printAuthHelp() {
+  console.log("Usage: ploy auth <subcommand> [options]");
+  console.log("");
+  console.log("Manage authentication with Ploy");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  login   Authenticate with Ploy via browser");
+  console.log("  logout  Clear stored credentials");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy auth login");
+  console.log("  ploy auth logout");
+  console.log("");
+  console.log(
+    "Run 'ploy auth <subcommand> --help' for subcommand-specific help"
+  );
+}
+function parseAuthArgs(args2) {
+  const options = {
+    subArgs: []
+  };
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printAuthHelp();
+    process.exit(0);
+  }
+  options.subcommand = args2[0];
+  options.subArgs = args2.slice(1);
+  return options;
+}
+async function authCommand(options) {
+  const { subcommand, subArgs } = options;
+  if (!subcommand) {
+    printAuthHelp();
+    process.exit(1);
+  }
+  switch (subcommand) {
+    case "login": {
+      const loginOptions = parseLoginArgs(subArgs);
+      await loginCommand(loginOptions);
+      break;
+    }
+    case "logout": {
+      parseLogoutArgs(subArgs);
+      await logoutCommand();
+      break;
+    }
+    case "-h":
+    case "--help":
+      printAuthHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.error("");
+      console.error("Available subcommands:");
+      console.error("  login   Authenticate with Ploy");
+      console.error("  logout  Clear stored credentials");
+      console.error("");
+      console.error("Run 'ploy auth --help' for more information");
+      process.exit(1);
+  }
+}
+
+// src/commands/build.ts
+init_cli();
+function detectPackageManager() {
+  const cwd = process.cwd();
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function runWranglerBuild() {
+  return new Promise((resolve, reject) => {
+    const packageManager = detectPackageManager();
+    let command2;
+    let args2;
+    if (packageManager === "npm") {
+      command2 = "npx";
+      args2 = ["wrangler", "build"];
+    } else if (packageManager === "yarn") {
+      command2 = "yarn";
+      args2 = ["wrangler", "build"];
+    } else {
+      command2 = "pnpm";
+      args2 = ["wrangler", "build"];
+    }
+    console.log(`Running: ${command2} ${args2.join(" ")}`);
+    const child = spawn(command2, args2, {
+      cwd: process.cwd(),
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", (error2) => {
+      reject(new Error(`Failed to run wrangler build: ${error2.message}`));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`wrangler build exited with code ${code}`));
+      }
+    });
+  });
+}
+async function buildCommand(options = {}) {
+  const cwd = process.cwd();
+  const configFile = options.config || "ploy.yaml";
+  console.log("Validating ploy.yaml...");
+  const config = readPloyConfigSync(cwd, options.config);
+  validatePloyConfig(config, configFile);
+  console.log("Configuration valid.");
+  console.log("");
+  await runWranglerBuild();
+}
+function parseBuildArgs(args2) {
+  const options = {};
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-c" || arg === "--config") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error(`Error: ${arg} requires a path argument`);
+        process.exit(1);
+      }
+      options.config = nextArg;
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      printBuildHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function printBuildHelp() {
+  console.log("Usage: ploy build [options]");
+  console.log("");
+  console.log("Build your Ploy project");
+  console.log("");
+  console.log("Options:");
+  console.log(
+    "  -c, --config <path>  Path to config file (default: ploy.yaml)"
+  );
+  console.log("  -h, --help           Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log(
+    "  ploy build                     Build using ploy.yaml in current directory"
+  );
+  console.log(
+    "  ploy build -c custom.yaml      Build using a custom config file"
+  );
+}
+
+// src/commands/types.ts
+init_cli();
+async function updateTsConfigInclude(cwd, outputPath) {
+  const tsconfigPath = join(cwd, "tsconfig.json");
+  try {
+    const content = await readFile(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(content);
+    if (!tsconfig.include) {
+      tsconfig.include = [];
+    }
+    if (tsconfig.include.includes(outputPath)) {
+      return false;
+    }
+    tsconfig.include.push(outputPath);
+    await writeFile(tsconfigPath, JSON.stringify(tsconfig, null, "	") + "\n");
+    return true;
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "code" in error2) {
+      if (error2.code === "ENOENT") {
+        return false;
+      }
+    }
+    console.warn(`Warning: Could not update tsconfig.json: ${error2}`);
+    return false;
+  }
+}
+function generateEnvType(config) {
+  const imports = [];
+  const properties = [];
+  if (config.ai) {
+    properties.push("	AI_URL: string;");
+    properties.push("	AI_TOKEN: string;");
+  }
+  if (config.db) {
+    imports.push("D1Database");
+    for (const bindingName of Object.keys(config.db)) {
+      properties.push(`	${bindingName}: D1Database;`);
+    }
+  }
+  if (config.queue) {
+    imports.push("QueueBinding");
+    for (const bindingName of Object.keys(config.queue)) {
+      properties.push(`	${bindingName}: QueueBinding;`);
+    }
+  }
+  if (config.workflow) {
+    imports.push("WorkflowBinding");
+    for (const bindingName of Object.keys(config.workflow)) {
+      properties.push(`	${bindingName}: WorkflowBinding;`);
+    }
+  }
+  const lines = [
+    "// This file is auto-generated by `ploy types`. Do not edit manually.",
+    ""
+  ];
+  if (imports.length > 0) {
+    lines.push(`import type { ${imports.join(", ")} } from "@meetploy/types";`);
+    lines.push("");
+  }
+  lines.push('declare module "@meetploy/nextjs" {');
+  lines.push("	interface PloyEnv {");
+  for (const prop of properties) {
+    lines.push(`	${prop}`);
+  }
+  lines.push("	}");
+  lines.push("}");
+  lines.push("");
+  lines.push("declare global {");
+  lines.push("	interface PloyEnv {");
+  for (const prop of properties) {
+    lines.push(`	${prop}`);
+  }
+  lines.push("	}");
+  lines.push("}");
+  lines.push("");
+  lines.push("export {};");
+  lines.push("");
+  return lines.join("\n");
+}
+function getOutputPath(options) {
+  if (options.output) {
+    return options.output;
+  }
+  return "env.d.ts";
+}
+async function typesCommand(options = {}) {
+  const cwd = process.cwd();
+  const config = await readPloyConfig(cwd);
+  if (!config) {
+    console.error("Error: ploy.yaml not found in current directory");
+    process.exit(1);
+  }
+  const hasBindings2 = config.ai || config.db || config.queue || config.workflow;
+  if (!hasBindings2) {
+    console.log("No bindings found in ploy.yaml. Generating empty Env.");
+  }
+  const content = generateEnvType(config);
+  const outputPath = getOutputPath(options);
+  const fullOutputPath = join(cwd, outputPath);
+  const outputDir = dirname(fullOutputPath);
+  await mkdir(outputDir, { recursive: true });
+  await writeFile(fullOutputPath, content, "utf-8");
+  console.log(`Generated ${outputPath}`);
+  const updated = await updateTsConfigInclude(cwd, outputPath);
+  if (updated) {
+    console.log(`Updated tsconfig.json to include ${outputPath}`);
+  }
+  process.exit(0);
+}
+function parseTypesArgs(args2) {
+  const options = {};
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-o" || arg === "--output") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error(`Error: ${arg} requires a path argument`);
+        process.exit(1);
+      }
+      options.output = nextArg;
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      printTypesHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function printTypesHelp() {
+  console.log("Usage: ploy types [options]");
+  console.log("");
+  console.log("Generate TypeScript types from ploy.yaml bindings");
+  console.log("");
+  console.log("Options:");
+  console.log("  -o, --output <path>  Output file path (default: env.d.ts)");
+  console.log("  -h, --help           Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log(
+    "  ploy types                    Generate env.d.ts in current directory"
+  );
+  console.log("  ploy types -o env.d.ts    Generate types to specific path");
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+if (!command) {
+  console.error("Usage: ploy <command>");
+  console.error("\nAvailable commands:");
+  console.error("  api     Interact with the Ploy API");
+  console.error("  auth    Manage authentication (login, logout)");
+  console.error("  build   Build your Ploy project");
+  console.error("  dev     Start development server");
+  console.error("  types   Generate TypeScript types from ploy.yaml");
+  process.exit(1);
+}
+function parseDevArgs(args2) {
+  const options = {
+    port: void 0,
+    host: void 0,
+    config: void 0,
+    watch: true,
+    verbose: false,
+    dashboardPort: void 0
+  };
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-p" || arg === "--port") {
+      const value = args2[++i];
+      if (value) {
+        options.port = parseInt(value, 10);
+      }
+    } else if (arg === "-h" || arg === "--host") {
+      options.host = args2[++i];
+    } else if (arg === "-c" || arg === "--config") {
+      options.config = args2[++i];
+    } else if (arg === "--no-watch") {
+      options.watch = false;
+    } else if (arg === "-v" || arg === "--verbose") {
+      options.verbose = true;
+    } else if (arg === "--dashboard-port") {
+      const value = args2[++i];
+      if (value) {
+        options.dashboardPort = parseInt(value, 10);
+      }
+    }
+  }
+  return options;
+}
+async function isNextJsProject(projectDir, configPath) {
+  const { readPloyConfig: readPloyConfig3 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+  try {
+    const config = await readPloyConfig3(projectDir, configPath);
+    if (config?.kind === "nextjs") {
+      return true;
+    }
+  } catch {
+  }
+  const nextConfigFiles = [
+    "next.config.ts",
+    "next.config.js",
+    "next.config.mts",
+    "next.config.mjs"
+  ];
+  for (const file of nextConfigFiles) {
+    if (existsSync(join(projectDir, file))) {
+      return true;
+    }
+  }
+  return false;
+}
+function findNextBinary(projectDir) {
+  const possiblePaths = [
+    join(projectDir, "node_modules", ".bin", "next"),
+    "npx next"
+  ];
+  for (const p of possiblePaths) {
+    if (p.includes("npx") || existsSync(p)) {
+      return p;
+    }
+  }
+  return "npx next";
+}
+async function startNextJsDev(options) {
+  const projectDir = process.cwd();
+  const nextPort = options.port ?? 3e3;
+  const dashboardPort = options.dashboardPort ?? nextPort + 1e3;
+  const { startDevDashboard: startDevDashboard2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+  const dashboard = await startDevDashboard2({
+    configPath: options.config,
+    port: dashboardPort,
+    verbose: options.verbose
+  });
+  console.log(
+    `
+  Ploy Dashboard: http://${options.host ?? "localhost"}:${dashboard.port}`
+  );
+  const nextBin = findNextBinary(projectDir);
+  const nextArgs = ["dev", "-p", String(nextPort)];
+  if (options.host) {
+    nextArgs.push("-H", options.host);
+  }
+  console.log(`  Starting Next.js dev server...`);
+  let nextProcess;
+  if (nextBin.includes("npx")) {
+    nextProcess = spawn("npx", ["next", ...nextArgs], {
+      cwd: projectDir,
+      stdio: "inherit",
+      shell: true,
+      env: {
+        ...process.env,
+        // Set environment variable so initPloyForDev knows the mock server URL
+        PLOY_MOCK_SERVER_URL: `http://localhost:${dashboard.port}`
+      }
+    });
+  } else {
+    nextProcess = spawn(nextBin, nextArgs, {
+      cwd: projectDir,
+      stdio: "inherit",
+      shell: true,
+      env: {
+        ...process.env,
+        PLOY_MOCK_SERVER_URL: `http://localhost:${dashboard.port}`
+      }
+    });
+  }
+  const cleanup = async () => {
+    console.log("\nShutting down...");
+    nextProcess.kill("SIGTERM");
+    await dashboard.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  nextProcess.on("exit", async (code) => {
+    await dashboard.close();
+    process.exit(code ?? 0);
+  });
+}
+if (command === "dev") {
+  const options = parseDevArgs(args.slice(1));
+  const projectDir = process.cwd();
+  const isNextJs = await isNextJsProject(projectDir, options.config);
+  if (isNextJs) {
+    await startNextJsDev({
+      port: options.port,
+      host: options.host,
+      config: options.config,
+      verbose: options.verbose,
+      dashboardPort: options.dashboardPort
+    });
+  } else {
+    const { startEmulator: startEmulator2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+    await startEmulator2({
+      port: options.port,
+      host: options.host,
+      configPath: options.config,
+      watch: options.watch,
+      verbose: options.verbose,
+      dashboardPort: options.dashboardPort
+    });
+  }
+} else if (command === "types") {
+  const options = parseTypesArgs(args.slice(1));
+  await typesCommand(options);
+} else if (command === "build") {
+  const options = parseBuildArgs(args.slice(1));
+  await buildCommand(options);
+} else if (command === "api") {
+  const options = parseApiArgs(args.slice(1));
+  await apiCommand(options);
+} else if (command === "auth") {
+  const options = parseAuthArgs(args.slice(1));
+  await authCommand(options);
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error("\nAvailable commands:");
+  console.error("  api     Interact with the Ploy API");
+  console.error("  auth    Manage authentication (login, logout)");
+  console.error("  build   Build your Ploy project");
+  console.error("  dev     Start development server");
+  console.error("  types   Generate TypeScript types from ploy.yaml");
+  process.exit(1);
 }
-//# sourceMappingURL=index.js.map