@kizenapps/cli 0.12.0 → 0.13.0

package/dist/index.js

@@ -89,7 +89,8 @@ async function runBuild(pluginDir, outputDir, onStep) {
     return serializePlugin(plugin, allReleaseNotes);
   });
   const jsonStr = JSON.stringify(bundle, null, 2);
-  const bundleSize = Buffer.byteLength(jsonStr, "utf-8");
+  const sizedBundle = bundle.map(({ allReleaseNotes: _notes, ...rest }) => rest);
+  const bundleSize = Buffer.byteLength(JSON.stringify(sizedBundle, null, 2), "utf-8");
   await writeFile(join2(outputDir, "bundle.json"), jsonStr, "utf-8");
   return { bundleSize };
 }
@@ -220,7 +221,7 @@ var BuildUI = ({ outputDir, pluginDir }) => {
         ] }) }, s);
       }),
       isDone && bundleSize !== null && /* @__PURE__ */ jsx4(Box3, { marginTop: 1, gap: 1, children: /* @__PURE__ */ jsxs2(Text4, { color: "green", children: [
-        "\u2713 bundle.json \u2014 ",
+        "\u2713 bundle \u2014 ",
         formatBytes(bundleSize)
       ] }) }),
       errorMessage !== null && /* @__PURE__ */ jsx4(Box3, { marginTop: 1, borderStyle: "single", borderColor: "red", paddingX: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "red", children: errorMessage }) })
@@ -257,95 +258,418 @@ function buildCommand(program2) {
   });
 }
 
-// src/commands/dev.ts
+// src/commands/create.ts
 import { createElement as createElement2 } from "react";
 import { render as render2 } from "ink";
 
-// src/ui/DevUI.tsx
-import { useCallback as useCallback3, useEffect as useEffect4, useRef, useState as useState5 } from "react";
-import { Box as Box5, Text as Text6, useInput as useInput2 } from "ink";
-import { watch } from "fs";
-import { createServer } from "http";
-import { join as join9 } from "path";
-import { WebSocketServer } from "ws";
-
-// src/server/requestHandler.ts
-import { createReadStream } from "fs";
-import { access as access2, readFile as readFile4 } from "fs/promises";
-import { dirname as dirname2, extname, join as join7 } from "path";
-import { fileURLToPath } from "url";
+// src/ui/CreateUI.tsx
+import { useCallback, useState as useState3 } from "react";
+import { Box as Box4, Text as Text5, useApp as useApp2, useInput } from "ink";
+import { join as join5 } from "path";
 
