infra-kit 0.3.13 → 0.3.15

package/dist/chunk-QLAQ7F4M.js

@@ -1,7 +0,0 @@
-import{B as f,W as E,d as x}from"./chunk-SSBYKOHY.js";import{q as w}from"./chunk-CHETBZ6M.js";import{a as k,b as S}from"./chunk-X46DP23W.js";import p from"node:fs/promises";import c from"node:path";import{z as s}from"zod";var i=class extends Error{env;constructor(e,o=null){super(e),this.name="EnvAuthError",this.env=o}},K=t=>t instanceof i;import b from"node:fs/promises";import $ from"node:os";var C=async t=>{try{return await b.access(t),!0}catch{return!1}},l=t=>{let e=$.homedir();return t.startsWith(e)?`~${t.slice(e.length)}`:t};var I="tokens.json",d=1,y=384,T=448,N=s.object({version:s.literal(d).default(d),envs:s.record(s.string().min(1),s.string().min(1))}).strict(),u=async()=>{let t=await E();return c.join(c.dirname(t.userProject),I)},g=async()=>{let t=await u(),e;try{e=await p.readFile(t,"utf-8")}catch{return null}let o;try{o=JSON.parse(e)}catch(n){throw new i(`Invalid JSON in the token store at ${l(t)}: ${n.message}
-Fix or delete the file, then re-add the token with \`infra-kit env-token-set <env>\`.`)}let r=N.safeParse(o);if(!r.success)throw new i(`Invalid token store at ${l(t)}: ${s.prettifyError(r.error)}
-Fix or delete the file, then re-add the token with \`infra-kit env-token-set <env>\`.`);return r.data},h=async t=>{let e=await u(),o=c.dirname(e),r=c.dirname(o),n=c.dirname(r);for(let a of[n,r,o])await p.mkdir(a,{recursive:!0,mode:T}),await p.chmod(a,T);w(e,`${JSON.stringify(t,null,2)}
-`,y),await p.chmod(e,y)},_=async(t,e)=>{let o=await g();await h({version:d,envs:{...o?.envs,[t]:e}})},j=async t=>{let e=await g();if(!e||!(t in e.envs))return;let o={...e.envs};delete o[t],await h({version:d,envs:o})};var D=()=>{let t="",e=[],o=!1;return{start(r){t=r,e=[],o=!1},setInteractive(){o=!0},addOption(r,n){e.push({flag:r,value:n})},formatOptions(){return e.map(r=>typeof r.value=="boolean"?r.value?r.flag:"":Array.isArray(r.value)?`${r.flag} "${r.value.join(", ")}"`:`${r.flag} "${r.value}"`).filter(Boolean).join(" ")},snapshot(){return e.length===0?null:{formattedOptions:this.formatOptions()}},print(){!o||e.length===0||!t||f.info(`\u{1F4DF} Equivalent command: 
-pnpm exec infra-kit ${t} ${this.formatOptions()}
-`)},reset(){t="",e=[],o=!1}}},v=D();import O from"node:process";var A=27,P=async(t,e)=>{let o=new AbortController,r={...e,signal:o.signal};if(x()||!O.stdin.isTTY)return t(r);let n=O.stdin,a=m=>{m.length===1&&m[0]===A&&o.abort()};k();try{let m=t(r);return n.isPaused()&&n.resume(),n.on("data",a),await m}finally{n.removeListener("data",a),S()}};import F from"@inquirer/confirm";import R from"node:process";var J=async(t,e)=>{let o=t?!0:await P(r=>F({message:e},r));t||v.setInteractive(),o||(f.info("Operation cancelled. Exiting..."),R.exit(0))};export{i as a,K as b,C as c,l as d,u as e,g as f,_ as g,j as h,v as i,P as j,J as k};
-//# sourceMappingURL=chunk-QLAQ7F4M.js.map

