@akanjs/cli 3.0.0-alpha.88 → 3.0.0-alpha.89

package/{index-a6c5pc4p.js → index-d61rcfa2.js}

@@ -2,16 +2,16 @@
 import {
   runner,
   script
-} from "./index-ft1sfjz0.js";
+} from "./index-cezy7yb3.js";
 import {
   WorkspaceExecutor,
   AppExecutor,
   LibExecutor,
   PkgExecutor
-} from "./index-k1n0h7dk.js";
+} from "./index-q8sn827n.js";
 import {
   LibraryScript
-} from "./index-xxe90kqy.js";
+} from "./index-zkvpaggp.js";
 import {
   HmrWatcher,
   WatchRootResolver
@@ -19,11 +19,21 @@ import {
 import {
   SlicePlanner,
   formatSlicePlan
-} from "./index-m9c7k0gm.js";
+} from "./index-pvb4vdwr.js";
 import {
   resolveMobileTargets
 } from "./index-47pj3aee.js";
 
+// pkgs/@akanjs/cli/openBrowser.ts
+import { spawn } from "child_process";
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
+  const child = spawn(command[0], command.slice(1), { detached: true, stdio: "ignore" });
+  child.on("error", () => {});
+  child.unref();
+  return Promise.resolve();
+}
+
 // pkgs/@akanjs/devkit/applicationBuildReporter.ts
 import { Logger } from "akanjs/common";
 
@@ -71,7 +81,7 @@ Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
 
 // pkgs/@akanjs/cli/application/application.script.ts
 import { confirm } from "@inquirer/prompts";
