webmux 0.17.0 → 0.19.0

package/bin/webmux.js

@@ -172,7 +172,10 @@ function listLocalGitBranches(cwd) {
 function readGitWorktreeStatus(cwd) {
   const dirtyOutput = runGit(["status", "--porcelain"], cwd);
   const commit = tryRunGit(["rev-parse", "HEAD"], cwd);
-  const ahead = tryRunGit(["rev-list", "--count", "@{upstream}..HEAD"], cwd);
+  let ahead = tryRunGit(["rev-list", "--count", "@{upstream}..HEAD"], cwd);
+  if (!ahead.ok) {
+    ahead = tryRunGit(["rev-list", "--count", "HEAD", "--not", "--remotes=origin"], cwd);
+  }
   return {
     dirty: dirtyOutput.length > 0,
     aheadCount: ahead.ok ? parseInt(ahead.stdout, 10) || 0 : 0,
@@ -271,9 +274,21 @@ class BunGitGateway {
     const result = tryRunGit(["diff", "HEAD", "--no-color"], cwd);
     return result.ok ? result.stdout : "";
   }
-  readUnpushedDiff(cwd) {
-    const result = tryRunGit(["diff", "@{upstream}..HEAD", "--no-color"], cwd);
-    return result.ok ? result.stdout : "";
+  listUnpushedCommits(cwd) {
+    let result = tryRunGit(["log", "--oneline", "@{upstream}..HEAD"], cwd);
+    if (!result.ok) {
+      result = tryRunGit(["log", "--oneline", "HEAD", "--not", "--remotes=origin"], cwd);
+    }
+    if (!result.ok || !result.stdout)
+      return [];
+    return result.stdout.split(`
+`).filter((line) => line.length > 0).map((line) => {
+      const spaceIdx = line.indexOf(" ");
+      return {
+        hash: line.slice(0, spaceIdx),
+        message: line.slice(spaceIdx + 1)
+      };
+    });
   }
 }
 var init_git = () => {};
@@ -9895,7 +9910,10 @@ function parseProjectConfig(parsed) {
         linkedRepos: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : isRecord3(parsed.integrations) && Array.isArray(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github) : []
       },
       linear: {
-        enabled: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled
+        enabled: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled,
+        autoCreateWorktrees: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.autoCreateWorktrees === "boolean" ? parsed.integrations.linear.autoCreateWorktrees : DEFAULT_CONFIG.integrations.linear.autoCreateWorktrees,
+        createTicketOption: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.createTicketOption === "boolean" ? parsed.integrations.linear.createTicketOption : DEFAULT_CONFIG.integrations.linear.createTicketOption,
+        ...isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.teamId === "string" && parsed.integrations.linear.teamId.trim() ? { teamId: parsed.integrations.linear.teamId.trim() } : {}
       }
     },
     lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
@@ -9905,21 +9923,39 @@ function parseProjectConfig(parsed) {
 function defaultConfig() {
   return parseProjectConfig({});
 }
+function parseLocalLinearOverlay(parsed) {
+  if (!isRecord3(parsed.integrations))
+    return null;
+  const linear = parsed.integrations.linear;
+  if (!isRecord3(linear))
+    return null;
+  const overlay = {};
+  if (typeof linear.enabled === "boolean")
+    overlay.enabled = linear.enabled;
+  if (typeof linear.autoCreateWorktrees === "boolean")
+    overlay.autoCreateWorktrees = linear.autoCreateWorktrees;
+  if (typeof linear.createTicketOption === "boolean")
+    overlay.createTicketOption = linear.createTicketOption;
+  if (typeof linear.teamId === "string" && linear.teamId.trim())
+    overlay.teamId = linear.teamId.trim();
+  return Object.keys(overlay).length > 0 ? overlay : null;
+}
 function loadLocalProjectConfigOverlay(root) {
   try {
     const text = readLocalConfigFile(root).trim();
     if (!text) {
-      return { worktreeRoot: null, profiles: {}, lifecycleHooks: {} };
+      return { worktreeRoot: null, profiles: {}, lifecycleHooks: {}, linear: null };
     }
     const parsed = parseConfigDocument(text);
     const ws = isRecord3(parsed.workspace) ? parsed.workspace : null;
     return {
       worktreeRoot: ws && typeof ws.worktreeRoot === "string" ? ws.worktreeRoot : null,
       profiles: parseProfiles(parsed.profiles, false),
-      lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks)
+      lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
+      linear: parseLocalLinearOverlay(parsed)
     };
   } catch {
-    return { worktreeRoot: null, profiles: {}, lifecycleHooks: {} };
+    return { worktreeRoot: null, profiles: {}, lifecycleHooks: {}, linear: null };
   }
 }
 function mergeHookCommand(projectCommand, localCommand) {
@@ -9970,7 +10006,13 @@ function loadConfig(dir, options = {}) {
       ...cloneProfiles(projectConfig.profiles),
       ...cloneProfiles(localOverlay.profiles)
     },
-    lifecycleHooks: mergeLifecycleHooks(projectConfig.lifecycleHooks, localOverlay.lifecycleHooks)
+    lifecycleHooks: mergeLifecycleHooks(projectConfig.lifecycleHooks, localOverlay.lifecycleHooks),
+    ...localOverlay.linear ? {
+      integrations: {
+        ...projectConfig.integrations,
+        linear: { ...projectConfig.integrations.linear, ...localOverlay.linear }
+      }
+    } : {}
   };
 }
 function expandTemplate(template, env) {
@@ -10001,7 +10043,7 @@ var init_config = __esm(() => {
     startupEnvs: {},
     integrations: {
       github: { linkedRepos: [] },
-      linear: { enabled: true }
+      linear: { enabled: true, autoCreateWorktrees: false, createTicketOption: false }
     },
     lifecycleHooks: {},
     autoName: null
@@ -10345,8 +10387,8 @@ class BunLifecycleHookRunner {
   }
   async run(input) {
     const cmd = await this.buildCommand(input.cwd, input.command);
-    console.debug(`[hook-runner] Spawning: ${cmd.join(" ")} cwd=${input.cwd}`);
-    console.debug(`[hook-runner] Env keys: ${Object.keys(input.env).join(", ")}`);
+    log.debug(`[hook-runner] Spawning: ${cmd.join(" ")} cwd=${input.cwd}`);
+    log.debug(`[hook-runner] envKeys=${Object.keys(input.env).length}`);
     const proc = Bun.spawn(cmd, {
       cwd: input.cwd,
       env: {
@@ -10361,17 +10403,19 @@ class BunLifecycleHookRunner {
       new Response(proc.stdout).text(),
       new Response(proc.stderr).text()
     ]);
-    console.debug(`[hook-runner] ${input.name} exitCode=${exitCode}`);
+    log.debug(`[hook-runner] ${input.name} exitCode=${exitCode}`);
     if (stdout.trim())
-      console.debug(`[hook-runner] stdout: ${stdout.trim()}`);
+      log.debug(`[hook-runner] stdout: ${stdout.trim()}`);
     if (stderr.trim())
-      console.debug(`[hook-runner] stderr: ${stderr.trim()}`);
+      log.debug(`[hook-runner] stderr: ${stderr.trim()}`);
     if (exitCode !== 0) {
       throw new Error(buildErrorMessage(input.name, exitCode, stdout, stderr));
     }
   }
 }
-var init_hooks = () => {};
+var init_hooks = __esm(() => {
+  init_log();
+});
 
 // backend/src/adapters/port-probe.ts
 class BunPortProbe {
@@ -11214,7 +11258,7 @@ class LifecycleService {
         agent,
         phase: "reconciling"
       });
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
       return {
         branch,
         worktreeId: initialized.meta.worktreeId
@@ -11249,7 +11293,7 @@ class LifecycleService {
         worktreePath: resolved.entry.path,
         launchMode
       });
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
       return {
         branch,
         worktreeId: initialized.meta.worktreeId
@@ -11262,7 +11306,7 @@ class LifecycleService {
     try {
       const resolved = await this.resolveExistingWorktree(branch);
       this.deps.tmux.killWindow(buildProjectSessionName(this.deps.projectRoot), buildWorktreeWindowName(branch));
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
     } catch (error) {
       throw this.wrapOperationError(error);
     }
@@ -11588,15 +11632,15 @@ class LifecycleService {
       deleteBranch: true,
       deleteBranchForce: true
     }, this.deps.git);
-    await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+    await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
   }
   async runLifecycleHook(input) {
-    console.debug(`[lifecycle-hook] name=${input.name} command=${input.command ?? "UNDEFINED"} meta=${input.meta ? "present" : "NULL"} cwd=${input.worktreePath}`);
+    log.debug(`[lifecycle-hook] name=${input.name} command=${input.command ?? "UNDEFINED"} meta=${input.meta ? "present" : "NULL"} cwd=${input.worktreePath}`);
     if (!input.command || !input.meta) {
-      console.debug(`[lifecycle-hook] SKIPPING ${input.name}: command=${!!input.command} meta=${!!input.meta}`);
+      log.debug(`[lifecycle-hook] SKIPPING ${input.name}: command=${!!input.command} meta=${!!input.meta}`);
       return;
     }
-    console.debug(`[lifecycle-hook] RUNNING ${input.name}: ${input.command} in ${input.worktreePath}`);
+    log.debug(`[lifecycle-hook] RUNNING ${input.name}: ${input.command} in ${input.worktreePath}`);
     const dotenvValues = await loadDotenvLocal(input.worktreePath);
     await this.deps.hooks.run({
       name: input.name,
@@ -11606,7 +11650,7 @@ class LifecycleService {
         WEBMUX_WORKTREE_PATH: input.worktreePath
       }, dotenvValues)
     });
-    console.debug(`[lifecycle-hook] COMPLETED ${input.name}`);
+    log.debug(`[lifecycle-hook] COMPLETED ${input.name}`);
   }
   async reportCreateProgress(progress) {
     await this.deps.onCreateProgress?.(progress);
@@ -11630,6 +11674,7 @@ var init_lifecycle_service = __esm(() => {
   init_policies();
   init_session_service();
   init_worktree_service();
+  init_log();
   LifecycleError = class LifecycleError extends Error {
     status;
     constructor(message, status2) {
@@ -11910,6 +11955,21 @@ var init_project_runtime = __esm(() => {
   init_tmux();
 });
 
+// backend/src/lib/async.ts
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const concurrency = Math.max(1, Math.min(limit, items.length || 1));
+  async function worker() {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await fn(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  return results;
+}
+
 // backend/src/services/reconciliation-service.ts
 import { basename as basename4, resolve as resolve6 } from "path";
 function makeUnmanagedWorktreeId(path) {
@@ -11952,11 +12012,34 @@ function resolveBranch(entry, metaBranch) {
 
 class ReconciliationService {
   deps;
-  constructor(deps2) {
+  freshnessMs;
+  now;
+  concurrency;
+  inFlight = null;
+  lastReconciledAt = 0;
+  constructor(deps2, options = {}) {
     this.deps = deps2;
+    this.freshnessMs = options.freshnessMs ?? 500;
+    this.now = options.now ?? Date.now;
+    this.concurrency = options.concurrency ?? 4;
   }
-  async reconcile(repoRoot) {
+  async reconcile(repoRoot, options = {}) {
+    if (this.inFlight) {
+      return await this.inFlight;
+    }
+    if (!options.force && this.now() - this.lastReconciledAt < this.freshnessMs) {
+      return;
+    }
     const normalizedRepoRoot = resolve6(repoRoot);
+    const reconcilePromise = this.runReconcile(normalizedRepoRoot).then(() => {
+      this.lastReconciledAt = this.now();
+    });
+    this.inFlight = reconcilePromise.finally(() => {
+      this.inFlight = null;
+    });
+    return await this.inFlight;
+  }
+  async runReconcile(normalizedRepoRoot) {
     const worktrees = this.deps.git.listWorktrees(normalizedRepoRoot);
     const sessionName = buildProjectSessionName(normalizedRepoRoot);
     let windows = [];
@@ -11966,40 +12049,32 @@ class ReconciliationService {
       windows = [];
     }
     const seenWorktreeIds = new Set;
-    for (const entry of worktrees) {
-      if (entry.bare)
-        continue;
-      if (resolve6(entry.path) === normalizedRepoRoot)
-        continue;
+    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve6(entry.path) !== normalizedRepoRoot);
+    const reconciledStates = await mapWithConcurrency(candidateEntries, this.concurrency, async (entry) => {
       const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
       const meta = await readWorktreeMeta(gitDir);
       const branch = resolveBranch(entry, meta?.branch ?? null);
       const worktreeId = meta?.worktreeId ?? makeUnmanagedWorktreeId(entry.path);
-      seenWorktreeIds.add(worktreeId);
-      this.deps.runtime.upsertWorktree({
+      const gitStatus = this.deps.git.readWorktreeStatus(entry.path);
+      const window = findWindow(windows, sessionName, branch);
+      return {
         worktreeId,
         branch,
         path: entry.path,
         profile: meta?.profile ?? null,
         agentName: meta?.agent ?? null,
-        runtime: meta?.runtime ?? "host"
-      });
-      const gitStatus = this.deps.git.readWorktreeStatus(entry.path);
-      this.deps.runtime.setGitState(worktreeId, {
-        exists: true,
-        branch,
-        dirty: gitStatus.dirty,
-        aheadCount: gitStatus.aheadCount,
-        currentCommit: gitStatus.currentCommit
-      });
-      const window = findWindow(windows, sessionName, branch);
-      this.deps.runtime.setSessionState(worktreeId, {
-        exists: window !== null,
-        sessionName: window?.sessionName ?? null,
-        paneCount: window?.paneCount ?? 0
-      });
-      if (meta) {
-        this.deps.runtime.setServices(worktreeId, await buildServiceStates(this.deps, {
+        runtime: meta?.runtime ?? "host",
+        git: {
+          dirty: gitStatus.dirty,
+          aheadCount: gitStatus.aheadCount,
+          currentCommit: gitStatus.currentCommit
+        },
+        session: {
+          exists: window !== null,
+          sessionName: window?.sessionName ?? null,
+          paneCount: window?.paneCount ?? 0
+        },
+        services: meta ? await buildServiceStates(this.deps, {
           allocatedPorts: meta.allocatedPorts,
           startupEnvValues: meta.startupEnvValues,
           worktreeId: meta.worktreeId,
@@ -12007,11 +12082,34 @@ class ReconciliationService {
           profile: meta.profile,
           agent: meta.agent,
           runtime: meta.runtime
-        }));
-      } else {
-        this.deps.runtime.setServices(worktreeId, []);
-      }
-      this.deps.runtime.setPrs(worktreeId, await readWorktreePrs(gitDir));
+        }) : [],
+        prs: await readWorktreePrs(gitDir)
+      };
+    });
+    for (const state of reconciledStates) {
+      seenWorktreeIds.add(state.worktreeId);
+      this.deps.runtime.upsertWorktree({
+        worktreeId: state.worktreeId,
+        branch: state.branch,
+        path: state.path,
+        profile: state.profile,
+        agentName: state.agentName,
+        runtime: state.runtime
+      });
+      this.deps.runtime.setGitState(state.worktreeId, {
+        exists: true,
+        branch: state.branch,
+        dirty: state.git.dirty,
+        aheadCount: state.git.aheadCount,
+        currentCommit: state.git.currentCommit
+      });
+      this.deps.runtime.setSessionState(state.worktreeId, {
+        exists: state.session.exists,
+        sessionName: state.session.sessionName,
+        paneCount: state.session.paneCount
+      });
+      this.deps.runtime.setServices(state.worktreeId, state.services);
+      this.deps.runtime.setPrs(state.worktreeId, state.prs);
     }
     for (const state of this.deps.runtime.listWorktrees()) {
       if (!seenWorktreeIds.has(state.worktreeId)) {
@@ -12133,13 +12231,14 @@ function getWorktreeCommandUsage(command) {
     case "add":
       return [
         "Usage:",
-        "  webmux add [branch] [--profile <name>] [--agent <claude|codex>] [--prompt <text>] [--env KEY=VALUE]",
+        "  webmux add [branch] [--profile <name>] [--agent <claude|codex>] [--prompt <text>] [--env KEY=VALUE] [--detach]",
         "",
         "Options:",
         "  --profile <name>         Worktree profile from .webmux.yaml",
         "  --agent <claude|codex>   Agent to launch in the worktree",
         "  --prompt <text>          Initial agent prompt",
         "  --env KEY=VALUE          Runtime env override (repeatable)",
+        "  -d, --detach             Create worktree without switching to it",
         "  --help                   Show this help message"
       ].join(`
 `);
@@ -12193,6 +12292,7 @@ function parseAgent(value) {
 function parseAddCommandArgs(args) {
   const input = {};
   const envOverrides = {};
+  let detach = false;
   for (let index = 0;index < args.length; index++) {
     const arg = args[index];
     if (!arg)
@@ -12200,6 +12300,10 @@ function parseAddCommandArgs(args) {
     if (arg === "--help" || arg === "-h") {
       return null;
     }
+    if (arg === "--detach" || arg === "-d") {
+      detach = true;
+      continue;
+    }
     if (arg === "--profile" || arg.startsWith("--profile=")) {
       const { value, nextIndex } = readOptionValue(args, index, "--profile");
       input.profile = value;
@@ -12239,7 +12343,7 @@ function parseAddCommandArgs(args) {
   if (Object.keys(envOverrides).length > 0) {
     input.envOverrides = envOverrides;
   }
-  return input;
+  return { input, detach };
 }
 function parseBranchCommandArgs(args) {
   let branch = null;
@@ -12353,8 +12457,8 @@ async function runWorktreeCommand(context, deps2 = {}) {
   const confirmPrune = deps2.confirmPrune ?? defaultConfirmPrune;
   try {
     if (context.command === "add") {
-      const input = parseAddCommandArgs(context.args);
-      if (!input) {
+      const parsed = parseAddCommandArgs(context.args);
+      if (!parsed) {
         stdout(getWorktreeCommandUsage("add"));
         return 0;
       }
@@ -12362,9 +12466,11 @@ async function runWorktreeCommand(context, deps2 = {}) {
         projectDir: context.projectDir,
         port: context.port
       });
-      const result = await runtime2.lifecycleService.createWorktree(input);
+      const result = await runtime2.lifecycleService.createWorktree(parsed.input);
       stdout(`Created worktree ${result.branch}`);
-      switchToTmuxWindow(runtime2.projectDir, result.branch);
+      if (!parsed.detach) {
+        switchToTmuxWindow(runtime2.projectDir, result.branch);
+      }
       return 0;
     }
     if (context.command === "list") {
@@ -12457,7 +12563,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.17.0",
+  version: "0.19.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -12517,7 +12623,7 @@ function usage2() {
 webmux \u2014 Dev dashboard for managing Git worktrees
 
 Usage:
-  webmux serve        Start the dashboard server
+  webmux serve        Start the dashboard server (--app opens in app mode)
   webmux init         Interactive project setup
   webmux service      Manage webmux as a system service
   webmux update       Update webmux to the latest version
@@ -12532,6 +12638,7 @@ Usage:
 
 Options:
   --port N            Set port (default: 5111)
+  --app               Open dashboard in browser app mode (minimal window)
   --debug             Show debug-level logs
   --version           Show version number
   --help              Show this help message
@@ -12544,11 +12651,12 @@ function isRootCommand(value) {
   return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "list" || value === "open" || value === "close" || value === "remove" || value === "merge" || value === "prune" || value === "completion";
 }
 function isServeRootOption(value) {
-  return value === "--port" || value === "--debug" || value === "--help" || value === "-h" || value === "--version" || value === "-V";
+  return value === "--port" || value === "--app" || value === "--debug" || value === "--help" || value === "-h" || value === "--version" || value === "-V";
 }
 function parseRootArgs(args) {
   let port = parseInt(process.env.PORT || "5111", 10);
   let debug = false;
+  let app = false;
   let command = null;
   const commandArgs = [];
   for (let index = 0;index < args.length; index++) {
@@ -12572,6 +12680,9 @@ function parseRootArgs(args) {
         index += 1;
         break;
       }
+      case "--app":
+        app = true;
+        break;
       case "--debug":
         debug = true;
         break;
@@ -12595,6 +12706,7 @@ Run webmux --help for usage.`);
   return {
     port,
     debug,
+    app,
     command,
     commandArgs
   };
@@ -12621,10 +12733,44 @@ async function loadEnvFile(path) {
     }
   }
 }
-function pipeWithPrefix(stream, prefix) {
+function findBrowserBinary() {
+  const candidates = process.platform === "darwin" ? [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+  ] : [
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+    "microsoft-edge",
+    "brave-browser"
+  ];
+  for (const candidate of candidates) {
+    const found = candidate.startsWith("/") ? existsSync5(candidate) : Bun.spawnSync(["which", candidate], { stdout: "pipe", stderr: "pipe" }).success;
+    if (found)
+      return candidate;
+  }
+  return null;
+}
+function openAppMode(url) {
+  const browser = findBrowserBinary();
+  if (!browser) {
+    console.log(`[app] No Chromium-based browser found \u2014 open ${url} manually`);
+    return;
+  }
+  console.log(`[app] Opening ${url} in app mode`);
+  Bun.spawn([browser, `--app=${url}`], {
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+}
+function pipeWithPrefix(stream, prefix, onTrigger) {
   const reader = stream.getReader();
   const decoder = new TextDecoder;
   let buffer = "";
+  let fired = false;
   (async () => {
     while (true) {
       const { done, value } = await reader.read();
@@ -12636,6 +12782,10 @@ function pipeWithPrefix(stream, prefix) {
       buffer = lines.pop();
       for (const line of lines) {
         console.log(`${prefix} ${line}`);
+        if (onTrigger && !fired && line.includes(onTrigger.text)) {
+          fired = true;
+          onTrigger.callback();
+        }
       }
     }
     if (buffer) {
@@ -12740,7 +12890,14 @@ async function main(args = process.argv.slice(2)) {
     stderr: "pipe"
   });
   children.push(be);
-  pipeWithPrefix(be.stdout, "[BE]");
+  if (parsed.app) {
+    pipeWithPrefix(be.stdout, "[BE]", {
+      text: "Dev Dashboard API running at",
+      callback: () => openAppMode(`http://localhost:${parsed.port}`)
+    });
+  } else {
+    pipeWithPrefix(be.stdout, "[BE]");
+  }
   pipeWithPrefix(be.stderr, "[BE]");
   await be.exited;
 }