@bpmnkit/cli 0.0.16 → 0.0.18

package/dist/tui.js

@@ -1,7 +1,10 @@
 import { spawn } from "node:child_process";
 import { renderBpmnAscii } from "@bpmnkit/ascii";
-import { appendAuditEntry, getAuditLog, getSettings, saveSettings } from "@bpmnkit/profiles";
+import { appendAuditEntry, deleteProfile, getActiveName, getAuditLog, getProfile, getSettings, listProfiles, saveSettings, useProfile, } from "@bpmnkit/profiles";
 import { runAskQuery } from "./commands/ask.js";
+import { pluginGroup, searchNpmRegistry } from "./commands/plugin.js";
+import { profileGroup } from "./commands/profile.js";
+import { readInstalledPlugins } from "./plugin-loader.js";
 // ─── ANSI helpers ─────────────────────────────────────────────────────────────
 const CSI = "\x1b[";
 const HIDE = `${CSI}?25l`;
@@ -83,12 +86,13 @@ const SKIP_FLAGS = new Set(["output", "profile", "help", "no-color", "debug"]);
 function buildFields(cmd) {
     const fields = [];
     for (const arg of cmd.args ?? []) {
+        const defaultVal = arg.default ?? "";
         fields.push({
             kind: "arg",
             label: arg.name,
             hint: arg.required ? "required" : "optional",
-            value: "",
-            cursor: 0,
+            value: defaultVal,
+            cursor: defaultVal.length,
             required: arg.required ?? false,
             argSpec: arg,
         });
@@ -189,8 +193,9 @@ function entriesToJson(entries) {
 }
 /**
  * Build initial entries for the JSON editor.
- * If fieldSpecs are provided, pre-populate with all known fields (in spec order),
- * merging in any existing values. Extra keys from existing JSON are appended at the end.
+ * If fieldSpecs are provided, pre-populate only required fields (in spec order),
+ * merging in any existing values. Optional fields are available via the add-row picker.
+ * Extra keys from existing JSON that are not in the spec are appended at the end.
  */
 function buildInitialEntries(existingJson, fieldSpecs) {
     const existing = {};
@@ -209,7 +214,10 @@ function buildInitialEntries(existingJson, fieldSpecs) {
         return parseJsonToEntries(existingJson);
     const seenKeys = new Set();
     const entries = [];
+    // Only pre-populate required fields; optional ones are added on demand
     for (const spec of fieldSpecs) {
+        if (!spec.required && !(spec.name in existing))
+            continue;
         seenKeys.add(spec.name);
         const val = existing[spec.name] ?? "";
         entries.push({ key: spec.name, keyCursor: spec.name.length, val, valCursor: val.length });
@@ -226,6 +234,57 @@ function buildInitialEntries(existingJson, fieldSpecs) {
 function getFieldSpec(key, fieldSpecs) {
     return fieldSpecs?.find((s) => s.name === key);
 }
+/**
+ * Return specs not already used as keys by OTHER entries (not the one at currentIndex).
+ * Pass null for currentIndex when adding a brand-new entry.
+ */
+function getAvailableFieldSpecs(currentIndex, entries, fieldSpecs) {
+    const usedKeys = new Set(entries
+        .filter((_, i) => i !== currentIndex)
+        .map((e) => e.key)
+        .filter(Boolean));
+    return fieldSpecs.filter((s) => !usedKeys.has(s.name));
+}
+/** Build profile info entries (key/value pairs with secrets redacted). */
+function buildProfileInfoEntries(profileName) {
+    const p = getProfile(profileName);
+    if (!p)
+        return [{ key: "status", value: "profile not found" }];
+    const info = [
+        { key: "name", value: p.name },
+        { key: "apiType", value: p.apiType },
+        { key: "baseUrl", value: p.config.baseUrl ?? "(default)" },
+    ];
+    const auth = p.config.auth;
+    if (auth) {
+        info.push({ key: "auth.type", value: auth.type });
+        if (auth.type === "bearer") {
+            info.push({ key: "auth.token", value: "***" });
+        }
+        else if (auth.type === "oauth2") {
+            info.push({ key: "auth.clientId", value: auth.clientId });
+            info.push({ key: "auth.clientSecret", value: "***" });
+            info.push({ key: "auth.tokenUrl", value: auth.tokenUrl });
+        }
+        else if (auth.type === "basic") {
+            info.push({ key: "auth.username", value: auth.username });
+            info.push({ key: "auth.password", value: "***" });
+        }
+    }
+    return info;
+}
+/** Rebuild profile list items after use/delete. */
+function rebuildProfileListItems() {
+    const profiles = listProfiles();
+    const active = getActiveName();
+    return profiles.map((p) => ({
+        active: p.name === active ? "●" : " ",
+        name: p.name,
+        apiType: p.apiType,
+        baseUrl: p.config.baseUrl ?? "(from env/file)",
+        authType: p.config.auth?.type ?? "—",
+    }));
+}
 // ─── Table helpers ────────────────────────────────────────────────────────────
 function getCellStr(item, col) {
     let val = item;
@@ -376,8 +435,12 @@ function renderMain(state, screen) {
         const desc = dim(fit(g.description, cols - nameW - 8));
         const line = `  ${name}  ${desc}`;
         lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
-        // Add separator after the pinned top section (ask, settings, profile)
-        if (!searching && g.name === "profile" && i < groups.length - 1) {
+        // Separator after pinned section (after "worker", before plugins or api groups)
+        if (!searching && g.name === "worker" && i < groups.length - 1) {
+            lines.push(`  ${dim("─".repeat(cols - 4))}`);
+        }
+        // Separator after the last plugin group (before api groups), only when plugins exist
+        if (!searching && g._plugin && !groups[i + 1]?._plugin && i < groups.length - 1) {
             lines.push(`  ${dim("─".repeat(cols - 4))}`);
         }
     }
@@ -507,6 +570,22 @@ function renderInput(state, screen) {
     lines.push("");
     if (screen.error) {
         lines.push(`  ${red("error:")} ${screen.error}`);
+        if (screen.errorRaw) {
+            const raw = screen.errorRaw;
+            lines.push(`  ${dim(`${raw.method} ${raw.url}`)}`);
+            lines.push(`  ${red(`HTTP ${raw.status}`)}`);
+            if (raw.body) {
+                try {
+                    const parsed = JSON.parse(raw.body);
+                    for (const l of JSON.stringify(parsed, null, 2).split("\n")) {
+                        lines.push(`  ${dim(l)}`);
+                    }
+                }
+                catch {
+                    lines.push(`  ${dim(raw.body)}`);
+                }
+            }
+        }
     }
     else if (screen.running) {
         lines.push(`  ${dim("running…")}`);
@@ -699,7 +778,12 @@ function renderResults(state, screen) {
             lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${out.total}`)}`);
         }
         const followupHint = screen.cmd.relations ? `  ${cyan("f")} follow-up` : "";
-        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} detail${followupHint}  ${dim("pgup/pgdn")} page${rawToggle}${curlToggle}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+        const profileListHints = screen.group.name === "profile" && screen.cmd.name === "list"
+            ? `  ${cyan("u")} use  ${cyan("s")} show  ${cyan("d")} delete`
+            : "";
+        if (screen.message)
+            lines.push(`  ${green(screen.message)}`);
+        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} detail${followupHint}${profileListHints}  ${dim("pgup/pgdn")} page${rawToggle}${curlToggle}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
     }
     else if (out.type === "item") {
         lines.push(renderHeader([screen.group.name, screen.cmd.name], cols, state.profile));
@@ -836,7 +920,7 @@ function renderProfile(state, screen) {
         const hi = Math.min(screen.scroll + viewH, state.profileInfo.length);
         lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${state.profileInfo.length}`)}`);
     }
-    lines.push(`  ${dim("↑↓")} scroll  ${cyan("esc/p")} close  ${cyan("q")} quit`);
+    lines.push(`  ${dim("↑↓")} scroll  ${cyan("esc")} close  ${cyan("q")} quit`);
     return lines;
 }
 const SETTINGS_ROWS = [
@@ -854,6 +938,24 @@ const SETTINGS_ROWS = [
         label: "Show Audit Log",
         description: "View recent commands executed for the active profile",
     },
+    {
+        kind: "nav",
+        id: "active-profile",
+        label: "Active Profile",
+        description: "View details for the current connection profile",
+    },
+    {
+        kind: "nav",
+        id: "profiles",
+        label: "Profiles",
+        description: "Manage and switch connection profiles",
+    },
+    {
+        kind: "nav",
+        id: "plugins",
+        label: "Plugins",
+        description: "Browse and manage CLI plugins",
+    },
 ];
 function renderSettings(state, screen) {
     const { cols } = termSize();
@@ -936,7 +1038,7 @@ function renderWorker(state, screen) {
             : screen.status === "stopping"
                 ? cyan("◌ STOPPING")
                 : dim("■ STOPPED");
-    const lines = [renderHeader(["job", "worker"], cols, state.profile), ""];
+    const lines = [renderHeader(["worker"], cols, state.profile), ""];
     lines.push(`  ${padEnd(dim("type"), 8)}  ${cyan(screen.jobType)}    ${dim("status")}  ${statusStr}`);
     lines.push(`  ${dim("─".repeat(cols - 4))}`);
     const { activated, completed, failed } = screen.stats;
@@ -1006,12 +1108,15 @@ function renderJsonEditor(state, screen) {
         const editKey = isCursor && screen.col === "key" && screen.editing;
         const editVal = isCursor && screen.col === "val" && screen.editing;
         const keyStr = renderText(entry.key, entry.keyCursor, keyW - (isKnown ? 0 : 0), editKey);
-        // For known enum fields in nav mode, show cycling hint instead of raw value
+        // For known enum fields in nav mode, show cycling hint instead of raw value.
+        // For non-enum known fields, show a type placeholder when value is empty.
         const valDisplay = !editVal && hasEnum && entry.val
             ? `${entry.val} ${dim("↑↓")}`
             : !editVal && hasEnum && !entry.val
                 ? dim("<pick ↑↓>")
-                : renderText(entry.val, entry.valCursor, valW - 4, editVal);
+                : !editVal && !hasEnum && spec && !entry.val
+                    ? dim(`<${spec.type}>`)
+                    : renderText(entry.val, entry.valCursor, valW - 4, editVal);
         const valStr = valDisplay;
         const keyPart = isCursor && screen.col === "key" && !editKey
             ? cyan(padEnd(keyStr, keyW))
@@ -1053,7 +1158,9 @@ function renderJsonEditor(state, screen) {
             : undefined;
         const editHint = editSpec?.enum
             ? `${dim("↑↓")} pick value  ${cyan("enter")} confirm  ${cyan("esc")} cancel`
-            : `${dim("←→")} cursor  ${cyan("tab")} switch col  ${cyan("enter")} confirm  ${cyan("esc")} cancel`;
+            : screen.col === "key" && screen.fieldSpecs && screen.fieldSpecs.length > 0
+                ? `${dim("↑↓")} pick field  ${dim("←→")} cursor  ${cyan("tab")} switch col  ${cyan("enter")} confirm  ${cyan("esc")} cancel`
+                : `${dim("←→")} cursor  ${cyan("tab")} switch col  ${cyan("enter")} confirm  ${cyan("esc")} cancel`;
         lines.push(`  ${editHint}`);
     }
     else {
@@ -1114,7 +1221,6 @@ async function runWorkerLoop(ws, state, variables, jobTimeout, maxJobs) {
                 worker: "casen-worker",
                 timeout: jobTimeout,
                 maxJobsToActivate: maxJobs,
-                requestTimeout: 20000,
             }));
         }
         catch (err) {
@@ -1128,20 +1234,56 @@ async function runWorkerLoop(ws, state, variables, jobTimeout, maxJobs) {
         for (const job of jobs) {
             if (!running)
                 break;
+            // Some Zeebe-compatible engines return `key` instead of `jobKey`
+            const jobKey = job.jobKey ?? job.key;
+            if (!jobKey) {
+                addWorkerLog(ws, "err", "Activated job has no key — skipping");
+                continue;
+            }
             ws.stats.activated++;
-            addWorkerLog(ws, "info", `Activated ${job.jobKey}  process=${job.processDefinitionId}  element=${job.elementId}`);
+            addWorkerLog(ws, "info", `Activated ${jobKey}  process=${job.processDefinitionId}  element=${job.elementId}`);
+            let jobResult = { outcome: "complete", variables };
+            const processJob = ws.cmd._worker?.processJob;
+            if (processJob) {
+                try {
+                    jobResult = await processJob({ ...job, jobKey });
+                }
+                catch (err) {
+                    addWorkerLog(ws, "err", `Handler error: ${err instanceof Error ? err.message : String(err)} — using defaults`);
+                }
+            }
             try {
-                await client.job.completeJob(job.jobKey, { variables });
-                ws.stats.completed++;
-                addWorkerLog(ws, "ok", `Completed ${job.jobKey}`);
+                if (jobResult.outcome === "complete") {
+                    await client.job.completeJob(jobKey, { variables: jobResult.variables });
+                    ws.stats.completed++;
+                    addWorkerLog(ws, "ok", `Completed ${jobKey}`);
+                }
+                else if (jobResult.outcome === "fail") {
+                    await client.job.failJob(jobKey, {
+                        errorMessage: jobResult.errorMessage,
+                        retries: jobResult.retries,
+                        retryBackOff: jobResult.retryBackOff,
+                    });
+                    ws.stats.failed++;
+                    addWorkerLog(ws, "err", `Failed ${jobKey}: ${jobResult.errorMessage}`);
+                }
+                else {
+                    await client.job.throwJobError(jobKey, {
+                        errorCode: jobResult.errorCode,
+                        errorMessage: jobResult.errorMessage,
+                        variables: jobResult.variables,
+                    });
+                    ws.stats.failed++;
+                    addWorkerLog(ws, "err", `Error ${jobKey} [${jobResult.errorCode}]: ${jobResult.errorMessage ?? ""}`);
+                }
             }
             catch (err) {
                 ws.stats.failed++;
-                addWorkerLog(ws, "err", `Failed to complete ${job.jobKey}: ${err instanceof Error ? err.message : String(err)}`);
+                addWorkerLog(ws, "err", `Failed to settle ${jobKey}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        if (jobs.length > 0)
-            await new Promise((r) => setTimeout(r, 100));
+        // Sleep between polls: brief yield after processing jobs, longer pause when idle
+        await new Promise((r) => setTimeout(r, jobs.length > 0 ? 100 : 2000));
     }
     ws.status = "stopped";
     addWorkerLog(ws, "info", `Stopped. Activated: ${ws.stats.activated}  Completed: ${ws.stats.completed}  Failed: ${ws.stats.failed}`);
@@ -1265,6 +1407,7 @@ async function runAskInTui(screen, state) {
         },
         raw: null,
         rawView: false,
+        message: "",
         curlView: false,
         altView: false,
         cursor: 0,
@@ -1403,6 +1546,9 @@ function render(state) {
         case "json-editor":
             lines = renderJsonEditor(state, screen);
             break;
+        case "plugins":
+            lines = renderPlugins(state, screen);
+            break;
     }
     process.stdout.write(`${CLEAR}${lines.join("\n")}\n`);
 }
@@ -1485,6 +1631,25 @@ function handleMainKey(key, screen, state, done) {
                     _timer: null,
                 });
             }
+            else if (group &&
+                group.commands.length === 1 &&
+                group.commands[0] &&
+                "_worker" in group.commands[0]) {
+                // Single-command worker group: skip commands list, go straight to input
+                const cmd = group.commands[0];
+                state.stack.push({
+                    kind: "input",
+                    group,
+                    cmd,
+                    fields: buildFields(cmd),
+                    cursor: 0,
+                    scroll: 0,
+                    editing: false,
+                    error: "",
+                    errorRaw: null,
+                    running: false,
+                });
+            }
             else if (group) {
                 state.stack.push({ kind: "commands", group, cursor: 0, search: "" });
             }
@@ -1549,6 +1714,7 @@ function handleCommandsKey(key, screen, state, done) {
                     scroll: 0,
                     editing: false,
                     error: "",
+                    errorRaw: null,
                     running: false,
                 });
             }
@@ -1578,6 +1744,7 @@ async function executeCommand(screen, state) {
     }
     screen.running = true;
     screen.error = "";
+    screen.errorRaw = null;
     render(state);
     const { writer, get } = makeCapturingWriter();
     // Wrap client factories to capture the last raw HTTP response
@@ -1636,6 +1803,7 @@ async function executeCommand(screen, state) {
             altView: false,
             cursor: 0,
             scroll: 0,
+            message: "",
         });
     }
     catch (err) {
@@ -1649,6 +1817,7 @@ async function executeCommand(screen, state) {
             error: msg,
         });
         screen.error = msg;
+        screen.errorRaw = rawCapture;
     }
     finally {
         screen.running = false;
@@ -1794,7 +1963,7 @@ async function handleInputKey(key, screen, state, done) {
             if (!field)
                 break;
             if (field.kind === "run") {
-                if (screen.cmd.name === "worker") {
+                if ("_worker" in screen.cmd) {
                     launchWorkerView(screen, state);
                 }
                 else {
@@ -1864,6 +2033,60 @@ async function handleInputKey(key, screen, state, done) {
 function handleResultsKey(key, screen, state, done) {
     const { rows } = termSize();
     const viewH = Math.max(3, rows - 10);
+    // Profile list inline shortcuts: u=use, s=show, d=delete
+    if (screen.group.name === "profile" &&
+        screen.cmd.name === "list" &&
+        screen.output.type === "list") {
+        // Clear stale message on any key in this context
+        screen.message = "";
+        if (key === "u" || key === "U") {
+            const item = screen.output.items[screen.cursor];
+            const name = item?.name;
+            if (name && useProfile(name)) {
+                state.profile = name;
+                state.profileInfo = buildProfileInfoEntries(name);
+                const items = rebuildProfileListItems();
+                screen.output = { type: "list", items, columns: screen.output.columns, total: items.length };
+                screen.message = `✓ Active profile: ${name}`;
+            }
+            else if (name) {
+                screen.message = `Profile "${name}" not found`;
+            }
+            render(state);
+            return;
+        }
+        if (key === "s" || key === "S") {
+            const item = screen.output.items[screen.cursor];
+            if (item) {
+                state.stack.push({
+                    kind: "detail",
+                    group: screen.group,
+                    cmd: screen.cmd,
+                    item,
+                    label: String(item.name ?? "profile"),
+                    cursor: 0,
+                    scroll: 0,
+                });
+            }
+            render(state);
+            return;
+        }
+        if (key === "d" || key === "D") {
+            const item = screen.output.items[screen.cursor];
+            const name = item?.name;
+            if (name && deleteProfile(name)) {
+                const items = rebuildProfileListItems();
+                screen.output = { type: "list", items, columns: screen.output.columns, total: items.length };
+                screen.cursor = Math.min(screen.cursor, Math.max(0, items.length - 1));
+                screen.message = `✓ Deleted profile "${name}"`;
+            }
+            else if (name) {
+                screen.message = `Cannot delete "${name}" (modeler profiles are read-only)`;
+            }
+            render(state);
+            return;
+        }
+    }
     // r/R toggles raw view; u/U toggles curl view — mutually exclusive
     if (key === "r" || key === "R") {
         screen.rawView = !screen.rawView;
@@ -2304,6 +2527,7 @@ function handleFollowupKey(key, screen, state, done) {
                     scroll: 0,
                     editing: false,
                     error: "",
+                    errorRaw: null,
                     running: false,
                 });
             }
@@ -2354,6 +2578,29 @@ function handleJsonEditorKey(key, screen, state, done) {
                 entry.valCursor = cur;
             }
         };
+        // Key cycling for key column when fieldSpecs are available
+        if (activeIsKey && screen.fieldSpecs && screen.fieldSpecs.length > 0) {
+            const available = getAvailableFieldSpecs(screen.cursor, screen.entries, screen.fieldSpecs);
+            if (available.length > 0) {
+                if (key === "\x1b[A" || key === "\x1b[B") {
+                    const curIdx = available.findIndex((s) => s.name === entry.key);
+                    let nextIdx;
+                    if (key === "\x1b[A") {
+                        nextIdx = curIdx <= 0 ? available.length - 1 : curIdx - 1;
+                    }
+                    else {
+                        nextIdx = curIdx < 0 || curIdx >= available.length - 1 ? 0 : curIdx + 1;
+                    }
+                    const newSpec = available[nextIdx];
+                    if (newSpec) {
+                        entry.key = newSpec.name;
+                        entry.keyCursor = entry.key.length;
+                    }
+                    render(state);
+                    return;
+                }
+            }
+        }
         // Enum cycling for value column of a known enum field
         const valSpec = !activeIsKey ? getFieldSpec(entry.key, screen.fieldSpecs) : undefined;
         const enumVals = valSpec?.enum;
@@ -2476,8 +2723,17 @@ function handleJsonEditorKey(key, screen, state, done) {
         case "\r":
         case "\n":
             if (isAddRow) {
-                // Add a new entry and start editing its key
-                screen.entries.push({ key: "", keyCursor: 0, val: "", valCursor: 0 });
+                // Add a new entry; pre-seed key from first available field spec if available
+                const newEntry = { key: "", keyCursor: 0, val: "", valCursor: 0 };
+                if (screen.fieldSpecs && screen.fieldSpecs.length > 0) {
+                    const available = getAvailableFieldSpecs(null, screen.entries, screen.fieldSpecs);
+                    const firstSpec = available[0];
+                    if (firstSpec) {
+                        newEntry.key = firstSpec.name;
+                        newEntry.keyCursor = firstSpec.name.length;
+                    }
+                }
+                screen.entries.push(newEntry);
                 screen.cursor = screen.entries.length - 1;
                 screen.col = "key";
                 screen.editing = true;
@@ -2495,18 +2751,23 @@ function handleJsonEditorKey(key, screen, state, done) {
             }
             break;
         case "a":
-        case "A":
-            // Insert new entry after cursor and start editing
-            screen.entries.splice(screen.cursor + 1, 0, {
-                key: "",
-                keyCursor: 0,
-                val: "",
-                valCursor: 0,
-            });
+        case "A": {
+            // Insert new entry after cursor; pre-seed key from first available field spec
+            const addEntry = { key: "", keyCursor: 0, val: "", valCursor: 0 };
+            if (screen.fieldSpecs && screen.fieldSpecs.length > 0) {
+                const available = getAvailableFieldSpecs(null, screen.entries, screen.fieldSpecs);
+                const firstSpec = available[0];
+                if (firstSpec) {
+                    addEntry.key = firstSpec.name;
+                    addEntry.keyCursor = firstSpec.name.length;
+                }
+            }
+            screen.entries.splice(screen.cursor + 1, 0, addEntry);
             screen.cursor = Math.min(screen.cursor + 1, screen.entries.length - 1);
             screen.col = "key";
             screen.editing = true;
             break;
+        }
         case "d":
         case "D":
             if (!isAddRow && screen.entries.length > 0) {
@@ -2600,6 +2861,15 @@ function handleSettingsKey(key, screen, state, done) {
             else if (row?.kind === "action" && row.id === "show-audit-log") {
                 state.stack.push({ kind: "audit-log", scroll: 0 });
             }
+            else if (row?.kind === "nav" && row.id === "active-profile") {
+                state.stack.push({ kind: "profile", scroll: 0 });
+            }
+            else if (row?.kind === "nav" && row.id === "profiles") {
+                state.stack.push({ kind: "commands", group: profileGroup, cursor: 0, search: "" });
+            }
+            else if (row?.kind === "nav" && row.id === "plugins") {
+                state.stack.push(newPluginsScreen());
+            }
             break;
         }
         case "\x1b":
@@ -2693,6 +2963,499 @@ function handleWorkerKey(key, screen, state, done) {
     }
     render(state);
 }
+// ─── Plugins screen ───────────────────────────────────────────────────────────
+const PLUGIN_MENU = [
+    { id: "search", label: "search", description: "Search the npm registry for plugins" },
+    { id: "list", label: "list", description: "Show installed plugins" },
+    { id: "install", label: "install", description: "Install a plugin from npm or local path" },
+    {
+        id: "update",
+        label: "update",
+        description: "Update installed plugins to their latest versions",
+    },
+    { id: "remove", label: "remove", description: "Remove a plugin" },
+];
+function newPluginsScreen() {
+    return {
+        kind: "plugins",
+        subview: "menu",
+        menuCursor: 0,
+        query: "",
+        queryCursor: 0,
+        resultKind: "search",
+        results: [],
+        resultCursor: 0,
+        resultScroll: 0,
+        promptLabel: "",
+        promptValue: "",
+        promptCursor: 0,
+        promptAction: "install",
+        message: "",
+        error: "",
+        running: false,
+    };
+}
+function renderPlugins(state, screen) {
+    const { cols, rows } = termSize();
+    if (screen.subview === "menu") {
+        const nameW = PLUGIN_MENU.reduce((m, item) => Math.max(m, item.label.length), 0) + 2;
+        const lines = [renderHeader(["settings", "plugins"], cols, state.profile), ""];
+        for (let i = 0; i < PLUGIN_MENU.length; i++) {
+            const item = PLUGIN_MENU[i];
+            if (!item)
+                continue;
+            const isCursor = i === screen.menuCursor;
+            const name = padEnd(isCursor ? cyan(item.label) : item.label, nameW);
+            const desc = dim(fit(item.description, cols - nameW - 6));
+            const line = `  ${name}  ${desc}`;
+            lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+        }
+        lines.push("");
+        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} open  ${cyan("esc")} back  ${cyan("q")} quit`);
+        return lines;
+    }
+    if (screen.subview === "search") {
+        const lines = [renderHeader(["settings", "plugins", "search"], cols, state.profile), ""];
+        lines.push(`  ${dim("Search the npm registry — leave empty to browse all plugins")}`);
+        lines.push("");
+        lines.push(`  > ${renderText(screen.query, screen.queryCursor, cols - 6, true)}`);
+        if (screen.running) {
+            lines.push("");
+            lines.push(`  ${dim("Searching…")}`);
+        }
+        else if (screen.error) {
+            lines.push("");
+            lines.push(`  ${red("error:")} ${screen.error}`);
+        }
+        lines.push("");
+        lines.push(`  ${dim("type query")}  ${cyan("enter")} search  ${cyan("esc")} back  ${cyan("^C")} quit`);
+        return lines;
+    }
+    if (screen.subview === "results") {
+        const viewH = Math.max(3, rows - 10);
+        const isSearch = screen.resultKind === "search";
+        const title = isSearch ? "search results" : "installed";
+        const lines = [renderHeader(["settings", "plugins", title], cols, state.profile), ""];
+        if (screen.results.length === 0) {
+            lines.push(`  ${dim(isSearch ? "No plugins found." : "No plugins installed.")}`);
+        }
+        else {
+            const nameW = Math.min(32, screen.results.reduce((m, r) => Math.max(m, r.name.length), 0)) + 2;
+            // Official badge shown for @bpmnkit/* packages (2 visible chars: "◆ ")
+            const BADGE = `${cyan("◆")} `;
+            const BADGE_W = 2;
+            const visible = screen.results.slice(screen.resultScroll, screen.resultScroll + viewH);
+            for (let vi = 0; vi < visible.length; vi++) {
+                const r = visible[vi];
+                if (!r)
+                    continue;
+                const ri = screen.resultScroll + vi;
+                const isCursor = ri === screen.resultCursor;
+                const isOfficial = r.name.startsWith("@bpmnkit/");
+                const badge = isOfficial ? BADGE : " ".repeat(BADGE_W);
+                const name = padEnd(isCursor ? cyan(r.name) : r.name, nameW);
+                const verStr = r.version.padEnd(10);
+                const extra = isSearch
+                    ? dim(fit(r.description, cols - nameW - BADGE_W - 14))
+                    : dim(r.installedAt.slice(0, 10));
+                const line = `  ${badge}${name}  ${verStr}  ${extra}`;
+                lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+            }
+        }
+        if (screen.message) {
+            lines.push("");
+            lines.push(`  ${screen.message}`);
+        }
+        lines.push("");
+        const actions = isSearch
+            ? `${cyan("enter/i")} install  ${cyan("esc")} back  ${cyan("q")} quit`
+            : `${cyan("enter/r")} remove  ${cyan("esc")} back  ${cyan("q")} quit`;
+        lines.push(`  ${dim("↑↓")} navigate  ${actions}`);
+        lines.push(`  ${cyan("◆")} ${dim("= official @bpmnkit plugin")}`);
+        return lines;
+    }
+    if (screen.subview === "prompt") {
+        const lines = [
+            renderHeader(["settings", "plugins", screen.promptAction], cols, state.profile),
+            "",
+        ];
+        lines.push(`  ${screen.promptLabel}`);
+        lines.push("");
+        lines.push(`  > ${renderText(screen.promptValue, screen.promptCursor, cols - 6, true)}`);
+        if (screen.running) {
+            lines.push("");
+            lines.push(`  ${dim("Running…")}`);
+        }
+        else if (screen.error) {
+            lines.push("");
+            lines.push(`  ${red("error:")} ${screen.error}`);
+        }
+        lines.push("");
+        lines.push(`  ${dim("type name")}  ${cyan("enter")} confirm  ${cyan("esc")} back  ${cyan("^C")} quit`);
+        return lines;
+    }
+    // "done"
+    const lines = [renderHeader(["settings", "plugins"], cols, state.profile), "", ""];
+    if (screen.error) {
+        lines.push(`  ${red("error:")} ${screen.error}`);
+    }
+    else {
+        for (const line of screen.message.split("\n")) {
+            lines.push(`  ${line}`);
+        }
+    }
+    lines.push("");
+    lines.push(`  ${cyan("esc")} back  ${cyan("q")} quit`);
+    return lines;
+}
+/** Temporarily restore the normal terminal, run fn (which may spawn processes), then re-enter. */
+async function runWithTerminal(fn) {
+    process.stdout.write(`${ALT_OFF}${SHOW}`);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(false);
+    try {
+        await fn();
+    }
+    finally {
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        process.stdout.write(`${ALT_ON}${HIDE}${CLEAR}`);
+    }
+}
+async function handlePluginsKey(key, screen, state, done) {
+    if (key === "\x03") {
+        done();
+        return;
+    }
+    // ── Menu subview ──────────────────────────────────────────────────────────
+    if (screen.subview === "menu") {
+        switch (key) {
+            case "\x1b[A":
+                if (screen.menuCursor > 0)
+                    screen.menuCursor--;
+                break;
+            case "\x1b[B":
+                if (screen.menuCursor < PLUGIN_MENU.length - 1)
+                    screen.menuCursor++;
+                break;
+            case "\r":
+            case "\n": {
+                const item = PLUGIN_MENU[screen.menuCursor];
+                if (item?.id === "search") {
+                    screen.subview = "search";
+                    screen.query = "";
+                    screen.queryCursor = 0;
+                    screen.error = "";
+                }
+                else if (item?.id === "list") {
+                    screen.running = true;
+                    screen.error = "";
+                    render(state);
+                    try {
+                        const plugins = await readInstalledPlugins();
+                        screen.resultKind = "installed";
+                        screen.results = plugins.map((p) => ({
+                            name: p.package,
+                            version: p.version,
+                            description: "",
+                            publisher: "",
+                            score: "",
+                            installedAt: p.installedAt,
+                        }));
+                        screen.resultCursor = 0;
+                        screen.resultScroll = 0;
+                        screen.message = "";
+                        screen.subview = "results";
+                    }
+                    catch (err) {
+                        screen.error = err instanceof Error ? err.message : String(err);
+                    }
+                    finally {
+                        screen.running = false;
+                    }
+                }
+                else if (item?.id === "install") {
+                    screen.subview = "prompt";
+                    screen.promptLabel = "Package name (e.g. casen-deploy or ./local-path):";
+                    screen.promptValue = "";
+                    screen.promptCursor = 0;
+                    screen.promptAction = "install";
+                    screen.error = "";
+                }
+                else if (item?.id === "update") {
+                    await runWithTerminal(async () => {
+                        const cmd = pluginGroup.commands.find((c) => c.name === "update");
+                        if (!cmd)
+                            return;
+                        const { writer } = makeCapturingWriter();
+                        await cmd.run({
+                            positional: [],
+                            flags: {},
+                            output: writer,
+                            getClient: state.getClient,
+                            getAdminClient: state.getAdminClient,
+                        });
+                    });
+                    screen.subview = "done";
+                    screen.message = green("✓ Update complete. Restart casen to activate changes.");
+                    screen.error = "";
+                }
+                else if (item?.id === "remove") {
+                    screen.subview = "prompt";
+                    screen.promptLabel = "Plugin package name to remove:";
+                    screen.promptValue = "";
+                    screen.promptCursor = 0;
+                    screen.promptAction = "remove";
+                    screen.error = "";
+                }
+                break;
+            }
+            case "\x1b":
+                state.stack.pop();
+                break;
+            case "q":
+            case "Q":
+                done();
+                return;
+        }
+        render(state);
+        return;
+    }
+    // ── Search subview ────────────────────────────────────────────────────────
+    if (screen.subview === "search") {
+        if (key === "\x1b") {
+            screen.subview = "menu";
+            render(state);
+            return;
+        }
+        if (key === "\r" || key === "\n") {
+            screen.running = true;
+            screen.error = "";
+            render(state);
+            try {
+                const raw = await searchNpmRegistry(screen.query);
+                screen.results = raw.map((r) => ({
+                    name: r.package.name,
+                    version: r.package.version,
+                    description: r.package.description ?? "",
+                    publisher: r.package.publisher?.username ?? "",
+                    score: r.score.final.toFixed(2),
+                    installedAt: "",
+                }));
+                screen.resultKind = "search";
+                screen.resultCursor = 0;
+                screen.resultScroll = 0;
+                screen.message = "";
+                screen.subview = "results";
+            }
+            catch (err) {
+                screen.error = err instanceof Error ? err.message : String(err);
+            }
+            finally {
+                screen.running = false;
+            }
+            render(state);
+            return;
+        }
+        if (key === "\x7f" || key === "\x08") {
+            if (screen.queryCursor > 0) {
+                screen.query =
+                    screen.query.slice(0, screen.queryCursor - 1) + screen.query.slice(screen.queryCursor);
+                screen.queryCursor--;
+            }
+        }
+        else if (key === "\x1b[D") {
+            if (screen.queryCursor > 0)
+                screen.queryCursor--;
+        }
+        else if (key === "\x1b[C") {
+            if (screen.queryCursor < screen.query.length)
+                screen.queryCursor++;
+        }
+        else if (key === "\x01" || key === "\x1b[H") {
+            screen.queryCursor = 0;
+        }
+        else if (key === "\x05" || key === "\x1b[F") {
+            screen.queryCursor = screen.query.length;
+        }
+        else if (key.length === 1 && key >= " ") {
+            screen.query =
+                screen.query.slice(0, screen.queryCursor) + key + screen.query.slice(screen.queryCursor);
+            screen.queryCursor++;
+        }
+        render(state);
+        return;
+    }
+    // ── Results subview ───────────────────────────────────────────────────────
+    if (screen.subview === "results") {
+        const { rows } = termSize();
+        const viewH = Math.max(3, rows - 10);
+        switch (key) {
+            case "\x1b[A":
+                if (screen.resultCursor > 0) {
+                    screen.resultCursor--;
+                    if (screen.resultCursor < screen.resultScroll)
+                        screen.resultScroll--;
+                }
+                break;
+            case "\x1b[B":
+                if (screen.resultCursor < screen.results.length - 1) {
+                    screen.resultCursor++;
+                    if (screen.resultCursor >= screen.resultScroll + viewH)
+                        screen.resultScroll++;
+                }
+                break;
+            case "\r":
+            case "\n":
+            case "i":
+            case "I":
+            case "r":
+            case "R": {
+                const result = screen.results[screen.resultCursor];
+                if (!result)
+                    break;
+                if (screen.resultKind === "installed" && (key === "i" || key === "I"))
+                    break;
+                const action = screen.resultKind === "installed" ? "remove" : "install";
+                const pkgName = result.name;
+                screen.message = dim(`${action === "install" ? "Installing" : "Removing"} ${pkgName}…`);
+                render(state);
+                const cmd = pluginGroup.commands.find((c) => c.name === action);
+                if (!cmd)
+                    break;
+                let opError = "";
+                let opMessage = "";
+                await runWithTerminal(async () => {
+                    const { writer, get } = makeCapturingWriter();
+                    try {
+                        await cmd.run({
+                            positional: [pkgName],
+                            flags: {},
+                            output: writer,
+                            getClient: state.getClient,
+                            getAdminClient: state.getAdminClient,
+                        });
+                        const out = get();
+                        if (out.type === "messages")
+                            opMessage = out.lines.join("\n");
+                        else
+                            opMessage = green(`✓ ${action === "install" ? "Installed" : "Removed"} ${pkgName}`);
+                    }
+                    catch (err) {
+                        opError = err instanceof Error ? err.message : String(err);
+                    }
+                });
+                screen.subview = "done";
+                screen.message = opMessage;
+                screen.error = opError;
+                break;
+            }
+            case "\x1b":
+                // Go back to search input if came from search, else back to menu
+                if (screen.resultKind === "search") {
+                    screen.subview = "search";
+                }
+                else {
+                    screen.subview = "menu";
+                }
+                break;
+            case "q":
+            case "Q":
+                done();
+                return;
+        }
+        render(state);
+        return;
+    }
+    // ── Prompt subview ────────────────────────────────────────────────────────
+    if (screen.subview === "prompt") {
+        if (key === "\x1b") {
+            screen.subview = "menu";
+            render(state);
+            return;
+        }
+        if (key === "\r" || key === "\n") {
+            const pkgName = screen.promptValue.trim();
+            if (!pkgName) {
+                screen.error = "Package name is required";
+                render(state);
+                return;
+            }
+            const cmd = pluginGroup.commands.find((c) => c.name === screen.promptAction);
+            if (!cmd)
+                return;
+            let opError = "";
+            let opMessage = "";
+            await runWithTerminal(async () => {
+                const { writer, get } = makeCapturingWriter();
+                try {
+                    await cmd.run({
+                        positional: [pkgName],
+                        flags: {},
+                        output: writer,
+                        getClient: state.getClient,
+                        getAdminClient: state.getAdminClient,
+                    });
+                    const out = get();
+                    if (out.type === "messages")
+                        opMessage = out.lines.join("\n");
+                    else
+                        opMessage = green("✓ Done");
+                }
+                catch (err) {
+                    opError = err instanceof Error ? err.message : String(err);
+                }
+            });
+            screen.subview = "done";
+            screen.message = opMessage;
+            screen.error = opError;
+            render(state);
+            return;
+        }
+        if (key === "\x7f" || key === "\x08") {
+            if (screen.promptCursor > 0) {
+                screen.promptValue =
+                    screen.promptValue.slice(0, screen.promptCursor - 1) +
+                        screen.promptValue.slice(screen.promptCursor);
+                screen.promptCursor--;
+            }
+        }
+        else if (key === "\x1b[D") {
+            if (screen.promptCursor > 0)
+                screen.promptCursor--;
+        }
+        else if (key === "\x1b[C") {
+            if (screen.promptCursor < screen.promptValue.length)
+                screen.promptCursor++;
+        }
+        else if (key === "\x01" || key === "\x1b[H") {
+            screen.promptCursor = 0;
+        }
+        else if (key === "\x05" || key === "\x1b[F") {
+            screen.promptCursor = screen.promptValue.length;
+        }
+        else if (key.length === 1 && key >= " ") {
+            screen.promptValue =
+                screen.promptValue.slice(0, screen.promptCursor) +
+                    key +
+                    screen.promptValue.slice(screen.promptCursor);
+            screen.promptCursor++;
+        }
+        render(state);
+        return;
+    }
+    // ── Done subview ──────────────────────────────────────────────────────────
+    switch (key) {
+        case "\x1b":
+            screen.subview = "menu";
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
 async function handleKey(key, state, done) {
     if (state.quitting)
         return;
@@ -2703,18 +3466,6 @@ async function handleKey(key, state, done) {
     const screen = state.stack[state.stack.length - 1];
     if (!screen)
         return;
-    // Global p/P: open profile view (skip when actively editing text)
-    if (key === "p" || key === "P") {
-        const isEditing = (screen.kind === "input" && screen.editing) ||
-            (screen.kind === "json-editor" && screen.editing) ||
-            (screen.kind === "settings" && screen.editing);
-        const isProfile = screen.kind === "profile";
-        if (!isEditing && !isProfile) {
-            state.stack.push({ kind: "profile", scroll: 0 });
-            render(state);
-            return;
-        }
-    }
     switch (screen.kind) {
         case "main":
             handleMainKey(key, screen, state, done);
@@ -2752,6 +3503,9 @@ async function handleKey(key, state, done) {
         case "json-editor":
             handleJsonEditorKey(key, screen, state, done);
             break;
+        case "plugins":
+            await handlePluginsKey(key, screen, state, done);
+            break;
     }
 }
 // ─── Shared TUI runner ────────────────────────────────────────────────────────