package/dist/chunk-RVTI3AL2.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/dev/render.ts"],
-  "sourcesContent": ["/**\n * Terminal renderer for `infra-kit dev` \u2014 a calm-print layer (never a full-screen TUI).\n *\n * The boot collapses into a single transient spinner; the final screen is a STATUS PANEL, one row per\n * server, carrying health, uptime, requests/min, restarts and an error count. There is no log tail:\n * every line \u2014 framework output, request logs, a handler's own `console.log` \u2014 is written to that\n * service's file under `<cacheRoot>/<session>/dev/<pid>/` and never printed. What still appears above\n * the panel is only what the RUNNER says: a restart, an unhealthy app, a dead engine.\n *\n * The panel's live fields are the reason it is a status surface and not a screenshot. With nothing\n * scrolling beside it, a panel whose numbers never move cannot be told apart from a hung process.\n *\n * All I/O is injected (`write` / `appendLog` / `isTTY` / `now`) so every frame is snapshot-testable and\n * the spinner is deterministically disabled in tests (`isTTY: false`).\n */\nimport process from 'node:process'\n\nimport type { DevUi } from './dev-ui.js'\n\nexport type LogLevel = 'info' | 'warn' | 'error' | 'debug'\n\n/**\n * Per-call options for {@link DevRenderer.log}.\n *\n * `tee: false` exists for exactly one caller: `DevServerRunner.reportFault`, which files the fault into the\n * sink ITSELF (at `error` level \u2014 that is what turns the panel row red) and then prints it. Without this\n * opt-out the print tees a SECOND copy into the same `runner.log`, so every fault is filed twice \u2014 a\n * literal 2\u00D7 amplifier sitting at the centre of the loop that wrote 455 GB.\n */\nexport interface LogOptions {\n  /** Also append the line to the log file. Default `true`; `false` prints without filing. */\n  tee?: boolean\n}\n\n/**\n * A row's liveness, as the runner's probe state machine resolved it.\n *\n * Five arms, not a boolean, because a probe has three outcomes and a row has a history. The two that\n * are neither `ok` nor `down` are the honest ones: a UI that has never answered yet is `starting`\n * (vite is spawned after the ready frame, so red would be a lie for the first seconds), and a port that\n * answers something OTHER than vite's ping is `unverified` \u2014 a squatter, a shadowing proxy, or a future\n * vite that dropped the endpoint are all consistent with that, and only one of them is broken. Red must\n * stay a PROOF of failure, so `unverified` renders a question mark and never a red dot.\n */\nexport type HealthState = 'ok' | 'down' | 'starting' | 'unverified' | 'unknown'\n\n/** Injected I/O seams. Defaults wire to the real stdout + a caller-provided file appender. */\nexport interface DevRendererDeps {\n  /** Terminal sink (default: `process.stdout.write`). */\n  write: (text: string) => void\n  /** File tee \u2014 always receives full detail (default: no-op; the runner passes its log appender). */\n  appendLog: (text: string) => void\n  /** Whether the terminal is a TTY. Gates the spinner + ANSI color; false in CI / when piped. */\n  isTTY: boolean\n  /** Clock seam (default: `() => new Date()`), so timestamps + `ready in Xs` are testable. */\n  now: () => Date\n  /** When true, boot narration reaches the terminal; otherwise it is file-only. */\n  verbose: boolean\n}\n\n/**\n * One resolved proxy route on a frontend, painted as an indented line under that app's row: which route,\n * where it lands, and whether it is the local backend or the shared cloud one. This is the \"all proxies \u2014\n * which one and where\" surface: unlike a {@link DegradedRow} it reports the happy path too, so a frontend\n * that proxies `/api` local and `/media` cloud shows both, and nobody has to guess where a route points.\n */\nexport interface ProxyRouteRow {\n  /** Route path (e.g. `/api`). */\n  route: string\n  /** Where the route resolves this run \u2014 the local backend or the shared cloud origin. */\n  source: 'local' | 'cloud'\n  /**\n   * The origin the route lands on. Omitted when it is not knowable (a `local` route whose backend is not\n   * up \u2014 a dead alias the degraded row already owns \u2014 or a `cloud` route with no `<env>` sourced).\n   */\n  target?: string\n}\n\n/**\n * One server's row on the status panel.\n *\n * The live fields below are what make the panel a STATUS surface rather than a screenshot. The terminal\n * no longer carries a log tail, so a static row would leave \"quiet\" indistinguishable from \"hung\" \u2014 the\n * moving numbers are the liveness tell, and they are not decoration.\n */\nexport interface EndpointRow {\n  /** Stream tag, e.g. `client/api`. */\n  tag: string\n  /** The app's `.localhost` alias URL \u2014 the only form, since an app that cannot be aliased never starts. */\n  url: string\n  /** Liveness, as {@link HealthState} defines it; `unknown` renders no dot at all (nothing to probe). */\n  health: HealthState\n  /** Milliseconds since this server last (re)started. Omitted on the boot frame. */\n  uptimeMs?: number\n  /** Watch-triggered restarts so far this session. */\n  restarts?: number\n  /** Requests served in the last 60s. */\n  rpm?: number\n  /**\n   * Errors this service has declared since boot \u2014 a 5xx, a `console.error`, a framework failure line.\n   * This is the ONLY error signal the user gets now that nothing prints, so a row that cannot count is\n   * a row that lies. A COUNT, never a classification: it is incremented from the level the emitter\n   * declared, never from anything read out of the line's text.\n   */\n  errors?: number\n  /**\n   * Resolved proxy routes for a frontend row (a `<app>/ui` endpoint), painted as an indented list under\n   * it. Absent on backend rows \u2014 a `<app>/api` endpoint proxies nothing \u2014 and on a frontend with no\n   * `dev.proxy` block.\n   */\n  proxies?: ProxyRouteRow[]\n}\n\n/**\n * A UI app whose URL the runner does not own, so it streams its own below \u2014 referenced, never given a\n * (fabricated) endpoint row. The fallback case only: a UI whose port the runner pre-assigned is an\n * {@link EndpointRow}, proxy or no proxy.\n */\nexport interface UiRef {\n  /** Stream tag, e.g. `client/ui`. */\n  tag: string\n  /**\n   * Errors this UI has declared since boot. Present for the same reason an {@link EndpointRow} has one:\n   * with nothing printing, a row that cannot count is a row that lies \u2014 and this row belongs to the app\n   * whose vite config never wired `infraKitDev()`, i.e. the one most likely to be misconfigured.\n   */\n  errors?: number\n  /** Resolved proxy routes for this frontend, painted as an indented list under its reference line. */\n  proxies?: ProxyRouteRow[]\n}\n\n/**\n * An app that was asked for but never came up. It has no URL and no health \u2014 but it MUST still get a\n * row: the header is a report of what the user asked for, and an app that silently vanishes from it\n * reads as \"not requested\" rather than \"broken\".\n */\nexport interface FailedRow {\n  /** Stream tag, e.g. `client/api`. */\n  tag: string\n  /** One-line reason, e.g. `config is missing field: 'connectionURL'`. */\n  reason: string\n}\n\n/**\n * A route that wanted a local backend and is falling back to cloud because that backend failed to start.\n *\n * It gets a row of its own \u2014 not a footnote on the failed backend's row \u2014 because the two facts land on\n * different people. `client/api \u25CF failed` says a server is down, which reads as \"that half is broken\".\n * It does NOT say the frontend beside it came up healthy and is now sending every `/api` request to the\n * shared cloud backend. That second fact is the one that gets you writing to the cloud dev database\n * while you believe you are on localhost, and it is invisible everywhere else on the screen: the vite\n * proxy resolved cleanly, so nothing else has anything to complain about.\n *\n * Only rendered under `--watch` \u2014 without it the run is refused outright (see `local-pairing.ts`).\n */\nexport interface DegradedRow {\n  /** Route path (e.g. `/api`). */\n  route: string\n  /** Stream tag of the frontend serving it, e.g. `client/ui`. */\n  tag: string\n  /**\n   * Where the route ACTUALLY resolves now. Not always `cloud`: the helper falls back to\n   * `route.default ?? route.from[0]`, so a single-source `from: ['local']` route with no `default` falls\n   * back to `local` \u2014 at an alias nothing registered, i.e. a 502 on every request. The row must name the\n   * real destination, or it is doing the same lying-by-omission it exists to prevent.\n   */\n  fallback: 'local' | 'cloud'\n  /** The cloud origin it now resolves to. Only ever set when `fallback` is `cloud` and it is knowable. */\n  target?: string\n}\n\n/** Everything {@link DevRenderer.ready} needs to paint the final header in one shot. */\nexport interface ReadySummary {\n  /** Resolved preset / target label (e.g. `client`, `*`). */\n  target: string\n  watch: boolean\n  /** Slugified release for the header meta; omitted outside a git repo. */\n  release?: string\n  /** Backend readiness time in ms (UI is fire-and-forget, so this is BE-only \u2014 labeled honestly). */\n  elapsedMs: number\n  /** Real backend endpoint rows (owned ports + pre-probed health). */\n  endpoints: EndpointRow[]\n  /** UI apps that print their own URL below. */\n  uiRefs: UiRef[]\n  /**\n   * Apps that failed to start. Optional only so the (many) existing summaries need not restate an\n   * empty list; a non-empty one downgrades the title from a green `ready` to an honest `N failed`.\n   */\n  failed?: FailedRow[]\n  /**\n   * Routes silently demoted from local to cloud by a backend that failed to start. Recomputed on every\n   * repaint, so a route CLEARS from the panel the moment `--watch` gets its backend up (see\n   * {@link DegradedRow}).\n   */\n  degraded?: DegradedRow[]\n  /** Human watch summary, e.g. `1 app \u00B7 5 packages`; omitted when not watching. */\n  watchSummary?: string\n  /**\n   * Compact, human-readable log path shown as the `logs \u2192 \u2026` label. A DIRECTORY, not a file\n   * (e.g. `~/.cache/infra-kit/<session>/dev/<pid>`): there is one log per service, so a single path\n   * would have to pick a favourite.\n   */\n  logPath: string\n  /** Absolute log path backing the clickable OSC-8 hyperlink (wrapped as `file://<logHref>`). */\n  logHref: string\n  /**\n   * Milliseconds since the session became ready \u2014 the panel's HEARTBEAT.\n   *\n   * Every other live field belongs to a backend: uptime, req/min, restarts. A UI-only session has no\n   * backend, so its rows have nothing that moves \u2014 and Ink does not repaint an identical frame, so the\n   * screen would sit perfectly still while the session ran. With no log tail left to prove otherwise,\n   * a motionless panel is indistinguishable from a hung process. This is the one field that ticks for\n   * EVERY session shape. Omitted on the boot frame, where nothing has elapsed yet.\n   */\n  sessionUptimeMs?: number\n}\n\nconst SPINNER_FRAMES = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F']\nconst SPINNER_INTERVAL_MS = 80\n\nconst ANSI = {\n  reset: '\\x1B[0m',\n  dim: '\\x1B[2m',\n  bold: '\\x1B[1m',\n  teal: '\\x1B[36m',\n  green: '\\x1B[32m',\n  blue: '\\x1B[34m',\n  red: '\\x1B[31m',\n} as const\n\n/** Erase the current line and return the cursor to column 0 (used to clear the spinner). */\nconst CLEAR_LINE = '\\r\\x1B[2K'\n\n/**\n * SGR color codes (`ESC [ \u2026 m`) and OSC-8 hyperlink wrappers (`ESC ] 8 ; ; \u2026 ESC \\`), non-greedy.\n * Matching the ESC control character is the whole point here \u2014 this pattern exists to remove it.\n */\n// eslint-disable-next-line sonarjs/no-control-regex, no-control-regex\nconst ANSI_PATTERN = /\\x1B\\[[0-9;]*m|\\x1B\\]8;;.*?\\x1B\\\\/g\n\n/**\n * Strip SGR colors + OSC-8 hyperlink escapes, keeping the hyperlink's visible label. Applied at the\n * file-tee seam so `logs.txt` stays greppable plain text even though the terminal frames it renders\n * from are colored + hyperlinked (both renderers format once, for a TTY, and tee the same string).\n */\nexport const stripAnsi = (s: string): string => {\n  return s.replace(ANSI_PATTERN, '')\n}\n\n/** Zero-pad to 2 digits for `HH:MM:SS`. */\nconst pad2 = (n: number): string => {\n  return String(n).padStart(2, '0')\n}\n\n/** `HH:MM:SS` for a tail timestamp. */\nexport const formatClock = (d: Date): string => {\n  return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`\n}\n\n/** `2.4s` for the `ready in \u2026` header. */\nexport const formatElapsed = (ms: number): string => {\n  return `${(ms / 1000).toFixed(1)}s`\n}\n\n/**\n * `47s` / `4m12s` / `2h03m` \u2014 the panel's liveness tell.\n *\n * With no log tail on screen, a panel whose numbers never move is indistinguishable from a hung\n * process. This is the field that proves the session is alive even when nothing is happening, so it is\n * always rendered and always advancing.\n */\nexport const formatUptime = (ms: number): string => {\n  const total = Math.max(0, Math.floor(ms / 1000))\n  const hours = Math.floor(total / 3600)\n  const minutes = Math.floor((total % 3600) / 60)\n  const seconds = total % 60\n\n  if (hours > 0) return `${hours}h${pad2(minutes)}m`\n  if (minutes > 0) return `${minutes}m${pad2(seconds)}s`\n\n  return `${seconds}s`\n}\n\n/**\n * Resolve the endpoint URL for an app: `https://<alias><prefix>`, where `alias` is the portless hostname\n * the runner registered (e.g. `feat-x.backend-api.localhost`). The runner refuses to start an app it could\n * not alias, so there is no port-form to fall back to.\n *\n * There is no port and no scheme choice, by construction. The proxy serves TLS on 443 \u2014 the implicit HTTPS\n * port \u2014 so the URL is byte-identical to the `dev.proxy` local template that `infra-kit/vite` proxies to,\n * and what the table prints cannot drift from what the frontend calls. Any port suffix here would mean the\n * proxy is not on 443, which `ensureProxy` has already refused to start.\n */\nexport const resolveEndpointUrl = (input: { prefixUrl: string; alias: string }): string => {\n  return `https://${input.alias}${input.prefixUrl}`\n}\n\nexport class DevRenderer implements DevUi {\n  private readonly deps: DevRendererDeps\n  private spinnerTimer: ReturnType<typeof setInterval> | null = null\n  private spinnerPhase = ''\n  private spinnerFrame = 0\n\n  constructor(deps: Partial<DevRendererDeps> = {}) {\n    this.deps = {\n      write:\n        deps.write ??\n        ((text: string): void => {\n          process.stdout.write(text)\n        }),\n      appendLog: deps.appendLog ?? ((): void => {}),\n      isTTY: deps.isTTY ?? Boolean(process.stdout.isTTY),\n      now:\n        deps.now ??\n        ((): Date => {\n          return new Date()\n        }),\n      verbose: deps.verbose ?? false,\n    }\n  }\n\n  /** Wrap `s` in an ANSI color on a TTY; return it untouched when piped (deterministic snapshots). */\n  private color(code: string, s: string): string {\n    return this.deps.isTTY ? `${code}${s}${ANSI.reset}` : s\n  }\n\n  /**\n   * Wrap `label` in an OSC-8 terminal hyperlink to `href` (a filesystem path \u2192 `file://` URI) so the\n   * log path is cmd/ctrl-clickable. Returns the bare `label` when piped (deterministic snapshots) or\n   * when `href` is empty \u2014 terminals without OSC-8 support silently ignore the escapes anyway.\n   */\n  private hyperlink(href: string, label: string): string {\n    if (!this.deps.isTTY || href === '') return label\n\n    // `encodeURI` escapes spaces / non-ASCII but leaves `#` and `?`, which a file URI reads as a\n    // fragment / query \u2014 encode those too so a path containing them still resolves to the real file.\n    const uri = encodeURI(href).replace(/[#?]/g, (c) => {\n      return `%${c.charCodeAt(0).toString(16).toUpperCase()}`\n    })\n\n    return `\\x1B]8;;file://${uri}\\x1B\\\\${label}\\x1B]8;;\\x1B\\\\`\n  }\n\n  /**\n   * Append one line to the log file ONLY \u2014 the canonical `[iso] [LEVEL] msg` shape, no terminal write.\n   * The single source of the file-tee format: the private {@link tee} and the Ink boot UI both route\n   * here, so the log file stays identical whichever renderer is live.\n   */\n  teeOnly(message: string, level: LogLevel): void {\n    this.deps.appendLog(`[${this.deps.now().toISOString()}] [${level.toUpperCase()}] ${stripAnsi(message)}\\n`)\n  }\n\n  /** File tee for a line that is ALSO written to the terminal; delegates the format to {@link teeOnly}. */\n  private tee(message: string, level: LogLevel): void {\n    this.teeOnly(message, level)\n  }\n\n  /**\n   * No-op for the plain renderer: it owns no Ink / raw-mode terminal state to release. Present to\n   * satisfy {@link DevUi} so the runner can call `dispose()` uniformly. Idempotent by construction.\n   */\n  dispose(): void {\n    // Nothing to release \u2014 the plain renderer never seizes the terminal.\n  }\n\n  /**\n   * Write one terminal line spinner-safely: if the spinner is live on a TTY, erase it, print the\n   * line, then repaint the spinner, so a mid-boot message never shreds the `\\r`-based spinner.\n   */\n  private emit(line: string): void {\n    if (this.spinnerTimer != null && this.deps.isTTY) {\n      this.deps.write(`${CLEAR_LINE}${line}\\n`)\n      this.paintSpinner()\n\n      return\n    }\n\n    this.deps.write(`${line}\\n`)\n  }\n\n  /** A general message routed by level (terminal + file tee). Debug is terminal-only in verbose. */\n  log(message: string, level: LogLevel = 'info', options: LogOptions = {}): void {\n    if (level !== 'debug' || this.deps.verbose) {\n      this.emit(message)\n    }\n    if (options.tee !== false) {\n      this.tee(message, level)\n    }\n  }\n\n  /** A boot-narration step: terminal only when `--verbose`, but always tee'd to the log. */\n  narrate(message: string): void {\n    if (this.deps.verbose) {\n      this.emit(message)\n    }\n    this.tee(message, 'info')\n  }\n\n  /** `LogFn`-shaped adapter for the build runner seam (which passes `(msg, level)`). */\n  readonly logFn = (message: string, level: LogLevel = 'info'): void => {\n    this.log(message, level)\n  }\n\n  // ---- boot spinner -------------------------------------------------------\n\n  /** Paint the current spinner frame in place (TTY only). */\n  private paintSpinner(): void {\n    const frame = SPINNER_FRAMES[this.spinnerFrame % SPINNER_FRAMES.length]!\n\n    this.deps.write(`${CLEAR_LINE}${this.color(ANSI.teal, frame)} ${this.color(ANSI.dim, this.spinnerPhase)}`)\n  }\n\n  /**\n   * Update the boot phase. On a TTY this drives a single transient spinner line; when piped it\n   * prints one plain phase line (no ANSI, deterministic). Always tee'd to the log.\n   */\n  bootStep(phase: string): void {\n    this.tee(phase, 'info')\n    this.spinnerPhase = phase\n\n    if (!this.deps.isTTY) {\n      this.deps.write(`${phase}\\n`)\n\n      return\n    }\n\n    if (this.spinnerTimer == null) {\n      this.spinnerTimer = setInterval(() => {\n        this.spinnerFrame += 1\n        this.paintSpinner()\n      }, SPINNER_INTERVAL_MS)\n      // Never keep the event loop alive for the spinner alone.\n      this.spinnerTimer.unref?.()\n    }\n    this.paintSpinner()\n  }\n\n  /** Stop + erase the spinner line (idempotent). Called before the ready header prints. */\n  stopSpinner(): void {\n    if (this.spinnerTimer != null) {\n      clearInterval(this.spinnerTimer)\n      this.spinnerTimer = null\n    }\n    if (this.deps.isTTY) {\n      this.deps.write(CLEAR_LINE)\n    }\n  }\n\n  // ---- the ready header ---------------------------------------------------\n\n  /**\n   * The error counter, shared by endpoint rows and UI reference rows.\n   *\n   * Zero is rendered, not omitted: with nothing else printing, this is the only failure signal on the\n   * screen, so a dim `\u26A0 0` is a claim worth making.\n   *\n   * Non-zero is BOLD red, and that is not decoration. A frontend that fails to compile still serves and\n   * still answers vite's ping, so its dot stays green \u2014 the dot is liveness, and the app IS alive. This\n   * counter is the only thing on the screen that says the app is nevertheless broken, so it has to win a\n   * glance against a green dot sitting two columns away.\n   */\n  private errorCount(errors: number): string {\n    const text = `\u26A0 ${errors}`\n\n    return errors > 0 ? this.color(`${ANSI.bold}${ANSI.red}`, text) : this.color(ANSI.dim, text)\n  }\n\n  /**\n   * The padded tag gutter for a PANEL row \u2014 red once the row has declared an error, teal otherwise.\n   *\n   * Footer only, never {@link formatHeaderLines}. The header is committed once through Ink's `<Static>`,\n   * so a tag reddened there would be a photograph of the boot: it could never turn red later, and \u2014 far\n   * worse \u2014 could never turn back. The panel repaints, so the color tracks the fact.\n   */\n  private tagCell(tag: string, tagWidth: number, errors: number | undefined): string {\n    return this.color((errors ?? 0) > 0 ? ANSI.red : ANSI.teal, tag.padEnd(tagWidth))\n  }\n\n  /** Format the health dot for an endpoint row \u2014 one arm per {@link HealthState}; `unknown` prints nothing. */\n  private healthDot(health: HealthState): string {\n    switch (health) {\n      case 'ok':\n        return this.color(ANSI.green, '\u25CF ok')\n      case 'down':\n        return this.color(ANSI.red, '\u25CF down')\n      case 'starting':\n        return this.color(ANSI.dim, '\u25CC starting')\n      // Answering, but not with vite's ping. Dim, never red: a non-204 is equally consistent with a\n      // broken squatter and a perfectly healthy vite behind something that shadows the ping, and a red\n      // dot on a coin-flip is how a dot stops being read at all.\n      case 'unverified':\n        return this.color(ANSI.dim, '\u25CD ?')\n      default:\n        return ''\n    }\n  }\n\n  /**\n   * Collapse the boot and print the final header in one shot: title line, one endpoint row per\n   * backend server (with health dot), a reference line per UI app, the watch line, the clickable\n   * log path, and a separator rule. Synchronous \u2014 health is pre-probed by the caller.\n   */\n  ready(summary: ReadySummary): void {\n    this.stopSpinner()\n\n    const lines = this.formatReadyLines(summary)\n\n    for (const line of lines) {\n      this.emit(line)\n      this.tee(line, 'info')\n    }\n  }\n\n  /** Column width for the aligned `tag` gutter \u2014 the widest endpoint/UI/failed tag. */\n  private tagWidth(summary: ReadySummary): number {\n    const tags = [\n      ...summary.endpoints.map((e) => {\n        return e.tag\n      }),\n      ...summary.uiRefs.map((u) => {\n        return u.tag\n      }),\n      ...(summary.failed ?? []).map((f) => {\n        return f.tag\n      }),\n      // A degraded row's gutter is `<tag> <route>`, which is wider than any bare tag \u2014 measure the label\n      // it actually prints or its `\u25CF cloud \u2026` cell would sit out of column with every row above it.\n      ...(summary.degraded ?? []).map((d) => {\n        return `${d.tag} ${d.route}`\n      }),\n    ]\n\n    return tags.reduce((w, t) => {\n      return Math.max(w, t.length)\n    }, 0)\n  }\n\n  /**\n   * The `infra-kit dev \u00B7 <meta>   ready in Xs` title line.\n   *\n   * A green `ready` is a claim about the whole session, so it is spent only when the whole session\n   * is up. With anything in `failed` the status turns red and counts the casualties instead \u2014 the\n   * boot time alone, next to a green word, is exactly how a half-dead session used to pass for a\n   * healthy one.\n   */\n  private titleLine(summary: ReadySummary): string {\n    const meta = [summary.target, summary.watch ? 'watch' : null, summary.release]\n      .filter((s): s is string => {\n        return Boolean(s)\n      })\n      .join(' \u00B7 ')\n\n    const failedCount = summary.failed?.length ?? 0\n    const elapsed = formatElapsed(summary.elapsedMs)\n    const status =\n      failedCount > 0\n        ? this.color(ANSI.red, `${failedCount} failed \u00B7 started in ${elapsed}`)\n        : this.color(ANSI.green, `ready in ${elapsed}`)\n\n    return `  ${this.color(ANSI.bold, 'infra-kit dev')}  ${this.color(ANSI.dim, meta)}   ${status}`\n  }\n\n  /** The static legend tail: watch line + clickable log path, then a separator rule. */\n  private legendLines(summary: ReadySummary): string[] {\n    const watchText = summary.watch && summary.watchSummary ? `watching ${summary.watchSummary}` : 'watch off'\n    const logLink = this.hyperlink(summary.logHref, summary.logPath)\n    const watchLine = `${watchText}          logs \u2192 ${logLink}`\n    const rule = '\u2500'.repeat(60)\n\n    return [`  ${this.color(ANSI.dim, watchLine)}`, `  ${this.color(ANSI.dim, rule)}`]\n  }\n\n  /**\n   * A UI reference row \u2014 used when infra-kit could not claim the UI's port, so it has no URL to print.\n   *\n   * It STILL carries an error count. That is the whole point: this row is exactly the misconfigured app\n   * (its vite config never wired `infraKitDev()`), which is the app most likely to be broken \u2014 and with\n   * no log tail on screen, a row with no error field is a row that cannot report the breakage. It used\n   * to be a bare reference line, so its errors were counted into a file nobody had a reason to open.\n   */\n  private uiRefLine(ref: UiRef, tagWidth: number, errors: number | undefined): string {\n    const errText = errors == null ? '' : `  ${this.errorCount(errors)}`\n\n    return `  ${this.color(ANSI.teal, ref.tag.padEnd(tagWidth))}  ${this.color(\n      ANSI.dim,\n      'no managed port (vite prints its own URL)',\n    )}${errText}`\n  }\n\n  /**\n   * The live half of an endpoint row: `up 4m12s   18/min   \u21BA2   \u26A0 3`.\n   *\n   * Empty on the boot frame (no field is set yet). Each field is omitted individually when absent \u2014 a\n   * server with no restarts should not have to say so.\n   */\n  private statusFields(endpoint: ReadySummary['endpoints'][number]): string {\n    const parts: string[] = []\n\n    if (endpoint.uptimeMs != null) parts.push(this.color(ANSI.dim, `up ${formatUptime(endpoint.uptimeMs)}`))\n    if (endpoint.rpm != null && endpoint.rpm > 0) parts.push(this.color(ANSI.dim, `${endpoint.rpm}/min`))\n    if (endpoint.restarts != null && endpoint.restarts > 0) parts.push(this.color(ANSI.dim, `\u21BA${endpoint.restarts}`))\n    // Errors are the exception to \"omit when zero\" \u2014 see {@link errorCount}.\n    if (endpoint.errors != null) {\n      parts.push(this.errorCount(endpoint.errors))\n    }\n\n    return parts.join('   ')\n  }\n\n  /** One endpoint row (`client/api  https://\u2026  \u25CF ok  up 4m12s  18/min  \u26A0 0`). */\n  private endpointLine(endpoint: ReadySummary['endpoints'][number], tagWidth: number, withHealthDot: boolean): string {\n    const dot = withHealthDot ? this.healthDot(endpoint.health) : ''\n    const status = this.statusFields(endpoint)\n    const suffix = [dot, status].filter(Boolean).join('  ')\n\n    return `  ${this.color(ANSI.teal, endpoint.tag.padEnd(tagWidth))}  ${this.color(ANSI.blue, endpoint.url)}${\n      suffix ? `  ${suffix}` : ''\n    }`\n  }\n\n  /** One failed row (`client/api  \u25CF failed  <reason>`) \u2014 no URL, because there is nothing listening. */\n  private failedLine(failed: FailedRow, tagWidth: number): string {\n    return `  ${this.color(ANSI.teal, failed.tag.padEnd(tagWidth))}  ${this.color(\n      ANSI.red,\n      '\u25CF failed',\n    )}  ${this.color(ANSI.dim, failed.reason)}`\n  }\n\n  /**\n   * One degraded-route row (`\u26A0 /api  \u25CF cloud (local backend failed)  https://dev.hulyo.co.il`).\n   *\n   * Tagged by ROUTE, not by app, and deliberately so: the app rows above already say what is up and what\n   * is down, and neither of them can say \"the frontend that came up healthy is talking to cloud\". The\n   * route is the thing that got redirected, so the route is what the row is about.\n   */\n  private degradedLine(row: DegradedRow, tagWidth: number): string {\n    const label = `${row.tag} ${row.route}`\n    // A `local` fallback is not a cloud proxy \u2014 it is a dead alias that 502s. Saying \"cloud\" there would\n    // name a destination the traffic never reaches.\n    const state = row.fallback === 'cloud' ? '\u25CF cloud (local backend down)' : '\u25CF dead alias (local backend down)'\n    const target = row.target ? `  ${this.color(ANSI.dim, row.target)}` : ''\n\n    return `  ${this.color(ANSI.red, '\u26A0')} ${this.color(ANSI.teal, label.padEnd(tagWidth))}  ${this.color(\n      ANSI.red,\n      state,\n    )}${target}`\n  }\n\n  /**\n   * The indented proxy lines painted under a frontend's row: `  \u251C /api    \u25CF local  https://\u2026`. One per\n   * resolved route, so \"which one and where\" is answered inline instead of left to guess. A filled dot is\n   * the local backend, a hollow one the shared cloud origin \u2014 the same local=\u25CF/cloud=\u25CB language the rest\n   * of the panel uses. The last route gets a `\u2514` elbow so the group reads as one block belonging to the\n   * app above it. Empty when the frontend declares no routes.\n   */\n  private proxyLines(proxies: ProxyRouteRow[]): string[] {\n    if (proxies.length === 0) return []\n\n    const routeWidth = Math.max(\n      ...proxies.map((p) => {\n        return p.route.length\n      }),\n    )\n\n    return proxies.map((p, i) => {\n      const elbow = i === proxies.length - 1 ? '\u2514' : '\u251C'\n      const dot = p.source === 'local' ? this.color(ANSI.green, '\u25CF') : this.color(ANSI.dim, '\u25CB')\n      const where = p.target ? `  ${this.color(ANSI.blue, p.target)}` : ''\n\n      return `    ${this.color(ANSI.dim, elbow)} ${this.color(ANSI.teal, p.route.padEnd(routeWidth))}  ${dot} ${this.color(\n        ANSI.dim,\n        p.source,\n      )}${where}`\n    })\n  }\n\n  /**\n   * Shared header layout: blank, title line, blank, one endpoint row per backend, a reference row per\n   * UI app, then the watch/log legend. `withHealthDot` is the ONLY difference between the static Ink\n   * header (false \u2014 health is live, the footer owns it) and the ready/boot frame (true).\n   */\n  private formatLines(summary: ReadySummary, { withHealthDot }: { withHealthDot: boolean }): string[] {\n    const tagWidth = this.tagWidth(summary)\n    const lines: string[] = ['', this.titleLine(summary), '']\n\n    for (const e of summary.endpoints) {\n      lines.push(this.endpointLine(e, tagWidth, withHealthDot))\n      // A frontend's proxy routes hang directly off its own row, so \"where does /api go\" reads as a\n      // property of the app rather than a footnote somewhere below it.\n      if (e.proxies) lines.push(...this.proxyLines(e.proxies))\n    }\n    // Failures sit with the live rows, not in the scrollback above: the log line announcing the crash\n    // is metres up the terminal by now, and the header is the only thing the user actually reads.\n    for (const f of summary.failed ?? []) {\n      lines.push(this.failedLine(f, tagWidth))\n    }\n    for (const u of summary.uiRefs) {\n      lines.push(this.uiRefLine(u, tagWidth, u.errors))\n      if (u.proxies) lines.push(...this.proxyLines(u.proxies))\n    }\n    // Below the app rows, because it is a consequence of one of them \u2014 a `\u25CF failed` backend is WHY a\n    // route went to cloud, and the two read as cause and effect only in that order.\n    for (const d of summary.degraded ?? []) {\n      lines.push(this.degradedLine(d, tagWidth))\n    }\n\n    lines.push('', ...this.legendLines(summary))\n\n    return lines\n  }\n\n  /**\n   * Static reference lines for the persistent Ink header, committed ONCE via `<Static>`: title,\n   * endpoint URLs WITHOUT the health dot (health is live \u2192 the footer owns it), UI reference rows,\n   * watch line, clickable log path, separator. Pure; colors follow `isTTY`.\n   */\n  formatHeaderLines(summary: ReadySummary): string[] {\n    return this.formatLines(summary, { withHealthDot: false })\n  }\n\n  /**\n   * The live status rows \u2014 THE PANEL. Re-rendered in place on every tick; never committed to `<Static>`.\n   *\n   * This is the only part of the screen that can change after `ready`, and that makes it the only place\n   * live fields can live. The header is committed once through `<Static>`, so anything painted there is\n   * a photograph: an uptime or an error count rendered into the header would be frozen at its boot value\n   * for the whole session, looking live and being a lie. (It was: the live fields went into the shared\n   * endpoint line first, the header picked them up, the footer kept printing a bare health dot, and a\n   * real run showed a panel with no uptime, no req/min and no error count at all. No unit test saw it \u2014\n   * only the rendered terminal did.)\n   *\n   * Every row is rendered, including an endpoint that was never probed and a UI with no backend at all:\n   * with no log tail on screen this panel is the entire signal, and a row that is absent cannot report\n   * that its service is broken.\n   */\n  formatFooterLines(summary: ReadySummary): string[] {\n    const tagWidth = this.tagWidth(summary)\n    const rows = summary.endpoints.map((e) => {\n      const dot = this.healthDot(e.health)\n      const status = this.statusFields(e)\n      const cells = [dot, status].filter(Boolean).join('  ')\n\n      return `  ${this.tagCell(e.tag, tagWidth, e.errors)}  ${cells}`\n    })\n\n    // A UI whose port infra-kit could not claim has no endpoint row \u2014 but its errors still have to land\n    // somewhere the user can see, and it is precisely the app most likely to be misconfigured.\n    for (const ref of summary.uiRefs) {\n      if (ref.errors == null) continue\n      rows.push(`  ${this.tagCell(ref.tag, tagWidth, ref.errors)}  ${this.errorCount(ref.errors)}`)\n    }\n\n    // Degraded routes live in the PANEL, not only in the header. The header is committed once through\n    // `<Static>` \u2014 a photograph \u2014 so a degraded row painted only there would still be on screen after\n    // `--watch` brought the backend back and the route went local again: a permanent warning about a\n    // condition that has been fixed, which trains the user to ignore it. The caller re-derives this list\n    // from the running set on every tick, so the row survives exactly as long as the problem does.\n    for (const d of summary.degraded ?? []) {\n      rows.push(this.degradedLine(d, tagWidth))\n    }\n\n    // The heartbeat. Without it a UI-only session \u2014 whose rows carry no backend uptime and no req/min \u2014\n    // would render an identical frame every tick, and Ink does not repaint an identical frame. The panel\n    // would be genuinely, verifiably alive and look exactly like a hung process.\n    if (summary.sessionUptimeMs != null) {\n      const beat = `up ${formatUptime(summary.sessionUptimeMs)}`\n\n      rows.push(`  ${this.color(ANSI.dim, beat)}`)\n    }\n\n    return rows\n  }\n\n  /**\n   * Build the ready-header lines with NO side effects (no terminal write, no tee), so both\n   * {@link ready} (which writes + tees them) and the Ink boot UI (which commits them via `<Static>`\n   * and tee-only's them) share one layout. Colors follow `isTTY` exactly like every other line.\n   */\n  formatReadyLines(summary: ReadySummary): string[] {\n    return this.formatLines(summary, { withHealthDot: true })\n  }\n\n  // ---- the live tail ------------------------------------------------------\n\n  /**\n   * One tagged, timestamped tail line: `14:02:11  client/api  GET /api/v1/ping 200 12ms`. Arrives\n   * strictly after {@link ready} (a request implies a running server), so it never interleaves the\n   * header. Timestamp comes from the injected clock.\n   */\n  event(input: { tag: string; text: string }): void {\n    const ts = formatClock(this.deps.now())\n    const line = `  ${this.color(ANSI.dim, ts)}  ${this.color(ANSI.teal, input.tag)}  ${input.text}`\n\n    this.emit(line)\n    this.tee(`${input.tag} ${input.text}`, 'info')\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["process", "SPINNER_FRAMES", "SPINNER_INTERVAL_MS", "ANSI", "CLEAR_LINE", "ANSI_PATTERN", "stripAnsi", "s", "pad2", "n", "formatClock", "d", "formatElapsed", "ms", "formatUptime", "total", "hours", "minutes", "seconds", "resolveEndpointUrl", "input", "DevRenderer", "deps", "text", "code", "href", "label", "c", "message", "level", "line", "options", "frame", "phase", "errors", "tag", "tagWidth", "health", "summary", "lines", "e", "u", "f", "w", "t", "meta", "failedCount", "elapsed", "status", "watchText", "logLink", "watchLine", "rule", "ref", "errText", "endpoint", "parts", "withHealthDot", "dot", "suffix", "failed", "row", "state", "target", "proxies", "routeWidth", "p", "elbow", "where", "rows", "cells", "beat", "ts"]
-}

package/dist/chunk-SHFPI4QA.js