-// src/lib/proxyCache.ts
-function createProxyCache(options = {}) {
-  const cache = /* @__PURE__ */ new Map();
-  const { onChange } = options;
-  const emitChange = () => {
-    onChange?.(cache.size);
+// src/lib/createPlugin.ts
+import { access, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+async function pathExists(path2) {
+  try {
+    await access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function precheckTargetDir(dir) {
+  if (await pathExists(join4(dir, "kizen.json"))) {
+    return "has-manifest";
+  }
+  if (await pathExists(join4(dir, ".kizenapp"))) {
+    return "has-kizenapp";
+  }
+  return "ok";
+}
+async function findAvailableSubDir(parentDir, baseName) {
+  const base = join4(parentDir, baseName);
+  if (!await pathExists(base)) {
+    return base;
+  }
+  for (let i = 1; i < 1e3; i++) {
+    const candidate = join4(parentDir, `${baseName}-${String(i)}`);
+    if (!await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not find an available directory name for "${baseName}"`);
+}
+function buildManifest(input) {
+  return {
+    name: input.name,
+    version: "1.0.0",
+    published: true,
+    api_name: input.apiName,
+    external_link: input.externalLink,
+    description: input.description,
+    entry: "src/",
+    engine: "1.0.0",
+    release_notes_directory: "releaseNotes/",
+    release_environments: ["prod"],
+    config_template: {},
+    base_config: {},
+    developer_business_id: input.developerBusinessId
   };
+}
+async function createPlugin(input) {
+  await mkdir2(input.targetDir, { recursive: true });
+  const manifest = buildManifest(input);
+  await writeFile2(
+    join4(input.targetDir, "kizen.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+  await mkdir2(join4(input.targetDir, "src"), { recursive: true });
+  await mkdir2(join4(input.targetDir, "releaseNotes"), { recursive: true });
+  ensureGitignore(input.targetDir);
+}
+
+// src/ui/CreateUI.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var FIELDS = ["name", "apiName", "externalLink", "description", "developerBusinessId"];
+var FIELD_LABELS = {
+  name: "Name",
+  apiName: "API name",
+  externalLink: "External link",
+  description: "Description",
+  developerBusinessId: "Business ID"
+};
+var REQUIRED_FIELDS = ["name", "apiName"];
+function inferApiName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+var Hint = ({ text }) => /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: text });
+function emptyValues(defaultBusinessId) {
   return {
-    get(key, fetcher) {
-      const existing = cache.get(key);
-      if (existing !== void 0) {
-        return existing.then((response) => ({ response, fromCache: true }));
+    name: "",
+    apiName: "",
+    externalLink: "",
+    description: "",
+    developerBusinessId: defaultBusinessId
+  };
+}
+var CreateUI = ({ parentDir, defaultBusinessId }) => {
+  const app = useApp2();
+  const [phase, setPhase] = useState3({ type: "target-select", cursor: 0 });
+  const [mode, setMode] = useState3("in-place");
+  const [values, setValues] = useState3(() => emptyValues(defaultBusinessId));
+  const [inputBuffer, setInputBuffer] = useState3("");
+  const [targetDir, setTargetDir] = useState3(parentDir);
+  const enterFieldEntry = useCallback((nextMode, initialValues) => {
+    setMode(nextMode);
+    setInputBuffer(initialValues.name);
+    setPhase({ type: "field-entry", field: 0, values: initialValues });
+  }, []);
+  const runPrecheck = useCallback(
+    async (dir) => {
+      const result = await precheckTargetDir(dir);
+      if (result !== "ok") {
+        setPhase({ type: "precheck-error", targetDir: dir, reason: result });
+        return;
       }
-      const pending = fetcher().then(async (response) => {
-        const headers = Object.fromEntries(response.headers);
-        delete headers["content-encoding"];
-        delete headers["content-length"];
-        return {
-          status: response.status,
-          headers,
-          body: Buffer.from(await response.arrayBuffer())
-        };
-      }).catch((error) => {
-        cache.delete(key);
-        emitChange();
-        throw error;
+      setTargetDir(dir);
+      enterFieldEntry("in-place", values);
+    },
+    [values, enterFieldEntry]
+  );
+  const resolveSubDirAndConfirm = useCallback(
+    async (finalValues) => {
+      try {
+        const dir = await findAvailableSubDir(parentDir, finalValues.apiName);
+        setTargetDir(dir);
+        setPhase({ type: "confirm", values: finalValues });
+      } catch (err) {
+        setPhase({
+          type: "error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
+    [parentDir]
+  );
+  const runWrite = useCallback(async (finalValues, dir) => {
+    try {
+      await createPlugin({
+        targetDir: dir,
+        name: finalValues.name,
+        apiName: finalValues.apiName,
+        externalLink: finalValues.externalLink,
+        description: finalValues.description,
+        developerBusinessId: finalValues.developerBusinessId
       });
-      cache.set(key, pending);
-      emitChange();
-      return pending.then((response) => {
-        if (response.status >= 400) {
-          cache.delete(key);
-          emitChange();
-        }
-        return { response, fromCache: false };
+      setPhase({ type: "done", targetDir: dir });
+    } catch (err) {
+      setPhase({
+        type: "error",
+        message: err instanceof Error ? err.message : String(err)
       });
-    },
-    clear() {
-      cache.clear();
-      emitChange();
     }
-  };
-}
-
-// src/lib/constants.ts
-var LOG_LIMIT = 50;
-var LOG_DISPLAY = 8;
-var FILE_WATCH_DEBOUNCE_MS = 150;
-var MIME_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".json": "application/json; charset=utf-8",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".map": "application/json"
+  }, []);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      app.exit();
+      return;
+    }
+    if (phase.type === "target-select") {
+      if (key.upArrow) {
+        setPhase({ type: "target-select", cursor: 0 });
+      } else if (key.downArrow) {
+        setPhase({ type: "target-select", cursor: 1 });
+      } else if (key.return) {
+        if (phase.cursor === 0) {
+          void runPrecheck(parentDir);
+        } else {
+          enterFieldEntry("sub-dir", values);
+        }
+      } else if (key.escape) {
+        app.exit();
+      }
+      return;
+    }
+    if (phase.type === "precheck-error") {
+      if (key.return || key.escape) {
+        app.exit();
+      }
+      return;
+    }
+    if (phase.type === "field-entry") {
+      const { field, values: current } = phase;
+      const fieldName = FIELDS[field];
+      if (!fieldName) {
+        return;
+      }
+      if (key.escape) {
+        app.exit();
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setInputBuffer((prev) => prev.slice(0, -1));
+        return;
+      }
+      if (key.upArrow && field > 0) {
+        const updated = { ...current, [fieldName]: inputBuffer };
+        const prevField = field - 1;
+        const prevName = FIELDS[prevField];
+        setPhase({ type: "field-entry", field: prevField, values: updated });
+        setValues(updated);
+        setInputBuffer(prevName ? updated[prevName] : "");
+        return;
+      }
+      if (key.return || key.tab || key.downArrow) {
+        const buffer = inputBuffer.trim();
+        const isRequired = REQUIRED_FIELDS.includes(fieldName);
+        if (isRequired && !buffer) {
+          setPhase({
+            type: "field-entry",
+            field,
+            values: current,
+            fieldError: `${FIELD_LABELS[fieldName]} is required`
+          });
+          return;
+        }
+        const valueToStore = fieldName === "description" ? inputBuffer : buffer;
+        const updated = { ...current, [fieldName]: valueToStore };
+        setValues(updated);
+        const nextField = field + 1;
+        if (nextField >= FIELDS.length) {
+          setInputBuffer("");
+          if (mode === "sub-dir") {
+            setPhase({ type: "resolving-target" });
+            void resolveSubDirAndConfirm(updated);
+          } else {
+            setPhase({ type: "confirm", values: updated });
+          }
+        } else {
+          const nextName = FIELDS[nextField];
+          const existing = nextName ? updated[nextName] : "";
+          const nextBuffer = nextName === "apiName" && !existing ? inferApiName(updated.name) : existing;
+          setPhase({ type: "field-entry", field: nextField, values: updated });
+          setInputBuffer(nextBuffer);
+        }
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setInputBuffer((prev) => prev + input);
+      }
+      return;
+    }
+    if (phase.type === "confirm") {
+      if (key.escape) {
+        const lastField = FIELDS.length - 1;
+        const lastName = FIELDS[lastField];
+        setPhase({ type: "field-entry", field: lastField, values: phase.values });
+        setInputBuffer(lastName ? phase.values[lastName] : "");
+        return;
+      }
+      if (key.return) {
+        setPhase({ type: "writing" });
+        void runWrite(phase.values, targetDir);
+      }
+      return;
+    }
+    if (phase.type === "done" || phase.type === "error") {
+      if (key.return || key.escape) {
+        app.exit();
+      }
+    }
+  });
+  if (phase.type === "target-select") {
+    const options = [
+      { label: "Use current directory", desc: parentDir },
+      { label: "Create new sub-directory", desc: `${parentDir}/<inferred from API name>` }
+    ];
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx5(AppHeader, {}),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Where should the new plugin live?" }),
+        options.map((opt, i) => {
+          const selected = phase.cursor === i;
+          return /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
+            /* @__PURE__ */ jsx5(Text5, { ...selected && { color: "cyan" }, children: selected ? "\u276F" : " " }),
+            /* @__PURE__ */ jsx5(Text5, { bold: selected, ...selected && { color: "cyan" }, children: opt.label }),
+            /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: opt.desc })
+          ] }, opt.label);
+        })
+      ] }),
+      /* @__PURE__ */ jsx5(Hint, { text: "\u2191\u2193 to move \xB7 Enter to select \xB7 Esc to cancel" })
+    ] });
+  }
+  if (phase.type === "precheck-error") {
+    const { targetDir: dir, reason } = phase;
+    const conflict = reason === "has-manifest" ? "kizen.json" : ".kizenapp/";
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx5(AppHeader, {}),
+      /* @__PURE__ */ jsx5(Text5, { color: "red", bold: true, children: "Cannot create plugin" }),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsxs3(Text5, { children: [
+          dir,
+          " already contains ",
+          /* @__PURE__ */ jsx5(Text5, { bold: true, children: conflict }),
+          "."
+        ] }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Remove the conflicting file/directory or choose a different target to avoid overwriting an existing plugin." })
+      ] }),
+      /* @__PURE__ */ jsx5(Hint, { text: "Enter or Esc to exit" })
+    ] });
+  }
+  if (phase.type === "field-entry") {
+    const { field: activeField, fieldError } = phase;
+    const targetLine = mode === "sub-dir" ? `Target: sub-directory of ${parentDir} (inferred from API name)` : `Target: ${targetDir}`;
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx5(AppHeader, {}),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Plugin details" }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: targetLine })
+      ] }),
+      fieldError !== void 0 && /* @__PURE__ */ jsxs3(Text5, { color: "red", children: [
+        "Error: ",
+        fieldError
+      ] }),
+      /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", gap: 0, children: FIELDS.map((name, i) => {
+        const isActive = activeField === i;
+        const displayValue = isActive ? inputBuffer : values[name];
+        const isRequired = REQUIRED_FIELDS.includes(name);
+        const label = `${FIELD_LABELS[name]}${isRequired ? "" : " (optional)"}`;
+        return /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
+          /* @__PURE__ */ jsx5(Box4, { width: 24, children: /* @__PURE__ */ jsx5(Text5, { bold: isActive, ...isActive && { color: "cyan" }, children: label }) }),
+          /* @__PURE__ */ jsx5(Text5, { ...isActive && { color: "cyan" }, children: ">" }),
+          /* @__PURE__ */ jsx5(Text5, { children: displayValue }),
+          isActive && /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "\u2588" })
+        ] }, name);
+      }) }),
+      /* @__PURE__ */ jsx5(Hint, { text: "Enter/Tab/\u2193 next \xB7 \u2191 previous \xB7 Backspace delete \xB7 Esc cancel" })
+    ] });
+  }
+  if (phase.type === "confirm") {
+    const manifest = buildManifest({
+      targetDir,
+      name: phase.values.name,
+      apiName: phase.values.apiName,
+      externalLink: phase.values.externalLink,
+      description: phase.values.description,
+      developerBusinessId: phase.values.developerBusinessId
+    });
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx5(AppHeader, {}),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Ready to create" }),
+        /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+          "Target: ",
+          targetDir
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "kizen.json preview" }),
+        /* @__PURE__ */ jsx5(Text5, { children: JSON.stringify(manifest, null, 2) })
+      ] }),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Also creates:" }),
+        /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+          "  ",
+          join5(targetDir, "src/")
+        ] }),
+        /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+          "  ",
+          join5(targetDir, "releaseNotes/")
+        ] }),
+        /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+          "  ",
+          join5(targetDir, ".gitignore"),
+          " (adds .kizenapp/)"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx5(Hint, { text: "Enter to create \xB7 Esc to go back" })
+    ] });
+  }
+  if (phase.type === "resolving-target") {
+    return /* @__PURE__ */ jsx5(Box4, { paddingY: 1, paddingX: 2, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Finding available sub-directory\u2026" }) });
+  }
+  if (phase.type === "writing") {
+    return /* @__PURE__ */ jsx5(Box4, { paddingY: 1, paddingX: 2, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Creating plugin\u2026" }) });
+  }
+  if (phase.type === "done") {
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx5(AppHeader, {}),
+      /* @__PURE__ */ jsxs3(Text5, { color: "green", bold: true, children: [
+        "Plugin created at ",
+        phase.targetDir
+      ] }),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Next steps:" }),
+        /* @__PURE__ */ jsxs3(Text5, { children: [
+          "  ",
+          "cd ",
+          phase.targetDir
+        ] }),
+        /* @__PURE__ */ jsxs3(Text5, { children: [
+          "  ",
+          "appbuilder dev"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx5(Hint, { text: "Enter or Esc to exit" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+    /* @__PURE__ */ jsx5(AppHeader, {}),
+    /* @__PURE__ */ jsx5(Text5, { color: "red", bold: true, children: "Failed to create plugin" }),
+    /* @__PURE__ */ jsx5(Text5, { children: phase.message }),
+    /* @__PURE__ */ jsx5(Hint, { text: "Enter or Esc to exit" })
+  ] });
 };
 
 // src/lib/credentials.ts
-import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile2, readdir as readdir2, writeFile as writeFile3 } from "fs/promises";
 import { homedir } from "os";
-import { dirname, join as join4 } from "path";
+import { dirname, join as join6 } from "path";
 var ENVIRONMENTS = ["go", "fmo", "staging", "integration", "test1"];
-var GLOBAL_CREDENTIALS_DIR = join4(homedir(), ".kizenappbuilder");
-var GLOBAL_CREDENTIALS_PATH = join4(GLOBAL_CREDENTIALS_DIR, "credentials.json");
+var GLOBAL_CREDENTIALS_DIR = join6(homedir(), ".kizenappbuilder");
+var GLOBAL_CREDENTIALS_PATH = join6(GLOBAL_CREDENTIALS_DIR, "credentials.json");
 var DEFAULT_PROFILE_NAME = "credentials";
 function isValidEnvironment(value) {
   return ENVIRONMENTS.includes(value);
@@ -375,11 +699,11 @@ async function loadGlobalCredentials() {
   }
 }
 async function saveGlobalCredentials(credentials) {
-  await mkdir2(dirname(GLOBAL_CREDENTIALS_PATH), { recursive: true });
-  await writeFile2(GLOBAL_CREDENTIALS_PATH, JSON.stringify(credentials, null, 2), "utf-8");
+  await mkdir3(dirname(GLOBAL_CREDENTIALS_PATH), { recursive: true });
+  await writeFile3(GLOBAL_CREDENTIALS_PATH, JSON.stringify(credentials, null, 2), "utf-8");
 }
 function getProfilePath(name) {
-  return join4(GLOBAL_CREDENTIALS_DIR, `${name}.json`);
+  return join6(GLOBAL_CREDENTIALS_DIR, `${name}.json`);
 }
 async function listCredentialProfiles() {
   const profiles = [
@@ -395,7 +719,7 @@ async function listCredentialProfiles() {
       if (name === DEFAULT_PROFILE_NAME) {
         continue;
       }
-      profiles.push({ name, path: join4(GLOBAL_CREDENTIALS_DIR, entry), isDefault: false });
+      profiles.push({ name, path: join6(GLOBAL_CREDENTIALS_DIR, entry), isDefault: false });
     }
   } catch {
   }
@@ -406,8 +730,8 @@ async function saveCredentialProfile(name, credentials) {
     await saveGlobalCredentials(credentials);
     return;
   }
-  await mkdir2(GLOBAL_CREDENTIALS_DIR, { recursive: true });
-  await writeFile2(getProfilePath(name), JSON.stringify(credentials, null, 2), "utf-8");
+  await mkdir3(GLOBAL_CREDENTIALS_DIR, { recursive: true });
+  await writeFile3(getProfilePath(name), JSON.stringify(credentials, null, 2), "utf-8");
 }
 async function loadCredentialProfile(name) {
   try {
@@ -417,26 +741,121 @@ async function loadCredentialProfile(name) {
   }
 }
 
+// src/commands/create.ts
+function createCommand(program2) {
+  program2.command("create").description("Scaffold a new Kizen plugin project").action(async () => {
+    const parentDir = process.cwd();
+    const globalCreds = await loadGlobalCredentials();
+    const defaultBusinessId = globalCreds?.businessId ?? "";
+    const { waitUntilExit } = render2(createElement2(CreateUI, { parentDir, defaultBusinessId }), {
+      exitOnCtrlC: false
+    });
+    await waitUntilExit();
+  });
+}
+
+// src/commands/dev.ts
+import { createElement as createElement3 } from "react";
+import { render as render3 } from "ink";
+
+// src/ui/DevUI.tsx
+import { useCallback as useCallback4, useEffect as useEffect4, useRef, useState as useState6 } from "react";
+import { Box as Box6, Text as Text7, useInput as useInput3 } from "ink";
+import { watch } from "fs";
+import { createServer } from "http";
+import { join as join11 } from "path";
+import { WebSocketServer } from "ws";
+
+// src/server/requestHandler.ts
+import { createReadStream } from "fs";
+import { access as access3, readdir as readdir3, readFile as readFile4, stat } from "fs/promises";
+import { dirname as dirname2, extname, join as join9, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/proxyCache.ts
+function createProxyCache(options = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  const { onChange } = options;
+  const emitChange = () => {
+    onChange?.(cache.size);
+  };
+  return {
+    get(key, fetcher) {
+      const existing = cache.get(key);
+      if (existing !== void 0) {
+        return existing.then((response) => ({ response, fromCache: true }));
+      }
+      const pending = fetcher().then(async (response) => {
+        const headers = Object.fromEntries(response.headers);
+        delete headers["content-encoding"];
+        delete headers["content-length"];
+        return {
+          status: response.status,
+          headers,
+          body: Buffer.from(await response.arrayBuffer())
+        };
+      }).catch((error) => {
+        cache.delete(key);
+        emitChange();
+        throw error;
+      });
+      cache.set(key, pending);
+      emitChange();
+      return pending.then((response) => {
+        if (response.status >= 400) {
+          cache.delete(key);
+          emitChange();
+        }
+        return { response, fromCache: false };
+      });
+    },
+    clear() {
+      cache.clear();
+      emitChange();
+    }
+  };
+}
+
+// src/lib/constants.ts
+var LOG_LIMIT = 50;
+var LOG_DISPLAY = 8;
+var FILE_WATCH_DEBOUNCE_MS = 150;
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".json": "application/json; charset=utf-8",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json"
+};
+
 // src/lib/config.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import { join as join7 } from "path";
 async function loadConfig(outputDir) {
   try {
-    const content = await readFile3(join5(outputDir, "config.json"), "utf-8");
+    const content = await readFile3(join7(outputDir, "config.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
   }
 }
 async function saveConfig(outputDir, config) {
-  await mkdir3(outputDir, { recursive: true });
-  await writeFile3(join5(outputDir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
+  await mkdir4(outputDir, { recursive: true });
+  await writeFile4(join7(outputDir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
 }
 
 // src/server/pythonExecutor.ts
-import { spawn, execFileSync } from "child_process";
-import { writeFile as writeFile4, rm, mkdtemp, access } from "fs/promises";
-import { join as join6 } from "path";
+import { spawn } from "child_process";
+import { writeFile as writeFile5, rm, mkdtemp, access as access2 } from "fs/promises";
+import { join as join8 } from "path";
 import { tmpdir } from "os";
 var WRAPPER_SCRIPT = `
 import sys, json, os, traceback
@@ -487,6 +906,80 @@ class _OutputsProxy:
 
 outputs = _OutputsProxy()
 
+# --- HTTP request capture (requests library only) ---
+_kizen_http_requests = []
+
+def _kizen_install_http_capture():
+    try:
+        import requests
+    except Exception:
+        return
+    import time, datetime
+
+    _original_send = requests.Session.send
+
+    def _kizen_send(self, request, **kwargs):
+        submitted_at = datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
+        start = time.time()
+        error_type = None
+        response = None
+        try:
+            response = _original_send(self, request, **kwargs)
+            return response
+        except Exception as exc:
+            error_type = type(exc).__name__
+            raise
+        finally:
+            body = request.body
+            if isinstance(body, bytes):
+                try:
+                    body = body.decode('utf-8')
+                except Exception:
+                    body = '<binary>'
+            elif body is None:
+                body = ''
+
+            status = 0
+            resp_headers = {}
+            resp_body = ''
+            if response is not None:
+                status = response.status_code
+                resp_headers = dict(response.headers)
+                if kwargs.get('stream'):
+                    resp_body = '<streamed>'
+                else:
+                    try:
+                        resp_body = response.text
+                    except Exception:
+                        resp_body = '<unreadable>'
+
+            _kizen_http_requests.append({
+                'method': request.method or '',
+                'url': request.url or '',
+                'headers': dict(request.headers or {}),
+                'body': body,
+                'requestSubmittedAt': submitted_at,
+                'session': True,
+                'responseStatusCode': status,
+                'responseHeaders': resp_headers,
+                'responseBody': resp_body,
+                'requestErrorType': error_type,
+                'duration': time.time() - start,
+            })
+
+    requests.Session.send = _kizen_send
+
+_kizen_install_http_capture()
+
+def _kizen_http_summary():
+    if not _kizen_http_requests:
+        return None
+    return {
+        'count': len(_kizen_http_requests),
+        'notLogged': 0,
+        'requests': _kizen_http_requests,
+    }
+
 # --- Execute user script ---
 try:
     exec(open(os.environ['__KIZEN_SCRIPT_PATH__'], encoding='utf-8').read())
@@ -495,6 +988,7 @@ try:
         'outputValues': outputs._values,
         'logs': outputs._logs,
         'error': None,
+        'httpRequests': _kizen_http_summary(),
     }
 except Exception:
     # Build a clean traceback that hides the wrapper internals.
@@ -514,6 +1008,7 @@ except Exception:
         'outputValues': outputs._values,
         'logs': outputs._logs,
         'error': ''.join(lines),
+        'httpRequests': _kizen_http_summary(),
     }
 
 # Write results between markers so we can extract them reliably
@@ -524,8 +1019,21 @@ sys.stdout.write('\\n__KIZEN_RESULT_END__\\n')
 sys.stdout.flush()
 `.trim();
 var DEFAULT_TIMEOUT = 3e4;
-var VENV_DIR = join6(process.cwd(), ".kizenapp", "venv");
-var VENV_PACKAGES = ["requests"];
+var VENV_DIR = join8(process.cwd(), ".kizenapp", "venv");
+var VENV_PACKAGES = [
+  "awslambdaric",
+  "bcrypt",
+  "fpdf2",
+  "lxml",
+  "msgpack",
+  "numpy",
+  "paramiko",
+  "pyjwt",
+  "pypdf",
+  "pytz",
+  "requests",
+  "tzdata"
+];
 var venvReady = null;
 function resolvePythonBinary(runtime) {
   const match = /^python-(\d+\.\d+)$/.exec(runtime);
@@ -534,19 +1042,82 @@ function resolvePythonBinary(runtime) {
   }
   return "python3";
 }
-function ensureVenv(runtime) {
+function runCommand(bin, args, onLine) {
+  return new Promise((resolve2, reject) => {
+    const proc = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const pipeLines = (source, stream) => {
+      const captured = [];
+      let buffer = "";
+      source.on("data", (chunk) => {
+        buffer += chunk.toString("utf-8");
+        let idx = buffer.indexOf("\n");
+        while (idx >= 0) {
+          const line = buffer.slice(0, idx).replace(/\r$/, "");
+          buffer = buffer.slice(idx + 1);
+          captured.push(line);
+          onLine?.(line, stream);
+          idx = buffer.indexOf("\n");
+        }
+      });
+      source.on("end", () => {
+        if (buffer.length > 0) {
+          const line = buffer.replace(/\r$/, "");
+          captured.push(line);
+          onLine?.(line, stream);
+        }
+      });
+      return captured;
+    };
+    const stderrCaptured = pipeLines(proc.stderr, "stderr");
+    pipeLines(proc.stdout, "stdout");
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        const tail = stderrCaptured.slice(-10).join("\n").trim();
+        const detail = tail.length > 0 ? `: ${tail}` : "";
+        reject(new Error(`${bin} exited with code ${String(code)}${detail}`));
+      }
+    });
+  });
+}
+var installListeners = /* @__PURE__ */ new Set();
+function emitInstall(event) {
+  for (const listener of installListeners) {
+    listener(event);
+  }
+}
+function ensureVenv(runtime, listener) {
+  if (listener) {
+    installListeners.add(listener);
+  }
   if (!venvReady) {
     venvReady = (async () => {
-      const venvPython = join6(VENV_DIR, "bin", "python");
+      const venvPython = join8(VENV_DIR, "bin", "python");
       try {
-        await access(venvPython);
+        await access2(venvPython);
       } catch {
         const systemPython = resolvePythonBinary(runtime);
-        execFileSync(systemPython, ["-m", "venv", VENV_DIR], { stdio: "ignore" });
+        await runCommand(systemPython, ["-m", "venv", VENV_DIR]);
+      }
+      emitInstall({ kind: "start" });
+      try {
+        await runCommand(
+          venvPython,
+          ["-m", "pip", "install", "--disable-pip-version-check", ...VENV_PACKAGES],
+          (line, stream) => {
+            emitInstall({ kind: "log", line, stream });
+          }
+        );
+        emitInstall({ kind: "complete" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        emitInstall({ kind: "error", message });
+        throw err;
+      } finally {
+        installListeners.clear();
       }
-      execFileSync(venvPython, ["-m", "pip", "install", "-q", ...VENV_PACKAGES], {
-        stdio: "ignore"
-      });
       return venvPython;
     })();
   }
@@ -571,16 +1142,16 @@ function parseResult(stdout) {
 }
 async function executePythonStep(params) {
   const timeout = params.timeout ?? DEFAULT_TIMEOUT;
-  const pythonBin = await ensureVenv(params.scriptRuntime);
+  const pythonBin = await ensureVenv(params.scriptRuntime, params.onInstallProgress);
   const start = Date.now();
   let tmpDir;
   try {
-    tmpDir = await mkdtemp(join6(tmpdir(), "kizen-step-"));
-    const wrapperPath = join6(tmpDir, "wrapper.py");
-    const scriptPath = join6(tmpDir, "script.py");
+    tmpDir = await mkdtemp(join8(tmpdir(), "kizen-step-"));
+    const wrapperPath = join8(tmpDir, "wrapper.py");
+    const scriptPath = join8(tmpDir, "script.py");
     await Promise.all([
-      writeFile4(wrapperPath, WRAPPER_SCRIPT, "utf-8"),
-      writeFile4(scriptPath, params.script, "utf-8")
+      writeFile5(wrapperPath, WRAPPER_SCRIPT, "utf-8"),
+      writeFile5(scriptPath, params.script, "utf-8")
     ]);
     const env = {
       ...process.env,
@@ -588,7 +1159,7 @@ async function executePythonStep(params) {
       __KIZEN_SECRETS__: JSON.stringify(params.secrets),
       __KIZEN_SCRIPT_PATH__: scriptPath
     };
-    const { exitCode, stdout, stderr } = await new Promise((resolve) => {
+    const { exitCode, stdout, stderr } = await new Promise((resolve2) => {
       const stdoutChunks = [];
       const stderrChunks = [];
       let settled = false;
@@ -612,7 +1183,7 @@ async function executePythonStep(params) {
         }
         settled = true;
         clearTimeout(timer);
-        resolve({
+        resolve2({
           exitCode: code ?? 1,
           stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
           stderr: Buffer.concat(stderrChunks).toString("utf-8")
@@ -625,7 +1196,7 @@ async function executePythonStep(params) {
         }
         settled = true;
         clearTimeout(timer);
-        resolve({
+        resolve2({
           exitCode: 1,
           stdout: "",
           stderr: err.message
@@ -647,6 +1218,9 @@ async function executePythonStep(params) {
       if (result.error !== null) {
         base2.error = result.error;
       }
+      if (result.httpRequests) {
+        base2.httpRequests = result.httpRequests;
+      }
       return base2;
     }
     const base = {
@@ -661,149 +1235,63 @@ async function executePythonStep(params) {
     if (exitCode !== 0) {
       base.error = `Process exited with code ${String(exitCode)}`;
     }
-    return base;
-  } finally {
-    if (tmpDir) {
-      void rm(tmpDir, { recursive: true, force: true });
-    }
-  }
-}
-
-// src/server/remoteCodeRunner.ts
-var BASE_URLS = {
-  go: "https://app.go.kizen.com/api",
-  fmo: "https://app.fmo.kizen.com/api",
-  staging: "https://staging.kizen.dev/api",
-  integration: "https://integration.kizen.dev/api",
-  test1: "https://test1.kizen.dev/api"
-};
-var SUPPORTED_RUNTIMES = ["python-3-13", "python-3-12"];
-var DEFAULT_RUNTIME = "python-3-12";
-var DATA_TYPE_TO_KIZEN = {
-  text: "s",
-  string: "s",
-  number: "n",
-  integer: "n",
-  boolean: "b",
-  date: "d",
-  datetime: "dt",
-  phone: "p",
-  phonenumber: "p",
-  uuid: "u",
-  file: "f",
-  list: "l"
-};
-function toKizenType(dataType) {
-  return DATA_TYPE_TO_KIZEN[dataType.toLowerCase()] ?? "s";
-}
-function resolveRuntime(runtime) {
-  if (SUPPORTED_RUNTIMES.includes(runtime)) {
-    return runtime;
-  }
-  return DEFAULT_RUNTIME;
-}
-function encodeInputs(inputs, inputTypes) {
-  const keys = Object.keys(inputs);
-  if (keys.length === 0) {
-    return null;
-  }
-  const encoded = {};
-  for (const key of keys) {
-    encoded[key] = {
-      t: toKizenType(inputTypes[key] ?? "string"),
-      v: inputs[key]
-    };
-  }
-  return encoded;
-}
-function encodeOutputTypes(outputTypes) {
-  const keys = Object.keys(outputTypes);
-  if (keys.length === 0) {
-    return null;
-  }
-  const encoded = {};
-  for (const key of keys) {
-    encoded[key] = toKizenType(outputTypes[key] ?? "string");
-  }
-  return encoded;
-}
-function decodeOutputValues(values) {
-  if (!values) {
-    return {};
-  }
-  const decoded = {};
-  for (const [key, encoded] of Object.entries(values)) {
-    decoded[key] = encoded.v;
-  }
-  return decoded;
-}
-async function executeRemoteStep(params, credentials) {
-  const baseUrl = BASE_URLS[credentials.environment];
-  const url = `${baseUrl}/coderunner/run`;
-  const start = Date.now();
-  const body = {
-    user_script: params.script,
-    runtime: resolveRuntime(params.scriptRuntime),
-    secrets: params.secretNames.length > 0 ? params.secretNames : void 0,
-    inputs: encodeInputs(params.inputs, params.inputTypes),
-    output_types: encodeOutputTypes(params.outputTypes)
-  };
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-API-KEY": credentials.apiKey,
-        "X-USER-ID": credentials.userId,
-        "X-BUSINESS-ID": credentials.businessId
-      },
-      body: JSON.stringify(body)
-    });
-    const durationMs = Date.now() - start;
-    if (!response.ok) {
-      const text = await response.text();
-      return {
-        success: false,
-        outputValues: {},
-        logs: [],
-        stdout: "",
-        stderr: "",
-        error: `Remote runner returned ${String(response.status)}: ${text}`,
-        exitCode: 1,
-        durationMs
-      };
-    }
-    const data = await response.json();
-    const hasError = data.error !== null;
-    const result = {
-      success: !hasError,
-      outputValues: decodeOutputValues(data.values),
-      logs: data.logs ?? [],
-      stdout: "",
-      stderr: "",
-      exitCode: hasError ? 1 : 0,
-      durationMs: data.duration_ms ?? durationMs
-    };
-    if (hasError && data.error) {
-      result.error = data.error.detail ? `${data.error.error}
-${data.error.detail}` : data.error.error;
+    return base;
+  } finally {
+    if (tmpDir) {
+      void rm(tmpDir, { recursive: true, force: true });
     }
-    return result;
-  } catch (err) {
-    return {
-      success: false,
-      outputValues: {},
-      logs: [],
-      stdout: "",
-      stderr: "",
-      error: `Remote execution failed: ${err instanceof Error ? err.message : String(err)}`,
-      exitCode: 1,
-      durationMs: Date.now() - start
-    };
   }
 }
 
 // src/server/requestHandler.ts
+var SOURCE_FILE_MAX_BYTES = 2 * 1024 * 1024;
+var SKIP_FILES = /* @__PURE__ */ new Set([".DS_Store", ".gitignore"]);
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".mdx",
+  ".yml",
+  ".yaml",
+  ".toml",
+  ".css",
+  ".scss",
+  ".html",
+  ".htm",
+  ".xml",
+  ".svg",
+  ".txt",
+  ".sh",
+  ".py",
+  ".env",
+  ".gitignore",
+  ".prettierrc",
+  ".eslintrc"
+]);
+function resolveSafePath(pluginDir, relParam) {
+  if (relParam.includes("\0")) {
+    return null;
+  }
+  const rel = relParam.replace(/^\/+/, "");
+  const abs = resolve(pluginDir, rel);
+  if (abs !== pluginDir && !abs.startsWith(pluginDir + sep)) {
+    return null;
+  }
+  return abs;
+}
+function isInsideSkippedDir(pluginDir, abs) {
+  const rel = abs === pluginDir ? "" : abs.slice(pluginDir.length + 1);
+  if (rel === "") {
+    return false;
+  }
+  const segments = rel.split(sep);
+  return segments.some((segment) => SKIP_DIRS.has(segment));
+}
 function proxyLogEntryToString(entry) {
   if (entry.kind === "info") {
     return entry.message;
@@ -813,17 +1301,17 @@ function proxyLogEntryToString(entry) {
 }
 function getViewerPath() {
   const filename = fileURLToPath(import.meta.url);
-  return join7(dirname2(filename), "viewer");
+  return join9(dirname2(filename), "viewer");
 }
 async function fileExists(filePath) {
   try {
-    await access2(filePath);
+    await access3(filePath);
     return true;
   } catch {
     return false;
   }
 }
-function createRequestHandler(viewerPath, createServerLog, createProxyLog, credentialsRef, activeProfileRef, outputDir, broadcast, onProxyCacheChange, lastPathRef) {
+function createRequestHandler(viewerPath, createServerLog, createProxyLog, credentialsRef, activeProfileRef, outputDir, broadcast, onProxyCacheChange, lastPathRef, pluginDir) {
   const proxyCache = createProxyCache({ onChange: onProxyCacheChange });
   return (req, res) => {
     void (async () => {
@@ -864,7 +1352,7 @@ function createRequestHandler(viewerPath, createServerLog, createProxyLog, crede
           return;
         }
         if (url === "/api/bundle") {
-          const bundlePath = join7(process.cwd(), ".kizenapp", "bundle.json");
+          const bundlePath = join9(process.cwd(), ".kizenapp", "bundle.json");
           try {
             const content = await readFile4(bundlePath, "utf-8");
             res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
@@ -901,36 +1389,31 @@ function createRequestHandler(viewerPath, createServerLog, createProxyLog, crede
             res.end(JSON.stringify({ error: "Missing required field: script" }));
             return;
           }
-          let result;
-          if (body.mode === "remote") {
-            if (!credentialsRef.current) {
-              res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
-              res.end(JSON.stringify({ error: "Credentials are required for remote execution" }));
-              return;
-            }
-            result = await executeRemoteStep(
-              {
-                script: body.script,
-                scriptRuntime: body.scriptRuntime ?? "python-3-12",
-                inputs: body.inputs ?? {},
-                inputTypes: body.inputTypes ?? {},
-                outputTypes: body.outputTypes ?? {},
-                secretNames: body.secretNames ?? []
-              },
-              credentialsRef.current
-            );
-          } else {
-            const stepParams = {
-              script: body.script,
-              scriptRuntime: body.scriptRuntime ?? "python-3.9",
-              inputs: body.inputs ?? {},
-              secrets: body.secrets ?? {}
-            };
-            if (typeof body.timeout === "number") {
-              stepParams.timeout = body.timeout;
+          const stepParams = {
+            script: body.script,
+            scriptRuntime: body.scriptRuntime ?? "python-3.9",
+            inputs: body.inputs ?? {},
+            secrets: body.secrets ?? {},
+            onInstallProgress: (event) => {
+              if (event.kind === "start") {
+                broadcast({ type: "venv-install-start" });
+              } else if (event.kind === "log") {
+                broadcast({
+                  type: "venv-install-log",
+                  line: event.line,
+                  stream: event.stream
+                });
+              } else if (event.kind === "complete") {
+                broadcast({ type: "venv-install-complete" });
+              } else {
+                broadcast({ type: "venv-install-error", message: event.message });
+              }
             }
-            result = await executePythonStep(stepParams);
+          };
+          if (typeof body.timeout === "number") {
+            stepParams.timeout = body.timeout;
           }
+          const result = await executePythonStep(stepParams);
           res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
           res.end(JSON.stringify(result));
           return;
@@ -998,9 +1481,113 @@ function createRequestHandler(viewerPath, createServerLog, createProxyLog, crede
           res.end(Buffer.from(await upstream.arrayBuffer()));
           return;
         }
+        if (url.startsWith("/api/source/tree") && req.method === "GET") {
+          const query = new URL(url, "http://localhost").searchParams;
+          const relParam = query.get("path") ?? "";
+          const abs = resolveSafePath(pluginDir, relParam);
+          if (abs === null) {
+            res.writeHead(403, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: "Invalid path" }));
+            return;
+          }
+          if (isInsideSkippedDir(pluginDir, abs)) {
+            res.writeHead(403, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: "Path is excluded" }));
+            return;
+          }
+          try {
+            const dirEntries = await readdir3(abs, { withFileTypes: true });
+            const entries = await Promise.all(
+              dirEntries.filter((entry) => {
+                if (entry.isDirectory()) {
+                  return !SKIP_DIRS.has(entry.name);
+                }
+                if (entry.isFile()) {
+                  return !SKIP_FILES.has(entry.name);
+                }
+                return false;
+              }).map(async (entry) => {
+                const kind = entry.isDirectory() ? "dir" : "file";
+                const result = {
+                  name: entry.name,
+                  kind
+                };
+                if (kind === "file") {
+                  try {
+                    const stats = await stat(join9(abs, entry.name));
+                    result.size = stats.size;
+                  } catch {
+                  }
+                }
+                return result;
+              })
+            );
+            entries.sort((a, b) => {
+              if (a.kind !== b.kind) {
+                return a.kind === "dir" ? -1 : 1;
+              }
+              return a.name.localeCompare(b.name);
+            });
+            const normalizedPath = abs === pluginDir ? "" : abs.slice(pluginDir.length + 1);
+            res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ path: normalizedPath, entries }));
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.writeHead(404, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: message }));
+          }
+          return;
+        }
+        if (url.startsWith("/api/source/file") && req.method === "GET") {
+          const query = new URL(url, "http://localhost").searchParams;
+          const relParam = query.get("path") ?? "";
+          if (relParam === "") {
+            res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: "Missing path" }));
+            return;
+          }
+          const abs = resolveSafePath(pluginDir, relParam);
+          if (abs === null) {
+            res.writeHead(403, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: "Invalid path" }));
+            return;
+          }
+          if (isInsideSkippedDir(pluginDir, abs)) {
+            res.writeHead(403, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: "Path is excluded" }));
+            return;
+          }
+          try {
+            const stats = await stat(abs);
+            if (!stats.isFile()) {
+              res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+              res.end(JSON.stringify({ error: "Not a file" }));
+              return;
+            }
+            if (stats.size > SOURCE_FILE_MAX_BYTES) {
+              res.writeHead(413, { "Content-Type": "application/json; charset=utf-8" });
+              res.end(JSON.stringify({ error: "File too large", size: stats.size }));
+              return;
+            }
+            const ext2 = extname(abs).toLowerCase();
+            const explicitMime = MIME_TYPES[ext2];
+            const isKnownText = TEXT_EXTENSIONS.has(ext2);
+            const contentType = explicitMime ?? (isKnownText ? "text/plain; charset=utf-8" : "application/octet-stream");
+            res.writeHead(200, {
+              "Content-Type": contentType,
+              "Content-Length": String(stats.size)
+            });
+            createReadStream(abs).pipe(res);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.writeHead(404, { "Content-Type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: message }));
+          }
+          return;
+        }
         const rawPath = url === "/" ? "/index.html" : url;
-        const filePath = join7(viewerPath, rawPath);
-        const resolvedPath = await fileExists(filePath) ? filePath : join7(viewerPath, "index.html");
+        const filePath = join9(viewerPath, rawPath);
+        const resolvedPath = await fileExists(filePath) ? filePath : join9(viewerPath, "index.html");
         const ext = extname(resolvedPath);
         const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
         res.writeHead(200, { "Content-Type": mimeType });
@@ -1034,7 +1621,7 @@ import { launch } from "chrome-launcher";
 import { createRequire } from "module";
 import { mkdirSync } from "fs";
 import { readFile as readFile5 } from "fs/promises";
-import { dirname as dirname3, join as join8 } from "path";
+import { dirname as dirname3, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CDP = createRequire(import.meta.url)("chrome-remote-interface");
 var CSP_HEADERS = /* @__PURE__ */ new Set([
@@ -1113,7 +1700,7 @@ async function serializeArgAsync(client, arg) {
 }
 async function installDockIcon(client) {
   try {
-    const iconPath = join8(dirname3(fileURLToPath2(import.meta.url)), "viewer", "icon.png");
+    const iconPath = join10(dirname3(fileURLToPath2(import.meta.url)), "viewer", "icon.png");
     const icon = await readFile5(iconPath);
     await client.Browser.setDockTile({ image: icon.toString("base64") });
   } catch {
@@ -1134,19 +1721,261 @@ async function launchChromeViewer(opts) {
     handleSIGINT: false,
     logLevel: "silent"
   });
+  const cdpPort = chrome.port;
   let client = null;
   let cookieTimer = null;
-  const cdpPort = chrome.port;
+  let mainTargetId = null;
+  let reconnectTimer = null;
+  let reconnectAttempt = 0;
+  let killed = false;
+  const dbg = (msg) => {
+    opts.debugLog?.(msg);
+  };
+  const vb = (msg) => {
+    if (opts.verbose) {
+      opts.debugLog?.(msg);
+    }
+  };
+  const clearCookieTimer = () => {
+    if (cookieTimer !== null) {
+      clearInterval(cookieTimer);
+      cookieTimer = null;
+    }
+  };
+  const isNewTabUrl = (url) => url === "chrome://new-tab-page/" || url === "chrome://newtab/";
+  const setupClient = async (c) => {
+    clearCookieTimer();
+    mainTargetId = null;
+    await installDockIcon(c);
+    await c.Fetch.enable({
+      patterns: KIZEN_DOMAINS.flatMap((d) => [
+        { urlPattern: `*://${d}/*`, requestStage: "Response" },
+        { urlPattern: `*://*.${d}/*`, requestStage: "Response" }
+      ])
+    });
+    c.on("Fetch.requestPaused", (rawParams) => {
+      void (async () => {
+        const params = rawParams;
+        const { requestId, request, responseHeaders, responseStatusCode } = params;
+        const url = request.url;
+        vb(`Fetch ${String(responseStatusCode ?? "?")} ${url}`);
+        const filtered = [];
+        let rewroteSetCookie = false;
+        for (const h of responseHeaders ?? []) {
+          if (CSP_HEADERS.has(h.name.toLowerCase())) {
+            continue;
+          }
+          if (h.name.toLowerCase() === "set-cookie" && isKizenUrl(url)) {
+            const patched = h.value.split("\n").map((cookie) => {
+              if (!/SameSite=/i.test(cookie)) {
+                return cookie + "; SameSite=None; Secure";
+              }
+              return cookie.replace(/SameSite=\w+/i, "SameSite=None");
+            }).join("\n");
+            filtered.push({ name: h.name, value: patched });
+            rewroteSetCookie = true;
+          } else {
+            filtered.push(h);
+          }
+        }
+        if (rewroteSetCookie) {
+          vb(`  rewrote Set-Cookie SameSite on ${url}`);
+        }
+        try {
+          const { body, base64Encoded } = await c.Fetch.getResponseBody({ requestId });
+          await c.Fetch.fulfillRequest({
+            requestId,
+            responseCode: responseStatusCode ?? 200,
+            responseHeaders: filtered,
+            body,
+            ...base64Encoded && { base64Encoded: true }
+          });
+        } catch (e) {
+          vb(`  fulfillRequest failed (${e.message}), falling through`);
+          try {
+            await c.Fetch.continueRequest({ requestId });
+          } catch (e2) {
+            vb(`  continueRequest also failed (${e2.message})`);
+          }
+        }
+      })();
+    });
+    cookieTimer = setInterval(() => {
+      void (async () => {
+        try {
+          const { cookies } = await c.Network.getAllCookies();
+          let patched = 0;
+          for (const cookie of cookies) {
+            if (!isKizenUrl(`https://${cookie.domain ?? ""}`)) {
+              continue;
+            }
+            if (cookie.sameSite === "None") {
+              continue;
+            }
+            const raw = cookie.domain ?? "";
+            const bare = raw.startsWith(".") ? raw.slice(1) : raw;
+            await c.Network.setCookie({
+              url: `https://${bare}`,
+              name: cookie.name,
+              value: cookie.value,
+              domain: raw,
+              path: cookie.path ?? "/",
+              secure: true,
+              ...cookie.httpOnly !== void 0 && { httpOnly: cookie.httpOnly },
+              ...cookie.expirationDate !== void 0 && {
+                expires: cookie.expirationDate
+              },
+              sameSite: "None"
+            });
+            patched++;
+          }
+          if (patched > 0) {
+            vb(`cookie-patch cycle: updated ${String(patched)} cookie(s) to SameSite=None`);
+          }
+        } catch (e) {
+          vb(`cookie-patch cycle failed: ${e.message}`);
+        }
+      })();
+    }, 2e3);
+    await c.send("Runtime.enable", { generatePreview: true });
+    c.on("Target.attachedToTarget", (rawParams) => {
+      const params = rawParams;
+      const { sessionId, targetInfo } = params;
+      vb(`attached session ${sessionId} (${targetInfo.type} ${targetInfo.url})`);
+      void c.send("Runtime.enable", { generatePreview: true }, sessionId).catch((e) => {
+        vb(`  Runtime.enable on session ${sessionId} failed: ${e.message}`);
+      });
+    });
+    await c.Target.setAutoAttach({
+      autoAttach: true,
+      waitForDebuggerOnStart: false,
+      flatten: true
+    });
+    await c.Target.setDiscoverTargets({ discover: true });
+    const handleTarget = (targetInfo) => {
+      if (targetInfo.type !== "page") {
+        return;
+      }
+      if (isNewTabUrl(targetInfo.url)) {
+        dbg(`closed stray new-tab-page target ${targetInfo.targetId}`);
+        if (mainTargetId !== null) {
+          void c.Target.activateTarget({ targetId: mainTargetId }).catch(() => {
+          });
+        }
+        void c.Target.closeTarget({ targetId: targetInfo.targetId }).catch(() => {
+        });
+        return;
+      }
+      if (mainTargetId === null) {
+        mainTargetId = targetInfo.targetId;
+        dbg(`captured main target ${targetInfo.targetId} (${targetInfo.url})`);
+      }
+    };
+    c.on("Target.targetCreated", (rawParams) => {
+      const { targetInfo } = rawParams;
+      vb(`target +${targetInfo.type} ${targetInfo.targetId} ${targetInfo.url}`);
+      handleTarget(targetInfo);
+    });
+    c.on("Target.targetInfoChanged", (rawParams) => {
+      const { targetInfo } = rawParams;
+      vb(`target ~${targetInfo.type} ${targetInfo.targetId} ${targetInfo.url}`);
+      handleTarget(targetInfo);
+    });
+    c.on("Runtime.consoleAPICalled", (rawParams) => {
+      void (async () => {
+        const { type, args } = rawParams;
+        if (args[0]?.type === "string" && String(args[0].value).includes("Chrome Security")) {
+          return;
+        }
+        const level = type === "warning" ? "warn" : ["log", "warn", "error", "info"].includes(type) ? type : "log";
+        vb(`console.${level} (${String(args.length)} arg(s))`);
+        const serialized = await Promise.all(args.map((arg) => serializeArgAsync(c, arg)));
+        opts.broadcast({ type: "console-message", level, args: serialized });
+      })().catch((e) => {
+        vb(`console serialization failed: ${e.message}`);
+      });
+    });
+    c.on("disconnect", () => {
+      if (killed || client !== c) {
+        return;
+      }
+      dbg("CDP disconnected");
+      client = null;
+      clearCookieTimer();
+      scheduleReconnect();
+    });
+  };
+  const scheduleReconnect = () => {
+    if (killed || reconnectTimer !== null) {
+      return;
+    }
+    const delay = Math.min(1e3 * 2 ** reconnectAttempt, 1e4);
+    const attemptNumber = reconnectAttempt + 1;
+    reconnectAttempt++;
+    dbg(`CDP reconnect scheduled in ${String(delay)}ms (attempt #${String(attemptNumber)})`);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      void (async () => {
+        let c;
+        try {
+          c = await CDP({ port: cdpPort });
+        } catch {
+          dbg(`CDP reconnect attempt #${String(attemptNumber)} failed`);
+          scheduleReconnect();
+          return;
+        }
+        if (killed) {
+          try {
+            await c.close();
+          } catch {
+          }
+          return;
+        }
+        client = c;
+        try {
+          await setupClient(c);
+          dbg(`CDP reconnected after ${String(attemptNumber)} attempt(s)`);
+          reconnectAttempt = 0;
+        } catch {
+          if (client === c) {
+            client = null;
+          }
+          try {
+            await c.close();
+          } catch {
+          }
+          dbg(`CDP reconnect attempt #${String(attemptNumber)} failed during setup`);
+          scheduleReconnect();
+        }
+      })();
+    }, delay);
+  };
   for (let attempt = 0; attempt < 10; attempt++) {
     await new Promise((r) => setTimeout(r, 300));
+    dbg(`CDP connect attempt ${String(attempt + 1)}/10`);
     try {
-      client = await CDP({ port: cdpPort });
+      const c = await CDP({ port: cdpPort });
+      client = c;
       if (opts.path) {
-        void client.send("Page.navigate", { url: `${baseUrl}${opts.path}` });
+        void c.send("Page.navigate", { url: `${baseUrl}${opts.path}` });
+      }
+      try {
+        await setupClient(c);
+        dbg("CDP connected");
+      } catch {
+        if (client === c) {
+          client = null;
+        }
+        try {
+          await c.close();
+        } catch {
+        }
+        dbg("CDP setup failed after connect");
       }
       break;
     } catch {
       if (attempt === 9) {
+        dbg("CDP unavailable after 10 attempts \u2014 viewer will run without interception");
         return {
           kill: () => {
             chrome.kill();
@@ -1162,120 +1991,20 @@ async function launchChromeViewer(opts) {
       }
     };
   }
-  const c = client;
-  await installDockIcon(c);
-  await c.Fetch.enable({
-    patterns: KIZEN_DOMAINS.flatMap((d) => [
-      { urlPattern: `*://${d}/*`, requestStage: "Response" },
-      { urlPattern: `*://*.${d}/*`, requestStage: "Response" }
-    ])
-  });
-  c.on("Fetch.requestPaused", (rawParams) => {
-    void (async () => {
-      const params = rawParams;
-      const { requestId, request, responseHeaders, responseStatusCode } = params;
-      const url = request.url;
-      const filtered = [];
-      for (const h of responseHeaders ?? []) {
-        if (CSP_HEADERS.has(h.name.toLowerCase())) {
-          continue;
-        }
-        if (h.name.toLowerCase() === "set-cookie" && isKizenUrl(url)) {
-          const patched = h.value.split("\n").map((cookie) => {
-            if (!/SameSite=/i.test(cookie)) {
-              return cookie + "; SameSite=None; Secure";
-            }
-            return cookie.replace(/SameSite=\w+/i, "SameSite=None");
-          }).join("\n");
-          filtered.push({ name: h.name, value: patched });
-        } else {
-          filtered.push(h);
-        }
-      }
-      try {
-        const { body, base64Encoded } = await c.Fetch.getResponseBody({ requestId });
-        await c.Fetch.fulfillRequest({
-          requestId,
-          responseCode: responseStatusCode ?? 200,
-          responseHeaders: filtered,
-          body,
-          ...base64Encoded && { base64Encoded: true }
-        });
-      } catch {
-        try {
-          await c.Fetch.continueRequest({ requestId });
-        } catch {
-        }
-      }
-    })();
-  });
-  cookieTimer = setInterval(() => {
-    void (async () => {
+  const kill = () => {
+    dbg("CDP kill requested \u2014 tearing down");
+    killed = true;
+    if (reconnectTimer !== null) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    clearCookieTimer();
+    if (client !== null) {
       try {
-        const { cookies } = await c.Network.getAllCookies();
-        for (const cookie of cookies) {
-          if (!isKizenUrl(`https://${cookie.domain ?? ""}`)) {
-            continue;
-          }
-          if (cookie.sameSite === "None") {
-            continue;
-          }
-          const raw = cookie.domain ?? "";
-          const bare = raw.startsWith(".") ? raw.slice(1) : raw;
-          await c.Network.setCookie({
-            url: `https://${bare}`,
-            name: cookie.name,
-            value: cookie.value,
-            domain: raw,
-            path: cookie.path ?? "/",
-            secure: true,
-            ...cookie.httpOnly !== void 0 && { httpOnly: cookie.httpOnly },
-            ...cookie.expirationDate !== void 0 && {
-              expires: cookie.expirationDate
-            },
-            sameSite: "None"
-          });
-        }
+        void client.close();
       } catch {
       }
-    })();
-  }, 2e3);
-  await c.send("Runtime.enable", { generatePreview: true });
-  c.on("Target.attachedToTarget", (rawParams) => {
-    const { sessionId } = rawParams;
-    void c.send("Runtime.enable", { generatePreview: true }, sessionId).catch(() => {
-    });
-  });
-  await c.Target.setAutoAttach({
-    autoAttach: true,
-    waitForDebuggerOnStart: false,
-    flatten: true
-  });
-  await c.Target.setDiscoverTargets({ discover: true });
-  c.on("Target.targetCreated", (rawParams) => {
-    const { targetInfo } = rawParams;
-    if (targetInfo.type === "page" && targetInfo.url === "chrome://newtab/") {
-      void c.Target.closeTarget({ targetId: targetInfo.targetId }).catch(() => {
-      });
-    }
-  });
-  c.on("Runtime.consoleAPICalled", (rawParams) => {
-    void (async () => {
-      const { type, args } = rawParams;
-      if (args[0]?.type === "string" && String(args[0].value).includes("Chrome Security")) {
-        return;
-      }
-      const level = type === "warning" ? "warn" : ["log", "warn", "error", "info"].includes(type) ? type : "log";
-      const serialized = await Promise.all(args.map((arg) => serializeArgAsync(c, arg)));
-      opts.broadcast({ type: "console-message", level, args: serialized });
-    })().catch(() => {
-    });
-  });
-  const kill = () => {
-    clearInterval(cookieTimer);
-    try {
-      void c.close();
-    } catch {
+      client = null;
     }
     chrome.kill();
   };
@@ -1283,10 +2012,10 @@ async function launchChromeViewer(opts) {
 }
 
 // src/hooks/useLogHistory.ts
-import { useCallback, useState as useState3 } from "react";
+import { useCallback as useCallback2, useState as useState4 } from "react";
 function useLogHistory(limit) {
-  const [history, setHistory] = useState3([]);
-  const append = useCallback(
+  const [history, setHistory] = useState4([]);
+  const append = useCallback2(
     (message) => {
       setHistory((h) => [...h, `${(/* @__PURE__ */ new Date()).toLocaleTimeString()}: ${message}`].slice(-limit));
     },
@@ -1296,29 +2025,29 @@ function useLogHistory(limit) {
 }
 
 // src/ui/CredentialSetupUI.tsx
-import { useCallback as useCallback2, useEffect as useEffect3, useState as useState4 } from "react";
-import { Box as Box4, Text as Text5, useInput } from "ink";
-import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
-var FIELDS = ["apiKey", "userId", "businessId"];
-var FIELD_LABELS = {
+import { useCallback as useCallback3, useEffect as useEffect3, useState as useState5 } from "react";
+import { Box as Box5, Text as Text6, useInput as useInput2 } from "ink";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var FIELDS2 = ["apiKey", "userId", "businessId"];
+var FIELD_LABELS2 = {
   apiKey: "API Key",
   userId: "User ID",
   businessId: "Business ID"
 };
-var Hint = ({ text }) => /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: text });
+var Hint2 = ({ text }) => /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: text });
 var CredentialSetupUI = ({
   initialMode,
   showProfileManager,
   onComplete,
   onCancel
 }) => {
-  const [phase, setPhase] = useState4(
+  const [phase, setPhase] = useState5(
     initialMode === "global" && !showProfileManager ? { type: "loading" } : initialMode === "global" && showProfileManager ? { type: "profile-loading" } : { type: "mode-select", cursor: 0 }
   );
-  const [inputBuffer, setInputBuffer] = useState4("");
-  const [error, setError] = useState4(null);
-  const [activeProfileName, setActiveProfileName] = useState4(void 0);
-  const handleModeChosen = useCallback2(
+  const [inputBuffer, setInputBuffer] = useState5("");
+  const [error, setError] = useState5(null);
+  const [activeProfileName, setActiveProfileName] = useState5(void 0);
+  const handleModeChosen = useCallback3(
     (mode) => {
       if (mode === "local") {
         onComplete({ mode: "local", credentials: null });
@@ -1328,7 +2057,7 @@ var CredentialSetupUI = ({
     },
     [onComplete]
   );
-  const handleProfileChosen = useCallback2(async (profile) => {
+  const handleProfileChosen = useCallback3(async (profile) => {
     if (profile === null) {
       setPhase({ type: "profile-loading" });
       const profiles = await listCredentialProfiles();
@@ -1341,7 +2070,7 @@ var CredentialSetupUI = ({
     const envCursor2 = existing ? Math.max(0, ENVIRONMENTS.indexOf(existing.environment)) : 0;
     setPhase({ type: "creds-entry", field: 0, values: existing ?? {}, envCursor: envCursor2 });
   }, []);
-  const handleSave = useCallback2(
+  const handleSave = useCallback3(
     async (values2, envCursor2) => {
       const environment = ENVIRONMENTS[envCursor2] ?? "go";
       const credentials = {
@@ -1366,7 +2095,7 @@ var CredentialSetupUI = ({
     },
     [onComplete, activeProfileName]
   );
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (key.ctrl && input === "c") {
       process.exit(0);
     }
@@ -1440,7 +2169,7 @@ var CredentialSetupUI = ({
     }
     if (phase.type === "creds-entry") {
       const { field, values: values2, envCursor: envCursor2 } = phase;
-      const isEnvField2 = field === FIELDS.length;
+      const isEnvField2 = field === FIELDS2.length;
       if (isEnvField2) {
         if (key.leftArrow) {
           setPhase({
@@ -1451,13 +2180,13 @@ var CredentialSetupUI = ({
           setPhase({ ...phase, envCursor: (envCursor2 + 1) % ENVIRONMENTS.length });
         } else if (key.upArrow) {
           setPhase({ ...phase, field: field - 1 });
-          setInputBuffer(values2[FIELDS[field - 1]] ?? "");
+          setInputBuffer(values2[FIELDS2[field - 1]] ?? "");
         } else if (key.return) {
           void handleSave(values2, envCursor2);
         }
         return;
       }
-      const fieldName = FIELDS[field];
+      const fieldName = FIELDS2[field];
       if (!fieldName) {
         return;
       }
@@ -1467,13 +2196,13 @@ var CredentialSetupUI = ({
         const updatedValues = { ...values2, [fieldName]: inputBuffer };
         const prevField = field - 1;
         setPhase({ ...phase, field: prevField, values: updatedValues });
-        setInputBuffer(updatedValues[FIELDS[prevField]] ?? "");
+        setInputBuffer(updatedValues[FIELDS2[prevField]] ?? "");
       } else if (key.return || key.tab || key.downArrow) {
         const updatedValues = { ...values2, [fieldName]: inputBuffer };
         const nextField = field + 1;
         setPhase({ ...phase, field: nextField, values: updatedValues });
-        if (nextField < FIELDS.length) {
-          setInputBuffer(updatedValues[FIELDS[nextField]] ?? "");
+        if (nextField < FIELDS2.length) {
+          setInputBuffer(updatedValues[FIELDS2[nextField]] ?? "");
         } else {
           setInputBuffer("");
         }
@@ -1482,7 +2211,7 @@ var CredentialSetupUI = ({
       }
     }
   });
-  const loadProfileList = useCallback2(async () => {
+  const loadProfileList = useCallback3(async () => {
     const profiles = await listCredentialProfiles();
     setPhase({ type: "profile-select", profiles, cursor: 0 });
   }, []);
@@ -1507,7 +2236,7 @@ var CredentialSetupUI = ({
   }, [phase.type]);
   if (phase.type === "loading" || phase.type === "saving" || phase.type === "profile-loading") {
     const label = phase.type === "saving" ? "Saving credentials\u2026" : phase.type === "profile-loading" ? "Loading profiles\u2026" : "Loading credentials\u2026";
-    return /* @__PURE__ */ jsx5(Box4, { paddingY: 1, paddingX: 2, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: label }) });
+    return /* @__PURE__ */ jsx6(Box5, { paddingY: 1, paddingX: 2, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: label }) });
   }
   if (phase.type === "done") {
     return null;
@@ -1517,41 +2246,41 @@ var CredentialSetupUI = ({
       { label: "Global", desc: `~/.kizenappbuilder/credentials.json`, mode: "global" },
       { label: "Local", desc: "Enter credentials in the browser dev tools", mode: "local" }
     ];
-    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
-      /* @__PURE__ */ jsx5(AppHeader, {}),
-      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
-        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Credential mode" }),
+    return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx6(AppHeader, {}),
+      /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Credential mode" }),
         options.map((opt, i) => {
           const selected = phase.cursor === i;
-          return /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
-            /* @__PURE__ */ jsx5(Text5, { ...selected && { color: "cyan" }, children: selected ? "\u276F" : " " }),
-            /* @__PURE__ */ jsx5(Text5, { bold: selected, ...selected && { color: "cyan" }, children: opt.label }),
-            /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: opt.desc })
+          return /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
+            /* @__PURE__ */ jsx6(Text6, { ...selected && { color: "cyan" }, children: selected ? "\u276F" : " " }),
+            /* @__PURE__ */ jsx6(Text6, { bold: selected, ...selected && { color: "cyan" }, children: opt.label }),
+            /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: opt.desc })
           ] }, opt.mode);
         })
       ] }),
-      /* @__PURE__ */ jsx5(Hint, { text: "\u2191\u2193 to move \xB7 Enter to select \xB7 Ctrl+C to quit" })
+      /* @__PURE__ */ jsx6(Hint2, { text: "\u2191\u2193 to move \xB7 Enter to select \xB7 Ctrl+C to quit" })
     ] });
   }
   if (phase.type === "profile-select") {
     const { profiles, cursor } = phase;
     const addNewIdx = profiles.length;
-    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
-      /* @__PURE__ */ jsx5(AppHeader, {}),
-      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
-        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Credential profiles" }),
+    return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx6(AppHeader, {}),
+      /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", gap: 0, children: [
+        /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Credential profiles" }),
         profiles.map((profile, i) => {
           const selected = cursor === i;
-          return /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
-            /* @__PURE__ */ jsx5(Text5, { ...selected && { color: "cyan" }, children: selected ? "\u276F" : " " }),
-            /* @__PURE__ */ jsx5(Text5, { bold: selected, ...selected && { color: "cyan" }, children: profile.isDefault ? "Default" : profile.name }),
-            /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: profile.path })
+          return /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
+            /* @__PURE__ */ jsx6(Text6, { ...selected && { color: "cyan" }, children: selected ? "\u276F" : " " }),
+            /* @__PURE__ */ jsx6(Text6, { bold: selected, ...selected && { color: "cyan" }, children: profile.isDefault ? "Default" : profile.name }),
+            /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: profile.path })
           ] }, profile.name);
         }),
-        /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
-          /* @__PURE__ */ jsx5(Text5, { ...cursor === addNewIdx && { color: "cyan" }, children: cursor === addNewIdx ? "\u276F" : " " }),
-          /* @__PURE__ */ jsx5(
-            Text5,
+        /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
+          /* @__PURE__ */ jsx6(Text6, { ...cursor === addNewIdx && { color: "cyan" }, children: cursor === addNewIdx ? "\u276F" : " " }),
+          /* @__PURE__ */ jsx6(
+            Text6,
             {
               bold: cursor === addNewIdx,
               ...cursor === addNewIdx && { color: "cyan" },
@@ -1560,69 +2289,69 @@ var CredentialSetupUI = ({
           )
         ] })
       ] }),
-      /* @__PURE__ */ jsx5(Hint, { text: "\u2191\u2193 to move \xB7 Enter to select \xB7 Esc to cancel" })
+      /* @__PURE__ */ jsx6(Hint2, { text: "\u2191\u2193 to move \xB7 Enter to select \xB7 Esc to cancel" })
     ] });
   }
   if (phase.type === "name-entry") {
     const { nameBuffer, nameError } = phase;
-    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
-      /* @__PURE__ */ jsx5(AppHeader, {}),
-      /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", gap: 0, children: /* @__PURE__ */ jsx5(Text5, { bold: true, children: "New credential profile" }) }),
-      nameError && /* @__PURE__ */ jsxs3(Text5, { color: "red", children: [
+    return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx6(AppHeader, {}),
+      /* @__PURE__ */ jsx6(Box5, { flexDirection: "column", gap: 0, children: /* @__PURE__ */ jsx6(Text6, { bold: true, children: "New credential profile" }) }),
+      nameError && /* @__PURE__ */ jsxs4(Text6, { color: "red", children: [
         "Error: ",
         nameError
       ] }),
-      /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
-        /* @__PURE__ */ jsx5(Box4, { width: 12, children: /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: "Profile name" }) }),
-        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: ">" }),
-        /* @__PURE__ */ jsx5(Text5, { children: nameBuffer }),
-        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "\u2588" })
+      /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
+        /* @__PURE__ */ jsx6(Box5, { width: 12, children: /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: "Profile name" }) }),
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: ">" }),
+        /* @__PURE__ */ jsx6(Text6, { children: nameBuffer }),
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "\u2588" })
       ] }),
