@sealant/mend 0.22.0 → 0.24.0

package/dist/agent-share.js

@@ -1,150 +0,0 @@
-import * as net from "node:net";
-import { setTimeout as delay } from "node:timers/promises";
-/** The bridge endpoint for a server url: ws(s), this machine named, the token as a query. */
-export const bridgeUrlOf = (serverUrl, token, host) => {
-    const url = new URL(`${serverUrl}/api/keys/bridge/ws`);
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    url.searchParams.set("host", host);
-    if (token !== null)
-        url.searchParams.set("token", token);
-    return url;
-};
-/** Reconnect backoff: 1s, 2s, … capped at 30s. */
-export const retryDelayMs = (attempt) => Math.min(30_000, 1000 * 2 ** Math.min(Math.max(attempt - 1, 0), 5));
-const SSH_AGENTC_REQUEST_IDENTITIES = 11;
-const SSH_AGENTC_SIGN_REQUEST = 13;
-/**
- * One complete agent exchange against the local agent: fresh connection,
- * write the framed request verbatim, read one framed response. A hardware
- * key blocks here until the touch — hence the generous timeout.
- */
-const askLocalAgent = (agentSock, payload) => new Promise((resolve, reject) => {
-    const connection = net.connect(agentSock, () => {
-        connection.write(payload);
-    });
-    const timer = setTimeout(() => {
-        connection.destroy();
-        reject(new Error("the agent did not answer within 60s — touch missed?"));
-    }, 60_000);
-    let pending = Buffer.alloc(0);
-    connection.on("data", (chunk) => {
-        pending = Buffer.concat([pending, chunk]);
-        if (pending.length >= 4 && pending.length >= 4 + pending.readUInt32BE(0)) {
-            clearTimeout(timer);
-            connection.end();
-            resolve(pending.subarray(0, 4 + pending.readUInt32BE(0)));
-        }
-    });
-    connection.on("error", (error) => {
-        clearTimeout(timer);
-        reject(error);
-    });
-});
-/** An abortable wait; an abort simply ends it early. */
-const sleep = (ms, signal) => delay(ms, undefined, { signal }).then(() => undefined, () => undefined);
-/** Share until the signal aborts; every connect, drop, and signature is an event. */
-export const shareAgent = async (options) => {
-    const { url, agentSock, signal, onEvent } = options;
-    // Requests are answered one at a time: the agent protocol has one in flight.
-    let chain = Promise.resolve();
-    let attempt = 0;
-    while (!signal.aborted) {
-        const ws = new WebSocket(url);
-        const onAbort = () => ws.close();
-        signal.addEventListener("abort", onAbort, { once: true });
-        const closed = new Promise((resolve) => {
-            ws.addEventListener("close", () => resolve(), { once: true });
-        });
-        const opened = await new Promise((resolve) => {
-            ws.addEventListener("open", () => resolve(true), { once: true });
-            ws.addEventListener("error", () => resolve(false), { once: true });
-        });
-        if (opened) {
-            attempt = 0;
-            onEvent({ kind: "connected" });
-            ws.addEventListener("message", (event) => {
-                const text = typeof event.data === "string"
-                    ? event.data
-                    : Buffer.from(event.data).toString("utf8");
-                let frame;
-                try {
-                    frame = JSON.parse(text);
-                }
-                catch {
-                    return;
-                }
-                if (frame.t !== "req" ||
-                    typeof frame.id !== "number" ||
-                    typeof frame.payload !== "string") {
-                    return;
-                }
-                const id = frame.id;
-                const payload = Buffer.from(frame.payload, "base64");
-                const type = payload[4];
-                const context = typeof frame.context === "string" ? frame.context : "mend";
-                chain = chain.then(async () => {
-                    const started = Date.now();
-                    if (type === SSH_AGENTC_SIGN_REQUEST)
-                        onEvent({ kind: "sign-requested", context });
-                    else if (type === SSH_AGENTC_REQUEST_IDENTITIES) {
-                        onEvent({ kind: "identities-requested", context });
-                    }
-                    try {
-                        const response = await askLocalAgent(agentSock, payload);
-                        if (ws.readyState !== WebSocket.OPEN)
-                            return null;
-                        ws.send(JSON.stringify({ t: "res", id, payload: response.toString("base64") }));
-                        if (type === SSH_AGENTC_SIGN_REQUEST) {
-                            onEvent({ kind: "signed", context, seconds: (Date.now() - started) / 1000 });
-                        }
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(JSON.stringify({ t: "err", id, message }));
-                        }
-                        if (type === SSH_AGENTC_SIGN_REQUEST)
-                            onEvent({ kind: "not-signed", context, message });
-                    }
-                    return null;
-                });
-            });
-        }
-        await closed;
-        signal.removeEventListener("abort", onAbort);
-        if (signal.aborted)
-            return;
-        attempt += 1;
-        const retryMs = retryDelayMs(attempt);
-        onEvent({ kind: "disconnected", retryMs });
-        await sleep(retryMs, signal);
-    }
-};
-/** Start sharing in the background; `stop` ends it. */
-export const startAgentShare = (options) => {
-    const controller = new AbortController();
-    const listeners = new Set();
-    let state = "connecting";
-    void shareAgent({
-        ...options,
-        signal: controller.signal,
-        onEvent: (event) => {
-            if (event.kind === "connected")
-                state = "connected";
-            else if (event.kind === "disconnected")
-                state = "connecting";
-            for (const listener of listeners)
-                listener(event);
-        },
-    });
-    return {
-        snapshot: () => state,
-        subscribe: (listener) => {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        stop: () => controller.abort(),
-    };
-};

package/dist/clipboard.js

@@ -1,73 +0,0 @@
-import { execFile } from "node:child_process";
-const IMAGE_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
-/** The first image type this reader accepts from a clipboard's offered list. */
-export const pickImageType = (offered) => {
-    const types = offered.split(/\s+/).map((type) => type.trim().toLowerCase());
-    for (const type of IMAGE_TYPES)
-        if (types.includes(type))
-            return type;
-    return null;
-};
-/**
- * AppleScript's `«data PNGf…»` literal: the PNG bytes as hex, from
- * `the clipboard as «class PNGf»`. Null when the clipboard held no image.
- */
-export const parsePngfHex = (output) => {
-    const match = /«data PNGf([0-9A-Fa-f]+)»/.exec(output.trim());
-    if (match?.[1] === undefined || match[1].length === 0)
-        return null;
-    return Buffer.from(match[1], "hex");
-};
-const MAX_BYTES = 32 * 1024 * 1024;
-/** One clipboard tool call; null when the tool is missing, fails, or times out. */
-const run = (command, args) => new Promise((resolve) => {
-    execFile(command, [...args], { encoding: "buffer", maxBuffer: MAX_BYTES, timeout: 3000 }, (error, stdout) => {
-        resolve(error === null ? stdout : null);
-    });
-});
-const fromWayland = async () => {
-    const offered = await run("wl-paste", ["--list-types"]);
-    if (offered === null)
-        return null;
-    const mediaType = pickImageType(offered.toString("utf8"));
-    if (mediaType === null)
-        return null;
-    const bytes = await run("wl-paste", ["--no-newline", "--type", mediaType]);
-    return bytes === null || bytes.length === 0 ? null : { bytes, mediaType };
-};
-const fromX11 = async () => {
-    const offered = await run("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"]);
-    if (offered === null)
-        return null;
-    const mediaType = pickImageType(offered.toString("utf8"));
-    if (mediaType === null)
-        return null;
-    const bytes = await run("xclip", ["-selection", "clipboard", "-t", mediaType, "-o"]);
-    return bytes === null || bytes.length === 0 ? null : { bytes, mediaType };
-};
-const fromMac = async () => {
-    const output = await run("osascript", ["-e", "the clipboard as «class PNGf»"]);
-    if (output === null)
-        return null;
-    const bytes = parsePngfHex(output.toString("utf8"));
-    return bytes === null ? null : { bytes, mediaType: "image/png" };
-};
-/**
- * Read an image off the clipboard: wl-paste on Wayland, xclip on X11,
- * osascript on macOS. Null when there is no image or no way to ask — the
- * caller then forwards the keystroke as it was.
- */
-export const readClipboardImage = async (platform = process.platform, env = process.env) => {
-    if (platform === "darwin")
-        return fromMac();
-    if (platform !== "linux" && platform !== "freebsd" && platform !== "openbsd")
-        return null;
-    if (env["WAYLAND_DISPLAY"] !== undefined && env["WAYLAND_DISPLAY"] !== "") {
-        const image = await fromWayland();
-        if (image !== null)
-            return image;
-    }
-    if (env["DISPLAY"] !== undefined && env["DISPLAY"] !== "")
-        return fromX11();
-    return null;
-};