@@ -1,2 +0,0 @@
-import{a as _}from"./chunk-LKKKDB6V.js";import{B as c,N as L,V as A,X as O,g as S,m as R}from"./chunk-SSBYKOHY.js";import B from"node:process";import{$ as w}from"zx";var M=async()=>{try{return await w`cmux --version`.quiet(),!0}catch{return!1}},j=async r=>{let{cwd:e,title:t,layout:o}=r,s=JSON.stringify(o),n=(await w({env:{...B.env,CMUX_QUIET:"1"}})`cmux new-workspace --name ${t} --cwd ${e} --focus false --layout ${s}`).stdout;return U(n)},F=async r=>{try{await w`cmux close-workspace --workspace ${r}`.quiet()}catch(e){c.debug({error:e,ref:r},"cmux: skipped closing dev workspace")}},U=r=>{let e=r.match(/workspace:\d+/);if(!e)throw new Error("cmux: could not locate workspace ref in new-workspace output");return e[0]};import{$ as J}from"zx";import{realpath as q}from"node:fs/promises";import{$ as I}from"zx";var y=async r=>{try{return await q(r)}catch{return r}},P=async()=>{try{let[r,e]=await Promise.all([I`cmux workspace list --json`.quiet(),I`cmux workspace-group list --json`.quiet()]),t=JSON.parse(r.stdout).workspaces??[],o=JSON.parse(e.stdout).groups??[],s=new Set(o.map(n=>n.anchor_workspace_ref).filter(n=>typeof n=="string")),a=new Map;for(let n of t)!n.current_directory||s.has(n.ref)||a.set(await y(n.current_directory),n.ref);return a}catch(r){return c.debug({error:r},"cmux: skipped listing workspaces by cwd"),new Map}};var G=async r=>{try{let t=(await P()).get(await y(r));if(!t)return;await J`cmux workspace close ${t}`.quiet()}catch(e){c.debug({error:e,cwd:r},"cmux: skipped closing workspace by cwd")}};import{$ as k}from"zx";var N=async r=>{try{let e=(await k`cmux workspace-group list --json`.quiet()).stdout;return(JSON.parse(e).groups??[]).find(s=>s.name===r)?.ref??null}catch(e){return c.debug({error:e,name:r},"cmux: skipped group lookup"),null}},H=async(r,e)=>{try{let o=(await k`cmux workspace-group create --name ${r} --from ${e.join(",")}`).stdout.match(/workspace_group:\d+/)?.[0]??await N(r);return o&&await k`cmux workspace-group pin ${o}`.quiet(),o??null}catch(t){return c.warn({error:t,name:r},"\u26A0\uFE0F cmux: failed to create workspace group"),null}};import{$ as m}from"zx";var z=async r=>{let{cwd:e,title:t,group:o}=r,s=A(await O()),a=o?(await m`cmux workspace create --cwd ${e} --group ${o} --group-placement end`).stdout:(await m`cmux workspace create --cwd ${e}`).stdout,n=Q(a),p=(await m`cmux list-pane-surfaces --workspace ${n}`).stdout,u=K(p);return await m`cmux new-split right --workspace ${n} --surface ${u}`,s==="three-pane"&&await m`cmux new-split down --workspace ${n} --surface ${u}`,t&&await m`cmux workspace rename --workspace ${n} --title ${t}`,n},K=r=>{let e=r.match(/surface:\d+/);if(!e)throw new Error("cmux: could not locate initial surface in list-pane-surfaces output");return e[0]},Q=r=>{let e=r.match(/workspace:\d+/);if(!e)throw new Error("cmux: could not locate workspace ref in workspace create output");return e[0]};var V=r=>{let{branch:e}=r,t=S(e);return t?R(t):e};var X=new Set(["ExitPromptError","AbortPromptError","PromptCancelledError"]),T=r=>r instanceof Error&&X.has(r.name),ne=r=>{if(T(r))return!0;let e=r?.cause;return T(e)};import{loadDev as Y}from"@slip-stream-kit/config/internal";import Z from"node:path";var rr=(r,e)=>{let t=new Set;for(let o of Object.values(r))for(let s of Object.keys(L(o,e).proxy))t.add(s);return[...t]},er=async(r,e)=>{let t={},o=[];return await Promise.all(e.map(async s=>{try{let n=(await Y(Z.join(r,"apps",s,"ui")))?.proxy?.routes;if(!n)return;t[s]=Object.fromEntries(Object.entries(n).map(([p,u])=>[p,u.packageName]))}catch(a){o.push({app:s,message:a instanceof Error?a.message:String(a)})}})),{routePkg:(s,a)=>t[s]?.[a],loadErrors:o}},pe=async(r,e,t,o)=>{let{routePkg:s,loadErrors:a}=await er(r,rr(e,t));return{ctx:{discovered:t,apiPkgByApp:Object.fromEntries(o.map(n=>[n.name,n.packageName])),routePkg:s},loadErrors:a}};import{execFile as tr}from"node:child_process";import{createHash as or}from"node:crypto";import{existsSync as W,readFileSync as d}from"node:fs";import sr from"node:http";import nr from"node:https";import ar from"node:net";import{homedir as ir}from"node:os";import{dirname as h,join as l}from"node:path";import f from"node:process";import cr from"node:tls";import{fileURLToPath as ur}from"node:url";import{promisify as pr}from"node:util";var mr=pr(tr),lr=r=>{let e=JSON.parse(d(r,"utf-8")),t=typeof e.bin=="string"?e.bin:e.bin?.portless;return t==null||t===""?null:t},fr=()=>{try{let r=h(ur(import.meta.url));for(;;){let e=l(r,"node_modules","portless","package.json");if(W(e)){let o=lr(e);return o==null?null:l(h(e),o)}let t=h(r);if(t===r)return null;r=t}}catch{return null}},b,D=()=>(b===void 0&&(b=fr()),b),gr=/^[\w@%+=:,./-]+$/,dr="'\\''",xr=r=>gr.test(r)?r:`'${r.replaceAll("'",dr)}'`,ve=(r,e)=>{let t=[e.execPath??f.execPath,e.bin,...r];return(e.sudo===!0?"sudo ":"")+t.map(xr).join(" ")},yr=1500,C=1500,wr="x-portless",E="127.0.0.1",Pr="localhost",kr="/Library/LaunchDaemons/sh.portless.proxy.plist",hr="/etc/systemd/system/portless.service",br=(r=W)=>{try{return f.platform==="darwin"?r(kr)?"yes":"no":f.platform==="linux"?r(hr)?"yes":"no":"unknown"}catch{return"unknown"}},Cr=r=>new Promise(e=>{let t=ar.connect({host:E,port:r}),o=s=>{t.destroy(),e(s)};t.setTimeout(C),t.once("connect",()=>{o(!0)}),t.once("timeout",()=>{o(!1)}),t.once("error",()=>{o(!1)})}),Er=(r,e)=>new Promise(t=>{let s=(e?nr.request:sr.request)({host:E,port:r,method:"HEAD",path:"/",timeout:C,...e?{rejectUnauthorized:!1,servername:Pr}:{}},a=>{a.resume(),t(a.headers[wr]==="1")});s.on("error",()=>{t(!1)}),s.on("timeout",()=>{s.destroy(),t(!1)}),s.end()}),vr=async(r,{timeoutMs:e})=>{let t=D();if(t==null)throw new Error("portless is not installed (not resolvable from node_modules)");await mr(f.execPath,[t,...r],{signal:AbortSignal.timeout(e),encoding:"utf-8",env:_(f.env)})},v=()=>f.env.PORTLESS_STATE_DIR??l(ir(),".portless"),Sr="ca.pem",Rr="ca.trusted",$=()=>l(v(),Sr),Se=()=>{try{let r=d(l(v(),Rr),"utf-8").trim();return r===""?!1:or("sha256").update(d($())).digest("hex")===r.toLowerCase()}catch{return!1}},Re=(r,e)=>new Promise(t=>{let o;try{o=d($())}catch{t({ok:!1,code:"ENOENT"});return}let s=cr.connect({host:E,port:r,servername:e,ca:[o],rejectUnauthorized:!0},()=>{let a=s.authorizationError,n=s.authorized;s.destroy(),t(n?{ok:!0}:{ok:!1,code:a?.code??a?.message??"UNKNOWN"})});s.setTimeout(C),s.once("timeout",()=>{s.destroy(),t({ok:!1,code:"ETIMEDOUT"})}),s.once("error",a=>{s.destroy(),t({ok:!1,code:a.code??"UNKNOWN"})})}),Le=()=>{try{let r=JSON.parse(d(l(v(),"routes.json"),"utf-8"));return Array.isArray(r)?r.flatMap(e=>{let{hostname:t,port:o}=e??{};return typeof t!="string"||t===""||typeof o!="number"?[]:[{name:t,port:o}]}):[]}catch{return[]}},Ae=(r={})=>{let e=r.bin===void 0?D():r.bin,t=r.run??vr,o=r.isListening??Cr,s=r.isProxyServing??Er,a=r.isServiceInstalled??br,n=r.timeoutMs??yr,p=null,u=async i=>{try{return await t(i,{timeoutMs:n}),!0}catch{return!1}},x=async()=>(p??=await u(["--version"]),p);return{binPath:()=>e,isAvailable:x,isProxyServing:async(i,g)=>!await x()||!await o(i)?!1:s(i,g),probeProxy:async(i,g)=>await o(i)?await s(i,g)?"serving":"not-portless":"daemon-down",isServiceInstalled:a,registerAlias:async(i,g)=>await x()?u(["alias",i,String(g)]):!1,removeAlias:async i=>{await x()&&await u(["alias","--remove",i])}}};export{pe as a,fr as b,ve as c,Cr as d,Er as e,$ as f,Se as g,Re as h,Le as i,Ae as j,y as k,P as l,G as m,N as n,H as o,M as p,j as q,F as r,z as s,V as t,ne as u};
-//# sourceMappingURL=chunk-SHFPI4QA.js.map