-      /* @__PURE__ */ jsx5(Hint, { text: "Type a name \xB7 Enter to confirm \xB7 Esc to go back" })
+      /* @__PURE__ */ jsx6(Hint2, { text: "Type a name \xB7 Enter to confirm \xB7 Esc to go back" })
     ] });
   }
   const { field: activeField, values, envCursor } = phase;
-  const isEnvField = activeField === FIELDS.length;
+  const isEnvField = activeField === FIELDS2.length;
   const profileLabel = activeProfileName ?? DEFAULT_PROFILE_NAME;
-  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
-    /* @__PURE__ */ jsx5(AppHeader, {}),
-    /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: activeProfileName !== void 0 ? `Profile: ${activeProfileName}` : "Global credentials" }),
-      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingY: 1, paddingX: 2, gap: 1, children: [
+    /* @__PURE__ */ jsx6(AppHeader, {}),
+    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", gap: 0, children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: activeProfileName !== void 0 ? `Profile: ${activeProfileName}` : "Global credentials" }),
+      /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
         "Saved to:",
         " ",
         activeProfileName !== void 0 ? `~/.kizenappbuilder/${activeProfileName}.json` : GLOBAL_CREDENTIALS_PATH
       ] })
     ] }),
-    error && /* @__PURE__ */ jsxs3(Text5, { color: "red", children: [
+    error && /* @__PURE__ */ jsxs4(Text6, { color: "red", children: [
       "Error: ",
       error
     ] }),
-    /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 0, children: [
-      FIELDS.map((name, i) => {
+    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", gap: 0, children: [
+      FIELDS2.map((name, i) => {
         const isActive = activeField === i;
         const displayValue = isActive ? inputBuffer : values[name] ?? "";
-        return /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
-          /* @__PURE__ */ jsx5(Box4, { width: 12, children: /* @__PURE__ */ jsx5(Text5, { bold: isActive, ...isActive && { color: "cyan" }, children: FIELD_LABELS[name] }) }),
-          /* @__PURE__ */ jsx5(Text5, { ...isActive && { color: "cyan" }, children: ">" }),
-          /* @__PURE__ */ jsx5(Text5, { children: displayValue }),
-          isActive && /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "\u2588" })
+        return /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
+          /* @__PURE__ */ jsx6(Box5, { width: 12, children: /* @__PURE__ */ jsx6(Text6, { bold: isActive, ...isActive && { color: "cyan" }, children: FIELD_LABELS2[name] }) }),
+          /* @__PURE__ */ jsx6(Text6, { ...isActive && { color: "cyan" }, children: ">" }),
+          /* @__PURE__ */ jsx6(Text6, { children: displayValue }),
+          isActive && /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "\u2588" })
         ] }, name);
       }),
