localdeck 1.0.0

package/dist/index.js

@@ -0,0 +1,1268 @@
+import {
+  Api,
+  DEFAULT_API_PORT,
+  HOME_DIR,
+  VERSION,
+  __require,
+  chooseUpstream,
+  connectHost,
+  dashboardDir,
+  ensureDaemon,
+  findDaemon,
+  findProjectFile,
+  getFreePort,
+  isPortFree,
+  killProcessTree,
+  listeningPorts,
+  loadProject,
+  loadProjectFile,
+  processTree,
+  serviceKey,
+  shellCommand,
+  startDaemon,
+  startForwarder,
+  startupGuidance,
+  startupLayers,
+  streamLines,
+  stripAnsi,
+  waitForReadiness,
+  wrapper_default
+} from "./index-3npyta7k.js";
+
+// src/index.ts
+import { spawn as spawn2 } from "node:child_process";
+import crypto from "node:crypto";
+import { parseArgs } from "node:util";
+
+// src/run.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+// src/ui.ts
+var on = process.stdout.isTTY && !process.env.NO_COLOR;
+var wrap = (code) => (s) => on ? `\x1B[${code}m${s}\x1B[0m` : s;
+var c = {
+  bold: wrap(1),
+  dim: wrap(2),
+  red: wrap(31),
+  green: wrap(32),
+  yellow: wrap(33),
+  cyan: wrap(36),
+  magenta: wrap(35),
+  blue: wrap(34)
+};
+function fail(message) {
+  console.error(`${c.red("error")} ${message}`);
+  process.exit(1);
+}
+function table(rows, header) {
+  const all = [header, ...rows];
+  const widths = header.map((_, i) => Math.max(...all.map((r) => stripLen(r[i] ?? ""))));
+  const line = (r) => r.map((cell, i) => cell + " ".repeat(widths[i] - stripLen(cell))).join("  ");
+  return [c.dim(line(header)), ...rows.map(line)].join(`
+`);
+}
+var stripLen = (s) => s.replace(/\x1b\[[0-9;]*m/g, "").length;
+function ago(ts) {
+  const s = Math.max(0, Math.round((Date.now() - ts) / 1000));
+  if (s < 60)
+    return `${s}s`;
+  if (s < 3600)
+    return `${Math.round(s / 60)}m`;
+  if (s < 86400)
+    return `${Math.round(s / 3600)}h`;
+  return `${Math.round(s / 86400)}d`;
+}
+
+// src/clean-urls.ts
+async function prepareCleanUrls(port, interactive, request = fetch, log = console.log) {
+  if (interactive)
+    log("LocalDeck: preparing app links. macOS may ask once to allow localhost port 80; cancelling keeps port-number links.");
+  try {
+    const response = await request(`http://127.0.0.1:${port}/api/forwarder`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ install: interactive, automatic: true }),
+      signal: AbortSignal.timeout(135000)
+    });
+    const status = await response.json();
+    if (response.ok && status?.ready === true)
+      return true;
+    if (interactive)
+      log(`LocalDeck: using port-number links. ${status?.error ?? "Forwarding is unavailable."}`);
+  } catch {
+    if (interactive)
+      log("LocalDeck: using port-number links; forwarding setup was unavailable.");
+  }
+  return false;
+}
+
+// src/run.ts
+var MAX_ATTACH_LOG_SOURCE_BYTES = 8000;
+var TERMINAL_GRACE_AFTER_MS = 500;
+var TERMINAL_FORCE_AFTER_MS = 1000;
+async function startService(opts, overrides = {}) {
+  const dependencies = {
+    ensureDaemon,
+    getFreePort,
+    createWebSocket: (url, options) => new wrapper_default(url, options),
+    spawn,
+    fetch: globalThis.fetch,
+    ...overrides
+  };
+  if (!opts.command.length)
+    throw new Error(`nothing to run for "${opts.name}"`);
+  const cwd = opts.cwd ?? process.cwd();
+  try {
+    if (!fs.statSync(cwd).isDirectory())
+      throw new Error("not a directory");
+  } catch {
+    throw new Error(`working directory does not exist or is not a directory: ${cwd}`);
+  }
+  const daemon = await dependencies.ensureDaemon();
+  const upstreamPort = opts.upstreamPort ?? await dependencies.getFreePort();
+  const paint = opts.color ?? c.cyan;
+  const tag = opts.prefix ? paint(`[${opts.name}] `) : "";
+  const project = opts.project ?? {
+    id: "standalone",
+    name: "standalone",
+    slug: "standalone"
+  };
+  const commandEnv = await expandRunEnvironment(opts.env, opts.after ?? [], project.id, daemon.apiPort, dependencies.fetch);
+  const ws = dependencies.createWebSocket(`ws://127.0.0.1:${daemon.apiPort}/api/attach`, {
+    headers: { authorization: `Bearer ${daemon.controlToken}` }
+  });
+  const send = (m) => ws.readyState === wrapper_default.OPEN && ws.send(JSON.stringify(m));
+  const service = await new Promise((resolve, reject) => {
+    ws.once("open", () => {
+      send({
+        type: "register",
+        key: serviceKey(project.id, opts.name.toLowerCase()),
+        projectId: project.id,
+        projectName: project.name,
+        projectSlug: project.slug,
+        name: opts.name,
+        managedBy: "terminal",
+        stablePort: opts.stablePort,
+        upstreamPort,
+        upstreamSource: opts.upstreamPort === undefined ? "assigned" : "manual",
+        cwd,
+        command: opts.displayCommand ?? opts.command.join(" ")
+      });
+    });
+    ws.on("message", (raw) => {
+      const msg = JSON.parse(raw.toString());
+      if (msg.type === "registered")
+        resolve(msg.service);
+      else if (msg.type === "error")
+        reject(new Error(msg.message));
+    });
+    ws.once("error", reject);
+  });
+  const argv = opts.command.map((a) => a.replaceAll("{port}", String(upstreamPort)));
+  const database = service.serviceType !== undefined && service.serviceType !== "http";
+  const env = {
+    ...process.env,
+    ...commandEnv,
+    PORT: String(upstreamPort),
+    LOCALDECK_PORT: String(service.stablePort),
+    LOCALDECK_SERVICE: service.name,
+    ...database ? {} : { LOCALDECK_URL: `http://localhost:${service.stablePort}` }
+  };
+  if (database) {
+    console.log(`${tag}${c.bold("LocalDeck")} ${c.dim("›")} ${paint(service.name)} ${c.dim("→")} ${c.green(`database localhost:${service.upstreamPort}`)} ${c.dim("(published port · no HTTP proxy)")}`);
+  } else {
+    const appUrl = opts.cleanUrls ? service.urls[0].replace(/^(http:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)?\.localhost):\d+(?=\/|$)/i, "$1") : service.urls[0];
+    console.log(`${tag}${c.bold("LocalDeck")} ${c.dim("›")} ${paint(service.name)} ${c.dim("→")} ${c.green(appUrl)} ${c.dim(`(also ${service.urls[1]} · dashboard http://localhost:${daemon.apiPort})`)}`);
+  }
+  const posix = process.platform !== "win32";
+  const child = dependencies.spawn(argv[0], argv.slice(1), { cwd, env, stdio: [opts.prefix ? "ignore" : "inherit", "pipe", "pipe"], shell: !posix, detached: posix });
+  if (child.pid)
+    send({ type: "pid", pid: child.pid });
+  const pipe = (stream, name, out) => {
+    stream.on("data", (chunk) => {
+      if (opts.prefix) {
+        const text = stripAnsi(chunk.toString());
+        recentOutput = (recentOutput + text).slice(-16000);
+        out.write(text.replace(/^(?=.)/gm, tag));
+      } else
+        out.write(chunk);
+    });
+    streamLines(stream, (line) => {
+      for (const part of splitAttachLogLine(stripAnsi(line)))
+        send({ type: "log", stream: name, line: part });
+    });
+  };
+  pipe(child.stdout, "stdout", process.stdout);
+  pipe(child.stderr, "stderr", process.stderr);
+  let hinted = false;
+  let recentOutput = "";
+  const hintOnPortClash = (chunk) => {
+    if (hinted)
+      return;
+    const text = chunk.toString();
+    if (/EADDRINUSE|address already in use|already in use/i.test(text) && text.includes(String(service.stablePort))) {
+      hinted = true;
+      console.error(`${tag}${c.yellow(`LocalDeck: your process tried to use port ${service.stablePort}, which LocalDeck is holding as the stable port for "${service.name}".`)}`);
+      console.error(`${tag}${c.yellow(`  Fix: run without --port (LocalDeck finds the tool's own port automatically), or pick a different stable port, e.g. --port ${service.stablePort + 1000}.`)}`);
+    }
+  };
+  child.stdout.on("data", hintOnPortClash);
+  child.stderr.on("data", hintOnPortClash);
+  let detectTimer;
+  let reported;
+  if (!opts.upstreamPort && child.pid) {
+    const rootPid = child.pid;
+    let idle = 0;
+    const tick = async () => {
+      if (child.exitCode !== null || child.signalCode)
+        return;
+      try {
+        const listeners = await listeningPorts(await processTree(rootPid));
+        const pick = chooseUpstream(listeners, upstreamPort);
+        if (pick) {
+          const key = `${connectHost(pick)}:${pick.port}`;
+          if (key !== reported) {
+            reported = key;
+            send({ type: "upstream", port: pick.port, host: connectHost(pick) });
+            if (pick.port !== upstreamPort)
+              console.log(`${tag}${c.dim(`LocalDeck: process is listening on ${key} (ignored $PORT) — ${service.urls[0]} now points there`)}`);
+          }
+          idle++;
+        }
+      } catch {}
+      detectTimer = setTimeout(tick, reported ? Math.min(2000 + idle * 500, 1e4) : 400);
+    };
+    detectTimer = setTimeout(tick, 300);
+  }
+  let stopping = false;
+  let cleanupPromise;
+  let leaderExit;
+  let finished = false;
+  let resolveDone;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+  const cleanup = (signal) => cleanupPromise ??= cleanupTerminalTree(child, signal);
+  const finishAfterCleanup = async (signal) => {
+    if (finished || !leaderExit)
+      return;
+    if (!await cleanup(signal)) {
+      cleanupPromise = undefined;
+      stopping = false;
+      console.error(`${tag}${c.red(`LocalDeck: process descendants survived cleanup; retry Stop`)}`);
+      return;
+    }
+    if (finished)
+      return;
+    finished = true;
+    if (detectTimer)
+      clearTimeout(detectTimer);
+    send({ type: "log", stream: "stderr", line: `process exited (${leaderExit.signal ?? `code ${leaderExit.code}`})` });
+    setTimeout(() => {
+      ws.close();
+      resolveDone(leaderExit.code ?? (leaderExit.signal ? 1 : 0));
+    }, 50);
+  };
+  const stop = (signal = "SIGTERM") => {
+    if (finished || stopping)
+      return;
+    stopping = true;
+    cleanup(signal).then(() => finishAfterCleanup(signal));
+  };
+  ws.on("message", (raw) => {
+    const msg = JSON.parse(raw.toString());
+    if (msg.type === "error") {
+      console.error(`${tag}${c.yellow(`LocalDeck: ${msg.message}`)}`);
+      reported = undefined;
+    } else if (msg.type === "stop") {
+      console.log(`${tag}${c.dim("LocalDeck: stop requested from dashboard/CLI")}`);
+      stop();
+    }
+  });
+  ws.on("close", () => {
+    if (!stopping)
+      console.error(`${tag}${c.yellow("LocalDeck: lost connection to daemon; the stable port is no longer proxied. Process keeps running.")}`);
+  });
+  child.on("exit", (code, signal) => {
+    if (code !== 0 && !hinted) {
+      const guidance = startupGuidance(recentOutput);
+      if (guidance)
+        console.error(`${tag}${c.yellow(["LocalDeck: " + guidance.title, ...guidance.steps].join(`
+`))}`);
+    }
+    leaderExit = { code, signal };
+    stopping = true;
+    finishAfterCleanup("SIGTERM");
+  });
+  child.on("error", (err) => {
+    stopping = true;
+    finished = true;
+    console.error(`${tag}${c.red(`LocalDeck: failed to start "${argv[0]}": ${err.message}`)}`);
+    ws.close();
+    resolveDone(1);
+  });
+  const readiness = opts.ready;
+  const readyOperation = readiness ? (async () => {
+    send({ type: "readiness", status: "checking", message: readiness.type === "tcp" ? "Waiting for the service to listen" : "Running configured readiness check" });
+    try {
+      const ready = await waitForReadiness({
+        name: service.name,
+        run: opts.displayCommand ?? opts.command.join(" "),
+        tags: [],
+        after: opts.after ?? [],
+        ready: readiness
+      }, async () => {
+        const response = await dependencies.fetch(`http://127.0.0.1:${daemon.apiPort}/api/services/${encodeURIComponent(service.key)}`);
+        if (response.status === 404)
+          return;
+        if (!response.ok)
+          throw new Error(`readiness status request failed (${response.status})`);
+        return response.json();
+      }, { cwd, env: commandEnv });
+      send({ type: "readiness", status: "ready", message: readiness.type === "tcp" ? "Listening on its upstream port" : "Configured readiness check passed" });
+      return ready;
+    } catch (error) {
+      send({ type: "readiness", status: "failed", message: error instanceof Error ? error.message.slice(0, 500) : "Readiness check failed" });
+      throw error;
+    }
+  })() : Promise.resolve(service);
+  readyOperation.catch(() => {});
+  return { name: opts.name, service, child, stop, done, ready: readyOperation };
+}
+async function cleanupTerminalTree(child, signal) {
+  await killProcessTree(child, signal);
+  if (process.platform === "win32")
+    return true;
+  const groupId = child.pid;
+  if (!groupId || !processGroupIsAlive(groupId))
+    return true;
+  if (await waitForProcessGroupExitWhileLeaderLives(child, groupId, TERMINAL_GRACE_AFTER_MS))
+    return true;
+  await killProcessTree(child, "SIGKILL");
+  return waitForProcessGroupExit(groupId, TERMINAL_FORCE_AFTER_MS);
+}
+function processGroupIsAlive(groupId) {
+  try {
+    process.kill(-groupId, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function waitForProcessGroupExit(groupId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (processGroupIsAlive(groupId)) {
+    if (Date.now() >= deadline)
+      return false;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(20, timeoutMs)));
+  }
+  return true;
+}
+async function waitForProcessGroupExitWhileLeaderLives(child, groupId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (processGroupIsAlive(groupId)) {
+    if (child.exitCode !== null || child.signalCode !== null || Date.now() >= deadline)
+      return false;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(20, timeoutMs)));
+  }
+  return true;
+}
+function splitAttachLogLine(line) {
+  if (Buffer.byteLength(line) <= MAX_ATTACH_LOG_SOURCE_BYTES)
+    return [line];
+  const chunks = [];
+  let characters = [];
+  let bytes = 0;
+  for (const character of line) {
+    const characterBytes = Buffer.byteLength(character);
+    if (characters.length && bytes + characterBytes > MAX_ATTACH_LOG_SOURCE_BYTES) {
+      chunks.push(characters.join(""));
+      characters = [];
+      bytes = 0;
+    }
+    characters.push(character);
+    bytes += characterBytes;
+  }
+  if (characters.length)
+    chunks.push(characters.join(""));
+  return chunks;
+}
+async function expandRunEnvironment(overrides, prerequisites, projectId, apiPort, fetchImpl) {
+  if (!overrides)
+    return {};
+  const allowed = new Set(prerequisites);
+  const services = new Map;
+  const load = async (rawName) => {
+    const name = rawName.toLowerCase();
+    if (!allowed.has(name))
+      throw new Error(`environment references undeclared prerequisite "${rawName}"`);
+    const cached = services.get(name);
+    if (cached)
+      return cached;
+    const response = await fetchImpl(`http://127.0.0.1:${apiPort}/api/services/${encodeURIComponent(serviceKey(projectId, name))}`);
+    if (response.status === 404)
+      throw new Error(`environment references unresolved prerequisite "${rawName}"`);
+    if (!response.ok)
+      throw new Error(`could not resolve prerequisite "${rawName}" (${response.status})`);
+    const service = await response.json();
+    services.set(name, service);
+    return service;
+  };
+  const reference = /\{service:([^}:]+):(port|url)\}/g;
+  const expanded = {};
+  for (const [name, value] of Object.entries(overrides)) {
+    let cursor = 0;
+    let output = "";
+    for (const match of value.matchAll(reference)) {
+      output += value.slice(cursor, match.index);
+      const service = await load(match[1]);
+      if (match[2] === "port")
+        output += String(service.serviceType && service.serviceType !== "http" ? service.upstreamPort : service.stablePort);
+      else {
+        if (service.serviceType && service.serviceType !== "http")
+          throw new Error(`environment variable ${name} cannot use a URL for database prerequisite "${match[1]}"`);
+        output += `http://localhost:${service.stablePort}`;
+      }
+      cursor = match.index + match[0].length;
+    }
+    expanded[name] = output + value.slice(cursor);
+    if (expanded[name].includes("{service:"))
+      throw new Error(`environment variable ${name} has an invalid service reference`);
+  }
+  return expanded;
+}
+async function runForeground(all) {
+  const daemon = await ensureDaemon();
+  const cleanUrls = await prepareCleanUrls(daemon.apiPort, Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI));
+  const running = [];
+  const controller = new AbortController;
+  const stopAll = (sig) => {
+    controller.abort();
+    running.forEach((r) => r.stop(sig));
+  };
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"])
+    process.on(sig, () => stopAll(sig));
+  const scheduled = await scheduleForegroundStarts(all, async (options) => {
+    const service = await startService({ ...options, cleanUrls });
+    running.push(service);
+    return service;
+  }, { signal: controller.signal });
+  for (const failed of scheduled.failed)
+    console.error(`${c.red("error")} starting "${failed.name}": ${failed.error.message}`);
+  const codes = await Promise.all(running.map((r) => r.done));
+  process.exit(codes.find((c2) => c2 !== 0) ?? (scheduled.failed.length ? 1 : 0));
+}
+async function scheduleForegroundStarts(all, launch, control = {}) {
+  const byName = new Map(all.map((options) => [options.name.toLowerCase(), options]));
+  const ready = new Map;
+  const schedule = (options, ancestors = new Set) => {
+    const name = options.name.toLowerCase();
+    if (ancestors.has(name))
+      return Promise.resolve({ error: new Error("project dependency graph contains a cycle") });
+    const existing = ready.get(name);
+    if (existing)
+      return existing;
+    let resolve;
+    const scheduled = new Promise((done) => {
+      resolve = done;
+    });
+    ready.set(name, scheduled);
+    (async () => {
+      const dependencies = options.after ?? [];
+      const nextAncestors = new Set(ancestors).add(name);
+      const prerequisiteResults = await Promise.all(dependencies.map((dependency) => {
+        const prerequisite = byName.get(dependency.toLowerCase());
+        if (!prerequisite)
+          return Promise.resolve({ error: new Error(`${options.name} starts after unknown service ${dependency}`) });
+        return schedule(prerequisite, nextAncestors);
+      }));
+      const failedDependency = prerequisiteResults.find((result) => result.error);
+      if (failedDependency)
+        return resolve({ error: new Error(`${options.name} was not started because a prerequisite failed: ${failedDependency.error.message}`) });
+      if (control.signal?.aborted)
+        return resolve({ error: new Error(`${options.name} was not started because startup was cancelled`) });
+      let service;
+      try {
+        service = await launch(options);
+      } catch (error) {
+        return resolve({ error: toError(error) });
+      }
+      if (control.signal?.aborted) {
+        service.stop("SIGTERM");
+        return resolve({ error: new Error(`${options.name} was stopped because startup was cancelled`) });
+      }
+      if (all.some((candidate) => (candidate.after ?? []).some((dependency) => dependency.toLowerCase() === name))) {
+        console.log(`${c.dim(`LocalDeck: waiting for ${service.name} before starting its dependents`)}`);
+      }
+      try {
+        await service.ready;
+      } catch (error) {
+        service.stop("SIGTERM");
+        return resolve({ error: toError(error) });
+      }
+      if (control.signal?.aborted) {
+        service.stop("SIGTERM");
+        return resolve({ error: new Error(`${options.name} was stopped because startup was cancelled`) });
+      }
+      console.log(`${c.green("✓")} ${service.name} ${options.ready?.type === "tcp" ? "is listening" : "passed readiness"}`);
+      resolve({ service });
+    })().catch((error) => resolve({ error: toError(error) }));
+    return scheduled;
+  };
+  const settled = await Promise.all(all.map((option) => schedule(option)));
+  return {
+    running: settled.flatMap((result) => result.service ? [result.service] : []),
+    failed: all.flatMap((option, index) => settled[index].error ? [{ name: option.name, error: settled[index].error }] : [])
+  };
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/project.ts
+import fs2 from "node:fs";
+import path from "node:path";
+function findProjectCommand(project, name) {
+  return project.commands.find((command) => command.name === name.toLowerCase());
+}
+function proposeFromPackageJson(dir = process.cwd()) {
+  const root = findPackageRoot(dir);
+  if (!root)
+    return [];
+  const manager = detectPackageManager(root);
+  const manifests = discoverWorkspaceManifests(root);
+  const entries = manifests.flatMap(({ file, cwd }) => {
+    const pkg = readJson(file);
+    const scripts = pkg?.scripts;
+    return scripts && typeof scripts === "object" ? Object.entries(scripts).filter(([, value]) => typeof value === "string").map(([name, run]) => ({ name, run, cwd })) : [];
+  });
+  const hasWorkspaceScripts = entries.some((e) => e.cwd);
+  const usable = entries.filter((e) => !(hasWorkspaceScripts && !e.cwd && /\b(?:turbo|nx|lerna)\b|\b(?:pnpm|npm|yarn|bun)\s+(?:-r|--recursive|workspaces?)/i.test(e.run)));
+  const chosen = usable.filter((entry) => usable.some((other) => other.cwd === entry.cwd && /^dev([:_-]|$)/.test(other.name)) ? /^dev([:_-]|$)/.test(entry.name) : /^(start|serve|preview)([:_-]|$)/.test(entry.name));
+  const out = [];
+  const taken = new Set;
+  for (const source of chosen) {
+    const script = source.name;
+    const [prefix, ...rest] = script.split(/[:_-]/);
+    let name = (source.cwd && !rest.length ? path.basename(source.cwd) : rest.join("-") || prefix).replace(/[^a-z0-9_-]/gi, "-").toLowerCase().replace(/^[^a-z0-9]+/, "");
+    if (!name)
+      name = "service";
+    if (taken.has(name))
+      name = script.replace(/[^a-z0-9_-]/gi, "-").toLowerCase().replace(/^[^a-z0-9]+/, "");
+    name = name.slice(0, 41);
+    if (taken.has(name)) {
+      let n = 2;
+      const base = name.replace(/-+$/, "").slice(0, 37);
+      while (taken.has(name))
+        name = `${base}-${n++}`.slice(0, 41);
+    }
+    taken.add(name);
+    out.push({
+      name,
+      run: `${manager} run ${script}`,
+      tags: [],
+      after: [],
+      ...source.cwd ? { cwd: source.cwd } : {},
+      ready: { type: "tcp", timeoutMs: 60000, intervalMs: 400 }
+    });
+  }
+  return out;
+}
+function findPackageRoot(from = process.cwd()) {
+  let dir = path.resolve(from);
+  for (;; ) {
+    if (fs2.existsSync(path.join(dir, "package.json")))
+      return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+}
+function detectPackageManager(root) {
+  const pkg = readJson(path.join(root, "package.json"));
+  if (typeof pkg?.packageManager === "string") {
+    const value = pkg.packageManager.split("@")[0];
+    if (["npm", "bun", "pnpm", "yarn"].includes(value))
+      return value;
+  }
+  const lockfiles = [["bun.lock", "bun"], ["bun.lockb", "bun"], ["pnpm-lock.yaml", "pnpm"], ["yarn.lock", "yarn"], ["package-lock.json", "npm"]];
+  return lockfiles.find(([file]) => fs2.existsSync(path.join(root, file)))?.[1] ?? "npm";
+}
+function readJson(file) {
+  try {
+    const value = JSON.parse(fs2.readFileSync(file, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new Error("manifest must contain an object");
+    return value;
+  } catch (error) {
+    if (fs2.existsSync(file))
+      throw new Error(`${file} is not valid JSON: ${error.message}`);
+    return;
+  }
+}
+function discoverWorkspaceManifests(root) {
+  const rootFile = path.join(root, "package.json");
+  const pkg = readJson(rootFile);
+  const out = [{ file: rootFile }];
+  const workspaces = Array.isArray(pkg?.workspaces) ? pkg.workspaces : Array.isArray(pkg?.packages) ? pkg.packages : Array.isArray(pkg?.workspaces?.packages) ? pkg.workspaces.packages : [];
+  const patterns = workspaces.filter((pattern) => typeof pattern === "string" && !pattern.includes("..") && !path.isAbsolute(pattern));
+  const matchers = patterns.map((pattern) => {
+    const clean = pattern.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+    const parts = clean.split("/");
+    const regex = parts.map((part, index) => part === "**" ? index === parts.length - 1 ? ".*" : "(?:[^/]+/)*" : part.split("*").map((piece) => piece.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*") + (index < parts.length - 1 ? "/" : "")).join("");
+    return { regex: new RegExp(`^${regex}$`), prefix: clean.split("*")[0], depth: parts.includes("**") ? Infinity : parts.length };
+  });
+  const walk = (dir, depth) => {
+    if (!matchers.some((matcher) => matcher.depth >= depth))
+      return;
+    for (const entry of fs2.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!entry.isDirectory() || entry.isSymbolicLink() || ["node_modules", ".git", ".superpowers", "dist"].includes(entry.name))
+        continue;
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(root, full).replace(/\\/g, "/");
+      if (!matchers.some((matcher) => matcher.prefix.startsWith(`${rel}/`) || rel.startsWith(matcher.prefix) || matcher.prefix === rel))
+        continue;
+      if (matchers.some((matcher) => matcher.regex.test(rel))) {
+        const file = path.join(full, "package.json");
+        if (fs2.existsSync(file) && fs2.lstatSync(file).isFile())
+          out.push({ file, cwd: rel });
+      }
+      walk(full, depth + 1);
+    }
+  };
+  walk(root, 1);
+  return out;
+}
+
+// src/index.ts
+import fs4 from "node:fs";
+import path3 from "node:path";
+
+// src/setup.ts
+import fs3 from "node:fs";
+import path2 from "node:path";
+import { spawnSync } from "node:child_process";
+async function doctor(dir = process.cwd(), options = {}) {
+  const executable = options.executable ?? ((command, args, timeoutMs) => spawnSync(command, args, { encoding: "utf8", timeout: timeoutMs }));
+  const checks = [];
+  const nodeProbe = executable("node", ["--version"], 2000);
+  const nodeVersion = String(nodeProbe.stdout ?? "").trim().replace(/^v/, "");
+  const nodeMajor = Number(nodeVersion.split(".")[0]);
+  checks.push({ name: "node", ok: nodeProbe.status === 0 && nodeMajor >= 20, message: nodeProbe.status === 0 ? `Node.js ${nodeVersion}` : "Node.js executable is unavailable", fix: nodeProbe.status === 0 && nodeMajor >= 20 ? undefined : "Install Node.js 20 or newer and put it on PATH." });
+  const root = findPackageRoot(dir);
+  if (!root)
+    checks.push({ name: "package-manager", ok: true, message: "No package.json; using explicitly configured commands." });
+  else {
+    let manager = "npm";
+    try {
+      manager = detectPackageManager(root);
+    } catch (error) {
+      checks.push({ name: "package.json", ok: false, message: error.message, fix: "Fix package.json syntax." });
+    }
+    const available = executable(manager, ["--version"], 2000).status === 0;
+    checks.push({ name: "package-manager", ok: available, message: `${manager} ${available ? "is available" : "is not available"}`, fix: available ? undefined : `Install ${manager} or put it on PATH.` });
+    let pkg;
+    try {
+      pkg = JSON.parse(fs3.readFileSync(path2.join(root, "package.json"), "utf8"));
+      if (!pkg || typeof pkg !== "object" || Array.isArray(pkg))
+        throw new Error("manifest must contain an object");
+    } catch (error) {
+      checks.push({ name: "package.json", ok: false, message: `${path2.join(root, "package.json")} is not valid JSON: ${error.message}`, fix: "Fix package.json syntax." });
+      pkg = {};
+    }
+    const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {}, ...pkg.optionalDependencies ?? {} };
+    if (Object.keys(deps).length) {
+      const installed = fs3.existsSync(path2.join(root, "node_modules")) || fs3.existsSync(path2.join(root, ".pnp.cjs"));
+      checks.push({ name: "dependencies", ok: installed, message: installed ? "node_modules exists" : "dependencies are not installed", fix: installed ? undefined : `Run ${manager} install.` });
+    }
+  }
+  const projectFile = findProjectFile(dir);
+  if (!projectFile)
+    checks.push({ name: "config", ok: false, message: "No LocalDeck config found", fix: "Run localdeck init." });
+  else {
+    try {
+      const project = loadProjectFile(projectFile);
+      checks.push({ name: "config", ok: true, message: `${path2.basename(projectFile)}: ${project.commands.length} service(s)` });
+      const dirs = [...new Set(project.commands.map((c2) => path2.resolve(project.dir, c2.cwd ?? ".")))];
+      for (const cwd of dirs) {
+        const exists = fs3.existsSync(cwd) && fs3.statSync(cwd).isDirectory();
+        checks.push({ name: `working-directory:${path2.relative(project.dir, cwd) || "."}`, ok: exists, message: exists ? "directory exists" : "directory does not exist", fix: exists ? undefined : "Fix the command cwd in your LocalDeck config." });
+      }
+      for (const cwd of new Set([project.dir, ...dirs])) {
+        if (!fs3.existsSync(cwd) || !fs3.statSync(cwd).isDirectory())
+          continue;
+        const label = path2.relative(project.dir, cwd) || ".";
+        const manifest = path2.join(cwd, "package.json");
+        if (cwd !== root && fs3.existsSync(manifest)) {
+          try {
+            const pkg = JSON.parse(fs3.readFileSync(manifest, "utf8"));
+            if (Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).length) {
+              const installed = [cwd, root ?? project.dir].some((directory) => fs3.existsSync(path2.join(directory, "node_modules")) || fs3.existsSync(path2.join(directory, ".pnp.cjs")));
+              checks.push({ name: `dependencies:${label}`, ok: installed, message: installed ? "Dependency installation found" : "Dependencies are not installed", fix: installed ? undefined : "Run the project's package manager install command." });
+            }
+          } catch {
+            checks.push({ name: `package.json:${label}`, ok: false, message: "Invalid package.json", fix: "Fix this workspace's package.json syntax." });
+          }
+        }
+        const envExample = path2.join(cwd, ".env.example");
+        if (!fs3.existsSync(envExample))
+          continue;
+        const required = envNames(fs3.readFileSync(envExample, "utf8"));
+        const envFile = path2.join(cwd, ".env");
+        const values = envAssignments(fs3.existsSync(envFile) ? fs3.readFileSync(envFile, "utf8") : "");
+        const commands = project.commands.filter((command) => path2.resolve(project.dir, command.cwd ?? ".") === cwd);
+        const missing = [...required].filter((name) => !process.env[name] && !values.get(name) && (!commands.length || !commands.every((command) => Boolean(command.env?.[name]))));
+        checks.push({ name: label === "." ? "environment" : `environment:${label}`, ok: !missing.length, message: missing.length ? `missing variable names: ${missing.join(", ")}` : "required variable names are present", fix: missing.length ? "Set the variables in this folder's .env or the environment." : undefined });
+      }
+      for (const command of project.commands)
+        if (command.run.includes("docker") || command.serviceType === "compose") {
+          const docker = executable("docker", ["--version"], 2000).status === 0;
+          const daemon = docker && executable("docker", ["info"], 3000).status === 0;
+          checks.push({ name: "docker", ok: daemon, message: daemon ? "Docker executable and daemon are available" : docker ? "Docker executable found but daemon is unavailable" : "Docker executable is unavailable", fix: daemon ? undefined : "Start Docker Desktop or the Docker daemon." });
+          break;
+        }
+      const ports = project.commands.map((c2) => c2.port).filter((p) => Number.isInteger(p));
+      const duplicates = [...new Set(ports.filter((p, i) => ports.indexOf(p) !== i))];
+      checks.push({ name: "stable-ports", ok: !duplicates.length, message: duplicates.length ? `conflicting configured ports: ${duplicates.join(", ")}` : "configured stable ports are unique", fix: duplicates.length ? "Assign each service a different stable port." : undefined });
+      const portFree = options.portFree ?? isPortFree;
+      for (const port of [...new Set(ports)])
+        if (!await portFree(port))
+          checks.push({ name: `stable-port:${port}`, ok: false, message: `port ${port} is already in use`, fix: "Choose another stable port or stop the process using it." });
+      for (const command of project.commands) {
+        const type = command.serviceType;
+        const nativeCheck = command.ready.type === "command" && /^(pg_isready|redis-cli)\b/.exec(command.ready.run)?.[1];
+        if (nativeCheck) {
+          const tool = nativeCheck;
+          const available = executable(tool, ["--version"], 2000).status === 0;
+          checks.push({ name: tool, ok: available, message: available ? `${tool} is available` : `${tool} is unavailable for configured ${type} checks`, fix: available ? undefined : `Install ${tool} or use a configured container check.` });
+        }
+      }
+    } catch (error) {
+      checks.push({ name: "config", ok: false, message: error.message, fix: "Fix the config JSON and run doctor again." });
+    }
+  }
+  return { ok: checks.every((check) => check.ok), checks };
+}
+function envNames(text) {
+  return new Set(text.split(/\r?\n/).map((line) => line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/)?.[1]).filter((v) => Boolean(v)));
+}
+function envAssignments(text) {
+  return new Map(text.split(/\r?\n/).map((line) => line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/)).filter((m) => Boolean(m)).map((m) => [m[1], m[2].trim().replace(/^(['"])(.*)\1$/, "$2")]));
+}
+// src/index.ts
+var HELP = `${c.bold("localdeck")} ${c.dim(`v${VERSION}`)} — stable ports, shareable links and logs for local dev servers
+
+${c.bold("Usage")}
+  localdeck run <name> [--port 4000] [--upstream 5173] [--] <command...>
+  localdeck <name>                  run a command from the project's .localdeck file
+  localdeck up [tag|name...]        run every .localdeck command (or just the tagged/named ones) in one terminal
+  localdeck up --profile <name>   run a saved profile and its prerequisites
+  localdeck init [--dry-run] [--force]  preview/create/replace the project configuration
+  localdeck init --name web --command 'your command'
+  localdeck commands              list configured services (alias: cmds)
+  localdeck mcp [--project <id>]    connect an AI client over stdio
+  localdeck doctor [--json]        diagnose setup without starting anything
+  localdeck forward [--to-port N]  forward 127.0.0.1:80 to 127.0.0.1:7777
+  localdeck ps                      list running services and their ports
+  localdeck port <name>             print a service's stable port (for scripts)
+  localdeck logs <name> [-f] [-n 100]  show recent output; -f follows live logs
+  localdeck requests <name> [-n 50]   show recent proxied HTTP requests
+  localdeck share <name> [--password xyz | --public]  create a public HTTPS tunnel
+  localdeck unshare <name>         close a service's public tunnel
+  localdeck stop <name>            stop a service and its child processes
+  localdeck open [name]             open the dashboard, or a service, in the browser
+  localdeck daemon status|start|stop|run
+  localdeck --help | --h | -h     show help
+  localdeck --version | --v | -v  show the installed version
+
+${c.bold("How it works")}
+  LocalDeck holds a stable port for each service (e.g. 4000) and proxies to
+  whatever port your process actually opens — it watches the process and
+  finds the port itself, so wrangler, vite, next etc. need no configuration.
+  ($PORT is also set, and {port} in a command is replaced, for tools that
+  want to be told.) Other services and browsers only ever use the stable
+  port, so nothing silently moves when a port is busy.
+  Dashboard: http://localhost:${DEFAULT_API_PORT}
+
+${c.bold(".localdeck")} (JSON, at the project root)
+  [
+    { "name": "database", "run": "npm run database" },
+    { "name": "api",      "run": "npm run api", "after": "database", "ready": "/health" },
+    { "name": "web",      "run": "npm run web", "after": "api" }
+  ]
+  "after" is the beginner-friendly startup order. LocalDeck verifies each
+  prerequisite is ready before starting its dependents. Omit "ready" to use
+  automatic port readiness; HTTP paths and advanced checks are optional.
+`;
+var defaultDependencies = {
+  loadProject,
+  ensureDaemon,
+  createApi: (port) => new Api(port),
+  findDaemon,
+  createWebSocket: (url) => new wrapper_default(url),
+  runForeground,
+  log: (message) => console.log(message),
+  warn: (message) => console.warn(message)
+};
+async function main(argv, overrides = {}) {
+  const dependencies = { ...defaultDependencies, ...overrides };
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case undefined:
+      console.log(HELP);
+      await printProjectCommands(false, dependencies);
+      return;
+    case "help":
+    case "-h":
+    case "--h":
+    case "--help":
+      console.log(HELP);
+      return;
+    case "up":
+      return cmdUp(rest, dependencies);
+    case "init":
+      return cmdInit(rest, dependencies);
+    case "mcp":
+      return (await import("./mcp-s6gapf6v.js")).runMcp(rest);
+    case "doctor":
+      return cmdDoctor(rest);
+    case "forward":
+      return cmdForward(rest);
+    case "commands":
+    case "cmds":
+      return printProjectCommands(true, dependencies);
+    case "-v":
+    case "--v":
+    case "--version":
+      console.log(VERSION);
+      return;
+    case "run":
+      return cmdRun(rest, dependencies);
+    case "ps":
+    case "ls":
+    case "ports":
+      return cmdPs(dependencies);
+    case "port":
+      return cmdPort(rest[0]);
+    case "logs":
+      return cmdLogs(rest, dependencies);
+    case "requests":
+      return cmdRequests(rest);
+    case "share":
+      return cmdShare(rest);
+    case "unshare":
+      return cmdUnshare(rest[0]);
+    case "stop":
+      return cmdStop(rest[0]);
+    case "open":
+      return cmdOpen(rest[0]);
+    case "daemon":
+      return cmdDaemon(rest[0]);
+    default: {
+      const project = tryLoadProject(dependencies);
+      const found = project && findProjectCommand(project, cmd);
+      if (found) {
+        const remembered = await rememberProject(project, dependencies);
+        const selected = startupLayers(project.commands, [found.name]).flat();
+        return dependencies.runForeground(selected.map((command, index) => toRunOptions(command, project, remembered, {
+          prefix: selected.length > 1,
+          color: PALETTE[index % PALETTE.length]
+        })));
+      }
+      const hint = project ? ` Commands in ${path3.basename(project.file)}: ${project.commands.map((p) => p.name).join(", ") || "(none)"}` : "";
+      fail(`unknown command "${cmd}". Run localdeck --help.${hint}`);
+    }
+  }
+}
+function tryLoadProject(dependencies) {
+  try {
+    return dependencies.loadProject();
+  } catch (err) {
+    fail(err.message);
+  }
+}
+function toRunOptions(p, project, remembered, extra = {}) {
+  return {
+    name: p.name,
+    ...remembered ? { project: remembered } : {},
+    stablePort: p.port,
+    upstreamPort: p.upstream,
+    command: shellCommand(p.run),
+    displayCommand: p.run,
+    cwd: p.cwd ? path3.resolve(project.dir, p.cwd) : project.dir,
+    after: p.after,
+    ready: p.ready,
+    ...p.env ? { env: p.env } : {},
+    ...p.serviceType ? { serviceType: p.serviceType } : {},
+    ...extra
+  };
+}
+async function rememberProject(project, dependencies) {
+  try {
+    const daemon = await dependencies.ensureDaemon();
+    return await dependencies.createApi(daemon.apiPort).rememberProject(project.file, daemon.controlToken);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    dependencies.warn(`LocalDeck: could not remember this project: ${message}`);
+    return;
+  }
+}
+async function printProjectCommands(failIfNone, dependencies) {
+  const project = tryLoadProject(dependencies);
+  if (!project) {
+    if (failIfNone)
+      fail("no .localdeck file found here or in a parent folder. Create one with: localdeck init");
+    return;
+  }
+  await rememberProject(project, dependencies);
+  console.log(`${c.bold("Project commands")} ${c.dim(`(${path3.relative(process.cwd(), project.file) || path3.basename(project.file)})`)}`);
+  const rows = project.commands.map((p) => [c.cyan(p.name), p.port ? String(p.port) : c.dim("auto"), p.after.join(",") || "", p.tags.join(",") || "", c.dim(p.run)]);
+  console.log(table(rows, ["NAME", "PORT", "AFTER", "TAGS", "RUN"]));
+  console.log(c.dim(`
+run one: localdeck <name>   ·   run all: localdeck up   ·   by tag: localdeck up <tag>`));
+}
+var PALETTE = [c.cyan, c.magenta, c.green, c.yellow, c.blue];
+async function cmdUp(args, dependencies) {
+  const project = tryLoadProject(dependencies);
+  if (!project)
+    fail("no .localdeck file found here or in a parent folder. Create one with: localdeck init");
+  const profileIndex = args.indexOf("--profile");
+  let profile;
+  if (profileIndex !== -1) {
+    profile = args[profileIndex + 1];
+    if (!profile)
+      fail("--profile needs a profile name");
+    args = args.filter((_, i) => i !== profileIndex && i !== profileIndex + 1);
+  }
+  const profiles = project.profiles;
+  if (profile && (!profiles || !Object.prototype.hasOwnProperty.call(profiles, profile)))
+    fail(`unknown profile "${profile}". Available profiles: ${Object.keys(profiles ?? {}).join(", ") || "(none)"}`);
+  let selected = project.commands;
+  if (profile) {
+    const names = new Set(profiles[profile]);
+    selected = project.commands.filter((command) => names.has(command.name));
+    if (!selected.length)
+      fail(`profile "${profile}" selects no configured services`);
+  }
+  if (args.length) {
+    const allowed = new Set(selected);
+    const matches = project.commands.filter((p) => args.some((a) => findProjectCommand(project, a) === p || p.tags.includes(a)));
+    const outside = matches.filter((p) => !allowed.has(p));
+    if (profile && outside.length)
+      fail(`service outside profile "${profile}": ${outside.map((p) => p.name).join(", ")}`);
+    selected = matches.filter((p) => allowed.has(p));
+    const unknown = args.filter((a) => !findProjectCommand(project, a) && !project.commands.some((p) => p.tags.includes(a)));
+    if (unknown.length)
+      fail(`no command or tag named ${unknown.map((u) => `"${u}"`).join(", ")} in ${path3.basename(project.file)}`);
+  }
+  if (!selected.length)
+    fail("nothing to run");
+  selected = startupLayers(project.commands, selected.map((command) => command.name)).flat();
+  const remembered = await rememberProject(project, dependencies);
+  await dependencies.runForeground(selected.map((p, i) => toRunOptions(p, project, remembered, { prefix: selected.length > 1, color: PALETTE[i % PALETTE.length] })));
+}
+async function cmdInit(args, dependencies) {
+  const root = findPackageRoot() ?? process.cwd();
+  const existing = [".localdeck", ".localdeck.json", "localdeck.json"].map((f) => path3.join(root, f)).find((f) => fs4.existsSync(f));
+  const filename = args.find((a) => a === ".localdeck.json" || a === "localdeck.json") ?? (existing ? path3.basename(existing) : ".localdeck");
+  const target = path3.join(root, filename);
+  if ((existing && existing !== target || fs4.existsSync(target)) && !args.includes("--force") && !args.includes("--dry-run"))
+    fail(`${path3.basename(existing ?? target)} already exists here (use --force to overwrite)`);
+  const manual = args.indexOf("--command");
+  const nameIndex = args.indexOf("--name");
+  const manualCommand = manual >= 0 ? args[manual + 1] : undefined;
+  const manualName = nameIndex >= 0 ? args[nameIndex + 1] : undefined;
+  if (manual >= 0 && (!manualCommand || manualCommand.startsWith("--")))
+    fail("--command requires a command value");
+  if (nameIndex >= 0 && (!manualName || manualName.startsWith("--")))
+    fail("--name requires a service name");
+  if (manualCommand !== undefined && !manualCommand.trim())
+    fail("--command must not be empty");
+  if (manualCommand && !manualName)
+    fail("--command requires --name <service>");
+  if (manualName && !/^[a-z0-9][a-z0-9_-]{0,40}$/i.test(manualName))
+    fail("--name must start with a letter or number and be at most 41 characters");
+  const proposed = manualCommand ? [{ name: manualName.toLowerCase(), run: manualCommand, tags: [], cwd: undefined }] : proposeFromPackageJson();
+  if (!proposed.length)
+    fail("could not infer any runnable scripts. Add --command '<command>' --name <service>, then run localdeck init again");
+  const commands = proposed;
+  const json = commands.map((p) => ({ name: p.name, run: p.run, ...p.cwd ? { cwd: p.cwd } : {}, ...p.tags.length ? { tag: p.tags.length === 1 ? p.tags[0] : p.tags } : {} }));
+  if (args.includes("--dry-run")) {
+    console.log(JSON.stringify({ file: target, commands: json }, null, 2));
+    return;
+  }
+  console.log(table(json.map((command) => [command.name, command.run, command.cwd ?? "."]), ["SERVICE", "COMMAND", "FOLDER"]));
+  fs4.writeFileSync(target, JSON.stringify({ commands: json }, null, 2) + `
+`);
+  console.log(`${c.green("created")} ${filename} ${c.dim(manualCommand ? "from your command" : "from package.json scripts")}`);
+  await printProjectCommands(false, dependencies);
+  console.log(c.dim(`
+Optional per command: "after": "api" to start in dependency order · "port": 5173 to pin the stable port · "tag": "apps" to start a group.`));
+}
+async function cmdDoctor(args) {
+  const report = await doctor();
+  if (!report.ok)
+    process.exitCode = 1;
+  if (args.includes("--json")) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  for (const check of report.checks)
+    console.log(`${check.ok ? c.green("ok") : c.red("fail")} ${check.name}: ${check.message}${check.fix ? ` — ${check.fix}` : ""}`);
+  if (!report.ok)
+    console.log(c.yellow("Repair the failed checks and run localdeck doctor again."));
+}
+async function cmdForward(args) {
+  const targetPort = parseForwardArgs(args);
+  let forwarder;
+  try {
+    forwarder = await startForwarder({ targetPort });
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+  console.log(`forwarding http://127.0.0.1:${forwarder.port} → 127.0.0.1:${targetPort} (Ctrl-C to stop)`);
+  await new Promise((resolve) => {
+    function stop() {
+      process.removeListener("SIGINT", stop);
+      process.removeListener("SIGTERM", stop);
+      forwarder.close().then(resolve);
+    }
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+function parseForwardArgs(args) {
+  if (!args.length)
+    return 7777;
+  if (args.length !== 2 || args[0] !== "--to-port")
+    fail("usage: localdeck forward [--to-port N]");
+  const targetPort = Number(args[1]);
+  if (!/^\d+$/.test(args[1]) || !Number.isInteger(targetPort) || targetPort < 1 || targetPort > 65535)
+    fail("--to-port needs a port number between 1 and 65535");
+  return targetPort;
+}
+async function api() {
+  const d = await findDaemon();
+  if (!d)
+    fail(`LocalDeck daemon is not running. Start a service with: localdeck run <name> -- <command>`);
+  return new Api(d.apiPort);
+}
+function need(name) {
+  if (!name)
+    fail("missing service name");
+  return name;
+}
+async function cmdRun(args, dependencies) {
+  const opts = {};
+  let name;
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === "--") {
+      i++;
+      break;
+    }
+    const m = a.match(/^(?:--(port|upstream)|-(p|u))(?:=(.+))?$/);
+    if (m) {
+      const key = m[1] ?? (m[2] === "p" ? "port" : "upstream");
+      const raw = m[3] ?? args[++i];
+      const n = Number(raw);
+      if (!Number.isInteger(n) || n < 1 || n > 65535)
+        fail(`--${key} needs a port number, got "${raw ?? ""}"`);
+      opts[key] = n;
+      i++;
+      continue;
+    }
+    if (!name) {
+      name = a;
+      i++;
+      continue;
+    }
+    break;
+  }
+  const command = args.slice(i);
+  if (!command.length) {
+    const project = tryLoadProject(dependencies);
+    const found = project && name ? findProjectCommand(project, name) : undefined;
+    if (found) {
+      const remembered = await rememberProject(project, dependencies);
+      const selected = startupLayers(project.commands, [found.name]).flat();
+      return dependencies.runForeground(selected.map((command2, index) => toRunOptions(command2, project, remembered, {
+        prefix: selected.length > 1,
+        color: PALETTE[index % PALETTE.length],
+        ...command2.name === found.name ? { stablePort: opts.port ?? found.port, upstreamPort: opts.upstream ?? found.upstream } : {}
+      })));
+    }
+    fail("nothing to run. Usage: localdeck run <name> [--port 4000] <command...>");
+  }
+  await dependencies.runForeground([{ name: need(name), stablePort: opts.port, upstreamPort: opts.upstream, command }]);
+}
+function status(s) {
+  if (s.status === "stopped")
+    return c.dim("stopped");
+  if (!s.upstreamReady)
+    return c.yellow("waiting");
+  return c.green("running");
+}
+async function cmdPs(dependencies) {
+  const daemon = await dependencies.findDaemon();
+  if (!daemon)
+    fail(`LocalDeck daemon is not running. Start a service with: localdeck run <name> -- <command>`);
+  const list = await dependencies.createApi(daemon.apiPort).services();
+  if (!list.length) {
+    dependencies.log(c.dim("no services. Start one with: localdeck run <name> -- <command>"));
+    return;
+  }
+  const rows = list.map((s) => [
+    c.cyan(s.name),
+    s.projectName,
+    c.dim(s.key),
+    status(s),
+    String(s.stablePort),
+    s.status === "stopped" ? "-" : `${s.upstreamHost === "::1" ? "[::1]:" : ""}${s.upstreamPort}${s.upstreamSource === "detected" ? c.dim(" ⌕") : ""}`,
+    s.pid ? String(s.pid) : "-",
+    `${s.stats.requests} ${s.stats.serverErrors + s.stats.proxyErrors ? c.red(`(${s.stats.serverErrors + s.stats.proxyErrors} err)`) : ""}`.trim(),
+    s.share ? c.magenta(s.share.url) : "-",
+    ago(s.startedAt),
+    c.dim(s.command ?? "")
+  ]);
+  dependencies.log(table(rows, ["NAME", "PROJECT", "KEY", "STATUS", "PORT", "UPSTREAM", "PID", "REQUESTS", "SHARE", "UP", "COMMAND"]));
+}
+async function cmdPort(name) {
+  const s = await (await api()).service(need(name));
+  console.log(s.stablePort);
+}
+function fmtLog(l) {
+  const t = new Date(l.ts).toLocaleTimeString();
+  const line = l.stream === "stderr" ? c.red(l.line) : l.stream === "system" ? c.dim(l.line) : l.line;
+  return `${c.dim(t)} ${line}`;
+}
+async function cmdLogs(args, dependencies) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { follow: { type: "boolean", short: "f" }, lines: { type: "string", short: "n", default: "100" } } });
+  const reference = need(positionals[0]);
+  const daemon = await dependencies.findDaemon();
+  if (!daemon)
+    fail(`LocalDeck daemon is not running. Start a service with: localdeck run <name> -- <command>`);
+  const a = dependencies.createApi(daemon.apiPort);
+  const service = await a.service(reference);
+  for (const l of await a.logs(service.key, Number(values.lines)))
+    dependencies.log(fmtLog(l));
+  if (!values.follow)
+    return;
+  const ws = dependencies.createWebSocket(`ws://127.0.0.1:${daemon.apiPort}/api/events`);
+  ws.on("message", (raw) => {
+    const ev = JSON.parse(raw.toString());
+    if (ev.type === "log" && ev.log.service === service.key)
+      dependencies.log(fmtLog(ev.log));
+  });
+  await new Promise((resolve, reject) => {
+    ws.once("close", resolve);
+    ws.once("error", reject);
+  });
+}
+async function cmdRequests(args) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { lines: { type: "string", short: "n", default: "50" } } });
+  const name = need(positionals[0]);
+  const rows = (await (await api()).requests(name, Number(values.lines))).map((r) => [
+    c.dim(new Date(r.ts).toLocaleTimeString()),
+    r.error ? c.red("ERR") : r.status >= 500 ? c.red(String(r.status)) : r.status >= 400 ? c.yellow(String(r.status)) : c.green(String(r.status)),
+    r.method,
+    r.path,
+    `${r.durationMs}ms`,
+    r.via === "share" ? c.magenta("share") : "",
+    r.error ? c.red(r.error) : ""
+  ]);
+  console.log(table(rows, ["TIME", "STATUS", "METHOD", "PATH", "TIME", "VIA", ""]));
+}
+async function cmdShare(args) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { password: { type: "string" }, public: { type: "boolean" } } });
+  if (values.public && values.password !== undefined)
+    fail("cannot combine --password and --public");
+  const name = need(positionals[0]);
+  const password = values.public ? undefined : values.password ?? crypto.randomBytes(6).toString("base64url");
+  process.stdout.write(c.dim("starting tunnel… "));
+  const info = await (await api()).share(name, password);
+  console.log(c.green("ok"));
+  console.log(`
+  ${c.bold(info.url)}`);
+  console.log(password ? `  password: ${c.bold(password)}` : `  ${c.yellow("public — anyone with the link can open it")}`);
+  console.log(c.dim(`
+  stays up until: localdeck unshare ${name}`));
+}
+async function cmdUnshare(name) {
+  const r = await (await api()).unshare(need(name));
+  console.log(r.ok ? `share for ${name} stopped` : c.dim(`${name} was not shared`));
+}
+async function cmdStop(name) {
+  const r = await (await api()).stop(need(name));
+  console.log(r.ok ? `stop sent to ${name}` : c.dim(`${name} is not running`));
+}
+async function cmdOpen(name) {
+  const d = await ensureDaemon();
+  let url = `http://localhost:${d.apiPort}`;
+  if (name) {
+    const service = await new Api(d.apiPort).service(name);
+    if (!service.urls[0])
+      fail(`${name} is a database endpoint at ${service.upstreamHost}:${service.upstreamPort}; open it with a database client`);
+    url = service.urls[0];
+  }
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  spawn2(opener, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).unref();
+  console.log(url);
+}
+async function cmdDaemon(sub) {
+  switch (sub) {
+    case "status": {
+      const d = await findDaemon();
+      console.log(d ? `running · pid ${d.pid} · http://localhost:${d.apiPort} · up ${ago(d.startedAt)} · ${HOME_DIR}` : "not running");
+      return;
+    }
+    case "stop": {
+      const d = await findDaemon();
+      if (!d)
+        return console.log("not running");
+      await new Api(d.apiPort).shutdown();
+      console.log("daemon stopped");
+      return;
+    }
+    case "start": {
+      const d = await ensureDaemon();
+      console.log(`running · pid ${d.pid} · http://localhost:${d.apiPort}`);
+      return;
+    }
+    case "run": {
+      const allowedBrowserOrigins = (process.env.LOCALDECK_DEV_ORIGINS ?? "").split(",").map((origin) => origin.trim()).filter(Boolean);
+      const daemon = await startDaemon({
+        dashboardDir: dashboardDir(),
+        ...allowedBrowserOrigins.length > 0 ? { allowedBrowserOrigins } : {}
+      });
+      console.log(`[${new Date().toISOString()}] localdeck daemon v${VERSION} on http://127.0.0.1:${daemon.apiPort} (pid ${process.pid})`);
+      const bye = async () => {
+        await daemon.stop();
+      };
+      process.on("SIGINT", bye);
+      process.on("SIGTERM", bye);
+      await daemon.stopped;
+      return;
+    }
+    default:
+      fail("usage: localdeck daemon status|start|stop|run");
+  }
+}
+async function runCli(argv = process.argv.slice(2)) {
+  try {
+    await main(argv);
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+}
+var WRAPPER_IMPORT = Symbol.for("localdeck.cli.wrapper-import");
+if (__require.main == __require.module && Reflect.get(globalThis, WRAPPER_IMPORT) !== true)
+  await runCli();
+export {
+  toRunOptions,
+  runCli,
+  parseForwardArgs,
+  main
+};