package/dist/chunk-SHFPI4QA.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/integrations/cmux/open-dev-workspace.ts", "../src/integrations/cmux/close-workspace-by-cwd.ts", "../src/integrations/cmux/list-workspaces-by-cwd.ts", "../src/integrations/cmux/cmux-groups.ts", "../src/integrations/cmux/open-workspace-with-layout.ts", "../src/integrations/cmux/workspace-title.ts", "../src/lib/errors/is-prompt-cancellation.ts", "../src/dev/preset-proxy-context.ts", "../src/dev/proxy/portless-driver.ts"],
-  "sourcesContent": ["import process from 'node:process'\nimport { $ } from 'zx'\n\nimport type { CmuxLayoutNode } from 'src/dev/cmux-layout'\nimport { logger } from 'src/lib/logger'\n\n/** Args for {@link openCmuxDevWorkspace}: the workspace root, title, and pane layout tree. */\ninterface OpenCmuxDevWorkspaceArgs {\n  cwd: string\n  title: string\n  layout: CmuxLayoutNode\n}\n\n/**\n * True iff the `cmux` CLI is invokable (i.e. `cmux --version` resolves). Used to\n * gate `--cmux` mode and fall back to single-process dev when cmux is absent.\n */\nexport const isCmuxAvailable = async (): Promise<boolean> => {\n  try {\n    await $`cmux --version`.quiet()\n\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Open ONE cmux workspace rooted at `cwd`, laid out per `layout` (one pane per\n * command). Runs in a `CMUX_QUIET=1` scoped env to suppress cmux's one-time compat\n * notice, then parses and returns the `workspace:<id>` ref from stdout.\n */\nexport const openCmuxDevWorkspace = async (args: OpenCmuxDevWorkspaceArgs): Promise<string> => {\n  const { cwd, title, layout } = args\n  const layoutJson = JSON.stringify(layout)\n\n  const $cmux = $({ env: { ...process.env, CMUX_QUIET: '1' } })\n  const output = (await $cmux`cmux new-workspace --name ${title} --cwd ${cwd} --focus false --layout ${layoutJson}`)\n    .stdout\n\n  return parseWorkspaceRef(output)\n}\n\n/**\n * Best-effort close of the cmux workspace `ref`, tearing down the workspace and\n * every pane process. Silently no-ops (debug-logged) if cmux isn't running or the\n * close fails, mirroring {@link file://./close-workspace-by-cwd.ts}.\n */\nexport const closeCmuxDevWorkspace = async (ref: string): Promise<void> => {\n  try {\n    await $`cmux close-workspace --workspace ${ref}`.quiet()\n  } catch (error) {\n    logger.debug({ error, ref }, 'cmux: skipped closing dev workspace')\n  }\n}\n\n/**\n * Extract the `workspace:<id>` ref from `cmux new-workspace` output (e.g.\n * `OK workspace:5`). Throws a clear error when no ref is present.\n *\n * @example\n * parseWorkspaceRef('OK workspace:5\\n') // => 'workspace:5'\n */\nconst parseWorkspaceRef = (output: string): string => {\n  const match = output.match(/workspace:\\d+/)\n\n  if (!match) {\n    throw new Error('cmux: could not locate workspace ref in new-workspace output')\n  }\n\n  return match[0]\n}\n", "import { $ } from 'zx'\n\nimport { logger } from 'src/lib/logger'\n\nimport { listCmuxWorkspacesByCwd, realpathForCmuxCwd } from './list-workspaces-by-cwd'\n\n/**\n * Best-effort close of the cmux workspace rooted at `cwd`. Resolves the workspace\n * ref via {@link listCmuxWorkspacesByCwd} (which excludes group anchors, so this\n * can never close a group header) and closes it. Silently no-ops if cmux isn't\n * running, no workspace matches the cwd, or the close fails.\n *\n * Called BEFORE `git worktree remove`, so `cwd` still exists and normalizes the\n * same way as cmux's reported `current_directory`.\n */\nexport const closeCmuxWorkspaceByCwd = async (cwd: string): Promise<void> => {\n  try {\n    const byCwd = await listCmuxWorkspacesByCwd()\n\n    const ref = byCwd.get(await realpathForCmuxCwd(cwd))\n\n    if (!ref) {\n      return\n    }\n\n    await $`cmux workspace close ${ref}`.quiet()\n  } catch (error) {\n    logger.debug({ error, cwd }, 'cmux: skipped closing workspace by cwd')\n  }\n}\n", "import { realpath } from 'node:fs/promises'\nimport { $ } from 'zx'\n\nimport { logger } from 'src/lib/logger'\n\ninterface CmuxWorkspaceListEntry {\n  ref: string\n  current_directory: string | null\n}\n\ninterface CmuxGroupListEntry {\n  anchor_workspace_ref: string | null\n}\n\n/**\n * Resolve `path` through the filesystem, falling back to the input when it can't\n * be resolved (e.g. the directory was already removed). Both the cmux-reported\n * cwd and the caller's target cwd are normalized the same way so a macOS\n * `/var`\u2192`/private/var` style symlink can't make two equal paths compare unequal\n * (the realpath-asymmetry footgun this repo has been burned by before).\n */\nconst safeRealpath = async (path: string): Promise<string> => {\n  try {\n    return await realpath(path)\n  } catch {\n    return path\n  }\n}\n\n/**\n * Build a `realpath(cwd) \u2192 workspace ref` map of every currently-open cmux\n * workspace, keyed on its working directory. This is the dedup/close identity for\n * infra-kit's worktree workspaces \u2014 unique per worktree, and (unlike the title)\n * stable after the repo-name title prefix was dropped (two repos can share a\n * branch name like `fix-post-script-ci-cd`, but never a worktree path).\n *\n * Two entries are deliberately excluded:\n *   - workspaces with no `current_directory` (e.g. `infra-kit dev` panes) \u2014 they\n *     carry no worktree identity;\n *   - group ANCHOR workspaces \u2014 cmux reports the anchor's cwd as the main-repo\n *     root, so it collides with the real main-checkout workspace. Keying an\n *     anchor into the map would shadow the main workspace (breaking dedup) and,\n *     worse, let close-by-cwd close the group header. Anchors are dropped up front\n *     via `workspace-group list`'s `anchor_workspace_ref`.\n *\n * Returns an empty map if cmux isn't running or the output can't be parsed \u2014\n * callers treat \"empty\" as \"unknown, proceed as if nothing is open\".\n */\nexport const listCmuxWorkspacesByCwd = async (): Promise<Map<string, string>> => {\n  try {\n    const [workspacesOutput, groupsOutput] = await Promise.all([\n      $`cmux workspace list --json`.quiet(),\n      $`cmux workspace-group list --json`.quiet(),\n    ])\n\n    const workspaces = (JSON.parse(workspacesOutput.stdout).workspaces ?? []) as CmuxWorkspaceListEntry[]\n    const groups = (JSON.parse(groupsOutput.stdout).groups ?? []) as CmuxGroupListEntry[]\n\n    const anchorRefs = new Set(\n      groups\n        .map((group) => {\n          return group.anchor_workspace_ref\n        })\n        .filter((ref): ref is string => {\n          return typeof ref === 'string'\n        }),\n    )\n\n    const byCwd = new Map<string, string>()\n\n    for (const workspace of workspaces) {\n      if (!workspace.current_directory || anchorRefs.has(workspace.ref)) {\n        continue\n      }\n\n      byCwd.set(await safeRealpath(workspace.current_directory), workspace.ref)\n    }\n\n    return byCwd\n  } catch (error) {\n    logger.debug({ error }, 'cmux: skipped listing workspaces by cwd')\n\n    return new Map()\n  }\n}\n\n/** Exported for callers that need the same normalization when looking up a target cwd. */\nexport { safeRealpath as realpathForCmuxCwd }\n", "import { $ } from 'zx'\n\nimport { logger } from 'src/lib/logger'\n\ninterface CmuxGroupListEntry {\n  ref: string\n  name: string\n}\n\n/**\n * Return the `workspace_group:N` ref of the sidebar group titled exactly `name`,\n * or `null` if no such group exists (or cmux is unreachable). Group names are the\n * repo name (basename of the main-repo root), so worktree workspaces for one repo\n * all resolve to the same group regardless of which worktree the command runs in.\n */\nexport const findCmuxGroupRefByName = async (name: string): Promise<string | null> => {\n  try {\n    const output = (await $`cmux workspace-group list --json`.quiet()).stdout\n\n    const groups = (JSON.parse(output).groups ?? []) as CmuxGroupListEntry[]\n\n    const match = groups.find((group) => {\n      return group.name === name\n    })\n\n    return match?.ref ?? null\n  } catch (error) {\n    logger.debug({ error, name }, 'cmux: skipped group lookup')\n\n    return null\n  }\n}\n\n/**\n * Create a pinned sidebar group named `name` seeded with EXACTLY `fromRefs`, and\n * return its ref (or `null` on failure).\n *\n * `--from` is load-bearing: `cmux workspace-group create` defaults `--from` to the\n * currently-selected/caller workspace, so omitting it silently captures an\n * unrelated workspace (and, under the `--all` fan-out, steals a sibling repo's\n * freshly-created workspace). Passing the seed refs explicitly makes creation\n * deterministic and capture-free \u2014 no snapshot/self-heal needed. The group also\n * gets a synthetic anchor workspace (its header row), matching how the user's\n * groups are already shaped.\n */\nexport const createCmuxGroupFrom = async (name: string, fromRefs: string[]): Promise<string | null> => {\n  try {\n    const output = (await $`cmux workspace-group create --name ${name} --from ${fromRefs.join(',')}`).stdout\n\n    const ref = output.match(/workspace_group:\\d+/)?.[0] ?? (await findCmuxGroupRefByName(name))\n\n    if (ref) {\n      await $`cmux workspace-group pin ${ref}`.quiet()\n    }\n\n    return ref ?? null\n  } catch (error) {\n    logger.warn({ error, name }, '\u26A0\uFE0F cmux: failed to create workspace group')\n\n    return null\n  }\n}\n", "import { $ } from 'zx'\n\nimport { getInfraKitConfig, resolveCmuxLayout } from 'src/lib/infra-kit-config'\n\ninterface OpenCmuxWorkspaceArgs {\n  cwd: string\n  title?: string\n  /**\n   * When set, the workspace is created directly inside this sidebar group\n   * (`workspace_group:N` ref) via `--group`, appended at the end so existing\n   * members aren't reordered. Omit to create an ungrouped workspace (e.g. the\n   * first worktree of a repo, which then seeds a new group).\n   */\n  group?: string\n}\n\n/**\n * Opens a new cmux workspace rooted at `cwd`, with panes arranged per the\n * configured `worktrees.cmux.layout` (resolved via {@link resolveCmuxLayout},\n * default `two-columns`):\n *   two-columns \u2014 left | right, both full-height (two panes)\n *   three-pane  \u2014 left-top / left-bottom | full-height right (three panes)\n * All panes inherit `cwd` from the workspace. Returns the created\n * `workspace:N` ref so callers can seed a group from it.\n */\nexport const openCmuxWorkspaceWithLayout = async (args: OpenCmuxWorkspaceArgs): Promise<string> => {\n  const { cwd, title, group } = args\n\n  const layout = resolveCmuxLayout(await getInfraKitConfig())\n\n  const newWorkspaceOutput = group\n    ? (await $`cmux workspace create --cwd ${cwd} --group ${group} --group-placement end`).stdout\n    : (await $`cmux workspace create --cwd ${cwd}`).stdout\n\n  const workspaceRef = parseWorkspaceRef(newWorkspaceOutput)\n\n  const surfacesOutput = (await $`cmux list-pane-surfaces --workspace ${workspaceRef}`).stdout\n\n  const leftTopRef = parseFirstSurfaceRef(surfacesOutput)\n\n  // Both layouts share the vertical split into left | right columns; only the\n  // legacy three-pane layout additionally splits the left column top/bottom.\n  await $`cmux new-split right --workspace ${workspaceRef} --surface ${leftTopRef}`\n\n  if (layout === 'three-pane') {\n    await $`cmux new-split down --workspace ${workspaceRef} --surface ${leftTopRef}`\n  }\n\n  if (title) {\n    await $`cmux workspace rename --workspace ${workspaceRef} --title ${title}`\n  }\n\n  return workspaceRef\n}\n\n/**\n * Extracts the first `surface:<id>` reference from the output of\n * `cmux list-pane-surfaces`. Used to locate the initial (primary) pane\n * surface so subsequent splits can be anchored relative to it.\n *\n * @example\n * const output = 'surface:12 (active)\\nsurface:13\\n'\n * parseFirstSurfaceRef(output) // => 'surface:12'\n */\nconst parseFirstSurfaceRef = (output: string): string => {\n  const match = output.match(/surface:\\d+/)\n\n  if (!match) {\n    throw new Error('cmux: could not locate initial surface in list-pane-surfaces output')\n  }\n\n  return match[0]\n}\n\n/**\n * Extracts the `workspace:<id>` reference from the output of\n * `cmux workspace create`. The returned ref is used to target the newly\n * created workspace in follow-up `cmux` commands (splits, rename, etc.).\n *\n * @example\n * const output = 'created workspace:7\\n'\n * parseWorkspaceRef(output) // => 'workspace:7'\n */\nconst parseWorkspaceRef = (output: string): string => {\n  const match = output.match(/workspace:\\d+/)\n\n  if (!match) {\n    throw new Error('cmux: could not locate workspace ref in workspace create output')\n  }\n\n  return match[0]\n}\n", "import { displayLabel, parseBranchName } from 'src/lib/release-id'\n\ninterface BuildCmuxWorkspaceTitleArgs {\n  branch: string\n}\n\n/**\n * Builds the cmux workspace title for a worktree. The title is now just the\n * branch's display label \u2014 the repo name is NOT prefixed, because every worktree\n * workspace lives inside a per-repo sidebar GROUP whose header already carries the\n * repo name (e.g. group `hulyo-monorepo` \u2192 workspaces titled `1.48.0`,\n * `checkout-redesign`, `dev`). Release branches render via their release-id label\n * (`release/v1.48.0` \u2192 `1.48.0`, `release/checkout-redesign` \u2192 `checkout-redesign`);\n * non-release branches fall back to the raw branch string.\n *\n * Note: the title is NO LONGER a dedup/close key \u2014 that role moved to the\n * workspace cwd (see {@link listCmuxWorkspacesByCwd}), because dropping the repo\n * prefix makes titles collide across repos (both hulyo and travelist can have a\n * `fix-post-script-ci-cd` branch).\n */\nexport const buildCmuxWorkspaceTitle = (args: BuildCmuxWorkspaceTitleArgs): string => {\n  const { branch } = args\n\n  const id = parseBranchName(branch)\n\n  return id ? displayLabel(id) : branch\n}\n", "/**\n * Names of the error classes thrown when an interactive prompt ends without a\n * value. From `@inquirer/core`: `ExitPromptError` (Ctrl-C \u2014 and ONLY Ctrl-C:\n * inquirer binds no escape key, so it raises this from readline's SIGINT) and\n * `AbortPromptError` (the prompt was aborted via an `AbortSignal`, which is how\n * Esc arrives \u2014 see lib/prompts/escapable-context). From our own Ink pickers:\n * `PromptCancelledError` (see ./prompt-cancelled-error), which is registered here\n * rather than impersonating an inquirer class name. All are intentional\n * cancellations, not failures.\n */\nconst CANCELLATION_ERROR_NAMES = new Set(['ExitPromptError', 'AbortPromptError', 'PromptCancelledError'])\n\nconst hasCancellationName = (value: unknown): boolean => {\n  return value instanceof Error && CANCELLATION_ERROR_NAMES.has(value.name)\n}\n\n/**\n * True when `error` represents a user (or signal) cancellation of an interactive\n * prompt \u2014 Ctrl-C anywhere, or Esc, which reaches an `@inquirer` prompt as an\n * abort and an Ink picker as a `PromptCancelledError`. Matched by `name` rather\n * than `instanceof` so it stays correct\n * even when pnpm dedupes more than one copy of `@inquirer/core` into the tree\n * (an `instanceof` check fails across realms/duplicate classes).\n *\n * Also unwraps one level of `cause`, so a cancellation re-wrapped in an\n * {@link ./operation-error.OperationError} is still recognised at the top-level\n * error boundary.\n *\n * @example\n * try {\n *   await checkbox({ message: 'Select release branches', choices })\n * } catch (err) {\n *   if (isPromptCancellation(err)) process.exit(0) // clean back-out, not an error\n *   throw err\n * }\n */\nexport const isPromptCancellation = (error: unknown): boolean => {\n  if (hasCancellationName(error)) return true\n\n  const cause = (error as { cause?: unknown } | null | undefined)?.cause\n\n  return hasCancellationName(cause)\n}\n", "/**\n * Assembles the impure {@link PresetProxyContext} `validatePresetProxy` needs, so the STATIC\n * proxy-locality rule in `presets.ts` never has to touch the filesystem or `loadDev` itself.\n *\n * Shared by two callers that must never disagree about what \"satisfiable\" means:\n *  - `infra-kit audit` (`commands/audit/preset-proxy-check.ts`) \u2014 checks every preset.\n *  - `infra-kit dev <preset>` (`dev-server.ts`) \u2014 checks only the one preset about to run, BEFORE\n *    any server spawns.\n */\nimport { loadDev } from '@slip-stream-kit/config/internal'\nimport path from 'node:path'\n\nimport { resolvePreset } from 'src/dev/presets'\nimport type { DiscoveredParts, PresetProxyContext } from 'src/dev/presets'\nimport type { DevPresets } from 'src/lib/infra-kit-config'\n\n/** A frontend config that a preset references but that failed to load (bad/invalid config). */\nexport interface LoadError {\n  app: string\n  message: string\n}\n\ninterface RoutePkgLookup {\n  routePkg: PresetProxyContext['routePkg']\n  loadErrors: LoadError[]\n}\n\n/**\n * The set of frontend app folders any preset's proxy override actually references \u2014\n * the only configs the caller needs to load. Scoping to these keeps an unrelated\n * broken frontend config from failing (or crashing) a check it was never relevant to.\n */\nconst collectReferencedApps = (presets: DevPresets, discovered: DiscoveredParts): string[] => {\n  const apps = new Set<string>()\n\n  for (const preset of Object.values(presets)) {\n    for (const app of Object.keys(resolvePreset(preset, discovered).proxy)) {\n      apps.add(app)\n    }\n  }\n\n  return [...apps]\n}\n\n/**\n * Load each referenced frontend's `dev.proxy.routes` into a sync `(app, route) \u2192 pkg`\n * lookup. A config that throws (schema-invalid, import error) is captured as a\n * {@link LoadError} instead of rejecting, so one bad config yields an actionable\n * result rather than crashing the whole check.\n */\nconst buildRoutePkgLookup = async (root: string, apps: string[]): Promise<RoutePkgLookup> => {\n  const routesByApp: Record<string, Record<string, string>> = {}\n  const loadErrors: LoadError[] = []\n\n  await Promise.all(\n    apps.map(async (app) => {\n      try {\n        const dev = await loadDev(path.join(root, 'apps', app, 'ui'))\n        const routes = dev?.proxy?.routes\n\n        if (!routes) return\n\n        routesByApp[app] = Object.fromEntries(\n          Object.entries(routes).map(([route, route_]) => {\n            return [route, route_.packageName]\n          }),\n        )\n      } catch (error) {\n        loadErrors.push({ app, message: error instanceof Error ? error.message : String(error) })\n      }\n    }),\n  )\n\n  return {\n    routePkg: (app, route) => {\n      return routesByApp[app]?.[route]\n    },\n    loadErrors,\n  }\n}\n\n/** Result of {@link buildPresetProxyContext}: the assembled context, plus any config that failed to load. */\nexport interface PresetProxyContextResult {\n  ctx: PresetProxyContext\n  loadErrors: LoadError[]\n}\n\n/**\n * Build the {@link PresetProxyContext} `validatePresetProxy` needs for `presets`: a sync\n * `(app, route) \u2192 pkg` lookup from each referenced frontend's `infra-kit.config.ts`\n * (the SAME file, through the same `loadDev`, that the vite helper resolves at runtime), plus\n * the api package name for every discovered api app.\n *\n * @example\n * const { ctx, loadErrors } = await buildPresetProxyContext('/repo', presets, discovered, apiApps)\n * const issues = validatePresetProxy(presets, ctx)\n */\nexport const buildPresetProxyContext = async (\n  root: string,\n  presets: DevPresets,\n  discovered: DiscoveredParts,\n  apiApps: { name: string; packageName: string }[],\n): Promise<PresetProxyContextResult> => {\n  const { routePkg, loadErrors } = await buildRoutePkgLookup(root, collectReferencedApps(presets, discovered))\n\n  return {\n    ctx: {\n      discovered,\n      apiPkgByApp: Object.fromEntries(\n        apiApps.map((a) => {\n          return [a.name, a.packageName]\n        }),\n      ),\n      routePkg,\n    },\n    loadErrors,\n  }\n}\n", "/**\n * Thin, injectable driver for the `portless` daemon (Layer B \u2014 see `.omc/plans/dev-https-portless.md`).\n *\n * `infra-kit dev` uses it to register `<release>.<package>.localhost \u2192 127.0.0.1:<port>` routes so the\n * hero URLs resolve over **HTTPS on :443, with no port in the URL**. Every call here is **time-bounded and\n * never throws**: a missing binary, a non-zero exit, or a wedged process resolves to `false`/no-op. That is\n * a reporting contract, not a tolerance one \u2014 portless IS a hard dependency of the dev loop, and\n * `DevServerRunner.ensureProxy` turns a `false` from this driver into a fatal, actionable start error.\n *\n * The binary is NOT resolved from `PATH`: `portless` is a normal npm dependency living in\n * `node_modules/.bin`, which is on `PATH` only when the process was launched via pnpm/npm. Since\n * `infra-kit dev` is often launched otherwise (a global bin, a cmux runner, a foreign cwd), we resolve\n * portless's own `dist/cli.js` by walking `node_modules` from this file (see {@link resolvePortlessBin})\n * and run it with the current `node` (`process.execPath`) \u2014 so it works regardless of how `dev` was\n * invoked. Args are fixed literals plus discovered release/package names + a numeric port, never\n * shell-interpolated.\n *\n * **The daemon is PROBED, never started.** `:443` is privileged, and portless binds it by re-execing\n * itself through `sudo` with an inherited stdio \u2014 which a detached `stdio:'ignore'` child can never\n * satisfy: the password prompt has nowhere to go. Setup is one-time and out-of-band: a root\n * `portless service install`, printed for the user by {@link formatPortlessCommand} (never as a bare\n * `portless`, which no shell can resolve \u2014 see there).\n *\n * All process I/O is injected (`run` for awaited commands, `isProxyServing` for the wire probe) so tests\n * never shell out and can assert the exact portless argv.\n */\nimport type { Buffer } from 'node:buffer'\nimport { execFile } from 'node:child_process'\nimport { createHash } from 'node:crypto'\nimport { existsSync, readFileSync } from 'node:fs'\nimport http from 'node:http'\nimport https from 'node:https'\nimport net from 'node:net'\nimport { homedir } from 'node:os'\nimport { dirname, join } from 'node:path'\nimport process from 'node:process'\nimport tls from 'node:tls'\nimport { fileURLToPath } from 'node:url'\nimport { promisify } from 'node:util'\n\nimport { withoutPackageManagerEnv } from 'src/lib/pm-env'\n\nconst execFileAsync = promisify(execFile)\n\n/** Read `bin.portless` (the `dist/cli.js` relative path) from a portless `package.json` on disk. */\nconst readBinRel = (pkgJsonPath: string): string | null => {\n  const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')) as { bin?: string | Record<string, string> }\n  const rel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.portless\n\n  return rel == null || rel === '' ? null : rel\n}\n\n/**\n * Resolve the absolute path to portless's CLI entry (`portless/dist/cli.js`) from node_modules,\n * independent of `PATH`. Returns `null` when portless is not installed, degrading the whole driver to\n * a no-op.\n *\n * portless is ESM-only (its `.` export exposes only `import`/`types`, no `require`), so\n * `createRequire().resolve` can't see it. We instead walk `node_modules` upward from this file \u2014 the\n * standard resolution path \u2014 and read the package's `package.json` straight off disk, which bypasses the\n * exports map that would otherwise hide both `package.json` and the main entry.\n */\nexport const resolvePortlessBin = (): string | null => {\n  try {\n    let dir = dirname(fileURLToPath(import.meta.url))\n\n    for (;;) {\n      const pkgJsonPath = join(dir, 'node_modules', 'portless', 'package.json')\n\n      if (existsSync(pkgJsonPath)) {\n        const rel = readBinRel(pkgJsonPath)\n\n        return rel == null ? null : join(dirname(pkgJsonPath), rel)\n      }\n      const parent = dirname(dir)\n\n      if (parent === dir) return null\n      dir = parent\n    }\n  } catch {\n    return null\n  }\n}\n\n/** Resolve portless's CLI once per process \u2014 the on-disk location never changes within a run. */\nlet cachedBin: string | null | undefined\nconst portlessBin = (): string | null => {\n  if (cachedBin === undefined) cachedBin = resolvePortlessBin()\n\n  return cachedBin\n}\n\n/**\n * Characters that survive a POSIX shell unquoted. Anything outside this set (a space, a paren \u2014 both of\n * which appear in real install paths like `/Applications/My Editor.app`) gets single-quoted.\n */\nconst SHELL_SAFE = /^[\\w@%+=:,./-]+$/\n\n/** A literal `'` inside single quotes: close, emit an escaped quote, reopen \u2014 the only way a shell allows it. */\nconst SINGLE_QUOTE_ESCAPE = \"'\\\\''\"\n\n/** Single-quote `value` for a POSIX shell unless it is already inert. */\nconst shellQuote = (value: string): string => {\n  return SHELL_SAFE.test(value) ? value : `'${value.replaceAll(\"'\", SINGLE_QUOTE_ESCAPE)}'`\n}\n\n/** Seams for {@link formatPortlessCommand}, injected so tests never depend on the real node_modules layout. */\nexport interface FormatPortlessCommandOptions {\n  /**\n   * Absolute path to portless's `dist/cli.js`. **Required and non-nullable on purpose.** The caller must\n   * have resolved portless before it can describe how to run it, so \"I could not find the binary\" cannot be\n   * silently rendered as a plausible-looking command \u2014 the type makes that unwritable rather than merely\n   * discouraged. A `null` bin is a different report (\"run `pnpm install`\"), which every caller makes first.\n   */\n  bin: string\n  /** Prefix with `sudo` \u2014 only `service install`, which binds the privileged `:443`, needs it. */\n  sudo?: boolean\n  execPath?: string\n}\n\n/**\n * Render a portless command the user can actually paste into a shell.\n *\n * This exists because the obvious string is a lie. `portless` is a plain npm dependency living in\n * `node_modules/.bin`, which is on `PATH` only inside a pnpm/npm script \u2014 so printing `sudo portless service\n * install` hands the user a command that dies with `sudo: portless: command not found`. `sudo` makes it\n * strictly worse: it replaces `PATH` with `secure_path`, so even a shell that *could* resolve `portless`\n * loses it the moment the command is elevated.\n *\n * We therefore print what the driver itself runs (see {@link defaultRun}): the current interpreter, by\n * absolute path, invoking portless's `dist/cli.js`, by absolute path. Nothing is resolved from `PATH`, so the\n * command works under `sudo`, from any cwd, and however `infra-kit` was launched.\n *\n * This is not merely cosmetic. portless's `service install` writes **the interpreter and script path it was\n * invoked with** straight into the launchd plist's `ProgramArguments` (`nodePath: process.execPath` plus\n * `process.argv[1]`), so the command printed here is the command that gets installed as a **root system\n * daemon**. Printing a name for the shell to resolve would not just fail \u2014 it would decide what runs as root.\n *\n * @example\n * formatPortlessCommand(['service', 'install'], { sudo: true, bin })\n * // 'sudo /usr/local/bin/node /repo/node_modules/portless/dist/cli.js service install'\n */\nexport const formatPortlessCommand = (args: string[], options: FormatPortlessCommandOptions): string => {\n  const words = [options.execPath ?? process.execPath, options.bin, ...args]\n  const prefix = options.sudo === true ? 'sudo ' : ''\n\n  return prefix + words.map(shellQuote).join(' ')\n}\n\n/** Awaited portless invocation. Rejects on non-zero exit / timeout; the driver swallows that into a no-op. */\nexport type PortlessRun = (args: string[], opts: { timeoutMs: number }) => Promise<void>\n\n/** Cheap \"is anything at all accepting TCP here?\" pre-filter in front of the wire probe. */\nexport type IsListening = (port: number) => Promise<boolean>\n\n/**\n * Ground-truth identity: is the process serving `port` actually **portless**, and (when `tls`) is it\n * serving **TLS**? See {@link defaultIsProxyServing} for why this cannot be answered from state files.\n */\nexport type IsProxyServing = (port: number, tls: boolean) => Promise<boolean>\n\nconst DEFAULT_TIMEOUT_MS = 1500\nconst PROBE_TIMEOUT_MS = 1500\n\n/** Response header portless sets on every response it serves. Node lower-cases response header names. */\nconst PORTLESS_HEADER = 'x-portless'\n\n/** IPv4 loopback: portless binds and dials `127.0.0.1`. */\nconst LOOPBACK = '127.0.0.1'\n\n/**\n * SNI for the probe. Node sends **no SNI to an IP literal** (RFC 6066), which would drop portless onto its\n * default certificate \u2014 whose SANs are `localhost`, `*.localhost`, `*.local` and contain **no IP entry**.\n * `localhost` is always in that set, so it is the one name guaranteed to work even on a machine with zero\n * aliases registered.\n */\nconst PROBE_SERVERNAME = 'localhost'\n\n/**\n * Whether portless's OS-level service (the thing `service install` registers) is present on disk.\n * `'unknown'` on a platform this check does not cover (currently anything but macOS/Linux) \u2014 a caller must\n * never read `'unknown'` as `'no'`, since doing so would tell an already-provisioned Windows machine to\n * reinstall.\n */\nexport type ServiceInstalled = 'yes' | 'no' | 'unknown'\n\n/**\n * portless's launchd service label (`sh.portless.proxy`, hard-coded in portless's own CLI) and the two\n * fixed paths its `service install`/`uninstall` write to on macOS and Linux. These are read-only constants\n * of portless's OWN implementation, not ours \u2014 see `dist/cli.js`'s `SERVICE_LABEL`/`buildServiceSpec`. There\n * is no per-user or per-project variant: `service install` always targets exactly one of these two paths.\n * Exported so a test can assert against the exact path this check reads, without hard-coding a second copy.\n */\nexport const DARWIN_SERVICE_PLIST_PATH = '/Library/LaunchDaemons/sh.portless.proxy.plist'\nexport const LINUX_SERVICE_UNIT_PATH = '/etc/systemd/system/portless.service'\n\n/** The `existsSync` seam {@link defaultIsServiceInstalled} takes, injected so tests never touch real root paths. */\nexport type ExistsCheck = (path: string) => boolean\n\n/**\n * Cheap, synchronous, never-throwing check for whether portless's OS service is registered \u2014 a plain\n * `existsSync` on the fixed path `service install` writes to, never a `launchctl`/`systemctl` shell-out. This\n * is what lets {@link createPortlessDriver}'s daemon-down classification tell \"never installed\" apart from\n * \"installed, but not currently answering\" without adding a second process spawn to every failed probe.\n *\n * Deliberately does not attempt Windows detection (a Task Scheduler task, which needs `schtasks` to query) \u2014\n * `'unknown'` there is honest; a guessed `'no'` would send an already-provisioned machine back through\n * `service install` for no reason.\n *\n * `exists` defaults to the real `existsSync` but is a normal parameter (not a named-import spy target) so a\n * test can assert both branches without touching `/Library/LaunchDaemons` \u2014 a root-owned path a dev machine\n * may genuinely have populated, which would make an un-injected assertion true or false depending on the\n * author's own machine state rather than the code under test.\n */\nexport const defaultIsServiceInstalled = (exists: ExistsCheck = existsSync): ServiceInstalled => {\n  try {\n    if (process.platform === 'darwin') return exists(DARWIN_SERVICE_PLIST_PATH) ? 'yes' : 'no'\n    if (process.platform === 'linux') return exists(LINUX_SERVICE_UNIT_PATH) ? 'yes' : 'no'\n\n    return 'unknown'\n  } catch {\n    return 'unknown'\n  }\n}\n\n/**\n * Fine-grained outcome of probing the proxy port, distinguishing the two ways \"not serving\" happens so\n * {@link createPortlessDriver}'s caller can print a distinct, actionable fix for each:\n *  - `'serving'` \u2014 portless answered on the wire (the old boolean `true`).\n *  - `'daemon-down'` \u2014 nothing is even accepting TCP on the port (refused). Combined with\n *    {@link ServiceInstalled} this splits into \"never installed\" vs \"installed but crashed/stopped\".\n *  - `'not-portless'` \u2014 something IS listening, but it did not answer with `X-Portless: 1` \u2014 a squatter has\n *    the port, and installing/trusting portless will not free it.\n */\nexport type ProxyProbeOutcome = 'serving' | 'daemon-down' | 'not-portless'\n\nexport const defaultIsListening: IsListening = (port) => {\n  return new Promise((resolve) => {\n    const socket = net.connect({ host: LOOPBACK, port })\n    const finish = (result: boolean): void => {\n      socket.destroy()\n      resolve(result)\n    }\n\n    socket.setTimeout(PROBE_TIMEOUT_MS)\n    socket.once('connect', () => {\n      finish(true)\n    })\n    socket.once('timeout', () => {\n      finish(false)\n    })\n    socket.once('error', () => {\n      finish(false)\n    })\n  })\n}\n\n/**\n * Is the listener on `port` portless itself, serving `tls`? Proven **on the wire**, by asking it: portless\n * sets `X-Portless: 1` on every response, before route lookup \u2014 so an unrouted host still answers the probe\n * (a 404 with the header is a pass). This mirrors portless's own `isProxyRunning`.\n *\n * This replaces the old state-file check (`proxy.port` + `proxy.pid`), which was **unsound**: portless's\n * `resolveStateDir(_port)` ignores its port argument, so `proxy.port` / `proxy.pid` / `proxy.tls` are\n * process-global singletons shared by every daemon on every port. Starting ANY daemon rewrites them, and\n * stopping ANY daemon DELETES them \u2014 so a second, unrelated daemon (or a stale sibling repo still on the\n * old CLI, falling back to an unprivileged port) makes a perfectly healthy `:443` daemon look dead. Both\n * were reproduced against portless 0.15.1; see `.omc/research/portless-https-spike.md`.\n *\n * `rejectUnauthorized: false` is deliberate and load-bearing: this probe answers *\"is portless serving\n * here?\"*, **never** *\"is its CA trusted?\"*. Validating the chain here would collapse two different\n * failures \u2014 a daemon that is down, and a CA that was never trusted \u2014 into one indistinguishable error,\n * with two different fixes (a root `service install` vs the sudo-free `trust`). Trust is a separate,\n * explicitly-validating probe (doctor's CA check).\n */\nexport const defaultIsProxyServing: IsProxyServing = (port, tls) => {\n  return new Promise((resolve) => {\n    const request = tls ? https.request : http.request\n    const req = request(\n      {\n        host: LOOPBACK,\n        port,\n        method: 'HEAD',\n        path: '/',\n        timeout: PROBE_TIMEOUT_MS,\n        ...(tls ? { rejectUnauthorized: false, servername: PROBE_SERVERNAME } : {}),\n      },\n      (res) => {\n        res.resume()\n        resolve(res.headers[PORTLESS_HEADER] === '1')\n      },\n    )\n\n    req.on('error', () => {\n      resolve(false)\n    })\n    req.on('timeout', () => {\n      req.destroy()\n      resolve(false)\n    })\n    req.end()\n  })\n}\n\nconst defaultRun: PortlessRun = async (args, { timeoutMs }) => {\n  const bin = portlessBin()\n\n  if (bin == null) throw new Error('portless is not installed (not resolvable from node_modules)')\n  await execFileAsync(process.execPath, [bin, ...args], {\n    signal: AbortSignal.timeout(timeoutMs),\n    encoding: 'utf-8',\n    env: withoutPackageManagerEnv(process.env),\n  })\n}\n\n/**\n * portless's state directory. Exported so `doctor` reports on the same directory the driver reads.\n *\n * The default is deliberately **unchanged** (`~/.portless`): portless's `service install` bakes\n * `PORTLESS_STATE_DIR`, resolved from `SUDO_USER`, into the launchd plist \u2014 so the root daemon reads the\n * invoking user's* home. Pointing this anywhere else by default would manufacture the very split it looks\n * like it prevents.\n */\nexport const portlessStateDir = (): string => {\n  return process.env.PORTLESS_STATE_DIR ?? join(homedir(), '.portless')\n}\n\n/** portless's local CA certificate \u2014 the root every host cert it mints is signed by. */\nconst CA_CERT_FILE = 'ca.pem'\n\n/**\n * Marker portless's `trust` writes: the **hex sha256 of `ca.pem`'s bytes** that was added to the login\n * keychain (`writeTrustMarker` \u2192 `caFingerprint`, `cli.js:78-101`). It records WHICH CA was trusted, so a\n * regenerated CA leaves a marker that no longer matches.\n */\nconst CA_TRUST_MARKER_FILE = 'ca.trusted'\n\n/** A route portless is serving: `<name> \u2192 127.0.0.1:<port>`. */\nexport interface PortlessRoute {\n  /**\n   * The registered hostname (e.g. `2-4.client-api.localhost`). Usable verbatim as a\n   * `portless alias --remove <name>` argument \u2014 portless strips a trailing TLD off the name it is handed\n   * (`parseHostnames`, `chunk-SD2PIWJU.js:68-79`) \u2014 and as a TLS `servername`.\n   */\n  name: string\n  port: number\n}\n\n/** Absolute path to portless's local CA certificate, in whichever state dir {@link portlessStateDir} names. */\nexport const readCaPath = (): string => {\n  return join(portlessStateDir(), CA_CERT_FILE)\n}\n\n/**\n * Was `portless trust` run for the CA that is on disk right now? Compares `sha256(ca.pem)` against the\n * fingerprint recorded in `ca.trusted`. `false` when either file is missing; never throws.\n *\n * **This proves the marker was written for THIS fingerprint \u2014 not that the keychain still trusts it.** A\n * user who deletes the certificate from Keychain Access by hand leaves the marker behind and gets a false\n * pass here. That residual is accepted (reading the keychain would mean shelling out to `security` on a\n * check that must stay cheap); it is why this is a *separate* check from the chain handshake\n * ({@link handshakeChainsToCa}), which proves what the daemon actually serves.\n */\nexport const caFingerprintMatches = (): boolean => {\n  try {\n    const recorded = readFileSync(join(portlessStateDir(), CA_TRUST_MARKER_FILE), 'utf-8').trim()\n\n    if (recorded === '') return false\n\n    const actual = createHash('sha256').update(readFileSync(readCaPath())).digest('hex')\n\n    return actual === recorded.toLowerCase()\n  } catch {\n    return false\n  }\n}\n\n/** Outcome of {@link handshakeChainsToCa}: `code` is the Node TLS error code, which the caller discriminates on. */\nexport type HandshakeResult = { ok: true } | { ok: false; code: string }\n\n/**\n * Does the certificate served on `port` chain to the CA in `ca.pem`? A **validating** TLS handshake \u2014 the\n * complement of {@link defaultIsProxyServing}, which deliberately does not validate.\n *\n * `servername` is **mandatory and load-bearing**, never optional: Node sends no SNI to an IP literal\n * (RFC 6066), which drops portless onto its default certificate, whose SANs (`localhost`, `*.localhost`,\n * `*.local`) contain **no IP entry** \u2014 so a validating probe of `127.0.0.1` with no `servername` fails with\n * `ERR_TLS_CERT_ALTNAME_INVALID` against a perfectly healthy daemon. Any such code coming back from here is\n * therefore a bug in the CALLER's probe, never a finding about the user's trust store. Passing an\n * unregistered name is safe: portless's SNI callback mints a cert on demand for any servername.\n *\n * Time-bounded; never throws.\n */\nexport const handshakeChainsToCa = (port: number, servername: string): Promise<HandshakeResult> => {\n  return new Promise((resolve) => {\n    let ca: Buffer<ArrayBufferLike>\n\n    try {\n      ca = readFileSync(readCaPath())\n    } catch {\n      resolve({ ok: false, code: 'ENOENT' })\n\n      return\n    }\n\n    const socket = tls.connect({ host: LOOPBACK, port, servername, ca: [ca], rejectUnauthorized: true }, () => {\n      // With `rejectUnauthorized: true` a chain failure normally surfaces as an 'error' event and this\n      // callback never runs; the check is here so a future Node that connects-then-reports can't slip a\n      // rejected chain through as a pass.\n      const authError = socket.authorizationError as NodeJS.ErrnoException | undefined\n      const authorized = socket.authorized\n\n      socket.destroy()\n      resolve(authorized ? { ok: true } : { ok: false, code: authError?.code ?? authError?.message ?? 'UNKNOWN' })\n    })\n\n    socket.setTimeout(PROBE_TIMEOUT_MS)\n    socket.once('timeout', () => {\n      socket.destroy()\n      resolve({ ok: false, code: 'ETIMEDOUT' })\n    })\n    socket.once('error', (err: NodeJS.ErrnoException) => {\n      socket.destroy()\n      resolve({ ok: false, code: err.code ?? 'UNKNOWN' })\n    })\n  })\n}\n\n/**\n * Routes portless currently has registered, read from `routes.json` in {@link portlessStateDir}. `[]` on any\n * failure (absent file, malformed JSON, unexpected shape) \u2014 an unreadable route list is reported as \"no\n * routes\", never as an error, because every caller uses this for diagnostics only.\n */\nexport const listRoutes = (): PortlessRoute[] => {\n  try {\n    const raw: unknown = JSON.parse(readFileSync(join(portlessStateDir(), 'routes.json'), 'utf-8'))\n\n    if (!Array.isArray(raw)) return []\n\n    return raw.flatMap((entry): PortlessRoute[] => {\n      const { hostname, port } = (entry ?? {}) as { hostname?: unknown; port?: unknown }\n\n      if (typeof hostname !== 'string' || hostname === '' || typeof port !== 'number') return []\n\n      return [{ name: hostname, port }]\n    })\n  } catch {\n    return []\n  }\n}\n\nexport interface PortlessDriver {\n  /**\n   * Absolute path to the `dist/cli.js` this driver executes, or `null` when portless is not installed.\n   *\n   * Exposed so a caller rendering a remediation ({@link formatPortlessCommand}) names the binary THIS driver\n   * would run, rather than re-resolving one behind its back \u2014 which, under an injected driver, would print a\n   * fix derived from the real machine instead of the one under test.\n   */\n  binPath: () => string | null\n  /** Resolve (and memoize) whether the `portless` binary is usable. Absent \u2192 every other call no-ops. */\n  isAvailable: () => Promise<boolean>\n  /**\n   * Is a portless daemon serving `port` over `tls`? **Probe only \u2014 this never starts anything.** Binding\n   * the privileged `:443` needs root, and portless's sudo re-exec cannot prompt from a detached child, so\n   * the daemon is installed once, out-of-band (a root `service install`). A `false` here is turned into a\n   * fatal, actionable start error by the caller.\n   */\n  isProxyServing: (port: number, tls: boolean) => Promise<boolean>\n  /**\n   * Same probe as {@link PortlessDriver.isProxyServing}, but reporting WHICH way it failed instead of\n   * collapsing every non-serving case into `false`. `ensureProxy` uses this to print a distinct, actionable\n   * message for \"nothing there\", \"something else is there\", and (combined with {@link isServiceInstalled})\n   * \"installed but not running\" vs \"never installed\". Never starts anything \u2014 probe only, same as above.\n   */\n  probeProxy: (port: number, tls: boolean) => Promise<ProxyProbeOutcome>\n  /**\n   * Is portless's OS-level service (what `service install` registers) present on disk? Cheap, synchronous,\n   * never throws. `'unknown'` on a platform this cannot check \u2014 a caller must not read that as `'no'`.\n   */\n  isServiceInstalled: () => ServiceInstalled\n  /**\n   * Register `<name> \u2192 127.0.0.1:<port>` (`name` = `<release>.<package>`). Returns `true` on success so\n   * the caller shows the hero URL only for an alias that actually resolves (best-effort otherwise).\n   */\n  registerAlias: (name: string, port: number) => Promise<boolean>\n  /** Deregister `<name>`. Best-effort. */\n  removeAlias: (name: string) => Promise<void>\n}\n\nexport interface PortlessDriverDeps {\n  /** Override the resolved `dist/cli.js` path (default: the real node_modules walk). Injected in tests. */\n  bin?: string | null\n  run?: PortlessRun\n  /** TCP liveness pre-filter (default: real `net` connect). Injected in tests. */\n  isListening?: IsListening\n  /** Wire-probe identity check (default: real `HEAD /` + `X-Portless`). Injected in tests. */\n  isProxyServing?: IsProxyServing\n  /** OS-service-on-disk check (default: real `existsSync` on the plist/unit path). Injected in tests. */\n  isServiceInstalled?: () => ServiceInstalled\n  timeoutMs?: number\n}\n\n/**\n * Build a {@link PortlessDriver}. Inject `run` in tests to assert argv without shelling out.\n * `isAvailable` memoizes so the binary is probed at most once per runner.\n */\nexport const createPortlessDriver = (deps: PortlessDriverDeps = {}): PortlessDriver => {\n  const bin = deps.bin === undefined ? portlessBin() : deps.bin\n  const run = deps.run ?? defaultRun\n  const isListening = deps.isListening ?? defaultIsListening\n  const isProxyServing = deps.isProxyServing ?? defaultIsProxyServing\n  const isServiceInstalled = deps.isServiceInstalled ?? defaultIsServiceInstalled\n  const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS\n  let availability: boolean | null = null\n\n  /** Run a portless subcommand, swallowing any failure into `false` (best-effort contract). */\n  const tryRun = async (args: string[]): Promise<boolean> => {\n    try {\n      await run(args, { timeoutMs })\n\n      return true\n    } catch {\n      return false\n    }\n  }\n\n  const isAvailable = async (): Promise<boolean> => {\n    availability ??= await tryRun(['--version'])\n\n    return availability\n  }\n\n  const serving = async (port: number, tls: boolean): Promise<boolean> => {\n    if (!(await isAvailable())) return false\n    // Nothing is even accepting TCP \u2192 skip the (more expensive) wire probe entirely.\n    if (!(await isListening(port))) return false\n\n    return isProxyServing(port, tls)\n  }\n\n  /**\n   * The classifying counterpart of {@link serving}. Deliberately does NOT gate on `isAvailable()` first (unlike\n   * `serving`): a broken/missing CLI binary says nothing about whether a daemon a PRIOR install started is\n   * still up on the wire, so the two are independent facts and the caller (which already checked availability\n   * before ever calling this) must not have that distinction collapsed here.\n   */\n  const probeProxy = async (port: number, tls: boolean): Promise<ProxyProbeOutcome> => {\n    if (!(await isListening(port))) return 'daemon-down'\n\n    return (await isProxyServing(port, tls)) ? 'serving' : 'not-portless'\n  }\n\n  const registerAlias = async (name: string, port: number): Promise<boolean> => {\n    if (!(await isAvailable())) return false\n\n    return tryRun(['alias', name, String(port)])\n  }\n\n  const removeAlias = async (name: string): Promise<void> => {\n    if (!(await isAvailable())) return\n    await tryRun(['alias', '--remove', name])\n  }\n\n  return {\n    binPath: () => {\n      return bin\n    },\n    isAvailable,\n    isProxyServing: serving,\n    probeProxy,\n    isServiceInstalled,\n    registerAlias,\n    removeAlias,\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["process", "$", "isCmuxAvailable", "$", "openCmuxDevWorkspace", "args", "cwd", "title", "layout", "layoutJson", "output", "process", "parseWorkspaceRef", "closeCmuxDevWorkspace", "ref", "error", "logger", "match", "$", "realpath", "$", "safeRealpath", "path", "realpath", "listCmuxWorkspacesByCwd", "workspacesOutput", "groupsOutput", "$", "workspaces", "groups", "anchorRefs", "group", "ref", "byCwd", "workspace", "error", "logger", "closeCmuxWorkspaceByCwd", "cwd", "ref", "listCmuxWorkspacesByCwd", "safeRealpath", "$", "error", "logger", "$", "findCmuxGroupRefByName", "name", "output", "$", "group", "error", "logger", "createCmuxGroupFrom", "fromRefs", "ref", "$", "openCmuxWorkspaceWithLayout", "args", "cwd", "title", "group", "layout", "resolveCmuxLayout", "getInfraKitConfig", "newWorkspaceOutput", "$", "workspaceRef", "parseWorkspaceRef", "surfacesOutput", "leftTopRef", "parseFirstSurfaceRef", "output", "match", "buildCmuxWorkspaceTitle", "args", "branch", "id", "parseBranchName", "displayLabel", "CANCELLATION_ERROR_NAMES", "hasCancellationName", "value", "isPromptCancellation", "error", "cause", "loadDev", "path", "collectReferencedApps", "presets", "discovered", "apps", "preset", "app", "resolvePreset", "buildRoutePkgLookup", "root", "routesByApp", "loadErrors", "routes", "loadDev", "path", "route", "route_", "error", "buildPresetProxyContext", "apiApps", "routePkg", "a", "execFile", "createHash", "existsSync", "readFileSync", "http", "https", "net", "homedir", "dirname", "join", "process", "tls", "fileURLToPath", "promisify", "execFileAsync", "promisify", "execFile", "readBinRel", "pkgJsonPath", "pkg", "readFileSync", "rel", "resolvePortlessBin", "dir", "dirname", "fileURLToPath", "join", "existsSync", "parent", "cachedBin", "portlessBin", "SHELL_SAFE", "SINGLE_QUOTE_ESCAPE", "shellQuote", "value", "formatPortlessCommand", "args", "options", "words", "process", "DEFAULT_TIMEOUT_MS", "PROBE_TIMEOUT_MS", "PORTLESS_HEADER", "LOOPBACK", "PROBE_SERVERNAME", "DARWIN_SERVICE_PLIST_PATH", "LINUX_SERVICE_UNIT_PATH", "defaultIsServiceInstalled", "exists", "defaultIsListening", "port", "resolve", "socket", "net", "finish", "result", "defaultIsProxyServing", "tls", "req", "https", "http", "res", "defaultRun", "timeoutMs", "bin", "withoutPackageManagerEnv", "portlessStateDir", "homedir", "CA_CERT_FILE", "CA_TRUST_MARKER_FILE", "readCaPath", "caFingerprintMatches", "recorded", "createHash", "handshakeChainsToCa", "servername", "ca", "authError", "authorized", "err", "listRoutes", "raw", "entry", "hostname", "createPortlessDriver", "deps", "run", "isListening", "isProxyServing", "isServiceInstalled", "availability", "tryRun", "isAvailable", "name"]
-}

