@north-light/api 0.3.579 → 0.3.587

package/dist/commands/sys/panels/profiles-panel.js

@@ -0,0 +1,655 @@
+// The Profiles settings destination: a map of profiles × their directories,
+// anchored on the directory the page was opened in.
+//
+// The startup profile menu (`core/profiles/select.ts`) is a CHOOSER — it shows
+// only profiles covering cwd, one matched dir each. This panel is the manager
+// behind its `v` key: every profile, every directory each one owns, which
+// directory is pinned where, and the edits that follow from seeing that
+// (adopt this dir, pin here, rename, remove a stale dir, delete).
+//
+// Most manifest edits and default bindings remain local. Pause/resume and
+// deletion cross broker lifecycle, so they route through crtrd.
+import { envNodeId } from '../../../shared/env.js';
+import { Input, matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
+import { basename } from 'node:path';
+import { PROFILE_PROJECT_MEMORY_VALUES } from '../../../api/dto/profiles.js';
+import { cliClient } from '../../api-client.js';
+import { clearDefaultProfile, defaultProfileDirs, getDefaultProfileId, setDefaultProfileId, } from '../../../core/profiles/default-binding.js';
+import { ROOT_PROFILE_ID, addProfileProject, createProfile, listProfiles, removeProfileProject, setProfileDeliveryLimit, } from '../../../core/profiles/manifest.js';
+import { tildify } from '../../../core/fs-utils.js';
+import { profileCoversCwd } from '../../../core/profiles/select.js';
+import { padAnsi, theme, visibleRange, wrapText, } from '../../../core/tui/panel.js';
+/** Coarse "used ..." for telling otherwise-alike profiles apart. */
+function relativeUsed(iso) {
+    if (iso === null)
+        return "never used";
+    const then = Date.parse(iso);
+    if (Number.isNaN(then))
+        return "used recently";
+    const secs = Math.max(0, Math.floor((Date.now() - then) / 1000));
+    if (secs < 60)
+        return "used just now";
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return `used ${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `used ${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `used ${days}d ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `used ${months}mo ago`;
+    return `used ${Math.floor(months / 12)}y ago`;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export class ProfilesPanel {
+    cwd;
+    onChange;
+    nameInput = new Input();
+    dirInput = new Input();
+    limitInput = new Input();
+    entries = [];
+    listIndex = 0;
+    dirIndex = 0;
+    mode = "list";
+    /** Profile the detail level / a confirm is about. */
+    openId = null;
+    notice;
+    noticeTone = "success";
+    mutating = false;
+    constructor(cwd, onChange) {
+        this.cwd = cwd;
+        this.onChange = onChange;
+        this.nameInput.onSubmit = () => {
+            this.submitName();
+            this.onChange();
+        };
+        this.nameInput.onEscape = () => {
+            this.mode = this.openId !== null ? "detail" : "list";
+            this.leaveField();
+            this.onChange();
+        };
+        this.dirInput.onSubmit = () => {
+            this.submitDir();
+            this.onChange();
+        };
+        this.dirInput.onEscape = () => {
+            this.mode = "detail";
+            this.leaveField();
+            this.onChange();
+        };
+        this.limitInput.onSubmit = () => {
+            this.submitLimit();
+            this.onChange();
+        };
+        this.limitInput.onEscape = () => {
+            this.mode = "detail";
+            this.leaveField();
+            this.onChange();
+        };
+        this.reload();
+    }
+    badge() {
+        return String(this.entries.length);
+    }
+    /** A live text field or a confirm keeps EVERY key, so a name containing `q`
+     *  can never close the page. The detail level claims only Escape and ← — they
+     *  mean "back to the profile list" here rather than "jump to the settings
+     *  rail" — and leaves the page's own navigation and cancel keys alone. */
+    ownsInput(data) {
+        if (this.mode === "list")
+            return false;
+        if (this.mode === "detail")
+            return matchesKey(data, "escape") || matchesKey(data, "left");
+        return true;
+    }
+    // state
+    /** Profiles covering cwd first (most recently used within), then the rest by
+     *  recency, with root last — the ones a startup pick is deciding between sit
+     *  at the top, where the eye starts. */
+    reload() {
+        const rank = (entry) => {
+            if (entry.profileId === ROOT_PROFILE_ID)
+                return 2;
+            return profileCoversCwd(entry, this.cwd) ? 0 : 1;
+        };
+        const used = (entry) => entry.manifest.last_used_at ?? "";
+        this.entries = listProfiles().sort((a, b) => {
+            const byRank = rank(a) - rank(b);
+            if (byRank !== 0)
+                return byRank;
+            const byUsed = used(b).localeCompare(used(a));
+            return byUsed !== 0 ? byUsed : a.manifest.name.localeCompare(b.manifest.name);
+        });
+        if (this.listIndex >= this.entries.length)
+            this.listIndex = Math.max(0, this.entries.length - 1);
+        const open = this.open();
+        if (open === null) {
+            if (this.mode !== "list")
+                this.mode = "list";
+            this.openId = null;
+        }
+        else if (this.dirIndex >= open.manifest.projects.length) {
+            this.dirIndex = Math.max(0, open.manifest.projects.length - 1);
+        }
+    }
+    selected() {
+        return this.entries[this.listIndex] ?? null;
+    }
+    open() {
+        if (this.openId === null)
+            return null;
+        return this.entries.find((e) => e.profileId === this.openId) ?? null;
+    }
+    currentDir() {
+        return this.open()?.manifest.projects[this.dirIndex] ?? null;
+    }
+    pinnedHere() {
+        return getDefaultProfileId(this.cwd);
+    }
+    say(text, tone = "success") {
+        this.notice = text;
+        this.noticeTone = tone;
+    }
+    /** Run a manifest mutation, turning its structured failure into the panel's
+     *  notice line rather than tearing the page down. */
+    attempt(what, ok) {
+        if (this.mutating)
+            return;
+        this.mutating = true;
+        void (async () => {
+            try {
+                await what();
+                this.reload();
+                this.say(ok);
+            }
+            catch (error) {
+                this.say(messageOf(error), "warning");
+            }
+            finally {
+                this.mutating = false;
+                this.onChange();
+            }
+        })();
+    }
+    // input
+    handleInput(data, matches) {
+        const handled = this.route(data, matches);
+        if (handled)
+            this.onChange();
+        return handled;
+    }
+    route(data, matches) {
+        switch (this.mode) {
+            case "new-name":
+            case "rename":
+                return this.routeText(this.nameInput, data);
+            case "add-dir":
+                return this.routeText(this.dirInput, data);
+            case "set-limit":
+                return this.routeText(this.limitInput, data);
+            case "confirm-delete":
+                return this.routeConfirm(data, () => void this.deleteOpen());
+            case "confirm-remove-dir":
+                return this.routeConfirm(data, () => this.removeDir());
+            case "detail":
+                return this.routeDetail(data, matches);
+            case "list":
+                return this.routeList(data, matches);
+        }
+    }
+    routeText(input, data) {
+        input.handleInput(data);
+        return true;
+    }
+    routeConfirm(data, confirm) {
+        const key = data.toLowerCase();
+        if (key === "y")
+            confirm();
+        else if (key === "n" || matchesKey(data, "escape") || matchesKey(data, "return")) {
+            this.mode = this.openId !== null ? "detail" : "list";
+            this.say("Cancelled.");
+        }
+        return true;
+    }
+    routeList(data, matches) {
+        if (matches?.("crtr.setup.list-down", data) === true) {
+            this.move(1);
+            return true;
+        }
+        if (matches?.("crtr.setup.list-up", data) === true) {
+            this.move(-1);
+            return true;
+        }
+        if (matches?.("crtr.setup.advance", data) === true) {
+            const entry = this.selected();
+            if (entry !== null) {
+                this.openId = entry.profileId;
+                this.dirIndex = 0;
+                this.mode = "detail";
+                this.notice = undefined;
+            }
+            return true;
+        }
+        switch (data.toLowerCase()) {
+            case "a":
+                return this.addCwdTo(this.selected());
+            case "d":
+                return this.togglePin();
+            case "n":
+                this.mode = "new-name";
+                this.edit(this.nameInput, basename(this.cwd) || "profile");
+                return true;
+            case "x":
+                return this.askDelete();
+            default:
+                return false;
+        }
+    }
+    routeDetail(data, matches) {
+        const open = this.open();
+        if (open === null) {
+            this.mode = "list";
+            return true;
+        }
+        if (matchesKey(data, "escape") || matchesKey(data, "left")) {
+            this.mode = "list";
+            this.notice = undefined;
+            return true;
+        }
+        if (matches?.("crtr.setup.list-down", data) === true) {
+            this.moveDir(1);
+            return true;
+        }
+        if (matches?.("crtr.setup.list-up", data) === true) {
+            this.moveDir(-1);
+            return true;
+        }
+        switch (data.toLowerCase()) {
+            case "a":
+                this.mode = "add-dir";
+                this.edit(this.dirInput, this.cwd);
+                return true;
+            case "l":
+                this.mode = "set-limit";
+                this.edit(this.limitInput, "");
+                return true;
+            case "x":
+                return this.askRemoveDir();
+            case "r":
+                this.mode = "rename";
+                this.edit(this.nameInput, open.manifest.name);
+                return true;
+            case "p":
+                return this.togglePause();
+            default:
+                return false;
+        }
+    }
+    /** Seed a field with the value the user most likely wants, cursor at its end
+     *  (`\x05` — the field is an edit-or-accept, never a blank you must retype). */
+    edit(input, value) {
+        input.setValue(value);
+        input.handleInput("\x05");
+        input.focused = true;
+        this.notice = undefined;
+    }
+    leaveField() {
+        this.nameInput.focused = false;
+        this.dirInput.focused = false;
+        this.limitInput.focused = false;
+    }
+    move(delta) {
+        if (this.entries.length === 0)
+            return;
+        this.listIndex =
+            (this.listIndex + delta + this.entries.length) % this.entries.length;
+        this.notice = undefined;
+    }
+    moveDir(delta) {
+        const count = this.open()?.manifest.projects.length ?? 0;
+        if (count === 0)
+            return;
+        this.dirIndex = (this.dirIndex + delta + count) % count;
+        this.notice = undefined;
+    }
+    // actions
+    addCwdTo(entry) {
+        if (entry === null)
+            return true;
+        this.attempt(() => addProfileProject(entry.profileId, this.cwd), `${tildify(this.cwd)} now belongs to "${entry.manifest.name}".`);
+        return true;
+    }
+    togglePin() {
+        const entry = this.selected();
+        if (entry === null)
+            return true;
+        if (this.pinnedHere() === entry.profileId) {
+            this.attempt(() => clearDefaultProfile(this.cwd), `${tildify(this.cwd)} no longer defaults to any profile.`);
+        }
+        else {
+            this.attempt(() => setDefaultProfileId(this.cwd, entry.profileId), `${tildify(this.cwd)} now starts as "${entry.manifest.name}" without asking.`);
+        }
+        return true;
+    }
+    submitName() {
+        const value = this.nameInput.getValue().trim();
+        const creating = this.mode === "new-name";
+        this.mode = creating ? "list" : "detail";
+        this.leaveField();
+        if (value === "") {
+            this.say("A profile name cannot be empty.", "warning");
+            return;
+        }
+        if (creating) {
+            this.attempt(async () => {
+                const createdId = (await createProfile(value, [{ path: this.cwd }])).profileId;
+                this.reload();
+                const at = this.entries.findIndex((e) => e.profileId === createdId);
+                if (at >= 0)
+                    this.listIndex = at;
+            }, `Created "${value}", owning ${tildify(this.cwd)}.`);
+            return;
+        }
+        const open = this.open();
+        if (open === null)
+            return;
+        void this.rename(open.profileId, value);
+    }
+    /** Rename through the daemon, which also renames the profile's canvas handle. */
+    async rename(profileId, name) {
+        if (this.mutating)
+            return;
+        this.mutating = true;
+        try {
+            await cliClient().updateProfile(profileId, { name });
+            this.reload();
+            this.say(`Renamed to "${name}".`);
+        }
+        catch (error) {
+            this.say(messageOf(error), "warning");
+        }
+        finally {
+            this.mutating = false;
+            this.onChange();
+        }
+    }
+    submitDir() {
+        const value = this.dirInput.getValue().trim();
+        const open = this.open();
+        this.mode = "detail";
+        this.leaveField();
+        if (open === null)
+            return;
+        if (value === "") {
+            this.say("Type the directory to add.", "warning");
+            return;
+        }
+        this.attempt(() => addProfileProject(open.profileId, value), `${tildify(value)} added to "${open.manifest.name}".`);
+    }
+    /** `<owner handle> <level>` sets one entry of the profile's `delivery_limits`. */
+    submitLimit() {
+        const parts = this.limitInput.getValue().trim().split(/\s+/);
+        const open = this.open();
+        this.mode = "detail";
+        this.leaveField();
+        if (open === null)
+            return;
+        const [owner, level] = parts;
+        if (parts.length !== 2 || owner === undefined || level === undefined || !PROFILE_PROJECT_MEMORY_VALUES.includes(level)) {
+            this.say(`Type an owner handle and a level (${PROFILE_PROJECT_MEMORY_VALUES.join(", ")}), e.g. "crouter preview".`, "warning");
+            return;
+        }
+        this.attempt(() => setProfileDeliveryLimit(open.profileId, owner, level), level === "content" ? `${owner} is no longer limited.` : `${owner} is delivered automatically up to "${level}".`);
+    }
+    askRemoveDir() {
+        if (this.currentDir() === null) {
+            this.say("This profile owns no directories.", "warning");
+            return true;
+        }
+        this.mode = "confirm-remove-dir";
+        this.notice = undefined;
+        return true;
+    }
+    removeDir() {
+        const open = this.open();
+        const dir = this.currentDir();
+        this.mode = "detail";
+        if (open === null || dir === null)
+            return;
+        this.attempt(() => removeProfileProject(open.profileId, dir.path), `${tildify(dir.path)} removed from "${open.manifest.name}".`);
+    }
+    togglePause() {
+        const open = this.open();
+        if (open !== null && !this.mutating)
+            void this.changePause(open);
+        return true;
+    }
+    async changePause(open) {
+        this.mutating = true;
+        const paused = open.manifest.paused_at !== null;
+        try {
+            if (paused)
+                await cliClient().resumeProfile(open.profileId);
+            else
+                await cliClient().pauseProfile(open.profileId);
+            this.reload();
+            this.say(paused
+                ? `"${open.manifest.name}" is active again.`
+                : `"${open.manifest.name}" is paused — no new nodes start under it.`);
+        }
+        catch (error) {
+            this.say(messageOf(error), "warning");
+        }
+        finally {
+            this.mutating = false;
+            this.onChange();
+        }
+    }
+    askDelete() {
+        const entry = this.selected();
+        if (entry === null)
+            return true;
+        if (entry.profileId === ROOT_PROFILE_ID) {
+            this.say("The root profile is the fallback identity for uncovered directories and cannot be deleted.", "warning");
+            return true;
+        }
+        this.openId = entry.profileId;
+        this.mode = "confirm-delete";
+        this.notice = undefined;
+        return true;
+    }
+    async deleteOpen() {
+        const open = this.open();
+        this.mode = "list";
+        if (open === null || this.mutating)
+            return;
+        this.mutating = true;
+        this.say(`Deleting "${open.manifest.name}"…`);
+        this.onChange();
+        try {
+            const result = await cliClient().deleteProfile(open.profileId, {
+                force: true,
+                caller_node_id: envNodeId() ?? null,
+            });
+            this.openId = null;
+            this.reload();
+            this.say(`Deleted "${result.name}" — ${result.nodes} nodes, ${result.crons} crons, ${result.default_pins} pins.`);
+        }
+        catch (error) {
+            this.say(messageOf(error), "warning");
+        }
+        finally {
+            this.mutating = false;
+            this.onChange();
+        }
+    }
+    // rendering
+    footerHint() {
+        switch (this.mode) {
+            case "new-name":
+                return "type a name · enter create · esc cancel";
+            case "rename":
+                return "type a name · enter save · esc cancel";
+            case "add-dir":
+                return "type a directory · enter add · esc cancel";
+            case "set-limit":
+                return "type <owner> <level> · enter save · esc cancel";
+            case "confirm-delete":
+            case "confirm-remove-dir":
+                return "y confirm · n cancel";
+            case "detail":
+                return "↑↓ dir · a add · l limit · x remove · r rename · p pause · esc back";
+            case "list":
+                return "↑↓ move · enter open · a add this dir · d pin here · n new · x delete";
+        }
+    }
+    render(width, height) {
+        // Each prompt renders over the level it acts on: naming a new profile and
+        // confirming a deletion belong to the list, while renaming, adding a
+        // directory and confirming its removal belong to the open profile.
+        const overList = this.mode === "list" ||
+            this.mode === "new-name" ||
+            this.mode === "confirm-delete";
+        const out = overList
+            ? this.renderList(width, height)
+            : this.renderDetail(width, height);
+        if (this.notice !== undefined) {
+            out.push("");
+            for (const line of wrapText(this.notice, width))
+                out.push(truncateToWidth(theme.fg(this.noticeTone, line), width));
+        }
+        return out;
+    }
+    header(width, title, meta) {
+        const left = theme.fg("accent", theme.bold(title));
+        const right = theme.fg("dim", meta);
+        return truncateToWidth(`${left}  ${right}`, width);
+    }
+    renderList(width, height) {
+        const out = [
+            this.header(width, "Profiles", `${this.entries.length} profile${this.entries.length === 1 ? "" : "s"}`),
+            truncateToWidth(theme.fg("dim", `Identities your sessions run under.  Here: ${tildify(this.cwd)}`), width),
+            "",
+        ];
+        // Prompts first: the very first profile is created from the empty list, so
+        // an empty-state message that returned before them would hide the field the
+        // user is typing into.
+        if (this.mode === "new-name")
+            return [...out, ...this.field(width, "New profile name", this.nameInput)];
+        if (this.mode === "confirm-delete")
+            return [...out, ...this.deletePrompt(width)];
+        if (this.entries.length === 0) {
+            out.push(truncateToWidth(theme.fg("dim", "  No profiles yet — press n to create one here."), width));
+            return out;
+        }
+        const pinned = this.pinnedHere();
+        const nameWidth = Math.min(22, Math.max(...this.entries.map((e) => e.manifest.name.length)));
+        const capacity = Math.max(1, height - 8);
+        const range = visibleRange(this.entries.length, this.listIndex, capacity);
+        for (let index = range.start; index < range.end; index += 1) {
+            const entry = this.entries[index];
+            const count = entry.manifest.projects.length;
+            const dirs = count === 0 ? "—" : `${count} dir${count === 1 ? "" : "s"}`;
+            const badges = [];
+            if (profileCoversCwd(entry, this.cwd))
+                badges.push("covers here");
+            if (pinned === entry.profileId)
+                badges.push("pinned");
+            if (entry.manifest.paused_at !== null)
+                badges.push("paused");
+            const body = `${padAnsi(entry.manifest.name, nameWidth)}  ${padAnsi(dirs, 8)}  ${padAnsi(relativeUsed(entry.manifest.last_used_at), 14)}  ${badges.join(" · ")}`;
+            if (index === this.listIndex)
+                out.push(theme.bg("selectedBg", padAnsi(`\u25b8 ${body}`, width)));
+            else
+                out.push(truncateToWidth(`  ${padAnsi(entry.manifest.name, nameWidth)}  ${theme.fg("dim", `${padAnsi(dirs, 8)}  ${padAnsi(relativeUsed(entry.manifest.last_used_at), 14)}`)}  ${theme.fg("muted", badges.join(" · "))}`, width));
+        }
+        if (range.start > 0 || range.end < this.entries.length)
+            out.push(truncateToWidth(theme.fg("dim", `  ${this.listIndex + 1}/${this.entries.length}`), width));
+        return out;
+    }
+    renderDetail(width, height) {
+        const open = this.open();
+        if (open === null)
+            return this.renderList(width, height);
+        const manifest = open.manifest;
+        const facts = [
+            `app ${manifest.grantee ?? 'app:terminal'}`,
+            `kind ${manifest.default_kind ?? "general"}`,
+            relativeUsed(manifest.last_used_at),
+            ...(manifest.paused_at !== null ? ["paused"] : []),
+        ];
+        const out = [
+            this.header(width, manifest.name, open.profileId),
+            truncateToWidth(theme.fg("dim", facts.join(" \u00b7 ")), width),
+            "",
+        ];
+        if (this.mode === "rename")
+            return [...out, ...this.field(width, "Rename profile", this.nameInput)];
+        if (this.mode === "add-dir")
+            return [
+                ...out,
+                ...this.field(width, "Directory to add to this profile", this.dirInput),
+            ];
+        if (this.mode === "set-limit")
+            return [
+                ...out,
+                ...this.field(width, "Delivery limit: owner handle and level (content removes it)", this.limitInput),
+            ];
+        const limits = Object.entries(manifest.delivery_limits ?? {});
+        if (limits.length > 0) {
+            out.push(truncateToWidth(theme.fg("dim", `limits ${limits.map(([owner, level]) => `${owner} ${level}`).join(" \u00b7 ")}`), width));
+            out.push("");
+        }
+        const projects = manifest.projects;
+        if (projects.length === 0) {
+            out.push(truncateToWidth(theme.fg("dim", "  Owns no directories — press a to add one."), width));
+            return out;
+        }
+        const pins = new Set(defaultProfileDirs(open.profileId));
+        const pathWidth = Math.min(Math.max(20, width - 16), Math.max(...projects.map((p) => tildify(p.path).length)));
+        const capacity = Math.max(1, height - 8);
+        const range = visibleRange(projects.length, this.dirIndex, capacity);
+        for (let index = range.start; index < range.end; index += 1) {
+            const project = projects[index];
+            const badges = [];
+            if (pins.has(project.path))
+                badges.push("pinned");
+            if (project.path === this.cwd)
+                badges.push("\u2190 here");
+            const path = padAnsi(tildify(project.path), pathWidth);
+            const body = `${path}  ${badges.join(" \u00b7 ")}`;
+            if (index === this.dirIndex)
+                out.push(theme.bg("selectedBg", padAnsi(`\u25b8 ${body}`, width)));
+            else
+                out.push(truncateToWidth(`  ${path}  ${theme.fg("muted", badges.join(" \u00b7 "))}`, width));
+        }
+        if (this.mode === "confirm-remove-dir") {
+            const dir = this.currentDir();
+            out.push("");
+            out.push(truncateToWidth(theme.fg("warning", `Remove ${dir !== null ? tildify(dir.path) : "this directory"} from "${manifest.name}"? Its files are untouched.  y / n`), width));
+        }
+        return out;
+    }
+    /** A labelled single-line text field, used by every prompt in the panel. */
+    field(width, label, input) {
+        return [
+            truncateToWidth(theme.fg("accent", label), width),
+            truncateToWidth(`  ${input.render(Math.max(8, width - 2))[0] ?? ""}`, width),
+        ];
+    }
+    deletePrompt(width) {
+        const open = this.open();
+        const name = open?.manifest.name ?? "";
+        const out = [];
+        for (const line of wrapText(`Delete "${name}" and everything it owns — every node, cron, inbox ticket and review under it, plus its documents (one that another document links to is kept until that link goes) and directory pins? This cannot be undone.`, width))
+            out.push(truncateToWidth(theme.fg("warning", line), width));
+        out.push("");
+        out.push(truncateToWidth(theme.fg("dim", "  y delete   n cancel"), width));
+        return out;
+    }
+}