-      /* @__PURE__ */ jsxs3(Box4, { gap: 2, children: [
-        /* @__PURE__ */ jsx5(Box4, { width: 12, children: /* @__PURE__ */ jsx5(Text5, { bold: isEnvField, ...isEnvField && { color: "cyan" }, children: "Environment" }) }),
-        /* @__PURE__ */ jsx5(Text5, { ...isEnvField && { color: "cyan" }, children: ">" }),
-        /* @__PURE__ */ jsx5(Box4, { gap: 1, children: ENVIRONMENTS.map((env, i) => {
+      /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
+        /* @__PURE__ */ jsx6(Box5, { width: 12, children: /* @__PURE__ */ jsx6(Text6, { bold: isEnvField, ...isEnvField && { color: "cyan" }, children: "Environment" }) }),
+        /* @__PURE__ */ jsx6(Text6, { ...isEnvField && { color: "cyan" }, children: ">" }),
+        /* @__PURE__ */ jsx6(Box5, { gap: 1, children: ENVIRONMENTS.map((env, i) => {
           const isSelected = i === envCursor;
           if (isEnvField) {
-            return /* @__PURE__ */ jsx5(Text5, { bold: isSelected, ...isSelected && { color: "cyan" }, children: isSelected ? `[${env}]` : env }, env);
+            return /* @__PURE__ */ jsx6(Text6, { bold: isSelected, ...isSelected && { color: "cyan" }, children: isSelected ? `[${env}]` : env }, env);
           }
-          return /* @__PURE__ */ jsx5(Text5, { dimColor: !isSelected, bold: isSelected, children: env }, env);
+          return /* @__PURE__ */ jsx6(Text6, { dimColor: !isSelected, bold: isSelected, children: env }, env);
         }) })
       ] })
     ] }),
-    isEnvField ? /* @__PURE__ */ jsx5(Hint, { text: "\u2190\u2192 to select \xB7 \u2191\u2193 to move \xB7 Enter to save \xB7 Esc to cancel" }) : /* @__PURE__ */ jsx5(Hint, { text: "\u2191\u2193 to move \xB7 Backspace to delete \xB7 Esc to cancel" }),
-    /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+    isEnvField ? /* @__PURE__ */ jsx6(Hint2, { text: "\u2190\u2192 to select \xB7 \u2191\u2193 to move \xB7 Enter to save \xB7 Esc to cancel" }) : /* @__PURE__ */ jsx6(Hint2, { text: "\u2191\u2193 to move \xB7 Backspace to delete \xB7 Esc to cancel" }),
+    /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
       "Profile: ",
       profileLabel
     ] })
