cdk-local 0.78.1 → 0.79.0

package/dist/local-studio-CSW1raG0.js

@@ -0,0 +1,1004 @@
+import { c as getEmbedConfig, s as getLogger, u as setEmbedConfig } from "./docker-cmd-Dqx2YENO.js";
+import { Hn as listTargets, Ln as resolveApp, cr as withErrorHandling, fr as appOptions, gr as regionOption, hr as parseContextOptions, lr as applyRoleArnIfSet, mr as contextOptions, pr as commonOptions, zn as Synthesizer } from "./local-list-DBlBRfA-.js";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Command, Option } from "commander";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { EventEmitter } from "node:events";
+
+//#region src/local/studio-events.ts
+/**
+* In-process event bus that every studio observation flows through. The
+* studio HTTP server subscribes and forwards events to the browser over
+* SSE; the dispatch / log-streaming layers emit onto it.
+*
+* A thin typed wrapper over {@link EventEmitter} so producers and the
+* server agree on the event shapes without `any`. Re-exported from
+* `cdk-local/internal` so a host CLI embedding studio can subscribe.
+*/
+var StudioEventBus = class {
+	emitter = new EventEmitter();
+	constructor() {
+		this.emitter.setMaxListeners(0);
+	}
+	emit(event, ...args) {
+		this.emitter.emit(event, ...args);
+	}
+	on(event, listener) {
+		this.emitter.on(event, listener);
+		return this;
+	}
+	off(event, listener) {
+		this.emitter.off(event, listener);
+		return this;
+	}
+	/**
+	* Number of listeners currently subscribed to `event`. Exposed so the
+	* SSE server's subscribe / unsubscribe symmetry can be asserted (a
+	* dropped client must not leak a listener).
+	*/
+	listenerCount(event) {
+		return this.emitter.listenerCount(event);
+	}
+};
+
+//#endregion
+//#region src/local/studio-ui.ts
+/**
+* The studio web UI, embedded as a string so it ships inside the
+* `cdk-local` npm package (decision D9) with no asset-copy build step —
+* `tsdown` bundles this module like any other source file. Served by
+* the studio HTTP server (`startStudioServer`) at `GET /`.
+*
+* 3-pane shell (decision D6), framework-free vanilla JS (decision D7):
+*   - left   = target list (from `GET /api/targets`); each runnable
+*     Lambda has an [Invoke] button and a selected-highlight.
+*   - center = the WORKSPACE for the selected target: an event composer
+*     (textarea + Invoke button) with the latest run's Request /
+*     Response / Logs shown BELOW it, so you can edit and re-invoke
+*     repeatedly without losing the composer.
+*   - right  = the timeline (history) of every invocation; clicking a
+*     row loads it back into the workspace.
+*
+* The center workspace is deliberately adjacent to the left target list
+* (short eye-travel: pick a target -> compose right next to it), and is
+* the primary surface — the timeline is secondary history.
+*/
+const STUDIO_CSS = `
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; font: 13px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace;
+    color: #e6e6e6; background: #1a1a1a; height: 100vh; overflow: hidden;
+  }
+  header {
+    padding: 8px 14px; background: #111; border-bottom: 1px solid #333;
+    display: flex; align-items: center; gap: 10px;
+  }
+  header .brand { font-weight: 700; color: #fff; }
+  header .meta { color: #888; font-size: 12px; }
+  main {
+    display: grid; grid-template-columns: 280px 5px 1fr 5px 320px;
+    height: calc(100vh - 38px);
+  }
+  .pane { overflow: auto; }
+  .splitter { background: #2a2a2a; cursor: col-resize; }
+  .splitter:hover, .splitter.dragging { background: #4ec97a; }
+  .pane h2 {
+    margin: 0; padding: 8px 12px; font-size: 11px; text-transform: uppercase;
+    letter-spacing: 0.5px; color: #888; background: #151515;
+    position: sticky; top: 0; border-bottom: 1px solid #2a2a2a; z-index: 1;
+  }
+  .group-title { padding: 8px 12px 2px; color: #6aa9ff; font-size: 11px; }
+  .target {
+    padding: 6px 12px; border-bottom: 1px solid #222; display: flex;
+    align-items: center; gap: 8px;
+  }
+  .target.runnable { cursor: pointer; }
+  .target.runnable:hover { background: #202020; }
+  .target.sel { background: #2a3550; }
+  .target .name { color: #ddd; flex: 1; overflow: hidden; text-overflow: ellipsis; }
+  .target .kind { color: #777; font-size: 11px; }
+  .target .invoke-btn {
+    padding: 2px 10px; font: 11px ui-monospace, Menlo, monospace; font-weight: 700;
+    color: #0d1f12; background: #4ec97a; border: 0; border-radius: 3px; cursor: pointer;
+  }
+  .target .invoke-btn:hover { background: #6fe097; }
+  .target.sel .invoke-btn { background: #6fe097; }
+  .empty { padding: 16px 12px; color: #666; }
+  .row {
+    padding: 5px 12px; border-bottom: 1px solid #222; cursor: pointer;
+    display: flex; gap: 8px; white-space: nowrap;
+  }
+  .row:hover { background: #222; }
+  .row.sel { background: #2a3550; }
+  .row .ts { color: #777; }
+  .row .label { color: #ddd; flex: 1; overflow: hidden; text-overflow: ellipsis; }
+  .row .status { color: #7bd88f; }
+  .row .status.err { color: #e0707a; }
+  #workspace { padding: 0 0 24px; }
+  .composer { padding: 10px 12px; border-bottom: 1px solid #2a2a2a; }
+  .composer .target-name { color: #fff; font-weight: 700; margin-bottom: 6px; }
+  .composer textarea {
+    width: 100%; min-height: 130px; resize: vertical; background: #111; color: #ddd;
+    border: 1px solid #333; border-radius: 3px; padding: 6px;
+    font: 12px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace;
+  }
+  .composer button {
+    margin-top: 8px; padding: 6px 18px; background: #2a7d46; color: #fff;
+    border: 0; border-radius: 3px; cursor: pointer; font: inherit; font-weight: 700;
+  }
+  .composer button:hover { background: #339152; }
+  .composer button:disabled { background: #333; color: #888; cursor: default; }
+  .composer .err { color: #e0707a; margin-top: 6px; min-height: 18px; }
+  .section { padding: 8px 12px; border-bottom: 1px solid #222; }
+  .section h3 { margin: 0 0 6px; font-size: 11px; color: #888; text-transform: uppercase; }
+  .section h3 .ok { color: #7bd88f; }
+  .section h3 .bad { color: #e0707a; }
+  .section pre { margin: 0; white-space: pre-wrap; word-break: break-word; color: #cfcfcf; }
+  #conn { font-size: 11px; }
+  #conn.up { color: #7bd88f; }
+  #conn.down { color: #e0707a; }
+`;
+const STUDIO_SCRIPT = `
+  const KIND_LABEL = { lambda: 'Lambda', api: 'API', alb: 'ALB', ecs: 'ECS', agentcore: 'AgentCore' };
+  const rowsById = new Map();      // invocationId -> timeline row element
+  const invById = new Map();       // invocationId -> latest invocation event
+  const logsById = new Map();      // invocationId -> [log lines]
+  const targetEls = new Map();     // targetId -> left-pane element
+  let active = null;               // { id, kind, ta, btn, msg, result }
+  let shownInvId = null;           // invocation whose result is in the workspace
+
+  function el(tag, cls, text) {
+    const e = document.createElement(tag);
+    if (cls) e.className = cls;
+    if (text != null) e.textContent = text;
+    return e;
+  }
+
+  async function loadTargets() {
+    const pane = document.getElementById('targets');
+    try {
+      const res = await fetch('/api/targets');
+      const data = await res.json();
+      pane.querySelectorAll('.group-title,.target,.empty').forEach((n) => n.remove());
+      let total = 0;
+      for (const group of data.groups) {
+        if (!group.entries.length) continue;
+        pane.appendChild(el('div', 'group-title', group.title));
+        for (const entry of group.entries) {
+          total += 1;
+          // Slice B: only Lambda targets are runnable from the UI (single-shot
+          // invoke). Other kinds list but are not yet selectable.
+          const runnable = group.kind === 'lambda';
+          const t = el('div', runnable ? 'target runnable' : 'target');
+          const name = el('span', 'name', entry.id);
+          name.title = entry.id; // full path on hover even when truncated
+          t.appendChild(name);
+          t.appendChild(el('span', 'kind', '(' + (KIND_LABEL[group.kind] || group.kind) + ')'));
+          if (runnable) {
+            const btn = el('button', 'invoke-btn', 'Invoke');
+            btn.onclick = (e) => { e.stopPropagation(); selectTarget(entry.id, group.kind); };
+            t.appendChild(btn);
+            t.onclick = () => selectTarget(entry.id, group.kind);
+            targetEls.set(entry.id, t);
+          }
+          pane.appendChild(t);
+        }
+      }
+      if (!total) pane.appendChild(el('div', 'empty', 'No runnable targets found.'));
+    } catch (err) {
+      pane.appendChild(el('div', 'empty', 'Failed to load targets: ' + err));
+    }
+  }
+
+  function highlightTarget(id) {
+    document.querySelectorAll('.target.sel').forEach((n) => n.classList.remove('sel'));
+    const t = targetEls.get(id);
+    if (t) t.classList.add('sel');
+  }
+
+  function selectTarget(id, kind) {
+    highlightTarget(id);
+    renderComposer(id, kind, '{}');
+  }
+
+  function renderComposer(id, kind, eventText) {
+    const ws = document.getElementById('workspace');
+    ws.innerHTML = '';
+
+    const composer = el('div', 'composer');
+    composer.appendChild(el('div', 'target-name', 'Invoke ' + id));
+    const ta = el('textarea');
+    ta.value = eventText;
+    ta.spellcheck = false;
+    composer.appendChild(ta);
+    composer.appendChild(document.createElement('br'));
+    const btn = el('button', null, 'Invoke');
+    const msg = el('div', 'err');
+    composer.appendChild(btn);
+    composer.appendChild(msg);
+
+    const result = el('div', 'result');
+
+    ws.appendChild(composer);
+    ws.appendChild(result);
+
+    active = { id, kind, ta, btn, msg, result };
+    btn.onclick = () => runInvoke();
+    shownInvId = null;
+    ta.focus();
+  }
+
+  async function runInvoke() {
+    if (!active) return;
+    const { id, kind, ta, btn, msg, result } = active;
+    let event;
+    try {
+      event = ta.value.trim() === '' ? {} : JSON.parse(ta.value);
+    } catch (err) {
+      msg.textContent = 'Invalid JSON: ' + err.message;
+      return;
+    }
+    msg.textContent = '';
+    btn.disabled = true;
+    btn.textContent = 'Invoking...';
+    result.innerHTML = '';
+    try {
+      const res = await fetch('/api/run', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ targetId: id, kind, event }),
+      });
+      const data = await res.json();
+      if (data.invocationId) {
+        shownInvId = data.invocationId;
+        renderResult(shownInvId);
+      }
+      if (!res.ok || data.ok === false) {
+        msg.textContent = 'Invoke failed: ' + (data.error || ('HTTP ' + res.status));
+      }
+    } catch (err) {
+      msg.textContent = 'Request failed: ' + err;
+    } finally {
+      btn.disabled = false;
+      btn.textContent = 'Invoke';
+    }
+  }
+
+  function fmt(body) {
+    return typeof body === 'string' ? body : JSON.stringify(body, null, 2);
+  }
+
+  function renderResult(invId) {
+    if (!active) return;
+    const result = active.result;
+    result.innerHTML = '';
+    const ev = invById.get(invId);
+    if (!ev) return;
+
+    const reqSec = el('div', 'section');
+    reqSec.appendChild(el('h3', null, 'Request'));
+    reqSec.appendChild(el('pre', null, ev.request != null ? fmt(ev.request) : '(none)'));
+    result.appendChild(reqSec);
+
+    const respSec = el('div', 'section');
+    const h = el('h3', null, 'Response');
+    if (ev.status != null) {
+      const cls = ev.status >= 200 && ev.status < 300 ? 'ok' : 'bad';
+      const meta = el('span', cls, '  ' + ev.status + (ev.durationMs != null ? ' · ' + ev.durationMs + 'ms' : ''));
+      h.appendChild(meta);
+    }
+    respSec.appendChild(h);
+    respSec.appendChild(el('pre', null, ev.response != null ? fmt(ev.response) : '(pending…)'));
+    result.appendChild(respSec);
+
+    const logs = logsById.get(invId) || [];
+    const logSec = el('div', 'section');
+    logSec.appendChild(el('h3', null, 'Logs'));
+    logSec.appendChild(el('pre', null, logs.length ? logs.join('\\n') : '(none)'));
+    result.appendChild(logSec);
+  }
+
+  function addInvocation(ev) {
+    invById.set(ev.id, Object.assign(invById.get(ev.id) || {}, ev));
+    const timeline = document.getElementById('timeline');
+    const placeholder = timeline.querySelector('.empty');
+    if (placeholder) placeholder.remove();
+
+    let row = rowsById.get(ev.id);
+    if (!row) {
+      row = el('div', 'row');
+      row.appendChild(el('span', 'ts'));
+      row.appendChild(el('span', 'label'));
+      row.appendChild(el('span', 'status'));
+      row.onclick = () => loadInvocation(ev.id);
+      rowsById.set(ev.id, row);
+      timeline.insertBefore(row, timeline.querySelector('.row')); // newest on top
+    }
+    const merged = invById.get(ev.id);
+    const d = new Date(merged.ts);
+    row.querySelector('.ts').textContent = d.toLocaleTimeString();
+    row.querySelector('.label').textContent = (merged.target || '') + '  ' + (merged.label || '');
+    const statusEl = row.querySelector('.status');
+    statusEl.textContent =
+      merged.status != null
+        ? merged.status + (merged.durationMs != null ? '  ' + merged.durationMs + 'ms' : '')
+        : '…';
+    statusEl.className = 'status' + (merged.status != null && (merged.status < 200 || merged.status >= 300) ? ' err' : '');
+
+    // Live-refresh the workspace result if it is showing this invocation.
+    if (shownInvId === ev.id) renderResult(ev.id);
+  }
+
+  function loadInvocation(id) {
+    const ev = invById.get(id);
+    if (!ev) return;
+    document.querySelectorAll('.row.sel').forEach((n) => n.classList.remove('sel'));
+    const row = rowsById.get(id);
+    if (row) row.classList.add('sel');
+    highlightTarget(ev.target);
+    renderComposer(ev.target, ev.kind, ev.request != null ? fmt(ev.request) : '{}');
+    shownInvId = id;
+    renderResult(id);
+  }
+
+  function connect() {
+    const conn = document.getElementById('conn');
+    const es = new EventSource('/api/events');
+    es.addEventListener('open', () => { conn.textContent = '● live'; conn.className = 'up'; });
+    es.addEventListener('error', () => { conn.textContent = '● disconnected'; conn.className = 'down'; });
+    es.addEventListener('invocation', (e) => addInvocation(JSON.parse(e.data)));
+    es.addEventListener('log', (e) => {
+      const ev = JSON.parse(e.data);
+      const arr = logsById.get(ev.containerId) || [];
+      arr.push(ev.line);
+      logsById.set(ev.containerId, arr);
+      if (shownInvId === ev.containerId) renderResult(ev.containerId);
+    });
+  }
+
+  function initSplitters() {
+    const main = document.querySelector('main');
+    let left = 280, right = 320;
+    const apply = () => {
+      main.style.gridTemplateColumns = left + 'px 5px 1fr 5px ' + right + 'px';
+    };
+    const wire = (splitterId, onMove) => {
+      const s = document.getElementById(splitterId);
+      s.addEventListener('mousedown', (e) => {
+        e.preventDefault();
+        const startX = e.clientX;
+        const l0 = left, r0 = right;
+        s.classList.add('dragging');
+        document.body.style.userSelect = 'none';
+        const move = (ev) => { onMove(ev.clientX - startX, l0, r0); apply(); };
+        const up = () => {
+          s.classList.remove('dragging');
+          document.body.style.userSelect = '';
+          document.removeEventListener('mousemove', move);
+          document.removeEventListener('mouseup', up);
+        };
+        document.addEventListener('mousemove', move);
+        document.addEventListener('mouseup', up);
+      });
+    };
+    const clamp = (v) => Math.max(160, Math.min(760, v));
+    wire('split-left', (dx, l0) => { left = clamp(l0 + dx); });
+    wire('split-right', (dx, l0, r0) => { right = clamp(r0 - dx); });
+  }
+
+  loadTargets();
+  connect();
+  initSplitters();
+`;
+/**
+* Render the full studio HTML document. `appLabel` is shown in the
+* header (the CDK app / stack context); `cliName` brands the title for
+* host CLIs that rebrand `cdkl`.
+*/
+function renderStudioHtml(appLabel, cliName) {
+	const safeApp = escapeHtml(appLabel);
+	const safeCli = escapeHtml(cliName);
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${safeCli} studio</title>
+<style>${STUDIO_CSS}</style>
+</head>
+<body>
+<header>
+  <span class="brand">${safeCli} studio</span>
+  <span class="meta">${safeApp}</span>
+  <span id="conn" class="down">● connecting</span>
+</header>
+<main>
+  <section class="pane" id="targets"><h2>Targets</h2></section>
+  <div class="splitter" id="split-left"></div>
+  <section class="pane" id="workspace"><div class="empty">Pick a Lambda on the left to invoke it.</div></section>
+  <div class="splitter" id="split-right"></div>
+  <section class="pane" id="timeline"><h2>Timeline</h2><div class="empty">No requests yet.</div></section>
+</main>
+<script>${STUDIO_SCRIPT}<\/script>
+</body>
+</html>`;
+}
+/** Minimal HTML-escape for the few interpolated text values. */
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+//#endregion
+//#region src/local/studio-server.ts
+/**
+* Project a {@link TargetListing} (the same enumeration `cdkl list`
+* prints) into the grouped shape the studio UI renders. ECS services and
+* task definitions are folded into one `ecs` group; everything else maps
+* one category to one group. Exported so a unit test can assert the
+* projection without booting the server.
+*/
+function toStudioTargetGroups(listing) {
+	const map = (entries) => entries.map((e) => {
+		const t = {
+			id: e.displayPath ?? e.qualifiedId,
+			qualifiedId: e.qualifiedId
+		};
+		if (e.kind) t.surface = e.kind;
+		return t;
+	});
+	return [
+		{
+			kind: "lambda",
+			title: "Lambda Functions",
+			entries: map(listing.lambdas)
+		},
+		{
+			kind: "api",
+			title: "APIs",
+			entries: map(listing.apis)
+		},
+		{
+			kind: "ecs",
+			title: "ECS Services / Tasks",
+			entries: [...map(listing.ecsServices), ...map(listing.ecsTaskDefinitions)]
+		},
+		{
+			kind: "agentcore",
+			title: "AgentCore Runtimes",
+			entries: map(listing.agentCoreRuntimes)
+		},
+		{
+			kind: "alb",
+			title: "Load Balancers",
+			entries: map(listing.loadBalancers)
+		}
+	];
+}
+const SSE_HEARTBEAT_MS = 15e3;
+/**
+* Boot the studio HTTP server: serves the embedded UI at `/`, the target
+* list at `/api/targets`, and a Server-Sent-Events stream of the bus's
+* `invocation` / `log` events at `/api/events`. Localhost-only by
+* default. Resolves once the socket is listening.
+*/
+async function startStudioServer(options) {
+	const host = options.host ?? "127.0.0.1";
+	const maxBump = options.maxPortBump ?? 20;
+	const html = renderStudioHtml(options.appLabel, options.cliName);
+	const targetsJson = JSON.stringify({ groups: options.targetGroups });
+	const server = createServer((req, res) => handleRequest(req, res, options.bus, html, targetsJson, options.onRun));
+	const boundPort = await listenWithBump(server, host, options.port, maxBump);
+	return {
+		url: `http://${host}:${boundPort}`,
+		port: boundPort,
+		close: () => new Promise((resolveClose, reject) => {
+			server.close((err) => err ? reject(err) : resolveClose());
+			server.closeAllConnections?.();
+		})
+	};
+}
+function handleRequest(req, res, bus, html, targetsJson, onRun) {
+	const path = (req.url ?? "/").split("?")[0];
+	if (req.method === "GET" && (path === "/" || path === "/index.html")) {
+		res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+		res.end(html);
+		return;
+	}
+	if (req.method === "GET" && path === "/api/targets") {
+		res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+		res.end(targetsJson);
+		return;
+	}
+	if (req.method === "GET" && path === "/api/events") {
+		serveSse(req, res, bus);
+		return;
+	}
+	if (req.method === "POST" && path === "/api/run") {
+		handleRun(req, res, onRun);
+		return;
+	}
+	res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+	res.end("Not found");
+}
+const MAX_RUN_BODY_BYTES = 5 * 1024 * 1024;
+/** Reply to `POST /api/run`: parse the JSON body, dispatch via `onRun`. */
+async function handleRun(req, res, onRun) {
+	const sendJson = (statusCode, payload) => {
+		res.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+		res.end(JSON.stringify(payload));
+	};
+	if (!onRun) {
+		sendJson(501, { error: "Running targets is not supported by this studio server." });
+		return;
+	}
+	let body;
+	try {
+		body = await readJsonBody(req);
+	} catch (err) {
+		sendJson(400, { error: err instanceof Error ? err.message : String(err) });
+		return;
+	}
+	try {
+		sendJson(200, await onRun(body));
+	} catch (err) {
+		sendJson(500, { error: err instanceof Error ? err.message : String(err) });
+	}
+}
+/** Read + JSON-parse a request body, bounded to {@link MAX_RUN_BODY_BYTES}. */
+function readJsonBody(req) {
+	return new Promise((resolveBody, reject) => {
+		let raw = "";
+		let bytes = 0;
+		let done = false;
+		const settle = (fn) => {
+			if (done) return;
+			done = true;
+			fn();
+		};
+		req.setEncoding("utf8");
+		req.on("data", (chunk) => {
+			if (done) return;
+			bytes += Buffer.byteLength(chunk);
+			if (bytes > MAX_RUN_BODY_BYTES) {
+				settle(() => reject(/* @__PURE__ */ new Error("Request body too large.")));
+				req.destroy();
+				return;
+			}
+			raw += chunk;
+		});
+		req.on("end", () => {
+			settle(() => {
+				if (raw.trim() === "") {
+					resolveBody(void 0);
+					return;
+				}
+				try {
+					resolveBody(JSON.parse(raw));
+				} catch {
+					reject(/* @__PURE__ */ new Error("Invalid JSON body."));
+				}
+			});
+		});
+		req.on("error", (err) => settle(() => reject(err)));
+	});
+}
+function serveSse(req, res, bus) {
+	res.writeHead(200, {
+		"content-type": "text/event-stream; charset=utf-8",
+		"cache-control": "no-cache, no-transform",
+		connection: "keep-alive"
+	});
+	let closed = false;
+	const heartbeat = setInterval(() => safeWrite(":hb\n\n"), SSE_HEARTBEAT_MS);
+	heartbeat.unref?.();
+	const onInvocation = (ev) => {
+		safeWrite(`event: invocation\ndata: ${JSON.stringify(ev)}\n\n`);
+	};
+	const onLog = (ev) => {
+		safeWrite(`event: log\ndata: ${JSON.stringify(ev)}\n\n`);
+	};
+	function cleanup() {
+		if (closed) return;
+		closed = true;
+		clearInterval(heartbeat);
+		bus.off("invocation", onInvocation);
+		bus.off("log", onLog);
+	}
+	function safeWrite(chunk) {
+		if (closed || res.writableEnded || res.destroyed) {
+			cleanup();
+			return;
+		}
+		res.write(chunk);
+	}
+	bus.on("invocation", onInvocation);
+	bus.on("log", onLog);
+	req.on("close", cleanup);
+	res.on("close", cleanup);
+	res.on("error", cleanup);
+	safeWrite(":ok\n\n");
+}
+/**
+* Listen on `port`, retrying `port+1`, `port+2`, ... on `EADDRINUSE` up
+* to `maxBump` extra attempts. Resolves with the bound port.
+*/
+function listenWithBump(server, host, port, maxBump) {
+	return new Promise((resolveListen, reject) => {
+		let attempt = 0;
+		const tryListen = (p) => {
+			const onError = (err) => {
+				if (err.code === "EADDRINUSE" && attempt < maxBump) {
+					attempt += 1;
+					server.removeListener("error", onError);
+					tryListen(p + 1);
+					return;
+				}
+				reject(err);
+			};
+			server.once("error", onError);
+			server.listen(p, host, () => {
+				server.removeListener("error", onError);
+				resolveListen(server.address().port);
+			});
+		};
+		tryListen(port);
+	});
+}
+
+//#endregion
+//#region src/local/studio-dispatch.ts
+let idCounter = 0;
+/**
+* Build the studio run dispatcher. Slice B drives a single-shot Lambda
+* invoke by spawning the SAME `cdkl invoke` the headless command runs —
+* studio is a control plane over the CLI, so re-using the whole command
+* (rather than re-wiring its internals) guarantees byte-for-byte parity
+* and keeps all of `cdkl invoke`'s process-global behavior
+* (`process.exit`, env mutation, stdin) isolated in a child process.
+*
+* The child's stdout is the Lambda response payload; its stderr (status
+* + container logs) is streamed line-by-line onto the bus as `log`
+* events. An `invocation` start event is emitted before spawn and an end
+* event (with response + status + duration) after exit, both keyed by
+* the same correlation id so the UI threads them into one timeline row.
+*/
+function createStudioDispatcher(config) {
+	const spawnFn = config.spawnFn ?? spawn;
+	const nodeBin = config.nodeBin ?? process.execPath;
+	const clock = config.clock ?? Date.now;
+	const idFactory = config.idFactory ?? (() => {
+		idCounter += 1;
+		return `inv-${clock()}-${idCounter}`;
+	});
+	async function run(req) {
+		const invocationId = idFactory();
+		const startedAt = clock();
+		if (req.kind !== "lambda") {
+			const error = `Running '${req.kind}' targets from studio is not supported yet (Lambda only).`;
+			config.bus.emit("invocation", {
+				id: invocationId,
+				ts: startedAt,
+				target: req.targetId,
+				kind: req.kind,
+				label: "invoke",
+				request: req.event,
+				response: error,
+				status: 501,
+				durationMs: clock() - startedAt
+			});
+			return {
+				invocationId,
+				ok: false,
+				status: 501,
+				error,
+				durationMs: clock() - startedAt
+			};
+		}
+		config.bus.emit("invocation", {
+			id: invocationId,
+			ts: startedAt,
+			target: req.targetId,
+			kind: req.kind,
+			label: "invoke",
+			request: req.event
+		});
+		let dir;
+		try {
+			dir = mkdtempSync(join(tmpdir(), "cdkl-studio-run-"));
+			const eventFile = join(dir, "event.json");
+			writeFileSync(eventFile, JSON.stringify(req.event ?? {}));
+			const args = [
+				"invoke",
+				req.targetId,
+				"--event",
+				eventFile
+			];
+			if (config.app) args.push("--app", config.app);
+			if (config.profile) args.push("--profile", config.profile);
+			if (config.region) args.push("--region", config.region);
+			for (const [k, v] of Object.entries(config.context ?? {})) args.push("-c", `${k}=${v}`);
+			const { code, stdout, stderr } = await runChild(spawnFn, nodeBin, [config.cliEntry, ...args], config.cwd ?? process.cwd(), invocationId, req.targetId, config.bus, clock);
+			const durationMs = clock() - startedAt;
+			const ok = code === 0;
+			const failure = stderr.trim() || `cdkl invoke exited ${code}`;
+			const stdoutLines = stdout.split("\n").map((l) => l.replace(/\r$/, "").trimEnd()).filter((l) => l.trim().length > 0);
+			let responseIdx = -1;
+			let response;
+			if (ok) {
+				for (let i = stdoutLines.length - 1; i >= 0; i -= 1) {
+					const parsed = tryParseJson(stdoutLines[i] ?? "");
+					if (parsed.ok) {
+						responseIdx = i;
+						response = parsed.value;
+						break;
+					}
+				}
+				if (responseIdx === -1 && stdoutLines.length > 0) {
+					responseIdx = stdoutLines.length - 1;
+					response = stdoutLines[responseIdx];
+				}
+			} else response = failure;
+			stdoutLines.forEach((line, i) => {
+				if (i === responseIdx) return;
+				config.bus.emit("log", {
+					ts: clock(),
+					containerId: invocationId,
+					target: req.targetId,
+					line,
+					stream: "stdout"
+				});
+			});
+			const raw = responseIdx >= 0 ? stdoutLines[responseIdx] ?? "" : "";
+			const status = ok ? 200 : 500;
+			config.bus.emit("invocation", {
+				id: invocationId,
+				ts: startedAt,
+				target: req.targetId,
+				kind: req.kind,
+				label: "invoke",
+				request: req.event,
+				response,
+				status,
+				durationMs
+			});
+			const result = {
+				invocationId,
+				ok,
+				status,
+				durationMs
+			};
+			if (raw) result.raw = raw;
+			if (response !== void 0) result.response = response;
+			if (!ok) result.error = failure;
+			return result;
+		} finally {
+			if (dir) rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	return { run };
+}
+/**
+* Spawn the child invoke, accumulate stdout, and stream stderr to the
+* bus line-by-line as `log` events. Resolves on process close.
+*/
+function runChild(spawnFn, nodeBin, argv, cwd, invocationId, target, bus, clock) {
+	return new Promise((resolve, reject) => {
+		let child;
+		try {
+			child = spawnFn(nodeBin, argv, { cwd });
+		} catch (err) {
+			reject(err instanceof Error ? err : new Error(String(err)));
+			return;
+		}
+		let stdout = "";
+		let stderr = "";
+		let lineBuf = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+			lineBuf += chunk;
+			let nl = lineBuf.indexOf("\n");
+			while (nl !== -1) {
+				const line = lineBuf.slice(0, nl);
+				lineBuf = lineBuf.slice(nl + 1);
+				if (line.length > 0) bus.emit("log", {
+					ts: clock(),
+					containerId: invocationId,
+					target,
+					line,
+					stream: "stderr"
+				});
+				nl = lineBuf.indexOf("\n");
+			}
+		});
+		child.on("error", (err) => reject(err));
+		child.on("close", (code) => {
+			if (lineBuf.length > 0) bus.emit("log", {
+				ts: clock(),
+				containerId: invocationId,
+				target,
+				line: lineBuf,
+				stream: "stderr"
+			});
+			resolve({
+				code,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+/** Try to JSON-parse `raw`; `ok` distinguishes a parsed value from a failure. */
+function tryParseJson(raw) {
+	if (raw === "") return {
+		ok: false,
+		value: void 0
+	};
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(raw)
+		};
+	} catch {
+		return {
+			ok: false,
+			value: void 0
+		};
+	}
+}
+
+//#endregion
+//#region src/cli/commands/local-studio.ts
+const STUDIO_TARGET_KINDS = [
+	"lambda",
+	"api",
+	"alb",
+	"ecs",
+	"agentcore"
+];
+/**
+* Validate + narrow the untyped `POST /api/run` body into a
+* {@link StudioRunRequest}. Throws (→ 400 from the server) on a malformed
+* body so a bad UI / curl payload fails loudly rather than spawning an
+* `invoke` for an empty target.
+*/
+function coerceRunRequest(body) {
+	if (typeof body !== "object" || body === null) throw new Error("Request body must be a JSON object.");
+	const { targetId, kind, event } = body;
+	if (typeof targetId !== "string" || targetId.trim() === "") throw new Error("Request body must include a non-empty \"targetId\" string.");
+	if (typeof kind !== "string" || !STUDIO_TARGET_KINDS.includes(kind)) throw new Error(`Request body "kind" must be one of: ${STUDIO_TARGET_KINDS.join(", ")}.`);
+	return {
+		targetId,
+		kind,
+		event
+	};
+}
+const DEFAULT_STUDIO_PORT = 9999;
+/**
+* Parse + validate the `--studio-port` value. Accepts `0` (OS-assigned)
+* through `65535`. Exported so a unit test can assert the bounds without
+* driving the full command. Throws on anything out of range / non-numeric.
+*/
+function parseStudioPort(raw) {
+	const port = raw.trim() === "" ? NaN : Number(raw);
+	if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`--studio-port must be 0..65535 (got ${raw}).`);
+	return port;
+}
+async function localStudioCommand(options) {
+	const logger = getLogger();
+	if (options.verbose) logger.setLevel("debug");
+	const port = parseStudioPort(options.studioPort);
+	await applyRoleArnIfSet({
+		roleArn: options.roleArn,
+		region: void 0,
+		profile: options.profile
+	});
+	const appCmd = resolveApp(options.app);
+	if (!appCmd) throw new Error(`No CDK app specified. Pass --app, set ${getEmbedConfig().envPrefix}_APP, or add "app" to cdk.json.`);
+	logger.info("Synthesizing CDK app...");
+	const synthesizer = new Synthesizer();
+	const context = parseContextOptions(options.context);
+	const synthOpts = {
+		app: appCmd,
+		output: options.output,
+		...options.profile && { profile: options.profile },
+		...Object.keys(context).length > 0 && { context }
+	};
+	const { stacks } = await synthesizer.synthesize(synthOpts);
+	const targetGroups = toStudioTargetGroups(listTargets(stacks));
+	const appLabel = stacks.map((s) => s.stackName).join(", ") || appCmd;
+	const bus = new StudioEventBus();
+	const dispatcher = createStudioDispatcher({
+		cliEntry: process.argv[1] ?? "",
+		bus,
+		cwd: process.cwd(),
+		...appCmd ? { app: appCmd } : {},
+		...options.profile ? { profile: options.profile } : {},
+		...options.region ? { region: options.region } : {},
+		...Object.keys(context).length > 0 ? { context } : {}
+	});
+	const server = await startStudioServer({
+		port,
+		bus,
+		targetGroups,
+		appLabel,
+		cliName: getEmbedConfig().cliName,
+		onRun: (body) => dispatcher.run(coerceRunRequest(body))
+	});
+	const cliName = getEmbedConfig().cliName;
+	logger.info(`${cliName} studio is running at ${server.url}`);
+	logger.info("Press Ctrl-C to stop.");
+	if (options.open && process.stdout.isTTY) openBrowser(server.url);
+	await blockUntilShutdown(server, cliName);
+}
+/** Best-effort cross-platform browser open. Failures are non-fatal. */
+function openBrowser(url) {
+	const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+	try {
+		const child = spawn(cmd, [url], {
+			stdio: "ignore",
+			detached: true,
+			shell: process.platform === "win32"
+		});
+		child.on("error", () => void 0);
+		child.unref();
+	} catch {}
+}
+/**
+* Block until SIGINT / SIGTERM, then close the studio server and resolve.
+* Mirrors the long-running serve commands' graceful-shutdown contract.
+*/
+function blockUntilShutdown(server, cliName) {
+	return new Promise((resolveShutdown) => {
+		let shuttingDown = false;
+		const shutdown = (signal) => {
+			if (shuttingDown) return;
+			shuttingDown = true;
+			getLogger().info(`Received ${signal}; stopping ${cliName} studio...`);
+			server.close().catch((err) => getLogger().warn(`Error stopping studio server: ${String(err)}`)).finally(() => resolveShutdown());
+		};
+		process.on("SIGINT", () => shutdown("SIGINT"));
+		process.on("SIGTERM", () => shutdown("SIGTERM"));
+	});
+}
+function createLocalStudioCommand(opts = {}) {
+	setEmbedConfig(opts.embedConfig);
+	const cmd = new Command("studio").description("Open the local studio: a web console that lists the synthesized CDK app's runnable targets and lets you invoke / serve them from the browser while watching all activity in one timeline. The interactive counterpart to the headless invoke / start-* commands.").action(withErrorHandling(async (options) => {
+		await localStudioCommand(options);
+	}));
+	addStudioSpecificOptions(cmd);
+	[
+		...commonOptions(),
+		...appOptions(),
+		...contextOptions
+	].forEach((opt) => cmd.addOption(opt));
+	cmd.addOption(regionOption);
+	return cmd;
+}
+/**
+* Register the option block `cdkl studio` adds on top of the shared
+* common / app / context option helpers. Kept in a named helper (not
+* inline in {@link createLocalStudioCommand}) so a host CLI embedding
+* this factory inherits new studio flags without a duplicate
+* `.addOption(...)` block, matching every other `add<Cmd>SpecificOptions`
+* extraction. Chainable: returns `cmd`.
+*/
+function addStudioSpecificOptions(cmd) {
+	cmd.addOption(new Option("--studio-port <port>", "Preferred port for the studio web server (bumps to the next free port on collision)").default(String(DEFAULT_STUDIO_PORT)));
+	cmd.addOption(new Option("--no-open", "Do not auto-open the browser when studio starts (TTY only)"));
+	return cmd;
+}
+
+//#endregion
+export { startStudioServer as a, StudioEventBus as c, createStudioDispatcher as i, coerceRunRequest as n, toStudioTargetGroups as o, createLocalStudioCommand as r, renderStudioHtml as s, addStudioSpecificOptions as t };
+//# sourceMappingURL=local-studio-CSW1raG0.js.map