@runa-ai/runa-cli 0.5.72 → 0.6.0

package/dist/dev-A7RW6XQV.js

@@ -0,0 +1,873 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { startAppBackground, waitForAppReady, detectApp } from './chunk-HD74F6W2.js';
+import { writeEnvLocalBridge } from './chunk-M47WJJVS.js';
+import { supabaseStartActor, envCheckActor, depsInstallActor, detectDatabase } from './chunk-HPYJPB5Y.js';
+import { init_local_supabase, detectLocalSupabasePorts } from './chunk-VM3IWOT5.js';
+import { secureExeca } from './chunk-RZLYEO4U.js';
+import { emitJsonSuccess } from './chunk-UU55OH7P.js';
+import './chunk-RRGQCUKT.js';
+import './chunk-JT5SUTWE.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { createCLILogger, CLIError } from '@runa-ai/runa';
+import { Command } from 'commander';
+import { fromPromise, setup, assign, createActor } from 'xstate';
+import { existsSync, rmSync, readFileSync, unlinkSync } from 'fs';
+import path4 from 'path';
+import { z } from 'zod';
+import net from 'net';
+import { mkdir } from 'fs/promises';
+
+createRequire(import.meta.url);
+
+// src/commands/dev/commands/dev.ts
+init_esm_shims();
+
+// src/commands/dev/contract.ts
+init_esm_shims();
+var DevInputSchema = z.object({
+  /** Port for Next.js dev server (default: 3000) */
+  port: z.number().int().positive().default(3e3),
+  /** Skip Supabase start */
+  skipDb: z.boolean().default(false),
+  /** Skip app start (Supabase only) */
+  skipApp: z.boolean().default(false),
+  /** Show detailed output */
+  verbose: z.boolean().default(false),
+  /** Stream app output to terminal (in addition to log file). Default: true */
+  stream: z.boolean().default(true),
+  /** Target directory (defaults to cwd) */
+  targetDir: z.string().optional(),
+  /** Replace existing runa dev process if already running */
+  replace: z.boolean().default(false),
+  /** Bundler to use for Next.js dev server */
+  bundler: z.enum(["turbopack", "webpack"]).optional()
+}).strict();
+z.enum(["pending", "running", "passed", "failed", "skipped"]);
+var DevOutputSchema = z.object({
+  /** Overall success status */
+  success: z.boolean(),
+  /** Exit code: 0 = success, 1 = failure */
+  exitCode: z.union([z.literal(0), z.literal(1)]),
+  /** App PID if started */
+  appPid: z.number().optional(),
+  /** Supabase status */
+  supabaseStarted: z.boolean().optional(),
+  /** Error message if failed */
+  error: z.string().optional()
+}).strict();
+
+// src/commands/dev/commands/dev.ts
+init_local_supabase();
+
+// src/commands/dev/machine.ts
+init_esm_shims();
+
+// src/commands/dev/actors/index.ts
+init_esm_shims();
+
+// src/commands/dev/actors/process-check.ts
+init_esm_shims();
+
+// src/commands/ci/utils/app-process.ts
+init_esm_shims();
+function killProcessGroup(pid) {
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    process.kill(pid, "SIGTERM");
+  }
+}
+function forceKillProcessGroup(pid) {
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+async function terminateAppProcessByPid(params) {
+  const { pid, logger } = params;
+  if (!Number.isFinite(pid) || pid <= 0) {
+    logger.warn(`Invalid PID: ${pid}`);
+    return;
+  }
+  logger.info(`Terminating app process group (pid=${pid})`);
+  killProcessGroup(pid);
+  await new Promise((r) => setTimeout(r, 1e3));
+  forceKillProcessGroup(pid);
+  logger.info("App process terminated");
+}
+
+// src/commands/dev/helpers/stale-process-detector.ts
+init_esm_shims();
+var SAFE_TO_KILL_NAMES = ["node", "next-server", "next-router-worker", "tsx", "ts-node"];
+async function findProcessOnPort(port) {
+  try {
+    const result = await secureExeca("lsof", ["-i", `:${port}`, "-sTCP:LISTEN", "-P", "-n"], {
+      reject: false
+    });
+    const stdout = String(result.stdout ?? "");
+    if (result.exitCode !== 0 || !stdout) {
+      return null;
+    }
+    const lines = stdout.trim().split("\n");
+    if (lines.length < 2) return null;
+    const dataLine = lines[1];
+    const parts = dataLine.split(/\s+/);
+    if (parts.length < 2) return null;
+    const name = parts[0];
+    const pid = parseInt(parts[1], 10);
+    if (Number.isNaN(pid) || pid <= 0) return null;
+    let command = "";
+    try {
+      const psResult = await secureExeca("lsof", ["-p", `${pid}`, "-Fn"], { reject: false });
+      command = String(psResult.stdout ?? "");
+    } catch {
+    }
+    return { pid, name, command };
+  } catch {
+    return null;
+  }
+}
+function isNodeOrNextProcess(name, command) {
+  const lowerName = name.toLowerCase();
+  if (!SAFE_TO_KILL_NAMES.some((safe) => lowerName === safe)) {
+    return false;
+  }
+  if (lowerName === "node") {
+    return command.toLowerCase().includes("next");
+  }
+  return true;
+}
+async function isServerHealthy(port) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2e3);
+    const response = await fetch(`http://localhost:${port}/`, {
+      signal: controller.signal,
+      method: "GET"
+    });
+    clearTimeout(timeout);
+    return response.status > 0;
+  } catch {
+    return false;
+  }
+}
+async function detectAndRecoverStaleProcess(port, logger) {
+  const processInfo = await findProcessOnPort(port);
+  if (!processInfo) {
+    return { status: "port-free" };
+  }
+  const { pid, name, command } = processInfo;
+  logger.info(`Found process on port ${port}: ${name} (PID: ${pid})`);
+  if (!isNodeOrNextProcess(name, command)) {
+    return { status: "foreign-process", pid, name };
+  }
+  const healthy = await isServerHealthy(port);
+  if (healthy) {
+    return { status: "healthy-running", pid, name };
+  }
+  logger.info(`Stale process detected (${name}, PID: ${pid}). Recovering...`);
+  try {
+    await terminateAppProcessByPid({ pid, logger });
+    logger.info(`Stale process terminated (PID: ${pid})`);
+    return { status: "stale-killed", pid, name };
+  } catch (error) {
+    return {
+      status: "detection-failed",
+      reason: `Failed to terminate PID ${pid}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/commands/dev/actors/shared.ts
+init_esm_shims();
+var consoleLogger = {
+  info: console.log,
+  warn: console.warn
+};
+
+// src/commands/dev/actors/process-check.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPortAvailable(port) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${port} is already in use. Use --port <number> to specify a different port, or --replace to restart.`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    server.once("listening", () => {
+      server.close(() => resolve());
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+function readPidFileContent(pidFile) {
+  try {
+    return readFileSync(pidFile, "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+function parsePid(content) {
+  const pid = Number.parseInt(content, 10);
+  return Number.isNaN(pid) ? null : pid;
+}
+async function stopExistingProcess(pid, replace) {
+  if (!isProcessAlive(pid)) return;
+  if (!replace) {
+    throw new Error(
+      `runa dev is already running (PID: ${pid}). Use --replace to restart, or stop the existing process first.`
+    );
+  }
+  await terminateAppProcessByPid({
+    pid,
+    logger: consoleLogger
+  });
+}
+function cleanupPidFile(pidFile) {
+  try {
+    unlinkSync(pidFile);
+  } catch {
+  }
+}
+async function handlePidFile(pidFile, replace) {
+  const pidFileContent = readPidFileContent(pidFile);
+  if (!pidFileContent) return;
+  const pid = parsePid(pidFileContent);
+  if (pid !== null) {
+    await stopExistingProcess(pid, replace);
+  }
+  cleanupPidFile(pidFile);
+}
+function isPortInUseError(portError) {
+  return portError instanceof Error && portError.message.includes("already in use");
+}
+async function waitForPortRelease(port) {
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      await checkPortAvailable(port);
+      return;
+    } catch {
+      if (attempt === 4) {
+        throw new Error(`Port ${port} still in use after killing stale process`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+}
+function createPortRecoveryError(result, port) {
+  if (result.status === "healthy-running") {
+    return new Error(
+      `Port ${port} is in use by a running server (${result.name}, PID: ${result.pid}). Use --port <number> or --replace to restart.`
+    );
+  }
+  return new Error(
+    `Port ${port} is in use by ${result.name} (PID: ${result.pid}). Stop it manually before running runa dev.`
+  );
+}
+async function recoverPortConflict(port, portError) {
+  if (!isPortInUseError(portError)) {
+    throw portError;
+  }
+  const result = await detectAndRecoverStaleProcess(port, consoleLogger);
+  if (result.status === "port-free") {
+    return false;
+  }
+  if (result.status === "stale-killed") {
+    await waitForPortRelease(port);
+    return true;
+  }
+  if (result.status === "detection-failed") {
+    throw portError;
+  }
+  throw createPortRecoveryError(result, port);
+}
+var processCheckActor = fromPromise(
+  async ({ input }) => {
+    const pidFile = path4.join(input.repoRoot, input.tmpDir, "app.pid");
+    let staleProcessRecovered = false;
+    await handlePidFile(pidFile, input.replace);
+    if (!input.skipApp) {
+      try {
+        await checkPortAvailable(input.port);
+      } catch (portError) {
+        staleProcessRecovered = await recoverPortConflict(input.port, portError);
+      }
+    }
+    return { staleProcessRecovered };
+  }
+);
+
+// src/commands/dev/actors/app-lifecycle.ts
+init_esm_shims();
+var appStartActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, appDir, port, tmpDir, stream, bundler } = input;
+    const fullTmpDir = path4.join(repoRoot, tmpDir);
+    await mkdir(fullTmpDir, { recursive: true });
+    const nextDir = path4.join(appDir, ".next");
+    if (existsSync(nextDir)) {
+      rmSync(nextDir, { recursive: true, force: true });
+      console.log("[runa dev] Cleaned .next cache for fresh start");
+    }
+    const result = await startAppBackground({
+      repoRoot,
+      appDir,
+      port,
+      env: process.env,
+      tmpDir: fullTmpDir,
+      mode: "dev",
+      stream,
+      bundler
+    });
+    await waitForAppReady({
+      port,
+      timeoutSeconds: 120,
+      tmpDir: fullTmpDir
+    });
+    return result;
+  }
+);
+var shutdownActor = fromPromise(
+  async ({ input }) => {
+    const { pid } = input;
+    if (pid > 0) {
+      await terminateAppProcessByPid({
+        pid,
+        logger: consoleLogger
+      });
+    }
+  }
+);
+
+// src/commands/dev/guards.ts
+init_esm_shims();
+function shouldSkipDb({ context }) {
+  return context.input.skipDb || !context.hasDatabase;
+}
+function shouldSkipApp({ context }) {
+  return context.input.skipApp;
+}
+var guards = {
+  shouldSkipDb,
+  shouldSkipApp
+};
+
+// src/commands/dev/types.ts
+init_esm_shims();
+function createOutput(context) {
+  return {
+    success: context.error === null,
+    exitCode: context.error ? 1 : 0,
+    appPid: context.appPid ?? void 0,
+    supabaseStarted: context.supabaseStarted,
+    error: context.error ?? void 0
+  };
+}
+
+// src/commands/dev/machine.ts
+var e2eMeta = {
+  idle: {
+    description: "Waiting for START event to begin dev workflow",
+    severity: "non-critical",
+    observables: {
+      log: "Starting dev"
+    },
+    assertions: ["expect(log).toContain('Starting dev')", "expect(state).toBe('idle')"],
+    nextStates: ["processCheck"]
+  },
+  processCheck: {
+    description: "Check for existing runa dev process and port availability",
+    severity: "blocking",
+    observables: {
+      log: "Checking for existing processes"
+    },
+    assertions: ["expect(log).toContain('Checking for existing processes')"],
+    nextStates: ["setup", "failed"]
+  },
+  setup: {
+    description: "Setup phase: deps, env, Supabase",
+    severity: "blocking",
+    observables: {
+      log: "Setup"
+    },
+    assertions: ["expect(log).toContain('Setup')"],
+    nextStates: ["appStart", "running", "failed"]
+  },
+  appStart: {
+    description: "Start Next.js dev server",
+    severity: "blocking",
+    observables: {
+      log: "Starting app",
+      process: "Next.js dev server process started"
+    },
+    assertions: ["expect(log).toContain('Starting app')", "expect(ctx.appPid).toBeGreaterThan(0)"],
+    nextStates: ["running", "failed"]
+  },
+  running: {
+    description: "Dev server running until STOP signal",
+    severity: "non-critical",
+    observables: {
+      log: "Dev server running",
+      http: "http://localhost:3000 responding"
+    },
+    assertions: ["expect(log).toContain('Dev server running')"],
+    nextStates: ["shutdown"]
+  },
+  shutdown: {
+    description: "Gracefully shutdown dev server",
+    severity: "blocking",
+    observables: {
+      log: "Shutting down",
+      process: "Dev server process terminated"
+    },
+    assertions: ["expect(log).toContain('Shutting down')"],
+    nextStates: ["done"]
+  },
+  done: {
+    description: "Dev workflow completed successfully",
+    severity: "final",
+    observables: {
+      exit: 0
+    },
+    assertions: ["expect(exitCode).toBe(0)"],
+    nextStates: []
+  },
+  failed: {
+    description: "Dev workflow failed with error",
+    severity: "final",
+    observables: {
+      exit: 1
+    },
+    assertions: ["expect(exitCode).toBe(1)"],
+    nextStates: []
+  }
+};
+function normalizeDevMachineInput(input) {
+  const normalizedInput = DevInputSchema.parse(input?.input ?? {});
+  const repoRoot = input?.repoRoot ?? normalizedInput.targetDir ?? process.cwd();
+  return {
+    input: normalizedInput,
+    repoRoot
+  };
+}
+var devMachine = setup({
+  types: {},
+  actors: {
+    processCheck: processCheckActor,
+    depsInstall: depsInstallActor,
+    envCheck: envCheckActor,
+    supabaseStart: supabaseStartActor,
+    appStart: appStartActor,
+    shutdown: shutdownActor
+  },
+  guards: {
+    shouldSkipDb: guards.shouldSkipDb,
+    shouldSkipApp: guards.shouldSkipApp
+  }
+}).createMachine({
+  id: "dev",
+  initial: "idle",
+  context: ({ input }) => {
+    const normalizedInput = normalizeDevMachineInput(input);
+    const repoRoot = normalizedInput.repoRoot;
+    return {
+      input: normalizedInput.input,
+      repoRoot,
+      tmpDir: ".runa/tmp/dev",
+      hasDatabase: detectDatabase(repoRoot),
+      appPid: null,
+      supabaseStarted: false,
+      staleProcessRecovered: false,
+      startTime: Date.now(),
+      error: null
+    };
+  },
+  states: {
+    // ============================================================
+    // Idle State
+    // ============================================================
+    idle: {
+      meta: { e2e: e2eMeta.idle },
+      on: {
+        START: { target: "processCheck" }
+      }
+    },
+    // ============================================================
+    // Process Check Phase
+    // ============================================================
+    processCheck: {
+      meta: { e2e: e2eMeta.processCheck },
+      invoke: {
+        src: "processCheck",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          tmpDir: context.tmpDir,
+          port: context.input.port,
+          replace: context.input.replace,
+          skipApp: context.input.skipApp
+        }),
+        onDone: {
+          target: "setup",
+          actions: assign({
+            staleProcessRecovered: ({ event }) => {
+              const output = event.output;
+              return output?.staleProcessRecovered ?? false;
+            }
+          })
+        },
+        onError: {
+          target: "failed",
+          actions: assign({
+            error: ({ event }) => event.error instanceof Error ? event.error.message : String(event.error)
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Setup Phase
+    // ============================================================
+    setup: {
+      meta: { e2e: e2eMeta.setup },
+      initial: "depsInstall",
+      states: {
+        depsInstall: {
+          invoke: {
+            src: "depsInstall",
+            input: ({ context }) => ({
+              repoRoot: context.repoRoot,
+              verbose: context.input.verbose
+            }),
+            onDone: { target: "envCheck" },
+            onError: {
+              target: "#dev.failed",
+              actions: assign({
+                error: ({ event }) => `Dependencies install failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`
+              })
+            }
+          }
+        },
+        envCheck: {
+          invoke: {
+            src: "envCheck",
+            input: ({ context }) => ({
+              repoRoot: context.repoRoot,
+              verbose: context.input.verbose
+            }),
+            onDone: { target: "supabaseStart" },
+            onError: { target: "supabaseStart" }
+            // Non-blocking
+          }
+        },
+        supabaseStart: {
+          always: [{ guard: "shouldSkipDb", target: "done" }],
+          invoke: {
+            src: "supabaseStart",
+            input: ({ context }) => ({
+              repoRoot: context.repoRoot,
+              verbose: context.input.verbose
+            }),
+            onDone: {
+              target: "done",
+              actions: assign({
+                supabaseStarted: ({ event }) => event.output.started || event.output.alreadyRunning
+              })
+            },
+            onError: { target: "done" }
+            // Non-blocking
+          }
+        },
+        done: {
+          type: "final"
+        }
+      },
+      onDone: [{ guard: "shouldSkipApp", target: "running" }, { target: "appStart" }]
+    },
+    // ============================================================
+    // App Start Phase
+    // ============================================================
+    appStart: {
+      meta: { e2e: e2eMeta.appStart },
+      invoke: {
+        src: "appStart",
+        input: ({ context }) => {
+          const detected = detectApp(context.repoRoot);
+          return {
+            repoRoot: context.repoRoot,
+            appDir: detected?.appDir ?? context.repoRoot,
+            port: context.input.port,
+            tmpDir: context.tmpDir,
+            stream: context.input.stream,
+            bundler: context.input.bundler
+          };
+        },
+        onDone: {
+          target: "running",
+          actions: assign({
+            appPid: ({ event }) => event.output.pid
+          })
+        },
+        onError: {
+          target: "failed",
+          actions: assign({
+            error: ({ event }) => `App start failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Running State (waiting for STOP signal)
+    // ============================================================
+    running: {
+      meta: { e2e: e2eMeta.running },
+      on: {
+        STOP: { target: "shutdown" }
+      }
+    },
+    // ============================================================
+    // Shutdown Phase
+    // ============================================================
+    shutdown: {
+      meta: { e2e: e2eMeta.shutdown },
+      invoke: {
+        src: "shutdown",
+        input: ({ context }) => ({
+          pid: context.appPid ?? 0
+        }),
+        onDone: { target: "done" },
+        onError: { target: "done" }
+        // Still exit on error
+      }
+    },
+    // ============================================================
+    // Final States
+    // ============================================================
+    done: {
+      meta: { e2e: e2eMeta.done },
+      type: "final"
+    },
+    failed: {
+      meta: { e2e: e2eMeta.failed },
+      type: "final"
+    }
+  },
+  output: ({ context }) => createOutput(context)
+});
+function getStateName(snapshot) {
+  if (typeof snapshot.value === "string") {
+    return snapshot.value;
+  }
+  const topLevel = Object.keys(snapshot.value)[0];
+  if (topLevel && typeof snapshot.value === "object") {
+    const nested = snapshot.value[topLevel];
+    if (nested && typeof nested === "string") {
+      return `${topLevel}.${nested}`;
+    }
+  }
+  return topLevel ?? "unknown";
+}
+function isComplete(snapshot) {
+  return snapshot.status === "done";
+}
+
+// src/commands/dev/commands/dev.ts
+var stateLogHandlers = {
+  idle: (logger) => {
+    logger.section("Dev Server");
+    logger.info("Starting development environment...");
+  },
+  processCheck: (logger) => {
+    logger.info("Checking for existing processes...");
+  },
+  setup: (logger) => {
+    logger.section("Phase 0: Setup");
+    logger.info("Checking environment prerequisites...");
+  },
+  "setup.depsInstall": (logger) => {
+    logger.info("  Checking dependencies...");
+  },
+  "setup.envCheck": (logger) => {
+    logger.info("  Checking environment variables...");
+  },
+  "setup.supabaseStart": (logger) => {
+    logger.info("  Starting Supabase...");
+  },
+  appStart: (logger) => {
+    logger.section("Phase 1: App Start");
+    logger.info("Starting Next.js dev server...");
+  },
+  running: (logger, context) => {
+    logger.section("Development Server Running");
+    logger.success(`App running at http://localhost:${context?.port ?? 3e3}`);
+    logger.info("");
+    logger.info("Press Ctrl+C to stop");
+  },
+  shutdown: (logger) => {
+    logger.info("");
+    logger.section("Shutting Down");
+    logger.info("Stopping dev server...");
+  }
+};
+function handleStateChange(snapshot, prevState, logger, port) {
+  const state = getStateName(snapshot);
+  if (state === prevState) return;
+  const handler = stateLogHandlers[state] ?? stateLogHandlers[state.split(".")[0]];
+  if (handler) {
+    handler(logger, { port });
+  }
+  if (prevState === "processCheck" && state.startsWith("setup") && snapshot.context.staleProcessRecovered) {
+    logger.success("  Stale process recovered. Port is now available.");
+  }
+}
+function printSummary(logger, output) {
+  if (output.success) {
+    logger.success("Dev server stopped successfully");
+  } else {
+    logger.error(`Dev server failed: ${output.error}`);
+  }
+}
+function shouldWritePortBridge(snapshot, previousState, currentState) {
+  return previousState.startsWith("setup") && (currentState === "appStart" || currentState === "running") && snapshot.context.supabaseStarted;
+}
+function logPortBridgeResult(logger, bridgeResult) {
+  if (bridgeResult.written) {
+    logger.info(
+      `  \u2192 .env.local written (port override: api=${bridgeResult.ports.api}, db=${bridgeResult.ports.db})`
+    );
+    return;
+  }
+  if (bridgeResult.reason === "user-managed") {
+    logger.warn("  \u2192 .env.local exists but is user-managed; port override skipped");
+  }
+}
+function tryWritePortBridge(snapshot, previousState, currentState, logger) {
+  if (!shouldWritePortBridge(snapshot, previousState, currentState)) {
+    return;
+  }
+  try {
+    const bridgeResult = writeEnvLocalBridge(
+      snapshot.context.repoRoot,
+      detectLocalSupabasePorts(snapshot.context.repoRoot)
+    );
+    logPortBridgeResult(logger, bridgeResult);
+  } catch {
+  }
+}
+function resolveOutputIfComplete(snapshot, resolve) {
+  if (!isComplete(snapshot)) return;
+  const output = snapshot.output;
+  if (output) {
+    resolve(output);
+  }
+}
+function findRepoRoot(startDir) {
+  let current = startDir;
+  while (current !== path4.dirname(current)) {
+    if (existsSync(path4.join(current, "turbo.json"))) {
+      return current;
+    }
+    const pkgPath = path4.join(current, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.workspaces) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    current = path4.dirname(current);
+  }
+  return startDir;
+}
+async function runDevMachine(input, logger) {
+  const repoRoot = input.targetDir ?? findRepoRoot(process.cwd());
+  return new Promise((resolve, reject) => {
+    const actor = createActor(devMachine, {
+      input: { input, repoRoot }
+    });
+    let previousState = "";
+    actor.subscribe((snapshot) => {
+      const currentState = getStateName(snapshot);
+      if (currentState !== previousState) {
+        handleStateChange(snapshot, previousState, logger, input.port);
+        tryWritePortBridge(snapshot, previousState, currentState, logger);
+        previousState = currentState;
+      }
+      resolveOutputIfComplete(snapshot, resolve);
+    });
+    actor.subscribe({
+      error: (error) => {
+        reject(error);
+        actor.stop();
+      }
+    });
+    const handleSignal = () => {
+      logger.info("");
+      logger.info("Received shutdown signal...");
+      actor.send({ type: "STOP" });
+    };
+    process.on("SIGINT", handleSignal);
+    process.on("SIGTERM", handleSignal);
+    actor.start();
+    actor.send({ type: "START" });
+  });
+}
+async function runDevAction(options, cmd) {
+  const logger = createCLILogger("dev");
+  try {
+    const result = await runDevMachine(options, logger);
+    printSummary(logger, result);
+    emitJsonSuccess(cmd, DevOutputSchema, result);
+    if (!result.success) {
+      throw new CLIError(result.error ?? "Dev server failed", "DEV_FAILED", [
+        "Check logs in .runa/tmp/dev/ for details",
+        "Run with --verbose for more output"
+      ]);
+    }
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      error instanceof Error ? error.message : String(error),
+      "DEV_ERROR",
+      ["Run with --verbose for more details"],
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+var devCommand = new Command("dev").description("Start development server (Supabase + Next.js)").option("--port <number>", "Port for Next.js dev server", (val) => Number.parseInt(val, 10), 3e3).option("--skip-db", "Skip Supabase start").option("--skip-app", "Start Supabase only (no app server)").option("--verbose", "Show detailed output").option("--no-stream", "Disable streaming app output to terminal (log to file only)").option("--target-dir <path>", "Target directory (defaults to repo root)").option("--replace", "Replace existing runa dev process if already running").option("--bundler <type>", "Bundler for Next.js dev server (turbopack or webpack)").action(async (options, cmd) => {
+  const input = {
+    port: options.port,
+    skipDb: options.skipDb ?? false,
+    skipApp: options.skipApp ?? false,
+    verbose: options.verbose ?? false,
+    stream: options.stream ?? true,
+    targetDir: options.targetDir,
+    replace: options.replace ?? false,
+    bundler: options.bundler
+  };
+  await runDevAction(input, cmd);
+});
+
+export { devCommand };