@@ -1630,7 +2359,7 @@ var CredentialSetupUI = ({
 };
 
 // src/ui/DevUI.tsx
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 var SKIP_WATCH_PREFIXES = [".kizenapp", ".git"];
 var DevUI = ({
   port,
@@ -1639,35 +2368,38 @@ var DevUI = ({
   credentials: initialCredentials,
   credentialMode: initialCredentialMode,
   activeCredentialProfile: initialActiveProfile,
-  lastPath: initialLastPath
+  lastPath: initialLastPath,
+  debug = false,
+  verbose = false
 }) => {
   const credentialsRef = useRef(initialCredentials);
   const activeProfileRef = useRef(initialActiveProfile);
   const lastPathRef = useRef(initialLastPath);
-  const [credMode, setCredMode] = useState5("main");
-  const [credentialMode, setCredentialMode] = useState5(
+  const [credMode, setCredMode] = useState6("main");
+  const [credentialMode, setCredentialMode] = useState6(
     initialCredentialMode
   );
-  const [status, setStatus] = useState5("starting");
-  const [errorMessage, setErrorMessage] = useState5(null);
+  const [status, setStatus] = useState6("starting");
+  const [errorMessage, setErrorMessage] = useState6(null);
   const [serverLogHistory, appendServerLog] = useLogHistory(LOG_LIMIT);
   const [buildLogHistory, appendBuildLog] = useLogHistory(LOG_LIMIT);
-  const [proxyLogHistory, setProxyLogHistory] = useState5([]);
-  const [buildStatus, setBuildStatus] = useState5("pending");
-  const [buildError, setBuildError] = useState5(null);
-  const [lastBuilt, setLastBuilt] = useState5(null);
-  const [lastBundleSize, setLastBundleSize] = useState5(null);
-  const [wsClientCount, setWsClientCount] = useState5(0);
-  const [proxyCacheSize, setProxyCacheSize] = useState5(0);
-  const [proxyCacheHits, setProxyCacheHits] = useState5(0);
-  const [proxyCacheMisses, setProxyCacheMisses] = useState5(0);
+  const [cdpLogHistory, appendCdpLog] = useLogHistory(LOG_LIMIT);
+  const [proxyLogHistory, setProxyLogHistory] = useState6([]);
+  const [buildStatus, setBuildStatus] = useState6("pending");
+  const [buildError, setBuildError] = useState6(null);
+  const [lastBuilt, setLastBuilt] = useState6(null);
+  const [lastBundleSize, setLastBundleSize] = useState6(null);
+  const [wsClientCount, setWsClientCount] = useState6(0);
+  const [proxyCacheSize, setProxyCacheSize] = useState6(0);
+  const [proxyCacheHits, setProxyCacheHits] = useState6(0);
+  const [proxyCacheMisses, setProxyCacheMisses] = useState6(0);
   const buildingRef = useRef(false);
   const viewerLaunchedRef = useRef(false);
   const chromeHandleRef = useRef(null);
   const debounceTimerRef = useRef(null);
   const wsClientsRef = useRef(/* @__PURE__ */ new Set());
   const pendingMessagesRef = useRef([]);
-  const broadcast = useCallback3((msg) => {
+  const broadcast = useCallback4((msg) => {
     const json = JSON.stringify(msg);
     if (wsClientsRef.current.size === 0) {
       pendingMessagesRef.current = [...pendingMessagesRef.current, json].slice(-LOG_LIMIT);
@@ -1680,22 +2412,30 @@ var DevUI = ({
     }
   }, []);
   const createServerLog = appendServerLog;
-  const launchChromeViewerCb = useCallback3(() => {
+  const launchChromeViewerCb = useCallback4(() => {
     chromeHandleRef.current?.kill();
     chromeHandleRef.current = null;
     void launchChromeViewer({
       port,
-      userDataDir: join9(outputDir, ".chrome"),
+      userDataDir: join11(outputDir, ".chrome"),
       broadcast,
-      ...lastPathRef.current !== void 0 && { path: lastPathRef.current }
+      ...lastPathRef.current !== void 0 && { path: lastPathRef.current },
+      ...debug && { debugLog: appendCdpLog },
+      ...verbose && { verbose: true }
     }).then((handle) => {
       chromeHandleRef.current = handle;
-      process.on("exit", () => {
-        handle.kill();
-      });
     });
-  }, [port, outputDir, broadcast]);
-  useInput2(
+  }, [port, outputDir, broadcast, debug, verbose, appendCdpLog]);
+  useEffect4(() => {
+    const onExit = () => {
+      chromeHandleRef.current?.kill();
+    };
+    process.on("exit", onExit);
+    return () => {
+      process.off("exit", onExit);
+    };
+  }, []);
+  useInput3(
     (input, key) => {
       if (input === "q" || key.ctrl && input === "c") {
         process.exit(0);
@@ -1716,7 +2456,7 @@ var DevUI = ({
     viewerLaunchedRef.current = true;
     launchChromeViewerCb();
   }, [status, launchChromeViewerCb]);
-  const handleCredentialsDone = useCallback3(
+  const handleCredentialsDone = useCallback4(
     (result) => {
       credentialsRef.current = result.credentials;
       activeProfileRef.current = result.profileName;
@@ -1731,7 +2471,7 @@ var DevUI = ({
     },
     [outputDir, broadcast]
   );
-  const createProxyLog = useCallback3(
+  const createProxyLog = useCallback4(
     (entry) => {
       setProxyLogHistory(
         (h) => [...h, `${(/* @__PURE__ */ new Date()).toLocaleTimeString()}: ${proxyLogEntryToString(entry)}`].slice(
@@ -1749,14 +2489,14 @@ var DevUI = ({
     },
     [broadcast]
   );
-  const createBuildLog = useCallback3(
+  const createBuildLog = useCallback4(
     (message) => {
       appendBuildLog(message);
       broadcast({ type: "log", message });
     },
     [appendBuildLog, broadcast]
   );
-  const triggerBuild = useCallback3(() => {
+  const triggerBuild = useCallback4(() => {
     if (buildingRef.current) {
       return;
     }
@@ -1808,7 +2548,7 @@ var DevUI = ({
   }, [pluginDir, triggerBuild, createBuildLog]);
   useEffect4(() => {
     const viewerPath = getViewerPath();
-    void fileExists(join9(viewerPath, "index.html")).then((viewerBuilt) => {
+    void fileExists(join11(viewerPath, "index.html")).then((viewerBuilt) => {
       if (!viewerBuilt) {
         setErrorMessage("Viewer not built. Run 'pnpm build:viewer' first.");
         setStatus("error");
@@ -1823,7 +2563,8 @@ var DevUI = ({
         outputDir,
         broadcast,
         setProxyCacheSize,
-        lastPathRef
+        lastPathRef,
+        pluginDir
       );
       const server = createServer(handler);
       const wss = new WebSocketServer({ server });
@@ -1855,9 +2596,9 @@ var DevUI = ({
         server.close();
       };
     });
-  }, [port, createServerLog, createProxyLog, broadcast, outputDir]);
+  }, [port, createServerLog, createProxyLog, broadcast, outputDir, pluginDir]);
   if (credMode === "editing") {
-    return /* @__PURE__ */ jsx6(
+    return /* @__PURE__ */ jsx7(
       CredentialSetupUI,
       {
         ...credentialMode !== void 0 && { initialMode: credentialMode },
@@ -1871,80 +2612,80 @@ var DevUI = ({
   }
   const elapsedSeconds = lastBuilt !== null ? Math.round((Date.now() - lastBuilt.getTime()) / 1e3) : null;
   const elapsedLabel = elapsedSeconds === null ? "" : elapsedSeconds < 5 ? " (just now)" : ` (${String(elapsedSeconds)}s ago)`;
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingY: 1, paddingX: 2, children: [
-    /* @__PURE__ */ jsx6(AppHeader, { marginBottom: 1 }),
-    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs4(Box5, { gap: 2, marginBottom: 0, children: [
-        /* @__PURE__ */ jsx6(Text6, { bold: true, dimColor: true, children: "App Build" }),
-        buildStatus === "pending" && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "waiting\u2026" }),
-        buildStatus === "building" && /* @__PURE__ */ jsxs4(Box5, { gap: 1, children: [
-          /* @__PURE__ */ jsx6(Spinner, {}),
-          /* @__PURE__ */ jsx6(Text6, { children: "Building plugin package\u2026" })
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", paddingY: 1, paddingX: 2, children: [
+    /* @__PURE__ */ jsx7(AppHeader, { marginBottom: 1 }),
+    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Box6, { gap: 2, marginBottom: 0, children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, dimColor: true, children: "App Build" }),
+        buildStatus === "pending" && /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "waiting\u2026" }),
+        buildStatus === "building" && /* @__PURE__ */ jsxs5(Box6, { gap: 1, children: [
+          /* @__PURE__ */ jsx7(Spinner, {}),
+          /* @__PURE__ */ jsx7(Text7, { children: "Building plugin package\u2026" })
         ] }),
-        buildStatus === "done" && /* @__PURE__ */ jsxs4(Box5, { gap: 1, children: [
-          /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713 Built" }),
-          lastBuilt !== null && /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+        buildStatus === "done" && /* @__PURE__ */ jsxs5(Box6, { gap: 1, children: [
+          /* @__PURE__ */ jsx7(Text7, { color: "green", children: "\u2713 Built" }),
+          lastBuilt !== null && /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
             "at ",
             lastBuilt.toLocaleTimeString(),
             elapsedLabel
           ] }),
-          lastBundleSize !== null && /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+          lastBundleSize !== null && /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
             "\xB7 bundle: ",
             formatBytes(lastBundleSize)
           ] })
         ] }),
-        buildStatus === "error" && /* @__PURE__ */ jsxs4(Text6, { color: "red", children: [
+        buildStatus === "error" && /* @__PURE__ */ jsxs5(Text7, { color: "red", children: [
           "\u2717 ",
           buildError ?? "unknown error"
         ] })
       ] }),
-      /* @__PURE__ */ jsx6(
-        Box5,
+      /* @__PURE__ */ jsx7(
+        Box6,
         {
           flexDirection: "column",
           height: LOG_DISPLAY + 2,
           borderStyle: "single",
           borderColor: "gray",
           overflow: "hidden",
-          children: buildLogHistory.slice(-LOG_DISPLAY).map((log, index) => /* @__PURE__ */ jsx6(Text6, { dimColor: true, wrap: "truncate", children: log }, index))
+          children: buildLogHistory.slice(-LOG_DISPLAY).map((log, index) => /* @__PURE__ */ jsx7(Text7, { dimColor: true, wrap: "truncate", children: log }, index))
         }
       )
     ] }),
-    /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
-        /* @__PURE__ */ jsx6(Text6, { bold: true, dimColor: true, children: "Web Server" }),
-        status === "starting" && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "starting\u2026" }),
-        status === "running" && /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
-          /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713 Running" }),
-          /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Box6, { gap: 2, children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, dimColor: true, children: "Web Server" }),
+        status === "starting" && /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "starting\u2026" }),
+        status === "running" && /* @__PURE__ */ jsxs5(Box6, { gap: 2, children: [
+          /* @__PURE__ */ jsx7(Text7, { color: "green", children: "\u2713 Running" }),
+          /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
             "\u25CF ",
             wsClientCount,
             " viewer",
             wsClientCount !== 1 ? "s" : ""
           ] })
         ] }),
-        status === "error" && /* @__PURE__ */ jsxs4(Text6, { color: "red", children: [
+        status === "error" && /* @__PURE__ */ jsxs5(Text7, { color: "red", children: [
           "\u2717 ",
           errorMessage ?? "Server error"
         ] })
       ] }),
-      /* @__PURE__ */ jsx6(
-        Box5,
+      /* @__PURE__ */ jsx7(
+        Box6,
         {
           flexDirection: "column",
           height: LOG_DISPLAY + 2,
           borderStyle: "single",
           borderColor: "gray",
           overflow: "hidden",
-          children: serverLogHistory.slice(-LOG_DISPLAY).map((log, index) => /* @__PURE__ */ jsx6(Text6, { dimColor: true, wrap: "truncate", children: log }, index))
+          children: serverLogHistory.slice(-LOG_DISPLAY).map((log, index) => /* @__PURE__ */ jsx7(Text7, { dimColor: true, wrap: "truncate", children: log }, index))
         }
       )
     ] }),
-    /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
-        /* @__PURE__ */ jsx6(Text6, { bold: true, dimColor: true, children: "Network Proxy" }),
-        /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713 Active" }),
-        /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Box6, { gap: 2, children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, dimColor: true, children: "Network Proxy" }),
+        /* @__PURE__ */ jsx7(Text7, { color: "green", children: "\u2713 Active" }),
+        /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
           "\u25CF ",
           proxyCacheSize,
           " key",
@@ -1957,26 +2698,47 @@ var DevUI = ({
           " miss"
         ] })
       ] }),
-      /* @__PURE__ */ jsx6(
-        Box5,
+      /* @__PURE__ */ jsx7(
+        Box6,
         {
           flexDirection: "column",
           height: LOG_DISPLAY + 2,
           borderStyle: "single",
           borderColor: "gray",
           overflow: "hidden",
-          children: proxyLogHistory.length === 0 ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: " No requests yet." }) : proxyLogHistory.slice(-LOG_DISPLAY).map((log, i) => /* @__PURE__ */ jsx6(Text6, { dimColor: true, wrap: "truncate", children: log }, i))
+          children: proxyLogHistory.length === 0 ? /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " No requests yet." }) : proxyLogHistory.slice(-LOG_DISPLAY).map((log, i) => /* @__PURE__ */ jsx7(Text7, { dimColor: true, wrap: "truncate", children: log }, i))
         }
       )
     ] }),
-    /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, gap: 1, children: [
-      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "[" }),
-      /* @__PURE__ */ jsx6(Text6, { children: "q" }),
-      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "] quit [" }),
-      /* @__PURE__ */ jsx6(Text6, { children: "c" }),
-      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "] credentials [" }),
-      /* @__PURE__ */ jsx6(Text6, { children: "v" }),
-      /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+    debug && /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Box6, { gap: 2, children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, dimColor: true, children: "CDP Debug" }),
+        /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
+          "\u25CF ",
+          cdpLogHistory.length,
+          " event(s)"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx7(
+        Box6,
+        {
+          flexDirection: "column",
+          height: LOG_DISPLAY + 2,
+          borderStyle: "single",
+          borderColor: "gray",
+          overflow: "hidden",
+          children: cdpLogHistory.length === 0 ? /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " No CDP events yet." }) : cdpLogHistory.slice(-LOG_DISPLAY).map((log, i) => /* @__PURE__ */ jsx7(Text7, { dimColor: true, wrap: "truncate", children: log }, i))
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, gap: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "[" }),
+      /* @__PURE__ */ jsx7(Text7, { children: "q" }),
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "] quit [" }),
+      /* @__PURE__ */ jsx7(Text7, { children: "c" }),
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "] credentials [" }),
+      /* @__PURE__ */ jsx7(Text7, { children: "v" }),
+      /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
         "] ",
         wsClientCount === 0 ? "open viewer" : "relaunch viewer"
       ] })