package/dist/chunk-SSBYKOHY.js

@@ -1,4 +0,0 @@
-import M from"node:process";import j from"pino";import pe from"pino-pretty";var O="/tmp/mcp-infra-kit.log",F=["token","*.token","serviceToken","*.serviceToken","DOPPLER_TOKEN","*.DOPPLER_TOKEN","INFRA_KIT_ENV_TOKEN","*.INFRA_KIT_ENV_TOKEN"],At=()=>{let e=M.argv.includes("--debug")?"debug":"info",t=j({level:e,redact:F},j.destination({dest:O}));return t.info(`Logger initialized with level: ${e}. Logging to: ${O}`),t},le=()=>{let e=M.argv.includes("--debug")?"debug":"info",t=["time","pid","hostname"];return e==="debug"&&t.push("level"),j({level:e,redact:F},pe({destination:2,ignore:t.join(","),colorize:!0}))},$t=le();import*as p from"node:fs";import*as a from"node:path";function ue(e){let t=e;for(let r=0;r<10;r++){let n=a.join(t,"pnpm-workspace.yaml");if(p.existsSync(n))return t;t=a.dirname(t)}throw new Error("Could not find monorepo root (pnpm-workspace.yaml)")}function G(e,t){let r=a.join(e,"package.json");if(!p.existsSync(r))return t;try{let n=JSON.parse(p.readFileSync(r,"utf-8"));return typeof n.name=="string"?n.name:t}catch{return t}}function Nt(e){let t=a.join(e,"apps"),r=[];if(!p.existsSync(t))throw new Error(`Apps directory not found: ${t}`);let n=p.readdirSync(t,{withFileTypes:!0}).filter(o=>o.isDirectory()).map(o=>o.name);for(let o of n){let i=a.join(t,o,"api"),c=a.join(i,"serverless.yml");p.existsSync(c)&&r.push({name:o,packageName:G(i,o),path:i})}return r}var B=["vite.config.ts","vite.config.mts","vite.config.cts","vite.config.js","vite.config.mjs","vite.config.cjs"],fe=["@slip-stream-kit/vite","@slip-stream-kit/config/vite","infra-kit/vite"];function de(e){for(let t of B){let r=a.join(e,t);if(p.existsSync(r))try{let n=p.readFileSync(r,"utf-8");return fe.some(o=>n.includes(o))}catch{return!1}}return!1}function _t(e){for(let t of B){let r=a.join(e,t);if(p.existsSync(r))try{return p.readFileSync(r,"utf-8").includes("infraKit(")}catch{return!1}}return!1}function ge(e){let t=a.join(e,"package.json");if(!p.existsSync(t))return!1;try{let r=JSON.parse(p.readFileSync(t,"utf-8"));return typeof r.scripts?.dev=="string"&&r.scripts.dev.length>0}catch{return!1}}function Lt(e){let t=a.join(e,"apps"),r=[];if(!p.existsSync(t))return r;let n=p.readdirSync(t,{withFileTypes:!0}).filter(o=>o.isDirectory()).map(o=>o.name);for(let o of n){let i=a.join(t,o,"ui");p.existsSync(i)&&ge(i)&&r.push({name:o,packageName:G(i,o),path:i,managedPort:de(i)})}return r}function Kt(e){let t=e?.filter(Boolean)??[];return t.length>0?t:null}function Ot(e){let t=ue(e),r=a.relative(a.join(t,"apps"),e),n=r.split(a.sep)[0];if(r===""||r.startsWith("..")||a.isAbsolute(r)||!n)throw new Error(`--self: not inside an apps/<app> directory (cwd: ${e}). Run from an app folder or use --app=<name>.`);return n}var me=new Set(["api","ui"]),W=e=>{let t=a.join(e,"dist");return p.existsSync(t)&&p.statSync(t).isDirectory()?t:void 0},I=e=>p.existsSync(e)?p.readdirSync(e,{withFileTypes:!0}).filter(t=>t.isDirectory()).map(t=>t.name):[];function Mt(e){let t=[];for(let n of I(a.join(e,"packages"))){let o=W(a.join(e,"packages",n));o!==void 0&&t.push(o)}let r=a.join(e,"apps");for(let n of I(r))for(let o of I(a.join(r,n))){if(me.has(o))continue;let i=a.join(r,n,o);if(!p.existsSync(a.join(i,"package.json")))continue;let c=W(i);c!==void 0&&t.push(c)}return t}function Ft(e){return e.map(t=>a.join(t.path,"dist")).filter(t=>p.existsSync(t))}function Wt(e,t,r){let n=a.normalize(e),o=r.find(c=>n.startsWith(a.normalize(c)));return o?{kind:"package",packageDir:o}:{kind:"app",app:t.find(c=>n.startsWith(a.normalize(c)))}}var he={"*/api":{},"*/ui":{}},V=e=>{let t=e.split("/"),[r,n]=t;return t.length!==2||!r?`devServersPresets: invalid target "${e}" (expected "<app>/api" or "<app>/ui")`:n!=="api"&&n!=="ui"?`devServersPresets: invalid target part "${n}" in "${e}" (expected "api" or "ui")`:null},ve=e=>{let t=V(e);if(t)throw new Error(t);let[r,n]=e.split("/");return{appGlob:r,part:n}},Bt=e=>{let t=[];for(let[r,n]of Object.entries(e))for(let o of Object.keys(n.apps??{})){let i=V(o);i&&t.push({preset:r,key:o,message:`preset "${r}": ${i}`})}return t},ye=(e,t)=>t==="api"?e.api:e.ui,ke=e=>[...new Set([...e.api,...e.ui])].sort(),z=(e,t)=>`${e}/${t}`,xe=e=>e?0:1,we=(e,t)=>t.watchDeps===void 0?e??{watchDeps:!0,rank:t.rank,explicitValue:!1}:!e||!e.explicitValue?{watchDeps:t.watchDeps,rank:t.rank,explicitValue:!0}:t.rank>e.rank?{watchDeps:t.watchDeps,rank:t.rank,explicitValue:!0}:e,be=(e,t,r)=>{let{app:n,part:o,watchDeps:i,isGlob:c}=r;if(!ye(t,o).includes(n)){c||e.unmatched.push(z(n,o));return}let l=z(n,o),u=we(e.targets.get(l),{watchDeps:i,rank:xe(c)});e.targets.set(l,{app:n,part:o,...u})},Pe=(e,t)=>{let r=Object.entries(e.apps??he),n={targets:new Map,proxy:{},unmatched:[]};for(let[c,l]of r){let{appGlob:u,part:g}=ve(c),m=u==="*",P=m?ke(t):[u];for(let C of P)be(n,t,{app:C,part:g,watchDeps:l.watchDeps,isGlob:m}),l.proxy&&(n.proxy[C]={...n.proxy[C]??{},...l.proxy})}let o=[...n.targets.values()].map(({app:c,part:l,watchDeps:u})=>({app:c,part:l,watchDeps:u})),i=[...new Set(o.filter(c=>c.part==="api").map(c=>c.app))];return{targets:o,cmux:e.cmux??!1,proxy:n.proxy,localApps:i,unmatched:n.unmatched}},zt=e=>{if(e.preset!=null)return e.preset;if(e.running.length===0)return"nothing";let t=new Set(e.running);return e.discovered.every(n=>t.has(n))?"*":[...t].sort().join(" + ")},Re=(e,t)=>Object.keys(e).find(r=>e[r]===t),Ee=({preset:e,app:t,route:r,launchedPkgs:n,ctx:o})=>{let i=o.routePkg(t,r);if(i===void 0)return{preset:e,app:t,route:r,kind:"unknown-route",message:`preset "${e}": proxy override "${r}" on "${t}" names a route not declared in ${t}'s infra-kit.config.ts dev.proxy.routes`};if(n.has(i))return null;let c=Re(o.apiPkgByApp,i),l=c?`add "${c}/api" to the preset`:`launch the api whose package is "${i}"`;return{preset:e,app:t,route:r,pkg:i,kind:"backend-not-launched",message:`preset "${e}": proxy override "${r}" \u2192 "local" requires backend "${i}" to run locally, but the preset does not launch it \u2014 ${l}, or set "${r}" to "cloud"`}},Vt=(e,t)=>{let r=[];for(let[n,o]of Object.entries(e)){let i=Pe(o,t.discovered),c=new Set(i.localApps.map(l=>t.apiPkgByApp[l]).filter(l=>l!==void 0));for(let[l,u]of Object.entries(i.proxy))for(let[g,m]of Object.entries(u)){if(m!=="local")continue;let P=Ee({preset:n,app:l,route:g,launchedPkgs:c,ctx:t});P&&r.push(P)}}return r};import L from"node:fs/promises";import ne from"node:os";import w from"node:path";import Ue from"node:process";import{z as s}from"zod";import v from"node:path";import Q from"node:process";import{$ as f}from"zx";var E=e=>{if(e===null||typeof e!="object")return;let t=e.stderr;return typeof t=="string"&&t.length>0?t:void 0},Se=(e,t)=>{let r=t.stderrExcerpt??E(e),n=[`failed to ${t.operation}`];return r&&n.push(`stderr: ${r.slice(0,200).trim()}`),t.remediation&&n.push(`try: ${t.remediation}`),n.join(" \u2014 ")},R=class extends Error{operation;remediation;constructor(t,r){super(Se(t,r),{cause:t}),this.name="OperationError",this.operation=r.operation,this.remediation=r.remediation}};var U={enabled:!1},x=()=>U.enabled;var Ce=/^v?(\d+)\.(\d+)\.(\d+)$/,je=/^(\d+)\.(\d+)\.(\d+)$/,Ie=/^[a-z0-9]+(?:-[a-z0-9]+)*$/,S="release/",D="release/v",X="refs/heads/",De="next";var H=new Set(["dev","main","next","hotfix","regular","release"]),h=class extends Error{constructor(t){super(t),this.name="InvalidReleaseNameError"}},y=class extends Error{constructor(t){super(t),this.name="InvalidReleaseRefError"}},J=e=>e.startsWith(X)?e.slice(X.length):e,Y=(e,t,r)=>({kind:"version",semver:{major:e,minor:t,patch:r},raw:`${e}.${t}.${r}`}),A=e=>{if(e.length===0)throw new h('Release name is empty. Provide a kebab-case name like "checkout-redesign".');if(e.length>50)throw new h(`Release name "${e}" is ${e.length} characters; the maximum is 50.`);if(!Ie.test(e))throw new h(`Release name "${e}" is not kebab-case. Use lowercase letters, digits, and single hyphens, e.g. "checkout-redesign".`);if(H.has(e))throw new h(`Release name "${e}" is reserved. Reserved names: ${[...H].join(", ")}.`)},$=e=>{let t=J(e.trim());if(!t.startsWith(S))return null;if(t.startsWith(D)){let n=t.slice(D.length),o=je.exec(n);if(o)return Y(Number(o[1]),Number(o[2]),Number(o[3]))}let r=t.slice(S.length);try{A(r)}catch{return null}return{kind:"name",name:r,raw:r}},Ae=e=>{let t=e.trim();if(J(t).startsWith(S)){let o=$(t);if(!o)throw new y(`"${e}" looks like a release branch but is not a valid release/v<semver> or release/<name> ref.`);return o}let n=Ce.exec(t);if(n)return Y(Number(n[1]),Number(n[2]),Number(n[3]));if(t.toLowerCase()===De)throw new y('The "next" token must be resolved to a concrete version (via computeNextVersion) before parsing a release ref.');try{A(t)}catch(o){let i=o instanceof Error?o.message:String(o);throw new y(`Cannot parse "${e}" as a release ref: ${i}`)}return{kind:"name",name:t,raw:t}},$e=e=>e.kind==="version"?`${D}${e.raw}`:`${S}${e.name}`,Te=(e,t)=>{let r=t==="hotfix"?"Hotfix":"Release";return e.kind==="version"?`${r} v${e.raw}`:`${r} ${e.name}`},Ne=e=>e.kind==="version"?`Release v${e.raw} (RC)`:`Release ${e.name} (RC)`,_e=e=>e.kind==="version"?`v${e.raw}`:e.name,Le=e=>e.raw,T=e=>e==null?!1:$(e)!==null,q=e=>{if(e===void 0)return null;let t=e instanceof Date?e.getTime():new Date(e).getTime();return Number.isNaN(t)?null:t},Ke=(e,t,r)=>{if(e.kind==="version"&&t.kind==="version")return e.semver.major!==t.semver.major?e.semver.major-t.semver.major:e.semver.minor!==t.semver.minor?e.semver.minor-t.semver.minor:e.semver.patch-t.semver.patch;if(e.kind==="version")return-1;if(t.kind==="version")return 1;let n=q(r?.a),o=q(r?.b);return n!==null&&o!==null&&n!==o?n-o:e.name<t.name?-1:e.name>t.name?1:0};var Z=async e=>{let t=await f({cwd:e})`git worktree list --porcelain`,r=[],n=null;for(let o of t.stdout.split(`
-`)){if(o.startsWith("worktree ")){n&&r.push(n),n={path:o.slice(9),branch:null,detached:!1,bare:!1,prunable:!1,locked:!1};continue}n&&(o.startsWith("branch ")?n.branch=o.slice(7).replace(/^refs\/heads\//,""):o==="detached"?n.detached=!0:o==="bare"?n.bare=!0:o==="locked"||o.startsWith("locked ")?n.locked=!0:(o==="prunable"||o.startsWith("prunable "))&&(n.prunable=!0))}return n&&r.push(n),r},Oe=async e=>{let t=await Z(Q.cwd()),r=n=>e==="release"?T(n):n.startsWith("feature/");return t.map(n=>n.branch).filter(n=>n!==null&&r(n))},Me=e=>{let t=E(e);return t&&/not a git repository/i.test(t)?"not a git repository":void 0},Fe=({hasStderr:e})=>{if(x())return"the infra-kit MCP server resolves its project from the working directory it was launched in; the operator must relaunch the server with its working directory set to an infra-kit project repo";let t="run infra-kit from inside an infra-kit project repo (or one of its git worktrees)";return e?`${t}; if you are already in one, the stderr in this message is the real cause`:t},k=async()=>{try{return(await f({quiet:!0})`git rev-parse --show-toplevel`).stdout.trim()}catch(e){let t=Me(e)??E(e);throw new R(e,{operation:`resolve the project root from ${Q.cwd()}`,stderrExcerpt:t,remediation:Fe({hasStderr:t!==void 0})})}},N=async e=>{let t=e??await k(),r=(await f({cwd:t,quiet:!0})`git rev-parse --git-common-dir`).stdout.trim(),n=v.resolve(t,r);return n.includes(`${v.sep}.git${v.sep}modules${v.sep}`)?t:v.dirname(n)},ee=async()=>(await f`git rev-parse --abbrev-ref HEAD`).stdout.trim(),We=async()=>(await f`git status --porcelain`).stdout.trim().length===0,Ge=async()=>{let e=await k(),[t,r]=await Promise.all([f({cwd:e})`git rev-parse --absolute-git-dir`,f({cwd:e})`git rev-parse --git-common-dir`]),n=t.stdout.trim(),o=v.resolve(e,r.stdout.trim());return n!==o},Be=async()=>{let e=await k();return v.basename(e)},ze=async e=>{(await f`git branch --list ${e}`).stdout.trim().length!==0&&await ee()!==e&&await f`git branch -D ${e}`},Ve=async e=>{(await f`git ls-remote --heads origin ${e}`).stdout.trim().length!==0&&await f`git push origin --delete ${e}`};var te="infra-kit.json",oe=".infra-kit",Xe="infra-kit.json",He="projects",qe=s.object({provider:s.literal("doppler"),config:s.object({name:s.string().min(1)})}),Je=s.discriminatedUnion("provider",[qe]),Ye=s.object({workspaceConfigPath:s.string().min(1)}),Qe=s.object({provider:s.literal("cursor"),config:Ye}),Ze=s.object({}),et=s.object({provider:s.literal("zed"),config:Ze}),re=s.discriminatedUnion("provider",[Qe,et]),tt=s.union([re,s.array(re).min(1)]),rt=s.object({provider:s.literal("jira"),config:s.object({baseUrl:s.string().url(),projectId:s.number().int().positive()})}),nt=s.discriminatedUnion("provider",[rt]),ot=["two-columns","three-pane"],st=s.object({layout:s.enum(ot).optional()}),it=s.object({openInGithubDesktop:s.boolean().optional(),openInCmux:s.boolean().optional(),cmux:st.optional()}),at=s.object({port:s.number().int().positive().optional(),prefixUrl:s.string().min(1).optional()}).strict(),ct=s.record(s.string().min(1),at),pt=s.enum(["local","cloud"]),lt=s.object({watchDeps:s.boolean().optional(),proxy:s.record(s.string().min(1),pt).optional()}).strict(),ut=s.object({apps:s.record(s.string().min(1),lt).optional(),cmux:s.boolean().optional()}).strict(),ft=s.record(s.string().min(1),ut),dt=s.object({port:s.number().int().positive().optional()}).strict(),gt=s.object({trigger:s.enum(["shell-startup","cli-invocation"]),config:s.string().min(1)}).strict(),mt=s.enum(["disallow","allow","cli-only"]),K=s.object({envManagement:Je,ide:tt.optional(),taskManager:nt.optional(),worktrees:it.optional(),envAutoLoad:gt.optional(),dev:ct.optional(),devServersPresets:ft.optional(),devProxy:dt.optional(),protectedEnvs:mt.optional()}).strict(),ht=443,se=K.superRefine((e,t)=>{if(!Array.isArray(e.ide))return;let r=new Set;for(let n of e.ide){if(r.has(n.provider)){t.addIssue({code:"custom",message:"each IDE provider may appear at most once",path:["ide"]});return}r.add(n.provider)}}),ie=K.partial(),vt=e=>{let t=e.ide;return t?Array.isArray(t)?t:[t]:[]},yt="two-columns",kt=e=>e.worktrees?.cmux?.layout??yt,d=null,b=null,ae=()=>`${Ue.cwd()} ${ne.homedir()}`,ce=async()=>{let e=ae();if(b&&b.key===e)return b.value;let t=await k(),r=await N(t),n=w.basename(r),o=w.join(ne.homedir(),oe),i={main:w.join(t,te),userGlobal:w.join(o,Xe),userProject:w.join(o,He,n,te),projectName:n};return b={key:e,value:i},i},xt=async()=>{let e=ae(),t=await ce(),r;try{r=await L.stat(t.main)}catch{d=null;let g=t.main.replace(/\.json$/,".yml");throw await _(g)?new Error(`infra-kit.json not found at ${t.main}. A legacy infra-kit.yml exists \u2014 run \`infra-kit init\` to convert it.`):new Error(x()?`infra-kit.json not found at ${t.main} \u2014 the directory the infra-kit MCP server was launched in is not an infra-kit project. The operator must relaunch the server with its working directory set to an infra-kit project repo.`:`infra-kit.json not found at ${t.main} \u2014 this git repo is not an infra-kit project. Run \`infra-kit init\` here to create it, cd into an infra-kit project repo, or check out a branch that has infra-kit.json.`)}let[n,o]=await Promise.all([_(t.userGlobal),_(t.userProject)]),i={main:Number(r.mtimeMs),userGlobal:n?Number(n.mtimeMs):null,userProject:o?Number(o.mtimeMs):null};if(d&&d.key===e&&Rt(d.mtimes,i))return d.value;let c=[{label:"infra-kit.json",path:t.main,required:!0},{label:"~/.infra-kit/infra-kit.json",path:t.userGlobal,required:!1},{label:`~/.infra-kit/projects/${t.projectName}/infra-kit.json`,path:t.userProject,required:!1}],l={};for(let g of c){let m=await Et(g);m!==null&&(l={...l,...m})}let u=se.safeParse(l);if(!u.success)throw new Error(`Invalid merged infra-kit config: ${s.prettifyError(u.error)}`);return d={key:e,mtimes:i,value:u.data},u.data},wt=()=>{d=null},bt=()=>{d=null,b=null},_=async e=>{try{return await L.stat(e)}catch{return null}},Pt=async e=>{try{return await L.readFile(e,"utf-8")}catch{return null}},Rt=(e,t)=>{let r=Object.keys(e);return r.length!==Object.keys(t).length?!1:r.every(n=>e[n]===t[n])},Et=async e=>{let t=await Pt(e.path);if(t===null){if(e.required)throw new Error(`${e.label} not found at ${e.path}`);return null}let r;try{r=t.trim()===""?{}:JSON.parse(t)}catch(o){throw new Error(`Invalid JSON in ${e.label} at ${e.path}: ${o.message}`)}if(St(r)&&"envTokens"in r)throw new Error(Ct(e));let n=ie.safeParse(r);if(!n.success)throw new Error(`Invalid ${e.label} at ${e.path}: ${s.prettifyError(n.error)}`);return n.data},St=e=>typeof e=="object"&&e!==null&&!Array.isArray(e),Ct=e=>[`Refusing to load ${e.label} \u2014 \`envTokens\` is not a config key.`,"A service token in a config file can be committed, backed up by your editor, or shared.","  1. REVOKE the token in Doppler now \u2014 treat it as compromised.",`  2. Remove the \`envTokens\` key from ${e.path}.`,"  3. Re-add it privately: `infra-kit env-token-set <env>`","     (it is written to ~/.infra-kit/projects/<repo>/tokens.json, mode 0600, never to the repo)."].join(`
-`);export{E as a,R as b,U as c,x as d,h as e,A as f,$ as g,Ae as h,$e as i,Te as j,Ne as k,_e as l,Le as m,T as n,Ke as o,Z as p,Oe as q,k as r,N as s,ee as t,We as u,Ge as v,Be as w,ze as x,Ve as y,O as z,At as A,$t as B,ue as C,Nt as D,_t as E,Lt as F,Kt as G,Ot as H,Mt as I,Ft as J,Wt as K,V as L,Bt as M,Pe as N,zt as O,Vt as P,oe as Q,ht as R,se as S,ie as T,vt as U,kt as V,ce as W,xt as X,wt as Y,bt as Z};
-//# sourceMappingURL=chunk-SSBYKOHY.js.map

package/dist/dev-wizard-run-XM5L23UP.js

@@ -1,2 +0,0 @@
-import{f as C,i as f,j as g}from"./chunk-QLAQ7F4M.js";import{B as u,C as b,D as y,F as k,P as x,X as v}from"./chunk-SSBYKOHY.js";import{e as w}from"./chunk-CHETBZ6M.js";import"./chunk-X46DP23W.js";import O from"@inquirer/checkbox";import _ from"@inquirer/confirm";import j,{Separator as I}from"@inquirer/select";import{loadDev as K}from"@slip-stream-kit/config/internal";import U from"node:path";import m from"node:process";var W=e=>e.split("/")[0],A=e=>new Map(e.apps.map(r=>[r.name,r])),D=e=>e.localCapable&&e.cloudCapable,N=(e,r,t)=>D(r)?t[`${e} ${r.path}`]??(r.cloudCapable?"cloud":"local"):r.localCapable?"local":"cloud",$=(e,r,t)=>{let a=new Set,o=new Map;for(let n of e){let s=r.get(W(n));for(let c of s?.backends??[]){o.set(c.packageName,c.ownerApp);for(let l of c.routes)N(n,l,t)==="local"&&a.add(c.packageName)}}return{localPkgs:a,ownerByPkg:o}},B=(e,r)=>{let t={},a=!1;for(let o of e?.backends??[]){let n=r.has(o.packageName);for(let s of o.routes){let c=s.localCapable&&n?"local":"cloud";t[s.path]=c,c==="cloud"&&(a=!0)}}return{overrides:t,anyCloud:a}},z=(e,r)=>{let t=A(r),a=e.targets.filter(p=>p.endsWith("/ui")),o=e.targets.filter(p=>p.endsWith("/api")),{localPkgs:n,ownerByPkg:s}=$(a,t,e.sources),c={},l=!1;for(let p of a){let{overrides:d,anyCloud:i}=B(t.get(W(p)),n);i&&(l=!0),c[p]=Object.keys(d).length>0?{proxy:d}:{}}for(let p of o)c[p]??={};for(let p of n){let d=s.get(p);d!=null&&(c[`${d}/api`]??={})}return{presetDef:{apps:c,cmux:e.cmux},anyCloudRoute:l,targetKeys:Object.keys(c).sort()}},M=(e,r)=>{let t=[`--target=${e.targetKeys.join(",")}`];return r.watch&&t.push("--watch"),r.cmux&&t.push("--cmux"),{flags:t.join(" ")}};var h={output:m.stderr,clearPromptOnDone:!0},q={select:e=>g(r=>j({message:e.message,choices:e.choices,default:e.default},r),h),checkbox:e=>g(r=>O({message:e.message,choices:e.choices},r),h),confirm:e=>g(r=>_({message:e.message,default:e.default},r),h)},E=(e,r)=>{let t=new Map;for(let[a,o]of Object.entries(e)){let n={path:a,localCapable:o.from.includes("local"),cloudCapable:o.from.includes("cloud"),default:o.default},s=t.get(o.packageName);s?(s.routes.push(n),s.localCapable=s.localCapable||n.localCapable,s.cloudCapable=s.cloudCapable||n.cloudCapable):t.set(o.packageName,{packageName:o.packageName,routes:[n],localCapable:n.localCapable,cloudCapable:n.cloudCapable,ownerApp:r.get(o.packageName)})}return[...t.values()]},T=async(e,r,t)=>{try{let a=(await K(e))?.proxy?.routes;return a?E(a,t):[]}catch(a){return u.warn(`\u26A0\uFE0F  Skipping ${r}: its dev config failed to load \u2014 ${a instanceof Error?a.message:String(a)}`),[]}},V=async e=>{let r=y(e),t=k(e),a=await v(),o=new Map(r.map(i=>[i.packageName,i.name])),n=new Map(r.map(i=>[i.name,i.packageName])),s=new Set(t.map(i=>i.name)),c=new Set(r.map(i=>i.name)),l=[...new Set([...c,...s])].sort(),p=await Promise.all(l.map(async i=>{let P=s.has(i);return{name:i,hasApi:c.has(i),hasUi:P,apiPackage:n.get(i),backends:P?await T(U.join(e,"apps",i,"ui"),i,o):[]}})),d=await C();return{apps:p,presets:Object.keys(a.devServersPresets??{}),environments:Object.keys(d?.envs??{}).sort()}},F=e=>{let r=[];for(let t of e.apps){if(t.hasUi){let a=t.backends.flatMap(n=>n.routes.map(s=>s.path)),o=a.length>0?`frontend \u2014 proxies ${[...a].sort().join(", ")}`:"frontend";r.push({name:`${t.name}/ui`,value:`${t.name}/ui`,description:o})}t.hasApi&&!t.hasUi&&r.push({name:`${t.name}/api`,value:`${t.name}/api`,description:"backend"})}return r},L=e=>{let r={api:e.apps.filter(o=>o.hasApi).map(o=>o.name),ui:e.apps.filter(o=>o.hasUi).map(o=>o.name)},t={},a=new Map;for(let o of e.apps){o.apiPackage!=null&&(t[o.name]=o.apiPackage);for(let n of o.backends)for(let s of n.routes)a.set(`${o.name} ${s.path}`,n.packageName)}return{discovered:r,apiPkgByApp:t,routePkg:(o,n)=>a.get(`${o} ${n}`)}},X=(e,r)=>x({__wizard__:e},L(r)).map(t=>t.message),Z="INFRA_KIT_DEV_WIZARD_CMUX",H=()=>m.env[Z]==="1",G=async(e,r,t)=>{let a=new Map(r.apps.map(n=>[n.name,n])),o={};for(let n of t){let s=a.get(n.split("/")[0]);for(let c of s?.backends??[])for(let l of c.routes){if(!l.localCapable||!l.cloudCapable)continue;let p=await e.select({message:`\u{1F500} ${n} ${l.path} \u2192 local or cloud?`,choices:[{name:"local (this machine)",value:"local"},{name:"cloud",value:"cloud"}],default:l.default??"local"});o[`${n} ${l.path}`]=p}}return o},J=(e,r,t)=>e.apps.find(a=>a.name===r)?.backends.flatMap(a=>a.routes).find(a=>a.path===t),Q=(e,r)=>{let t=[];for(let[a,o]of Object.entries(e.presetDef.apps??{})){if(!a.endsWith("/ui")||!o.proxy)continue;let n=a.split("/")[0];for(let[s,c]of Object.entries(o.proxy)){let l=J(r,n,s),p=l&&l.localCapable&&l.cloudCapable?"":" (only option)";t.push(`  ${a} ${s} \u2192 ${c}${p}`)}}if(t.length!==0){u.info("Resolved routes:");for(let a of[...t].sort())u.info(a)}},R=async(e,r)=>{if(r.apps.length===0)return u.warn("No apps discovered to run."),null;let t=await e.checkbox({message:"\u{1F4E6} Which packages?",choices:F(r)});if(t.length===0)return u.warn("No packages selected."),null;let a=t.filter(i=>i.endsWith("/ui")),o=await G(e,r,a),n=await e.confirm({message:"\u{1F440} Rebuild & restart on save (watch)?",default:!1}),s=H()?await e.confirm({message:"\u{1F9E9} Run each app in its own cmux pane?",default:!1}):!1,c={targets:t,sources:o,watch:n,cmux:s},l=z(c,r);if(l.anyCloudRoute){if(r.environments.length===0)return u.warn("\u2601\uFE0F  This selection routes to a cloud environment, but no environment token is loaded."),u.warn("   Run `infra-kit env-load` to add one, then re-run the wizard."),null;c.env=await e.select({message:"\u2601\uFE0F  Point cloud routes at which environment?",choices:r.environments.map(i=>({name:i,value:i}))}),m.env[w]=c.env}let p=X(l.presetDef,r);if(p.length>0){u.warn("\u26A0\uFE0F  Proxy audit found issues with this selection:");for(let i of p)u.warn(`   \u2022 ${i}`);return null}Q(l,r),Y(l,c);let d=l.targetKeys.filter(i=>i.endsWith("/api")).map(i=>i.split("/")[0]);return s&&d.length>0?{include:d,presetDef:l.presetDef,watch:n,cmux:!0}:(s&&u.info("\u2139\uFE0F  cmux needs at least one local backend (panes are backend-only) \u2014 running in-process instead."),{presetDef:l.presetDef,watch:n,cmux:!1})},Y=(e,r)=>{f.setInteractive();let t=M(e,r);f.addOption(t.flags,!0),f.print(),u.info("\u2139\uFE0F  Prefer a short name? Save this selection as a devPreset and run `infra-kit dev <name>`.")},ee=async(e,r)=>{let t=await e.confirm({message:"\u{1F440} Rebuild & restart on save (watch)?",default:!1});return f.setInteractive(),f.addOption(r,!0),t&&f.addOption("--watch",!0),f.print(),{preset:r,watch:t,cmux:!1}},S=" manual",re=async(e,r)=>{if(r.presets.length===0)return R(e,r);let t=await e.select({message:"\u{1F680} Start from a preset, or configure manually?",choices:[...r.presets.map(a=>({name:a,value:a})),new I(" "),{name:"Manual (custom)\u2026",value:S}]});return t===S?R(e,r):ee(e,t)},be=async(e=q,r=b(m.cwd()))=>re(e,await V(r));export{S as MANUAL_CHOICE,Z as WIZARD_CMUX_VAR,X as auditManualPlan,q as defaultPrompts,V as gatherWizardModel,T as loadBackends,be as runDevWizard,re as runWizardFlow};
-//# sourceMappingURL=dev-wizard-run-XM5L23UP.js.map

package/dist/persistent-ink-dev-ui-PLLSRSGL.js

@@ -1,2 +0,0 @@
-import{a as p,c as u}from"./chunk-RVTI3AL2.js";import{a as l}from"./chunk-TPVXMJ7N.js";import{render as C}from"ink";import O from"node:process";import{Box as c,Static as S,Text as d}from"ink";import{useEffect as F,useState as b}from"react";import{jsx as a,jsxs as v}from"react/jsx-runtime";var g=r=>{let{phase:e,narration:t,readyLines:i}=r,[o,f]=b(0);return F(()=>{if(i)return;let n=setInterval(()=>{f(s=>s+1)},w);return()=>{clearInterval(n)}},[i]),i?a(S,{items:i,children:(n,s)=>a(d,{children:n},s)}):v(c,{flexDirection:"column",children:[v(c,{children:[a(d,{color:"cyan",children:m[o%m.length]}),a(d,{dimColor:!0,children:` ${e}`})]}),t?a(d,{dimColor:!0,children:t}):null]})},m=["\u280B","\u2819","\u2839","\u2838","\u283C","\u2834","\u2826","\u2827","\u2807","\u280F"],w=80;import{Box as P,Static as D,Text as L}from"ink";import{Fragment as T,jsx as h,jsxs as z}from"react/jsx-runtime";var R=r=>{let{headerLines:e,logLines:t,footerLines:i}=r,o=[...e,...t],f=B(i,r.maxFooterLines);return z(T,{children:[h(D,{items:o,children:(n,s)=>h(L,{children:n},s)}),h(P,{flexDirection:"column",children:f.map((n,s)=>h(L,{children:n},s))})]})},B=(r,e)=>{if(e==null||e<1||r.length<=e)return r;let t=r.slice(0,e-1);return[...t,`  \u2026 +${r.length-t.length} more`]};import{jsx as x}from"react/jsx-runtime";var y=class{renderer;renderFn;stdout;verbose;now;instance=null;finalized=!1;persistent=!1;phase="";narration="";headerLines=[];logLines=[];footerLines=[];constructor(e){this.verbose=e.verbose??!1,this.renderFn=e.render??C,this.stdout=e.stdout??l(O.stdout),this.now=e.now??(()=>new Date),this.renderer=new u({appendLog:e.appendLog,verbose:this.verbose,isTTY:!0,write:t=>{this.stdout.write(t)},now:this.now})}logFn=(e,t="info")=>{this.log(e,t)};renderBoot(e){let t=x(g,{phase:this.phase,narration:this.narration,readyLines:e});if(this.instance){this.instance.rerender(t);return}this.instance=this.renderFn(t,{stdout:this.stdout,exitOnCtrlC:!1,patchConsole:!1})}unmount(){this.instance&&(this.instance.unmount(),this.instance=null)}narrate(e){if(this.renderer.teeOnly(e,"info"),this.persistent){this.verbose&&(this.logLines.push(e),this.rerenderPersistent());return}this.finalized||(this.narration=e,this.instance&&this.renderBoot())}log(e,t="info",i={}){let o=t!=="debug"||this.verbose;if(this.persistent){i.tee!==!1&&this.renderer.teeOnly(e,t),o&&(this.logLines.push(e),this.rerenderPersistent());return}o&&this.unmount(),this.renderer.log(e,t,i)}bootStep(e){this.renderer.teeOnly(e,"info"),!this.finalized&&(this.phase=e,this.renderBoot())}stopSpinner(){this.persistent||this.unmount()}ready(e){this.headerLines=this.renderer.formatHeaderLines(e),this.footerLines=this.renderer.formatFooterLines(e),this.logLines=[];for(let t of this.headerLines)this.renderer.teeOnly(t,"info");this.finalized=!0,this.persistent=!0,typeof this.stdout.on=="function"&&this.stdout.on("resize",this.onResize),this.rerenderPersistent()}maxFooterLines(){return Math.max(3,(this.stdout.rows??24)-6)}rerenderPersistent(){let e=x(R,{headerLines:this.headerLines,logLines:this.logLines,footerLines:this.footerLines,maxFooterLines:this.maxFooterLines()});if(this.instance){this.instance.rerender(e);return}this.instance=this.renderFn(e,{stdout:this.stdout,exitOnCtrlC:!1,patchConsole:!1})}onResize=()=>{this.persistent&&this.rerenderPersistent()};event(e){if(this.persistent){let t=`  ${p(this.now())}  ${e.tag}  ${e.text}`;this.renderer.teeOnly(`${e.tag} ${e.text}`,"info"),this.logLines.push(t),this.rerenderPersistent();return}this.unmount(),this.renderer.event(e)}refresh(e){this.persistent&&(this.footerLines=this.renderer.formatFooterLines(e),this.rerenderPersistent())}dispose(){this.persistent&&(this.rerenderPersistent(),typeof this.stdout.off=="function"&&this.stdout.off("resize",this.onResize)),this.finalized=!0,this.persistent=!1,this.unmount()}};export{y as PersistentInkDevUi};
-//# sourceMappingURL=persistent-ink-dev-ui-PLLSRSGL.js.map

package/dist/persistent-ink-dev-ui-PLLSRSGL.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/tui/dev-ui/persistent-ink-dev-ui.tsx", "../src/tui/dev-ui/boot-region.tsx", "../src/tui/dev-ui/live-region.tsx"],
-  "sourcesContent": ["import { render as inkRender } from 'ink'\nimport process from 'node:process'\nimport type { ReactElement } from 'react'\n\nimport type { DevUi, LogLevel, LogOptions, ReadySummary } from 'src/dev/dev-ui'\nimport { DevRenderer, formatClock } from 'src/dev/render'\nimport { createSafeStream } from 'src/tui/safe-stderr'\n\nimport { BootRegion } from './boot-region'\nimport { LiveRegion } from './live-region'\n\n/**\n * Ink-backed {@link DevUi} for `infra-kit dev`: a boot region that collapses into a PERSISTENT status\n * panel. It is the UI on any interactive TTY.\n *\n * There is one shape of session now, not two. Until recently `ready` branched on `summary.hasUiChild`\n * and, for a UI session, unmounted Ink and handed off to a DECSTBM scroll-region UI \u2014 because the\n * `turbo run dev` child's piped output produced an unbounded tail, Ink repaints its live region on every\n * appended line, and a pinned footer can only survive a scrolling stream if the TERMINAL is told to\n * confine it.\n *\n * That tail no longer exists. Framework lines and request lines go to their per-service log files and\n * are never printed, so there is nothing to scroll past the panel and nothing for a scroll region to\n * defend it from. The branch, the handoff, and the whole DECSTBM machinery were deleted with the stream\n * that justified them.\n *\n * What still prints above the panel is only what the RUNNER says \u2014 a restart, an unhealthy app, a dead\n * engine. Those are rare and they are events, not logs.\n *\n * The embedded {@link DevRenderer} owns the file-tee format (`teeOnly`); in persistent mode it is used\n * ONLY for teeing, never its direct stdout write, which would collide with the live region. Every\n * component here is OUTPUT-ONLY (no `useInput`) \u2014 see live-region.tsx.\n */\n\n/** The subset of an Ink render handle this UI drives \u2014 shared by `ink` and `ink-testing-library`. */\ninterface RenderHandle {\n  rerender: (tree: ReactElement) => void\n  unmount: () => void\n}\n\n/** Render seam: `ink`'s `render` by default; `ink-testing-library`'s `render` is injected in tests. */\ntype RenderFn = (tree: ReactElement, options?: unknown) => RenderHandle\n\nexport interface PersistentInkDevUiDeps {\n  /** File tee \u2014 the same appender the runner hands the plain renderer. */\n  appendLog: (text: string) => void\n  /** Mirrors the renderer's verbose gate: only in verbose does a `debug` log reach the terminal. */\n  verbose?: boolean\n  /** Clock seam (for deterministic tee + event timestamps in tests). */\n  now?: () => Date\n  /** Render seam (default `ink`'s `render`); tests inject `ink-testing-library`'s `render`. */\n  render?: RenderFn\n  /**\n   * Target stream (default: `process.stdout` behind the scrollback-safe filter).\n   *\n   * The runner injects a stream whose `write` BYPASSES the output interceptor. That is not optional:\n   * the interceptor owns `process.stdout` for the life of the session, so a panel painted through the\n   * raw stream would have its frames filed into a log file instead of drawn \u2014 a blank screen, with no\n   * error and no failing test.\n   */\n  stdout?: NodeJS.WriteStream\n}\n\nexport class PersistentInkDevUi implements DevUi {\n  private readonly renderer: DevRenderer\n  private readonly renderFn: RenderFn\n  private readonly stdout: NodeJS.WriteStream\n  private readonly verbose: boolean\n  private readonly now: () => Date\n  /** Live Ink handle, or `null` when not mounted. */\n  private instance: RenderHandle | null = null\n  /** True once boot is done: never mount the boot region again. */\n  private finalized = false\n  /** True while the persistent panel owns the terminal (after ready). */\n  private persistent = false\n  private phase = ''\n  private narration = ''\n  private headerLines: string[] = []\n  private logLines: string[] = []\n  private footerLines: string[] = []\n\n  constructor(deps: PersistentInkDevUiDeps) {\n    this.verbose = deps.verbose ?? false\n    this.renderFn = deps.render ?? (inkRender as RenderFn)\n    // NOT raw `process.stdout`: Ink writes `ESC[3J` (erase saved lines) whenever a frame overflows the\n    // viewport, which wipes the terminal's SCROLLBACK \u2014 the user's history, and every previous command's\n    // output when `dev` runs as a session-shell child. `createSafeStream` drops that one escape and\n    // forwards everything else live.\n    this.stdout = deps.stdout ?? createSafeStream(process.stdout as NodeJS.WriteStream)\n    this.now =\n      deps.now ??\n      ((): Date => {\n        return new Date()\n      })\n    this.renderer = new DevRenderer({\n      appendLog: deps.appendLog,\n      verbose: this.verbose,\n      isTTY: true,\n      write: (text) => {\n        this.stdout.write(text)\n      },\n      now: this.now,\n    })\n  }\n\n  /** `LogFn`-shaped adapter for the build runner seam. */\n  readonly logFn = (message: string, level: LogLevel = 'info'): void => {\n    this.log(message, level)\n  }\n\n  // ---- boot ---------------------------------------------------------------\n\n  /** Mount the Ink boot region (or rerender it in place) with the current phase + narration. */\n  private renderBoot(readyLines?: string[]): void {\n    const tree = <BootRegion phase={this.phase} narration={this.narration} readyLines={readyLines} />\n\n    if (this.instance) {\n      this.instance.rerender(tree)\n\n      return\n    }\n    this.instance = this.renderFn(tree, { stdout: this.stdout, exitOnCtrlC: false, patchConsole: false })\n  }\n\n  /** Unmount Ink if mounted (idempotent). */\n  private unmount(): void {\n    if (this.instance) {\n      this.instance.unmount()\n      this.instance = null\n    }\n  }\n\n  narrate(message: string): void {\n    this.renderer.teeOnly(message, 'info')\n    if (this.persistent) {\n      // Visible only in verbose (matches the plain renderer); tee already happened above.\n      if (this.verbose) {\n        this.logLines.push(message)\n        this.rerenderPersistent()\n      }\n\n      return\n    }\n    if (this.finalized) {\n      return\n    }\n    this.narration = message\n    if (this.instance) {\n      this.renderBoot()\n    }\n  }\n\n  log(message: string, level: LogLevel = 'info', options: LogOptions = {}): void {\n    const willWrite = level !== 'debug' || this.verbose\n\n    if (this.persistent) {\n      // Never the embedded renderer's direct stdout write here \u2014 append to the live region instead.\n      // `tee: false` means the caller has ALREADY filed this line (see `DevServerRunner.reportFault`);\n      // teeing it again would put a second copy of every fault into `runner.log`.\n      if (options.tee !== false) {\n        this.renderer.teeOnly(message, level)\n      }\n      if (willWrite) {\n        this.logLines.push(message)\n        this.rerenderPersistent()\n      }\n\n      return\n    }\n    if (willWrite) {\n      this.unmount()\n    }\n    this.renderer.log(message, level, options)\n  }\n\n  bootStep(phase: string): void {\n    this.renderer.teeOnly(phase, 'info')\n    if (this.finalized) {\n      return\n    }\n    this.phase = phase\n    this.renderBoot()\n  }\n\n  stopSpinner(): void {\n    if (!this.persistent) {\n      this.unmount()\n    }\n  }\n\n  // ---- the persistent panel ----------------------------------------------\n\n  /** Commit the header, tee it, mount the live panel, and STAY mounted for the rest of the session. */\n  ready(summary: ReadySummary): void {\n    this.headerLines = this.renderer.formatHeaderLines(summary)\n    this.footerLines = this.renderer.formatFooterLines(summary)\n    this.logLines = []\n    for (const line of this.headerLines) {\n      this.renderer.teeOnly(line, 'info')\n    }\n    this.finalized = true\n    this.persistent = true\n    // Re-clamp the panel when the terminal resizes. Guarded: an injected (test/piped) stream may not\n    // be an EventEmitter TTY.\n    if (typeof this.stdout.on === 'function') {\n      this.stdout.on('resize', this.onResize)\n    }\n    this.rerenderPersistent()\n  }\n\n  /**\n   * Cap for the pinned panel: it is a live region and cannot scroll, so it must never exceed the\n   * viewport. Reserve rows for the runner's occasional lines above it; fall back to an 80\u00D724 assumption\n   * when the stream reports no row count (piped / test stdout).\n   */\n  private maxFooterLines(): number {\n    return Math.max(3, (this.stdout.rows ?? 24) - 6)\n  }\n\n  /** Mount or repaint the live region from the current header / logs / panel snapshot. */\n  private rerenderPersistent(): void {\n    const tree = (\n      <LiveRegion\n        headerLines={this.headerLines}\n        logLines={this.logLines}\n        footerLines={this.footerLines}\n        maxFooterLines={this.maxFooterLines()}\n      />\n    )\n\n    if (this.instance) {\n      this.instance.rerender(tree)\n\n      return\n    }\n    this.instance = this.renderFn(tree, { stdout: this.stdout, exitOnCtrlC: false, patchConsole: false })\n  }\n\n  /** Re-clamp + repaint on terminal resize (SIGWINCH), so a shrink never overflows the viewport. */\n  private readonly onResize = (): void => {\n    if (this.persistent) {\n      this.rerenderPersistent()\n    }\n  }\n\n  /**\n   * A tagged, timestamped line. The runner no longer emits any \u2014 framework and request lines go to their\n   * per-service files instead of the terminal \u2014 but the seam stays on the {@link DevUi} contract for the\n   * plain/non-TTY renderer, which still streams.\n   */\n  event(input: { tag: string; text: string }): void {\n    if (this.persistent) {\n      const line = `  ${formatClock(this.now())}  ${input.tag}  ${input.text}`\n\n      this.renderer.teeOnly(`${input.tag} ${input.text}`, 'info')\n      this.logLines.push(line)\n      this.rerenderPersistent()\n\n      return\n    }\n    this.unmount()\n    this.renderer.event(input)\n  }\n\n  /**\n   * Repaint the live status rows in place from a fresh summary (header + runner lines untouched).\n   *\n   * This is the panel's heartbeat. With no log tail on screen, a panel whose numbers never move is\n   * indistinguishable from a hung process \u2014 so this is what proves the session is alive.\n   */\n  refresh(summary: ReadySummary): void {\n    // A session still in boot has no panel to refresh.\n    if (!this.persistent) {\n      return\n    }\n    this.footerLines = this.renderer.formatFooterLines(summary)\n    this.rerenderPersistent()\n  }\n\n  dispose(): void {\n    if (this.persistent) {\n      // Commit the last panel state, then release the terminal.\n      this.rerenderPersistent()\n      if (typeof this.stdout.off === 'function') {\n        this.stdout.off('resize', this.onResize)\n      }\n    }\n    this.finalized = true\n    this.persistent = false\n    this.unmount()\n  }\n}\n", "import { Box, Static, Text } from 'ink'\nimport { useEffect, useState } from 'react'\n\n/**\n * The Ink boot region for `infra-kit dev`: an animated spinner + phase line while the server boots,\n * then the ready header committed to scrollback via `<Static>`.\n *\n * HARD INVARIANT \u2014 this component (and every boot component under `src/tui/dev-ui/`) is OUTPUT-ONLY.\n * It MUST NEVER call `useInput`. `useInput` arms Ink's raw mode + Ctrl-C interception, which would\n * steal SIGINT from the process signal handler that owns dev-server shutdown. The spinner animates via\n * a self-contained interval only; there is no keyboard input during boot. Do not add `useInput` here.\n */\n\nexport interface BootRegionProps {\n  /** Current boot phase, shown beside the spinner. */\n  phase: string\n  /** Latest narration detail (dim subtitle under the spinner); empty hides the line. */\n  narration: string\n  /**\n   * When set, boot is done: the pre-formatted ready-header lines are committed to scrollback via\n   * `<Static>` and the transient spinner region is gone. The renderer unmounts right after.\n   */\n  readyLines?: string[]\n}\n\n/** Animated boot spinner + phase/narration, or the committed ready header once `readyLines` is set. */\nexport const BootRegion = (props: BootRegionProps) => {\n  const { phase, narration, readyLines } = props\n\n  const [frame, setFrame] = useState(0)\n\n  useEffect(() => {\n    // No spinner once the ready header is committed.\n    if (readyLines) {\n      return\n    }\n\n    const timer = setInterval(() => {\n      setFrame((f) => {\n        return f + 1\n      })\n    }, SPINNER_INTERVAL_MS)\n\n    return () => {\n      clearInterval(timer)\n    }\n  }, [readyLines])\n\n  if (readyLines) {\n    // `<Static>` writes each line once, above the (now empty) live region, so the header persists in\n    // scrollback after unmount. Lines are pre-formatted by DevRenderer.formatReadyLines.\n    return (\n      <Static items={readyLines}>\n        {(line, index) => {\n          return <Text key={index}>{line}</Text>\n        }}\n      </Static>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box>\n        <Text color=\"cyan\">{SPINNER_FRAMES[frame % SPINNER_FRAMES.length]}</Text>\n        <Text dimColor>{` ${phase}`}</Text>\n      </Box>\n      {narration ? <Text dimColor>{narration}</Text> : null}\n    </Box>\n  )\n}\n\nconst SPINNER_FRAMES = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F']\nconst SPINNER_INTERVAL_MS = 80\n", "import { Box, Static, Text } from 'ink'\n\n/**\n * The persistent Ink live region for `infra-kit dev` (backend-only sessions): the committed header +\n * growing log scrollback above, and a live health footer re-rendered in place below.\n *\n * HARD INVARIANT \u2014 this component (and every component under `src/tui/dev-ui/`) is OUTPUT-ONLY. It\n * MUST NEVER call `useInput`. `useInput` arms Ink's raw mode + Ctrl-C interception, which would steal\n * SIGINT from the process signal handler that owns dev-server shutdown. There is no keyboard input in\n * the live region \u2014 it is props only, with no state, no effects, no input. Do not add `useInput` here.\n */\n\nexport interface LiveRegionProps {\n  /** Reference header, committed once to scrollback via `<Static>` (from `formatHeaderLines`). */\n  headerLines: string[]\n  /** Log lines committed above the footer as they arrive (also via the SAME `<Static>`). */\n  logLines: string[]\n  /** Live footer, re-rendered in place on every health change (from `formatFooterLines`). */\n  footerLines: string[]\n  /**\n   * Cap on rendered footer rows so a many-backend session never eats a short viewport (the footer is a\n   * live region \u2014 it cannot scroll). Overflow collapses into a trailing dim `\u2026 +N more` line. Omit for\n   * no cap. The pinned footer must stay short; the full health picture is always in the log file.\n   */\n  maxFooterLines?: number\n}\n\n/**\n * A SINGLE `<Static>` streams the header then the growing logs (Ink writes only newly-appended items\n * each commit, so the header lands first and logs accrete beneath it \u2014 one block, never two). The\n * footer is an ordinary `<Box>`, so it repaints in place on each rerender without touching scrollback.\n */\nexport const LiveRegion = (props: LiveRegionProps) => {\n  const { headerLines, logLines, footerLines } = props\n\n  const staticItems = [...headerLines, ...logLines]\n  const footer = clampFooter(footerLines, props.maxFooterLines)\n\n  return (\n    <>\n      <Static items={staticItems}>\n        {(line, index) => {\n          return <Text key={index}>{line}</Text>\n        }}\n      </Static>\n      <Box flexDirection=\"column\">\n        {footer.map((line, index) => {\n          return <Text key={index}>{line}</Text>\n        })}\n      </Box>\n    </>\n  )\n}\n\n/** Cap the footer to `max` rows, collapsing the overflow into one trailing `  \u2026 +N more` line. */\nexport const clampFooter = (lines: string[], max?: number): string[] => {\n  if (max == null || max < 1 || lines.length <= max) {\n    return lines\n  }\n\n  const shown = lines.slice(0, max - 1)\n\n  return [...shown, `  \u2026 +${lines.length - shown.length} more`]\n}\n"],
-  "mappings": "uFAAA,OAAS,UAAUA,MAAiB,MACpC,OAAOC,MAAa,eCDpB,OAAS,OAAAC,EAAK,UAAAC,EAAQ,QAAAC,MAAY,MAClC,OAAS,aAAAC,EAAW,YAAAC,MAAgB,QAqDnB,cAAAC,EAQX,QAAAC,MARW,oBA5BV,IAAMC,EAAcC,GAA2B,CACpD,GAAM,CAAE,MAAAC,EAAO,UAAAC,EAAW,WAAAC,CAAW,EAAIH,EAEnC,CAACI,EAAOC,CAAQ,EAAIT,EAAS,CAAC,EAmBpC,OAjBAD,EAAU,IAAM,CAEd,GAAIQ,EACF,OAGF,IAAMG,EAAQ,YAAY,IAAM,CAC9BD,EAAUE,GACDA,EAAI,CACZ,CACH,EAAGC,CAAmB,EAEtB,MAAO,IAAM,CACX,cAAcF,CAAK,CACrB,CACF,EAAG,CAACH,CAAU,CAAC,EAEXA,EAIAN,EAACJ,EAAA,CAAO,MAAOU,EACZ,UAACM,EAAMC,IACCb,EAACH,EAAA,CAAkB,SAAAe,GAARC,CAAa,EAEnC,EAKFZ,EAACN,EAAA,CAAI,cAAc,SACjB,UAAAM,EAACN,EAAA,CACC,UAAAK,EAACH,EAAA,CAAK,MAAM,OAAQ,SAAAiB,EAAeP,EAAQO,EAAe,MAAM,EAAE,EAClEd,EAACH,EAAA,CAAK,SAAQ,GAAE,aAAIO,CAAK,GAAG,GAC9B,EACCC,EAAYL,EAACH,EAAA,CAAK,SAAQ,GAAE,SAAAQ,EAAU,EAAU,MACnD,CAEJ,EAEMS,EAAiB,CAAC,SAAK,SAAK,SAAK,SAAK,SAAK,SAAK,SAAK,SAAK,SAAK,QAAG,EAClEH,EAAsB,GCxE5B,OAAS,OAAAI,EAAK,UAAAC,EAAQ,QAAAC,MAAY,MAuC9B,mBAAAC,EAGa,OAAAC,EAHb,QAAAC,MAAA,oBAPG,IAAMC,EAAcC,GAA2B,CACpD,GAAM,CAAE,YAAAC,EAAa,SAAAC,EAAU,YAAAC,CAAY,EAAIH,EAEzCI,EAAc,CAAC,GAAGH,EAAa,GAAGC,CAAQ,EAC1CG,EAASC,EAAYH,EAAaH,EAAM,cAAc,EAE5D,OACEF,EAAAF,EAAA,CACE,UAAAC,EAACH,EAAA,CAAO,MAAOU,EACZ,UAACG,EAAMC,IACCX,EAACF,EAAA,CAAkB,SAAAY,GAARC,CAAa,EAEnC,EACAX,EAACJ,EAAA,CAAI,cAAc,SAChB,SAAAY,EAAO,IAAI,CAACE,EAAMC,IACVX,EAACF,EAAA,CAAkB,SAAAY,GAARC,CAAa,CAChC,EACH,GACF,CAEJ,EAGaF,EAAc,CAACG,EAAiBC,IAA2B,CACtE,GAAIA,GAAO,MAAQA,EAAM,GAAKD,EAAM,QAAUC,EAC5C,OAAOD,EAGT,IAAME,EAAQF,EAAM,MAAM,EAAGC,EAAM,CAAC,EAEpC,MAAO,CAAC,GAAGC,EAAO,aAAQF,EAAM,OAASE,EAAM,MAAM,OAAO,CAC9D,EFmDiB,cAAAC,MAAA,oBAnDV,IAAMC,EAAN,KAA0C,CAC9B,SACA,SACA,OACA,QACA,IAET,SAAgC,KAEhC,UAAY,GAEZ,WAAa,GACb,MAAQ,GACR,UAAY,GACZ,YAAwB,CAAC,EACzB,SAAqB,CAAC,EACtB,YAAwB,CAAC,EAEjC,YAAYC,EAA8B,CACxC,KAAK,QAAUA,EAAK,SAAW,GAC/B,KAAK,SAAWA,EAAK,QAAWC,EAKhC,KAAK,OAASD,EAAK,QAAUE,EAAiBC,EAAQ,MAA4B,EAClF,KAAK,IACHH,EAAK,MACJ,IACQ,IAAI,MAEf,KAAK,SAAW,IAAII,EAAY,CAC9B,UAAWJ,EAAK,UAChB,QAAS,KAAK,QACd,MAAO,GACP,MAAQK,GAAS,CACf,KAAK,OAAO,MAAMA,CAAI,CACxB,EACA,IAAK,KAAK,GACZ,CAAC,CACH,CAGS,MAAQ,CAACC,EAAiBC,EAAkB,SAAiB,CACpE,KAAK,IAAID,EAASC,CAAK,CACzB,EAKQ,WAAWC,EAA6B,CAC9C,IAAMC,EAAOX,EAACY,EAAA,CAAW,MAAO,KAAK,MAAO,UAAW,KAAK,UAAW,WAAYF,EAAY,EAE/F,GAAI,KAAK,SAAU,CACjB,KAAK,SAAS,SAASC,CAAI,EAE3B,MACF,CACA,KAAK,SAAW,KAAK,SAASA,EAAM,CAAE,OAAQ,KAAK,OAAQ,YAAa,GAAO,aAAc,EAAM,CAAC,CACtG,CAGQ,SAAgB,CAClB,KAAK,WACP,KAAK,SAAS,QAAQ,EACtB,KAAK,SAAW,KAEpB,CAEA,QAAQH,EAAuB,CAE7B,GADA,KAAK,SAAS,QAAQA,EAAS,MAAM,EACjC,KAAK,WAAY,CAEf,KAAK,UACP,KAAK,SAAS,KAAKA,CAAO,EAC1B,KAAK,mBAAmB,GAG1B,MACF,CACI,KAAK,YAGT,KAAK,UAAYA,EACb,KAAK,UACP,KAAK,WAAW,EAEpB,CAEA,IAAIA,EAAiBC,EAAkB,OAAQI,EAAsB,CAAC,EAAS,CAC7E,IAAMC,EAAYL,IAAU,SAAW,KAAK,QAE5C,GAAI,KAAK,WAAY,CAIfI,EAAQ,MAAQ,IAClB,KAAK,SAAS,QAAQL,EAASC,CAAK,EAElCK,IACF,KAAK,SAAS,KAAKN,CAAO,EAC1B,KAAK,mBAAmB,GAG1B,MACF,CACIM,GACF,KAAK,QAAQ,EAEf,KAAK,SAAS,IAAIN,EAASC,EAAOI,CAAO,CAC3C,CAEA,SAASE,EAAqB,CAC5B,KAAK,SAAS,QAAQA,EAAO,MAAM,EAC/B,MAAK,YAGT,KAAK,MAAQA,EACb,KAAK,WAAW,EAClB,CAEA,aAAoB,CACb,KAAK,YACR,KAAK,QAAQ,CAEjB,CAKA,MAAMC,EAA6B,CACjC,KAAK,YAAc,KAAK,SAAS,kBAAkBA,CAAO,EAC1D,KAAK,YAAc,KAAK,SAAS,kBAAkBA,CAAO,EAC1D,KAAK,SAAW,CAAC,EACjB,QAAWC,KAAQ,KAAK,YACtB,KAAK,SAAS,QAAQA,EAAM,MAAM,EAEpC,KAAK,UAAY,GACjB,KAAK,WAAa,GAGd,OAAO,KAAK,OAAO,IAAO,YAC5B,KAAK,OAAO,GAAG,SAAU,KAAK,QAAQ,EAExC,KAAK,mBAAmB,CAC1B,CAOQ,gBAAyB,CAC/B,OAAO,KAAK,IAAI,GAAI,KAAK,OAAO,MAAQ,IAAM,CAAC,CACjD,CAGQ,oBAA2B,CACjC,IAAMN,EACJX,EAACkB,EAAA,CACC,YAAa,KAAK,YAClB,SAAU,KAAK,SACf,YAAa,KAAK,YAClB,eAAgB,KAAK,eAAe,EACtC,EAGF,GAAI,KAAK,SAAU,CACjB,KAAK,SAAS,SAASP,CAAI,EAE3B,MACF,CACA,KAAK,SAAW,KAAK,SAASA,EAAM,CAAE,OAAQ,KAAK,OAAQ,YAAa,GAAO,aAAc,EAAM,CAAC,CACtG,CAGiB,SAAW,IAAY,CAClC,KAAK,YACP,KAAK,mBAAmB,CAE5B,EAOA,MAAMQ,EAA4C,CAChD,GAAI,KAAK,WAAY,CACnB,IAAMF,EAAO,KAAKG,EAAY,KAAK,IAAI,CAAC,CAAC,KAAKD,EAAM,GAAG,KAAKA,EAAM,IAAI,GAEtE,KAAK,SAAS,QAAQ,GAAGA,EAAM,GAAG,IAAIA,EAAM,IAAI,GAAI,MAAM,EAC1D,KAAK,SAAS,KAAKF,CAAI,EACvB,KAAK,mBAAmB,EAExB,MACF,CACA,KAAK,QAAQ,EACb,KAAK,SAAS,MAAME,CAAK,CAC3B,CAQA,QAAQH,EAA6B,CAE9B,KAAK,aAGV,KAAK,YAAc,KAAK,SAAS,kBAAkBA,CAAO,EAC1D,KAAK,mBAAmB,EAC1B,CAEA,SAAgB,CACV,KAAK,aAEP,KAAK,mBAAmB,EACpB,OAAO,KAAK,OAAO,KAAQ,YAC7B,KAAK,OAAO,IAAI,SAAU,KAAK,QAAQ,GAG3C,KAAK,UAAY,GACjB,KAAK,WAAa,GAClB,KAAK,QAAQ,CACf,CACF",
-  "names": ["inkRender", "process", "Box", "Static", "Text", "useEffect", "useState", "jsx", "jsxs", "BootRegion", "props", "phase", "narration", "readyLines", "frame", "setFrame", "timer", "f", "SPINNER_INTERVAL_MS", "line", "index", "SPINNER_FRAMES", "Box", "Static", "Text", "Fragment", "jsx", "jsxs", "LiveRegion", "props", "headerLines", "logLines", "footerLines", "staticItems", "footer", "clampFooter", "line", "index", "lines", "max", "shown", "jsx", "PersistentInkDevUi", "deps", "inkRender", "createSafeStream", "process", "DevRenderer", "text", "message", "level", "readyLines", "tree", "BootRegion", "options", "willWrite", "phase", "summary", "line", "LiveRegion", "input", "formatClock"]
-}