package/dist/dashboard-model.js

@@ -1,308 +0,0 @@
-import { HARNESS_COMMANDS, LIVE_STATUSES } from "./shared.js";
-/**
- * The worktree IS the session's identity (one worktree per session): its
- * branch, with the noisy default prefix receded. What you are working on
- * leads every row; the harness is a fact about it, not its name.
- */
-export const worktreeName = (branch) => branch.startsWith("mend/") ? branch.slice("mend/".length) : branch;
-/**
- * What to call an UNNAMED worktree: its branch is `mend/session/<uuid>` —
- * noise nobody recognizes — so the auto-name label stands in, and before one
- * lands, the short session id. A named worktree is always its own name.
- */
-export const worktreeDisplayName = (session) => {
-    const name = worktreeName(session.branch);
-    if (!name.startsWith("session/"))
-        return name;
-    return session.label ?? `session ${session.id.slice(0, 8)}`;
-};
-/** True when the label already IS the row's identity — don't repeat it. */
-export const labelIsIdentity = (session) => worktreeName(session.branch).startsWith("session/") && session.label !== null;
-export const WORKBENCH_KEY = ["workbench"];
-export const fetchWorkbench = async (ctx) => {
-    const projects = await ctx.api("GET", "/projects");
-    const [fetched, services] = await Promise.all([
-        Promise.all(projects.map((project) => ctx.api("GET", `/projects/${project.id}`))),
-        ctx.api("GET", "/services"),
-    ]);
-    const servicesBySession = new Map();
-    for (const service of services) {
-        const bucket = servicesBySession.get(service.sessionId) ?? [];
-        bucket.push(service);
-        servicesBySession.set(service.sessionId, bucket);
-    }
-    // What lives in each LIVE worktree: the agent and shells come from the
-    // session detail (settled sessions have nothing live — no fetch for them).
-    const liveSessions = fetched.flatMap((detail) => detail.sessions.filter((session) => LIVE_STATUSES.has(session.status)));
-    const detailed = await Promise.all(liveSessions.map(async (session) => {
-        try {
-            return await ctx.api("GET", `/sessions/${session.id}`);
-        }
-        catch {
-            return null;
-        }
-    }));
-    const processesBySession = new Map();
-    for (const detail of detailed) {
-        if (detail === null)
-            continue;
-        processesBySession.set(detail.session.id, detail.processes.filter((process) => process.exitedAt === null && process.kind !== "service"));
-    }
-    return {
-        projects,
-        details: new Map(fetched.map((detail) => [detail.project.id, detail])),
-        servicesBySession,
-        processesBySession,
-    };
-};
-// ─── optimistic cache surgery: pure Workbench → Workbench ───────────────────
-/** Apply `f` to every session row in every project detail. */
-export const mapWorkbenchSessions = (data, f) => ({
-    ...data,
-    details: new Map([...data.details].map(([id, detail]) => [id, { ...detail, sessions: detail.sessions.map(f) }])),
-});
-export const mapProjectSessions = (data, projectId, f) => {
-    const detail = data.details.get(projectId);
-    if (detail === undefined)
-        return data;
-    const details = new Map(data.details);
-    details.set(projectId, { ...detail, sessions: f(detail.sessions) });
-    return { ...data, details };
-};
-export const prependSession = (data, projectId, session) => mapProjectSessions(data, projectId, (sessions) => [session, ...sessions]);
-export const replaceSession = (data, projectId, oldId, session) => mapProjectSessions(data, projectId, (sessions) => sessions.map((candidate) => (candidate.id === oldId ? session : candidate)));
-export const removeSession = (data, projectId, sessionId) => mapProjectSessions(data, projectId, (sessions) => sessions.filter((candidate) => candidate.id !== sessionId));
-export const deriveProjects = (data) => (data?.projects ?? []).map((project) => {
-    const detail = data?.details.get(project.id);
-    const sessions = detail?.sessions ?? [];
-    const live = sessions.filter((s) => LIVE_STATUSES.has(s.status)).length;
-    const open = (detail?.annotations ?? []).reduce((sum, a) => sum + a.openComments, 0);
-    return { project, total: sessions.length, live, open };
-});
-export const bySessionRecency = (a, b) => {
-    const aLive = LIVE_STATUSES.has(a.status) ? 1 : 0;
-    const bLive = LIVE_STATUSES.has(b.status) ? 1 : 0;
-    if (aLive !== bLive)
-        return bLive - aLive;
-    return b.createdAt.localeCompare(a.createdAt);
-};
-export const toSessionItem = (data, detail) => (session) => ({
-    session,
-    annotation: detail.annotations.find((a) => a.sessionId === session.id),
-    services: data.servicesBySession.get(session.id) ?? [],
-    processes: data.processesBySession.get(session.id) ?? [],
-});
-/**
- * A settled session that never had a conversation — no transcript captured, none in the harness
- * home — cannot be resumed or handed off. The dashboard hides it; `mend sessions --all` still
- * lists it, and removing the worktree takes it along.
- */
-export const isDeadEnd = (session) => !LIVE_STATUSES.has(session.status) && session.hasTranscript === false;
-export const deriveWorktrees = (data, projectId) => {
-    if (data === undefined || projectId === null)
-        return [];
-    const detail = data.details.get(projectId);
-    if (detail === undefined)
-        return [];
-    const item = toSessionItem(data, detail);
-    const sorted = detail.sessions
-        .filter((session) => !isDeadEnd(session))
-        .toSorted(bySessionRecency);
-    const groups = [];
-    if (detail.worktrees !== undefined) {
-        const claimed = new Set();
-        for (const worktree of detail.worktrees) {
-            const members = sorted.filter((session) => session.worktreeId === worktree.id);
-            for (const member of members)
-                claimed.add(member.id);
-            groups.push({
-                key: worktree.id,
-                id: worktree.id,
-                name: worktree.name.startsWith("wt-")
-                    ? (members.find((m) => m.label !== null)?.label ??
-                        (members[0] === undefined ? worktree.name : `session ${members[0].id.slice(0, 8)}`))
-                    : worktree.name,
-                branch: worktree.branch,
-                baseRef: worktree.baseRef,
-                createdAt: worktree.createdAt,
-                sessions: members.map(item),
-                live: members.filter((session) => LIVE_STATUSES.has(session.status)).length,
-                annotation: detail.annotations.find((a) => members.some((m) => m.id === a.sessionId)),
-            });
-        }
-        // Optimistic pending rows have no worktree yet — each is its own group.
-        for (const session of sorted) {
-            if (claimed.has(session.id))
-                continue;
-            groups.push(pseudoGroup(session, item));
-        }
-    }
-    else {
-        for (const session of sorted)
-            groups.push(pseudoGroup(session, item));
-    }
-    return groups.toSorted((a, b) => {
-        if (a.live > 0 !== b.live > 0)
-            return a.live > 0 ? -1 : 1;
-        const aNewest = a.sessions[0]?.session.createdAt ?? a.createdAt;
-        const bNewest = b.sessions[0]?.session.createdAt ?? b.createdAt;
-        return bNewest.localeCompare(aNewest);
-    });
-};
-export const pseudoGroup = (session, item) => ({
-    key: session.id,
-    id: null,
-    name: worktreeDisplayName(session),
-    branch: session.branch,
-    baseRef: session.baseRef,
-    createdAt: session.createdAt,
-    sessions: [item(session)],
-    live: LIVE_STATUSES.has(session.status) ? 1 : 0,
-    annotation: item(session).annotation,
-});
-export const deriveRows = (groups) => groups.flatMap((group) => [
-    { kind: "worktree", group },
-    ...group.sessions.map((item) => ({ kind: "session", group, item })),
-]);
-export const rowKeyOf = (row) => row.kind === "worktree" ? `wt:${row.group.key}` : `s:${row.item.session.id}`;
-/** The picker's rows: resume offers the same harness first, then the crossings. */
-export const deriveHarnesses = (resuming) => {
-    if (resuming !== null) {
-        const others = Object.keys(HARNESS_COMMANDS).filter((h) => h !== resuming.harness);
-        return [
-            {
-                harness: null,
-                label: resuming.harness,
-                hint: "same harness — native resume, conversation intact",
-            },
-            ...others.map((harness) => ({
-                harness,
-                label: harness,
-                hint: harness === "shell"
-                    ? "a bash in the worktree — resume either agent from inside"
-                    : "the conversation crosses as a distilled prompt",
-            })),
-        ];
-    }
-    return Object.keys(HARNESS_COMMANDS).map((harness) => ({
-        harness,
-        label: harness,
-        hint: harness === "shell"
-            ? "a plain bash session — new worktree, recorded"
-            : `mend ${harness} — new worktree, recorded session`,
-    }));
-};
-/** The worktree's folded status word: waiting wins, then running, then idle. */
-export const foldGroupStatus = (group) => {
-    const statuses = group.sessions.map((item) => item.session.status);
-    if (statuses.includes("waiting"))
-        return "waiting";
-    if (statuses.includes("running") || statuses.includes("starting"))
-        return "running";
-    if (statuses.includes("idle"))
-        return "idle";
-    return statuses[0] ?? "idle";
-};
-// ─── attach + verb helpers ──────────────────────────────────────────────────
-/**
- * Where "get me in" should land when the session has no live agent terminal:
- * the newest LIVE shell, so repeated attaches rejoin the same one instead of
- * stacking a fresh bash per attempt (the five-orphan-shells failure mode).
- * Null = nothing attachable; opening a new shell is then honest.
- */
-export const liveShellOf = (processes) => processes.findLast((process) => process.kind === "shell" && process.exitedAt === null) ?? null;
-/**
- * The session's live protocol agent — a phone pickup driving the same
- * conversation over stream-json. It holds the workspace with no PTY behind it,
- * so a terminal "get me in" must take it over (hand back to a TUI) rather than
- * report the attach unavailable or open a bare shell. Null = no pickup to take.
- */
-export const liveProtocolOf = (processes) => processes.find((process) => process.kind === "agent-protocol" && process.exitedAt === null) ??
-    null;
-/**
- * The optimistic stop: the row settles AND its live process/service fact
- * lines drop in the same paint — the server's refetch only confirms.
- */
-export const markSessionStopped = (data, sessionId) => {
-    const processesBySession = new Map(data.processesBySession);
-    processesBySession.delete(sessionId);
-    const servicesBySession = new Map(data.servicesBySession);
-    servicesBySession.delete(sessionId);
-    return {
-        ...mapWorkbenchSessions(data, (session) => session.id === sessionId ? { ...session, status: "stopped" } : session),
-        processesBySession,
-        servicesBySession,
-    };
-};
-/** The optimistic removal: the whole group leaves the list before the server answers. */
-export const removeWorktreeGroup = (data, projectId, group) => {
-    const memberIds = new Set(group.sessions.map((item) => item.session.id));
-    const detail = data.details.get(projectId);
-    if (detail === undefined)
-        return data;
-    const details = new Map(data.details);
-    details.set(projectId, {
-        ...detail,
-        sessions: detail.sessions.filter((session) => !memberIds.has(session.id)),
-        ...(detail.worktrees === undefined
-            ? {}
-            : { worktrees: detail.worktrees.filter((worktree) => worktree.id !== group.id) }),
-    });
-    return { ...data, details };
-};
-/**
- * Subsequence fuzzy score, fzf-flavored: every query character must appear in
- * order; consecutive hits and segment starts (after `/`, `-`, `_`, `.`) score
- * higher; earlier matches beat later ones. Null = no match. Case-insensitive.
- */
-export const fuzzyScore = (query, candidate) => {
-    if (query === "")
-        return 0;
-    const q = query.toLowerCase();
-    const c = candidate.toLowerCase();
-    let score = 0;
-    let last = -1;
-    for (const char of q) {
-        const at = c.indexOf(char, last + 1);
-        if (at === -1)
-            return null;
-        if (at === last + 1)
-            score += 3;
-        else if (at === 0 || "/-_.".includes(c[at - 1] ?? ""))
-            score += 2;
-        else
-            score += 1;
-        score -= (at - last - 1) * 0.01;
-        last = at;
-    }
-    return score;
-};
-/**
- * The picker's rows for one query: fuzzy-filtered, best score first, ties by
- * most recent commit; an empty query lists everything, default branch on top.
- */
-export const filterBranches = (branches, query) => {
-    const scored = branches.flatMap((branch) => {
-        const score = fuzzyScore(query, branch.name);
-        return score === null ? [] : [{ branch, score }];
-    });
-    return scored
-        .toSorted((a, b) => {
-        if (query === "" && a.branch.isDefault !== b.branch.isDefault) {
-            return a.branch.isDefault ? -1 : 1;
-        }
-        if (a.score !== b.score)
-            return b.score - a.score;
-        return b.branch.committedAt.localeCompare(a.branch.committedAt);
-    })
-        .map((entry) => entry.branch);
-};
-/** Commit the base step: the highlighted branch (default branch = null base). */
-export const advanceFromBase = (current) => {
-    const chosen = filterBranches(current.branches ?? [], current.query)[current.baseIndex];
-    return {
-        ...current,
-        base: chosen === undefined || chosen.isDefault ? null : chosen.name,
-        step: "harness",
-    };
-};