-import { Logger as Logger5 } from "akanjs/common";
+import { Logger as Logger6 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/application/application.runner.ts
 import path5 from "path";
@@ -239,6 +249,8 @@ class IncrementalBuilderHost {
   app;
   ready = false;
   #onMessage;
+  #stdio;
+  #onOutput;
   #proc = null;
   #status = "stopped";
   #restartAttempts = 0;
@@ -249,11 +261,13 @@ class IncrementalBuilderHost {
   #manualStop = false;
   #inFlight = new Map;
   #startOptions = {};
-  constructor({ app, entry, env, onMessage }) {
+  constructor({ app, entry, env, stdio = "inherit", onMessage, onOutput }) {
     this.app = app;
     this.entry = entry;
     this.env = env;
+    this.#stdio = stdio;
     this.#onMessage = onMessage;
+    this.#onOutput = onOutput ?? null;
   }
   get status() {
     return this.#status;
@@ -279,7 +293,7 @@ class IncrementalBuilderHost {
     proc = Bun.spawn(["bun", this.entry], {
       cwd: this.app.cwdPath,
       env: { ...this.env, AKAN_WATCH: "1", ...afterRecycle ? { AKAN_BUILDER_ANNOUNCE_BOOT: "1" } : {} },
-      stdio: ["ignore", "inherit", "inherit"],
+      stdio: ["ignore", this.#stdio, this.#stdio],
       ipc: (msg) => {
         if (this.#proc !== proc)
           return;
@@ -327,8 +341,24 @@ class IncrementalBuilderHost {
       }
     });
     this.#proc = proc;
+    if (this.#stdio === "pipe" && this.#onOutput) {
+      this.#drain(proc.stdout, "stdout");
+      this.#drain(proc.stderr, "stderr");
+    }
     this.logger.verbose(`builder spawned pid=${proc.pid} entry=${this.entry}${isRestart ? " restart=1" : ""}`);
   }
+  async#drain(stream, kind) {
+    if (!stream)
+      return;
+    const decoder = new TextDecoder;
+    try {
+      for await (const chunk of stream) {
+        const text = decoder.decode(chunk, { stream: true });
+        if (text)
+          this.#onOutput?.(kind, text);
+      }
+    } catch {}
+  }
   #scheduleRestart() {
     if (this.#manualStop || this.#restartTimer)
       return;
@@ -424,7 +454,10 @@ class IncrementalBuilderHost {
     this.ready = false;
     this.#status = "stopped";
   }
-  static async create(app, env, onMessage) {
+  static async create(app, env, onMessage, {
+    stdio = "inherit",
+    onOutput
+  } = {}) {
     const candidates = [
       path.join(app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
       path.join(app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
@@ -433,7 +466,7 @@ class IncrementalBuilderHost {
     ];
     for (const c of candidates)
       if (await Bun.file(c).exists())
-        return new IncrementalBuilderHost({ app, entry: c, env, onMessage });
+        return new IncrementalBuilderHost({ app, entry: c, env, stdio, onMessage, onOutput });
     throw new Error(`[cli] frontend builder entry not found; looked in: ${candidates.join(", ")}`);
   }
 }
@@ -502,6 +535,15 @@ var shouldRestartBuilderByDevPlan = (message) => message.devPlan?.actions.includ
 var shouldAbandonBackendRecovery = (attempts, maxAttempts = BACKEND_RECOVERY_MAX_ATTEMPTS) => attempts >= maxAttempts;
 var normalizeBackendReportedGeneration = (generation) => generation >= 0 ? generation : undefined;
 var shouldRestartDevHostByDevPlan = (message) => message.devPlan?.actions.includes("restart-dev-host") ?? message.kinds.includes("config");
+var devHostStateByBackendState = {
+  starting: "starting",
+  ready: "ready",
+  "restart-pending": "restarting",
+  recovering: "recovering",
+  stopping: "stopped",
+  stopped: "stopped"
+};
+var devHostStateOf = (state, gaveUp) => state === "stopped" && gaveUp ? "failed" : devHostStateByBackendState[state];
 var RESTART_ROLE_ORDER = ["server", "shared", "barrel", "config"];
 var generationValue = (generation) => generation ?? -1;
 var isLegacyBackendFallbackFile = (file, workspaceRoot) => {
@@ -826,8 +868,10 @@ var BUILDER_RECOVERY_MAX_DELAY_MS = 60000;
 class AkanAppHost {
   app;
   logger = new Logger3("AkanAppHost");
-  withInk;
+  stdio;
   env;
+  #onDevEvent;
+  #lastDevState = null;
   #backend = null;
   #builder = null;
   #backendReady = false;
@@ -866,12 +910,23 @@ class AkanAppHost {
   #builderGapStamp = null;
   #pendingBuilderMessages = [];
   #builderRequests = new BuilderRequestRouter;
-  constructor(app, { env, withInk = false }) {
+  constructor(app, {
+    env,
+    stdio = "inherit",
+    onDevEvent
+  }) {
     this.app = app;
     this.env = env;
-    this.withInk = withInk;
+    this.stdio = stdio;
+    this.#onDevEvent = onDevEvent ?? null;
     this.#backendGraph = new BackendImportGraph(app, this.logger);
   }
+  #emitDevEvent(state, detail) {
+    if (!this.#onDevEvent || state === this.#lastDevState)
+      return;
+    this.#lastDevState = state;
+    this.#onDevEvent({ app: this.app.name, state, ...detail ? { detail } : {} });
+  }
   async start() {
     if (this.#backend)
       await this.#stopBackend();
@@ -926,7 +981,7 @@ class AkanAppHost {
     this.#backendStderrTail = [];
     const backend = Bun.spawn(["bun", `apps/${this.app.name}/main.ts`], {
       cwd: this.app.workspace.workspaceRoot,
-      stdio: this.withInk ? ["ignore", "pipe", "pipe"] : ["inherit", "inherit", "inherit"],
+      stdio: this.stdio === "pipe" ? ["ignore", "pipe", "pipe"] : ["inherit", "inherit", "inherit"],
       env: this.env,
       ipc: (msg) => {
         if (!msg || typeof msg !== "object")
@@ -967,7 +1022,7 @@ class AkanAppHost {
     });
     this.#backend = backend;
     this.logger.verbose(`backend spawned pid=${backend.pid}`);
-    if (this.withInk) {
+    if (this.stdio === "pipe") {
       this.#forwardBackendStream(backend.stderr, "stderr");
       this.#forwardBackendStream(backend.stdout, "stdout");
     }
@@ -988,14 +1043,13 @@ class AkanAppHost {
     try {
       for await (const chunk of stream) {
         const text = decoder.decode(chunk, { stream: true });
-        if (!text.trim())
+        if (!text)
           continue;
         if (kind === "stderr") {
           this.#recordBackendStderr(text);
-          this.logger.warn(`[backend] ${text.trimEnd()}`);
-        } else {
-          this.logger.verbose(`[backend] ${text.trimEnd()}`);
-        }
+          process.stderr.write(text);
+        } else
+          process.stdout.write(text);
       }
     } catch {}
   }
@@ -1042,6 +1096,7 @@ class AkanAppHost {
     const prev = this.#backendLifecycleState;
     this.#backendLifecycleState = next;
     this.logger.verbose(`[backend-lifecycle] ${prev} -> ${next}${detail ? ` ${detail}` : ""}`);
+    this.#emitDevEvent(devHostStateOf(next, this.#backendGaveUp), detail);
   }
   #sendToBackend(message) {
     if (!this.#backend || !this.#backendReady) {
@@ -1371,6 +1426,7 @@ ${this.#backendStderrTail.join(`
       return;
     }
     this.#suspended = true;
+    this.#emitDevEvent("suspended", `idle ${Math.round(idleMs / 1000)}s`);
     this.#stopBuilder();
     this.#openBuilderGap("idle suspend");
     this.logger.info(`[idle-suspend] no build activity for ${Math.round(idleMs / 1000)}s; released the builder \u2014 the next edit or route request brings it back`);
@@ -1435,6 +1491,7 @@ ${this.#backendStderrTail.join(`
       this.#wokeAtMono = performance.now();
       this.#flushPendingBuilderMessages();
       this.#armIdleSuspend();
+      this.#emitDevEvent(devHostStateOf(this.#backendLifecycleState, this.#backendGaveUp));
     }
   }
   async#applyIdleWake(batch) {
@@ -1771,6 +1828,9 @@ ${this.#backendStderrTail.join(`
     for (let attempt = 1;attempt <= BUILDER_START_MAX_ATTEMPTS; attempt++) {
       this.#builder = await IncrementalBuilderHost.create(this.app, this.env, (msg) => {
         this.#enqueueBuilderMessage(msg);
+      }, {
+        stdio: this.stdio,
+        onOutput: (kind, text) => void (kind === "stderr" ? process.stderr : process.stdout).write(text)
       });
       try {
         await this.#waitForBuilderReady(attempt, { announceBootState });
@@ -1904,22 +1964,10 @@ ${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
 // pkgs/@akanjs/cli/application/application.runner.ts
 import { Logger as Logger4 } from "akanjs/common";
 import ora from "ora";
-
-// pkgs/@akanjs/cli/openBrowser.ts
-import { spawn } from "child_process";
-function openBrowser(url) {
-  const command = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
-  const child = spawn(command[0], command.slice(1), { detached: true, stdio: "ignore" });
-  child.on("error", () => {});
-  child.unref();
-  return Promise.resolve();
-}
-
-// pkgs/@akanjs/cli/application/application.runner.ts
-var loadBuildRunner = async () => (await import("./applicationBuildRunner-27wyznpv.js")).ApplicationBuildRunner;
-var loadReleasePackager = async () => (await import("./applicationReleasePackager-ktjt0erc.js")).ApplicationReleasePackager;
-var loadCapacitorApp = async () => (await import("./capacitorApp-kwa67kzs.js")).CapacitorApp;
-var loadAbstractCompactor = async () => (await import("./abstractCompactor-pwc6d6yk.js")).AbstractCompactor;
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-b21m07fs.js")).ApplicationBuildRunner;
+var loadReleasePackager = async () => (await import("./applicationReleasePackager-3wh58n2m.js")).ApplicationReleasePackager;
+var loadCapacitorApp = async () => (await import("./capacitorApp-gzcx6txb.js")).CapacitorApp;
+var loadAbstractCompactor = async () => (await import("./abstractCompactor-cefxzggj.js")).AbstractCompactor;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
@@ -2086,9 +2134,14 @@ try {
   } = {}) {
     return new (await loadBuildRunner())(app, { fast, reporter }).build({ spinner });
   }
-  async start(app, { open = false, onStart, withInk = false } = {}) {
+  async start(app, {
+    open = false,
+    onStart,
+    onDevEvent,
+    stdio = "inherit"
+  } = {}) {
     const { env } = await app.prepareCommand("start");
-    const appHost = await new AkanAppHost(app, { env, withInk }).start();
+    const appHost = await new AkanAppHost(app, { env, stdio, onDevEvent }).start();
     onStart?.();
     if (open)
       setTimeout(() => openBrowser(`http://localhost:${env.AKAN_PUBLIC_CLIENT_PORT ?? env.PORT ?? "8282"}`), 3000);
@@ -2320,6 +2373,444 @@ ${detail}`
   }
 }
 
+// pkgs/@akanjs/cli/application/devPortReclaimer.ts
+class DevPortReclaimer {
+  static lsofTimeoutMs = 3000;
+  static releaseTimeoutMs = 8000;
+  static maxAncestorDepth = 8;
+  static #releasePollMs = 100;
+  static wsPortOffset = 1e4;
+  static portsFor(ports) {
+    return [...new Set(ports.flatMap((port) => [port, port + DevPortReclaimer.wsPortOffset]))].sort((left, right) => left - right);
+  }
+  static isAkanCommand(command) {
+    return /(^|\/)akan(\s|$)/.test(command) || command.includes("@akanjs/cli") || command.includes("akanjs/server") || /\bapps\/[^/\s]+\/main\.ts\b/.test(command) || command.includes("incrementalBuilder.proc") || command.includes("rscWorker");
+  }
+  async reclaim(ports) {
+    const killed = [];
+    const foreign = [];
+    const seen = new Set;
+    for (const port of DevPortReclaimer.portsFor(ports)) {
+      for (const holder of await this.holdersOf(port)) {
+        if (seen.has(holder.pid))
+          continue;
+        seen.add(holder.pid);
+        if (!holder.akan) {
+          foreign.push(holder);
+          continue;
+        }
+        if (await this.#terminate(holder.pid))
+          killed.push(holder);
+        else
+          foreign.push(holder);
+      }
+    }
+    return { killed, foreign };
+  }
+  async holdersOf(port) {
+    const holders = [];
+    for (const listenerPid of await this.#pidsOn(port)) {
+      if (listenerPid === process.pid || listenerPid === process.ppid)
+        continue;
+      const command = await this.#commandOf(listenerPid);
+      if (!command)
+        continue;
+      if (!DevPortReclaimer.isAkanCommand(command)) {
+        holders.push({ pid: listenerPid, command, port, listenerPid, akan: false });
+        continue;
+      }
+      const root = await this.#akanRootOf(listenerPid, command);
+      holders.push({ pid: root.pid, command: root.command, port, listenerPid, akan: true });
+    }
+    return holders;
+  }
+  async#akanRootOf(pid, command) {
+    let root = { pid, command };
+    for (let depth = 0;depth < DevPortReclaimer.maxAncestorDepth; depth += 1) {
+      const parentPid = await this.#ppidOf(root.pid);
+      if (parentPid === null || parentPid <= 1 || parentPid === process.pid || parentPid === process.ppid)
+        break;
+      const parentCommand = await this.#commandOf(parentPid);
+      if (!parentCommand || !DevPortReclaimer.isAkanCommand(parentCommand))
+        break;
+      root = { pid: parentPid, command: parentCommand };
+    }
+    return root;
+  }
+  async#ppidOf(pid) {
+    const output = await this.#run(["ps", "-p", String(pid), "-o", "ppid="]);
+    const parsed = Number(output.trim());
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+  async#pidsOn(port) {
+    const output = await this.#run(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"]);
+    return [
+      ...new Set(output.split(`
+`).map((line) => Number(line.trim())).filter((pid) => Number.isInteger(pid) && pid > 0))
+    ];
+  }
+  async#commandOf(pid) {
+    const output = await this.#run(["ps", "-p", String(pid), "-o", "command="]);
+    return output.trim() || null;
+  }
+  async#terminate(pid) {
+    if (!this.#signal(pid, "SIGTERM"))
+      return !this.#alive(pid);
+    const deadline = Date.now() + DevPortReclaimer.releaseTimeoutMs;
+    while (Date.now() < deadline) {
+      if (!this.#alive(pid))
+        return true;
+      await Bun.sleep(DevPortReclaimer.#releasePollMs);
+    }
+    this.#signal(pid, "SIGKILL");
+    await Bun.sleep(DevPortReclaimer.#releasePollMs);
+    return !this.#alive(pid);
+  }
+  #signal(pid, signal) {
+    try {
+      process.kill(pid, signal);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  #alive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  }
+  async#run(command) {
+    const proc = Bun.spawn(command, { stdio: ["ignore", "pipe", "ignore"] });
+    const timer = setTimeout(() => proc.kill("SIGKILL"), DevPortReclaimer.lsofTimeoutMs);
+    try {
+      return await new Response(proc.stdout).text();
+    } catch {
+      return "";
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+// pkgs/@akanjs/cli/application/devStreamView.ts
+import { Logger as Logger5 } from "akanjs/common";
+import chalk from "chalk";
+var appColors = ["cyan", "magenta", "yellow", "green", "blue", "red"];
+
+class DevStreamView {
+  #logger = new Logger5("akan start");
+  #partial = new Map;
+  #lastState = new Map;
+  #color = new Map;
+  #width = 0;
+  constructor(appNames) {
+    this.#width = appNames.reduce((max, name) => Math.max(max, name.length), 0);
+    appNames.forEach((name, idx) => {
+      this.#color.set(name, appColors[idx % appColors.length] ?? "cyan");
+    });
+  }
+  onOutput = (app, kind, text) => {
+    const key = `${app}:${kind}`;
+    const pending = `${this.#partial.get(key) ?? ""}${text}`;
+    const lines = pending.split(`
+`);
+    this.#partial.set(key, lines.pop() ?? "");
+    if (lines.length === 0)
+      return;
+    const prefixed = lines.map((line) => `${this.#prefix(app)}${line}`).join(`
+`);
+    (kind === "stderr" ? process.stderr : process.stdout).write(`${prefixed}
+`);
+  };
+  onStatus = (statuses) => {
+    for (const status of statuses) {
+      if (this.#lastState.get(status.name) === status.state)
+        continue;
+      this.#lastState.set(status.name, status.state);
+      const detail = status.detail ? ` (${status.detail})` : "";
+      const where = status.state === "ready" ? ` \u2014 ${status.url}` : "";
+      const line = `${status.name} ${status.state}${detail}${where}`;
+      if (status.state === "failed")
+        this.#logger.error(line);
+      else if (status.state === "stopped")
+        this.#logger.warn(line);
+      else
+        this.#logger.info(line);
+    }
+  };
+  onNote = (text, level) => {
+    if (level === "warn")
+      this.#logger.warn(text);
+    else
+      this.#logger.info(text);
+  };
+  waitForExit = () => new Promise(() => {
+    return;
+  });
+  close = () => {
+    for (const [key, remainder] of this.#partial) {
+      if (!remainder)
+        continue;
+      const app = key.slice(0, key.lastIndexOf(":"));
+      process.stdout.write(`${this.#prefix(app)}${remainder}
+`);
+    }
+    this.#partial.clear();
+  };
+  #prefix(app) {
+    const color = this.#color.get(app) ?? "cyan";
+    return `${chalk[color](app.padEnd(this.#width))} ${chalk.dim("\u2502")} `;
+  }
+}
+
+// pkgs/@akanjs/cli/application/devSupervisor.ts
+class DevSupervisor {
+  static supervisedEnvKey = "AKAN_DEV_SUPERVISED";
+  static childHooks() {
+    if (process.env[DevSupervisor.supervisedEnvKey] !== "1" || !process.send)
+      return {};
+    const send = process.send.bind(process);
+    return {
+      stdio: "pipe",
+      onDevEvent: (event) => {
+        try {
+          send(event);
+        } catch {}
+      }
+    };
+  }
+  static readyTimeoutMs = 180000;
+  static shutdownGraceMs = 12000;
+  #options;
+  #children = new Map;
+  #view = null;
+  #stopping = false;
+  constructor(options) {
+    this.#options = options;
+  }
+  get statuses() {
+    return [...this.#children.values()].map((child) => child.status);
+  }
+  async run(view) {
+    this.#view = view;
+    const ports = await this.#assignPorts();
+    for (const app of this.#options.apps)
+      this.#children.set(app.name, this.#makeChild(app, ports.get(app.name) ?? 0));
+    this.#publishStatus();
+    const stopped = this.#installSignalHandlers();
+    this.#bootInOrder();
+    await Promise.race([view.waitForExit(), stopped]);
+    await this.stop();
+    view.close?.();
+  }
+  async#assignPorts() {
+    const taken = new Set;
+    const ports = new Map;
+    for (const app of this.#options.apps) {
+      let port = await app.getDevPort();
+      while (taken.has(port))
+        port += 1;
+      taken.add(port);
+      ports.set(app.name, port);
+    }
+    return ports;
+  }
+  #makeChild(app, port) {
+    let markReady;
+    const ready = new Promise((resolve) => {
+      markReady = resolve;
+    });
+    return {
+      status: {
+        app,
+        name: app.name,
+        port,
+        url: `http://localhost:${port}`,
+        state: "starting",
+        detail: "queued",
+        exitCode: null
+      },
+      proc: null,
+      ready,
+      markReady,
+      opened: false
+    };
+  }
+  async#bootInOrder() {
+    const concurrency = Math.max(1, Math.trunc(this.#options.concurrency ?? 1));
+    const queue = [...this.#children.values()];
+    const waves = [];
+    for (let idx = 0;idx < queue.length; idx += concurrency)
+      waves.push(queue.slice(idx, idx + concurrency));
+    for (const wave of waves) {
+      if (this.#stopping)
+        return;
+      for (const child of wave)
+        this.#spawnChild(child);
+      this.#publishStatus();
+      await Promise.all(wave.map(async (child) => await this.#waitForReady(child)));
+    }
+  }
+  async#waitForReady(child) {
+    let timer = null;
+    const expired = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("expired"), DevSupervisor.readyTimeoutMs);
+    });
+    try {
+      if (await Promise.race([child.ready.then(() => "ready"), expired]) === "expired")
+        this.#note(`${child.status.name} has not reported ready after ${Math.round(DevSupervisor.readyTimeoutMs / 1000)}s; starting the next app anyway`, "warn");
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  static childArgs(name, { write = true } = {}) {
+    return [
+      "start",
+      name,
+      "--plain",
+      "--dbup",
+      "false",
+      "--write",
+      String(write)
+    ];
+  }
+  #spawnChild(child) {
+    const { app, name, port } = child.status;
+    const args = DevSupervisor.childArgs(name, { write: this.#options.write ?? true });
+    const proc = Bun.spawn([process.execPath, Bun.main, ...args], {
+      cwd: app.workspace.workspaceRoot,
+      env: {
+        ...process.env,
+        [DevSupervisor.supervisedEnvKey]: "1",
+        AKAN_PUBLIC_APP_NAME: name,
+        AKAN_DEV_PORT: String(port)
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      ipc: (message) => {
+        if (!message || typeof message !== "object" || typeof message.state !== "string")
+          return;
+        this.#applyChildEvent(child, message);
+      },
+      serialization: "advanced",
+      onExit: (_proc, exitCode, signalCode) => {
+        child.proc = null;
+        child.status.exitCode = exitCode;
+        if (this.#stopping)
+          return;
+        child.status.state = "stopped";
+        child.status.detail = signalCode ? `killed by ${signalCode}` : `exited with ${exitCode}`;
+        child.markReady();
+        this.#publishStatus();
+      }
+    });
+    child.proc = proc;
+    child.status.state = "starting";
+    child.status.detail = `pid ${proc.pid}`;
+    this.#drain(proc.stdout, name, "stdout");
+    this.#drain(proc.stderr, name, "stderr");
+  }
+  #applyChildEvent(child, event) {
+    child.status.state = event.state;
+    child.status.detail = event.detail ?? "";
+    if (event.state === "ready") {
+      child.markReady();
+      if (this.#options.open && !child.opened) {
+        child.opened = true;
+        openBrowser(child.status.url);
+      }
+    }
+    if (event.state === "failed")
+      child.markReady();
+    this.#publishStatus();
+  }
+  async#drain(stream, name, kind) {
+    const decoder = new TextDecoder;
+    try {
+      for await (const chunk of stream) {
+        const text = decoder.decode(chunk, { stream: true });
+        if (text)
+          this.#view?.onOutput(name, kind, text);
+      }
+    } catch {}
+  }
+  #publishStatus() {
+    this.#view?.onStatus(this.statuses);
+  }
+  #note(text, level) {
+    this.#view?.onNote(text, level);
+  }
+  #installSignalHandlers() {
+    return new Promise((resolve) => {
+      let asked = false;
+      const onSignal = () => {
+        if (asked) {
+          this.#note("abandoning the wait; children may be left running", "warn");
+          process.exit(130);
+        }
+        asked = true;
+        resolve();
+      };
+      process.on("SIGINT", onSignal);
+      process.on("SIGTERM", onSignal);
+    });
+  }
+  async restart(name) {
+    const child = this.#children.get(name);
+    if (!child || this.#stopping)
+      return;
+    const running = child.proc;
+    if (running) {
+      running.kill("SIGTERM");
+      await running.exited;
+    }
+    child.status.state = "starting";
+    child.status.detail = "restarting";
+    child.status.exitCode = null;
+    this.#publishStatus();
+    this.#spawnChild(child);
+    this.#publishStatus();
+  }
+  async stop() {
+    if (this.#stopping)
+      return;
+    this.#stopping = true;
+    const running = [...this.#children.values()].filter((child) => Boolean(child.proc));
+    for (const child of running)
+      child.proc.kill("SIGTERM");
+    const exited = Promise.all(running.map(async (child) => await child.proc.exited));
+    let timer = null;
+    const expired = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("expired"), DevSupervisor.shutdownGraceMs);
+    });
+    try {
+      if (await Promise.race([exited.then(() => "exited"), expired]) === "expired") {
+        for (const child of running) {
+          if (!child.proc.killed) {
+            this.#note(`${child.status.name} did not exit in time; killing it`, "warn");
+            child.proc.kill("SIGKILL");
+          }
+        }
+      }
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+}
+
+// pkgs/@akanjs/cli/application/devUiMode.ts
+var resolveDevUi = (plain, { isTty = !!process.stdout.isTTY, columns = process.stdout.columns ?? 0 } = {}) => {
+  if (plain)
+    return { mode: "stream", downgraded: false };
+  if (!isTty || columns <= 0)
+    return { mode: "stream", downgraded: true };
+  return { mode: "tui", downgraded: false };
+};
+
 // pkgs/@akanjs/cli/application/application.script.ts
 class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
   static dbShutdownTimeoutMs = 20000;
@@ -2403,7 +2894,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     spinner.succeed(`Application created in apps/${app.name}`);
     await app.scanSync();
     if (start)
-      await this.start(app, { open: true });
+      await this.startOne(app, { open: true });
   }
   async removeApplication(app) {
     const spinner = app.spinning("Removing application...");
@@ -2414,7 +2905,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     const spinner = app.spinning("Planning distributable slice...");
     const plan = await this.applicationRunner.planSlice(app);
     spinner.succeed(`Slice planned (${plan.libs.length} libs, ${plan.warnings.length} warnings)`);
-    Logger5.rawLog(format === "json" ? JSON.stringify(plan, null, 2) : formatSlicePlan(plan));
+    Logger6.rawLog(format === "json" ? JSON.stringify(plan, null, 2) : formatSlicePlan(plan));
   }
   async sync(sys) {
     if (sys.type === "app")
@@ -2425,13 +2916,13 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async compact(sys, { module = null, minLines, interactive = false } = {}) {
     const { scanned, reports } = await this.applicationRunner.compact(sys, { module, minLines, interactive });
     if (!reports.length) {
-      Logger5.rawLog(`No abstract file long enough to compact in ${sys.name} (${scanned} scanned)`);
+      Logger6.rawLog(`No abstract file long enough to compact in ${sys.name} (${scanned} scanned)`);
       return;
     }
     for (const report of reports)
-      Logger5.rawLog(`${report.status}: ${report.path} (${report.beforeLines} -> ${report.afterLines} lines)`);
+      Logger6.rawLog(`${report.status}: ${report.path} (${report.beforeLines} -> ${report.afterLines} lines)`);
     const compactedNum = reports.filter((report) => report.status === "compacted").length;
-    Logger5.rawLog(`Compacted ${compactedNum}/${reports.length} abstract files in ${sys.name}`);
+    Logger6.rawLog(`Compacted ${compactedNum}/${reports.length} abstract files in ${sys.name}`);
   }
   async script(app, filename) {
     const scriptFilename = filename ?? await this.applicationRunner.getScriptFilename(app);
@@ -2448,18 +2939,18 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async build(app, { write = true, fast = false, quiet = false } = {}) {
     await app.scanSync({ write });
     if (!quiet)
-      Logger5.rawLog(`Creating an optimized production build for ${app.name}...`);
+      Logger6.rawLog(`Creating an optimized production build for ${app.name}...`);
     try {
       const result = await this.applicationRunner.build(app, {
         fast,
         spinner: !quiet
       });
-      Logger5.rawLog(`${app.name} built in dist/apps/${app.name}`);
+      Logger6.rawLog(`${app.name} built in dist/apps/${app.name}`);
       if (!quiet)
         ApplicationBuildReporter.printSummary(result);
     } catch (error) {
-      Logger5.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
-      Logger5.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      Logger6.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
+      Logger6.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
       throw error;
     }
   }
@@ -2471,7 +2962,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       spinner.succeed(`${app.name} typechecked`);
     } catch (error) {
       spinner.fail(`${app.name} typecheck failed`);
-      Logger5.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      Logger6.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
       throw error;
     }
   }
@@ -2496,12 +2987,20 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     }
     await this.applicationRunner.test(exec);
   }
-  async start(app, {
-    open = false,
-    dbup = true,
-    withInk = false,
-    write = true
-  } = {}) {
+  async start(apps, { open = false, dbup = true, write = true, plain = false, kill = false, concurrency = 1 } = {}) {
+    const first = apps[0];
+    if (!first)
+      throw new Error("No app selected to start");
+    const { mode, downgraded } = resolveDevUi(plain);
+    if (downgraded)
+      first.workspace.log("no sized terminal to draw on; printing prefixed lines instead");
+    if (kill)
+      await this.reclaimDevPorts(apps);
+    if (mode === "stream" && apps.length === 1)
+      return await this.startOne(first, { open, dbup, write, ...DevSupervisor.childHooks() });
+    await this.#startMany(apps, { open, dbup, write, mode, concurrency });
+  }
+  async startOne(app, { open = false, dbup = true, stdio = "inherit", write = true, onDevEvent } = {}) {
     await app.scanSync({ write });
     const akanConfig = await app.getConfig();
     const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
@@ -2517,10 +3016,55 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       onStart: () => {
         spinner.succeed(`${app.name} prepared, ready to start`);
       },
-      withInk
+      onDevEvent,
+      stdio
     });
     return akanAppHost;
   }
+  async reclaimDevPorts(apps) {
+    const workspace = apps[0]?.workspace;
+    if (!workspace)
+      return;
+    const ports = await Promise.all(apps.map(async (app) => await app.getDevPort()));
+    const { killed, foreign } = await new DevPortReclaimer().reclaim(ports);
+    for (const holder of killed)
+      workspace.log(`freed port ${holder.port} \u2014 killed pid ${holder.pid} (${holder.command})`);
+    for (const holder of foreign)
+      Logger6.rawLog(`port ${holder.port} is held by pid ${holder.pid} and was left alone: ${holder.command}`, undefined, "error");
+    if (killed.length === 0 && foreign.length === 0)
+      workspace.log("dev ports are free; nothing to kill");
+  }
+  async#startMany(apps, { open, dbup, write, mode, concurrency }) {
+    const workspace = apps[0]?.workspace;
+    if (!workspace)
+      throw new Error("No app selected to start");
+    const startedDatabase = dbup ? await this.#prepareSharedDatabase(apps) : false;
+    const supervisor = new DevSupervisor({ apps, mode, concurrency, open, write });
+    const view = mode === "tui" ? await (await import("./devTuiView-7jy8f30g.js")).createDevTuiView(supervisor) : new DevStreamView(apps.map((app) => app.name));
+    await supervisor.run(view);
+    if (startedDatabase)
+      await this.#stopDatabase(workspace);
+  }
+  async#prepareSharedDatabase(apps) {
+    const workspace = apps[0]?.workspace;
+    if (!workspace)
+      return false;
+    const modes = new Set;
+    for (const app of apps) {
+      if (app.getEnv() !== "local")
+        continue;
+      const akanConfig = await app.getConfig();
+      const mode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
+      await this.syncDatabaseModeDependencies(app, akanConfig, mode);
+      if (mode !== "single")
+        modes.add(mode);
+    }
+    let started = false;
+    for (const mode of modes)
+      if (!await this.dbup(workspace, mode))
+        started = true;
+    return started;
+  }
   async buildIos(app, { write = true, target, env = "debug", regenerate = false } = {}) {
     await app.scanSync({ write });
     await this.applicationRunner.buildIos(app, { target, env, regenerate });
@@ -2618,7 +3162,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     let stopping = false;
     process.on("SIGINT", () => {
       if (stopping) {
-        Logger5.rawLog("Abandoning the local database teardown; containers are left running.", undefined, "error");
+        Logger6.rawLog("Abandoning the local database teardown; containers are left running.", undefined, "error");
         process.exit(130);
       }
       stopping = true;
@@ -2626,13 +3170,21 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     });
   }
   async#stopDatabase(workspace) {
-    const timeout = new Promise((resolve) => setTimeout(() => resolve("timeout"), ApplicationScript.dbShutdownTimeoutMs));
-    const result = await Promise.race([this.dbdown(workspace).catch(() => {
-      return;
-    }), timeout]);
-    if (result !== "timeout")
-      return;
-    Logger5.rawLog(`Local database did not stop within ${ApplicationScript.dbShutdownTimeoutMs}ms; run \`akan dbdown\` once Docker responds.`, undefined, "error");
+    let timer = null;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("timeout"), ApplicationScript.dbShutdownTimeoutMs);
+    });
+    try {
+      const result = await Promise.race([this.dbdown(workspace).catch(() => {
+        return;
+      }), timeout]);
+      if (result !== "timeout")
+        return;
+      Logger6.rawLog(`Local database did not stop within ${ApplicationScript.dbShutdownTimeoutMs}ms; run \`akan dbdown\` once Docker responds.`, undefined, "error");
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
   }
 }