@@ -1986,14 +2748,14 @@ var DevUI = ({
 
 // src/commands/dev.ts
 async function runSetupUI(initialMode) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let unmountFn = null;
     const handleComplete = (result) => {
       unmountFn?.();
-      resolve(result);
+      resolve2(result);
     };
-    const { unmount } = render2(
-      createElement2(CredentialSetupUI, {
+    const { unmount } = render3(
+      createElement3(CredentialSetupUI, {
         ...initialMode !== void 0 && { initialMode },
         onComplete: handleComplete
       }),
@@ -2003,68 +2765,75 @@ async function runSetupUI(initialMode) {
   });
 }
 function devCommand(program2) {
-  program2.command("dev").description("Start the plugin viewer dev server").option("-p, --port <port>", "port to listen on", "3121").option("-c, --credentials <path>", "path to a credentials JSON file").action(async (options) => {
-    const port = parseInt(options.port, 10);
-    const pluginDir = process.cwd();
-    const outputDir = `${pluginDir}/.kizenapp`;
-    ensureGitignore(pluginDir);
-    let credentials = null;
-    let credentialMode;
-    let activeCredentialProfile;
-    const { lastPath } = await loadConfig(outputDir);
-    if (options.credentials) {
-      credentials = await loadCredentialsFromFile(options.credentials);
-    } else {
-      const config = await loadConfig(outputDir);
-      if (config.credentialMode === "local") {
-        credentialMode = "local";
-      } else if (config.credentialMode === "global") {
-        credentialMode = "global";
-        activeCredentialProfile = config.activeCredentialProfile;
-        if (activeCredentialProfile) {
-          credentials = await loadCredentialProfile(activeCredentialProfile);
-          if (!credentials) {
+  program2.command("dev").description("Start the plugin viewer dev server").option("-p, --port <port>", "port to listen on", "3121").option("-c, --credentials <path>", "path to a credentials JSON file").option("-d, --debug", "Enable CDP lifecycle logs in the TUI").option("-v, --verbose", "Log every CDP event and handled error (implies --debug)").action(
+    async (options) => {
+      const port = parseInt(options.port, 10);
+      const pluginDir = process.cwd();
+      const outputDir = `${pluginDir}/.kizenapp`;
+      ensureGitignore(pluginDir);
+      let credentials = null;
+      let credentialMode;
+      let activeCredentialProfile;
+      const { lastPath } = await loadConfig(outputDir);
+      if (options.credentials) {
+        credentials = await loadCredentialsFromFile(options.credentials);
+      } else {
+        const config = await loadConfig(outputDir);
+        if (config.credentialMode === "local") {
+          credentialMode = "local";
+        } else if (config.credentialMode === "global") {
+          credentialMode = "global";
+          activeCredentialProfile = config.activeCredentialProfile;
+          if (activeCredentialProfile) {
+            credentials = await loadCredentialProfile(activeCredentialProfile);
+            if (!credentials) {
+              credentials = await loadGlobalCredentials();
+              activeCredentialProfile = void 0;
+            }
+          } else {
             credentials = await loadGlobalCredentials();
-            activeCredentialProfile = void 0;
+          }
+          if (!credentials) {
+            const result = await runSetupUI("global");
+            credentials = result.credentials;
+            activeCredentialProfile = result.profileName;
           }
         } else {
-          credentials = await loadGlobalCredentials();
-        }
-        if (!credentials) {
-          const result = await runSetupUI("global");
+          const result = await runSetupUI();
           credentials = result.credentials;
+          credentialMode = result.mode;
           activeCredentialProfile = result.profileName;
+          const profile = result.profileName;
+          await saveConfig(outputDir, {
+            credentialMode: result.mode,
+            ...profile !== void 0 && { activeCredentialProfile: profile }
+          });
         }
-      } else {
-        const result = await runSetupUI();
-        credentials = result.credentials;
-        credentialMode = result.mode;
-        activeCredentialProfile = result.profileName;
-        const profile = result.profileName;
-        await saveConfig(outputDir, {
-          credentialMode: result.mode,
-          ...profile !== void 0 && { activeCredentialProfile: profile }
-        });
       }
+      const verbose = options.verbose === true;
+      const debug = verbose || options.debug === true;
+      const { waitUntilExit } = render3(
+        createElement3(DevUI, {
+          port,
+          pluginDir,
+          outputDir,
+          credentials,
+          ...credentialMode !== void 0 && { credentialMode },
+          ...activeCredentialProfile !== void 0 && { activeCredentialProfile },
+          ...lastPath !== void 0 && { lastPath },
+          debug,
+          verbose
+        }),
+        { exitOnCtrlC: false }
+      );
+      await waitUntilExit();
     }
-    const { waitUntilExit } = render2(
-      createElement2(DevUI, {
-        port,
-        pluginDir,
-        outputDir,
-        credentials,
-        ...credentialMode !== void 0 && { credentialMode },
-        ...activeCredentialProfile !== void 0 && { activeCredentialProfile },
-        ...lastPath !== void 0 && { lastPath }
-      }),
-      { exitOnCtrlC: false }
-    );
-    await waitUntilExit();
-  });
+  );
 }
 
 // src/index.ts
 program.name("appbuilder").description("Kizen plugin app builder").version("0.1.0");
+createCommand(program);
 buildCommand(program);
 devCommand(program);
 program.parse();