@luuthuong/devboard 0.0.0-stage → 1.0.0

package/server-dist/server/sessions.js

@@ -0,0 +1,315 @@
+// Session discovery for Claude Code.
+// Ports jsonl_parser.rs and session_discovery.rs.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { IS_WINDOWS, log, readLines, run, takeChars } from "./util.js";
+function extractTextContent(obj) {
+    const content = obj?.message?.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const joined = content
+            .filter((b) => b?.type === "text" && typeof b.text === "string")
+            .map((b) => b.text)
+            .join("\n");
+        if (joined)
+            return joined;
+    }
+    return undefined;
+}
+/** First few lines of a Claude .jsonl → metadata, or null when it has no messages. */
+export async function extractMetadata(filePath) {
+    const meta = {
+        sessionId: path.basename(filePath, path.extname(filePath)),
+        messageCount: 0,
+    };
+    let foundFirstUser = false;
+    try {
+        for await (const line of readLines(filePath)) {
+            if (!line || !line.includes('"type"'))
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const msgType = typeof obj?.type === "string" ? obj.type : "";
+            if (!meta.projectPath && typeof obj.cwd === "string")
+                meta.projectPath = obj.cwd;
+            if (!meta.gitBranch && typeof obj.gitBranch === "string")
+                meta.gitBranch = obj.gitBranch;
+            if (msgType === "user" || msgType === "assistant")
+                meta.messageCount++;
+            if (msgType === "user" && !foundFirstUser) {
+                foundFirstUser = true;
+                meta.firstPrompt = extractTextContent(obj);
+            }
+            if (meta.messageCount >= 5 && foundFirstUser)
+                break;
+        }
+    }
+    catch {
+        return null;
+    }
+    return meta.messageCount === 0 ? null : meta;
+}
+/** "-Users-foo-bar" → "/Users/foo/bar". */
+export function decodeDirectoryName(name) {
+    let result = name;
+    if (result.startsWith("-"))
+        result = "/" + result.slice(1);
+    return result.replaceAll("-", "/");
+}
+const PUSH_RE = /git\s+push\s+(?:-\S+\s+)*(?:origin|upstream)\s+(\S+)/g;
+const CHECKOUT_RE = /git\s+checkout\s+-[bB]\s+(\S+)/g;
+const SWITCH_RE = /git\s+switch\s+(?:-c|--create)\s+(\S+)/g;
+const WORKTREE_RE = /git\s+worktree\s+add\s+\S+\s+-b\s+(\S+)/g;
+/** Branches a session pushed/created, scraped from its Bash tool calls. */
+export async function extractPushedBranches(filePath) {
+    const branches = new Set();
+    try {
+        for await (const line of readLines(filePath)) {
+            if (!line || !line.includes('"tool_use"'))
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const content = obj?.message?.content;
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (block?.type !== "tool_use" || block?.name !== "Bash")
+                    continue;
+                const command = block?.input?.command;
+                if (typeof command !== "string")
+                    continue;
+                for (const re of [PUSH_RE, CHECKOUT_RE, SWITCH_RE, WORKTREE_RE]) {
+                    for (const m of command.matchAll(re)) {
+                        const b = m[1];
+                        if (b !== "main" && b !== "master" && !b.startsWith("-"))
+                            branches.add(b);
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return [...branches].sort();
+}
+// ── Claude directory resolution ──────────────────────────────────────────────
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function readdirSafe(p) {
+    try {
+        return fs.readdirSync(p);
+    }
+    catch {
+        return [];
+    }
+}
+function capitalize(s) {
+    return s ? s[0].toUpperCase() + s.slice(1) : s;
+}
+/** Every Claude `projects` directory that exists: native, Claude Desktop, and
+ *  WSL distros (via UNC paths, then a wsl.exe fallback). */
+async function resolveAllClaudeDirs() {
+    const dirs = [];
+    const push = (p) => {
+        if (!dirs.includes(p))
+            dirs.push(p);
+    };
+    if (IS_WINDOWS) {
+        const profile = process.env.USERPROFILE;
+        if (profile) {
+            const p = path.join(profile, ".claude", "projects");
+            if (isDir(p))
+                push(p);
+        }
+        const appData = process.env.APPDATA;
+        if (appData) {
+            const p = path.join(appData, "Claude", "projects");
+            if (isDir(p))
+                push(p);
+        }
+        for (const wslRoot of ["\\\\wsl$", "\\\\wsl.localhost"]) {
+            for (const distro of readdirSafe(wslRoot)) {
+                const distroPath = path.join(wslRoot, distro);
+                for (const user of readdirSafe(path.join(distroPath, "home"))) {
+                    const p = path.join(distroPath, "home", user, ".claude", "projects");
+                    if (isDir(p))
+                        push(p);
+                }
+                const rootP = path.join(distroPath, "root", ".claude", "projects");
+                if (isDir(rootP))
+                    push(rootP);
+            }
+        }
+        // Fallback: ask wsl.exe for $HOME when UNC enumeration finds nothing.
+        const home = await run("wsl.exe", ["-e", "bash", "-c", "echo $HOME"], { timeoutMs: 8000 });
+        const wslHome = home.stdout.trim();
+        if (home.ok && wslHome) {
+            const distro = await run("wsl.exe", ["-e", "bash", "-c", "cat /etc/os-release | grep ^ID= | cut -d= -f2"], {
+                timeoutMs: 8000,
+            });
+            const id = distro.stdout.trim();
+            const candidates = [id, capitalize(id), `${id}-22.04`, "Ubuntu", "Ubuntu-22.04", "Ubuntu-24.04", "Debian"];
+            for (const wslRoot of ["\\\\wsl.localhost", "\\\\wsl$"]) {
+                for (const name of candidates) {
+                    if (!name)
+                        continue;
+                    const p = path.join(wslRoot, name, wslHome.replace(/^\/+/, ""), ".claude", "projects");
+                    if (isDir(p))
+                        push(p);
+                }
+            }
+        }
+    }
+    else {
+        const p = path.join(os.homedir(), ".claude", "projects");
+        if (isDir(p))
+            push(p);
+        if (isWsl()) {
+            const p2 = wslClaudeDir();
+            if (p2)
+                push(p2);
+        }
+    }
+    if (dirs.length === 0)
+        dirs.push(path.join(os.homedir(), ".claude", "projects"));
+    return dirs;
+}
+export function isWsl() {
+    try {
+        return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    }
+    catch {
+        return false;
+    }
+}
+function wslClaudeDir() {
+    const usersDir = "/mnt/c/Users";
+    if (!isDir(usersDir))
+        return null;
+    const profile = process.env.USERPROFILE;
+    if (profile) {
+        const p = path.join(profile, "AppData", "Roaming", "Claude", "projects");
+        if (isDir(p))
+            return p;
+    }
+    for (const user of readdirSafe(usersDir)) {
+        const p = path.join(usersDir, user, "AppData", "Roaming", "Claude", "projects");
+        if (isDir(p))
+            return p;
+    }
+    return null;
+}
+// ── mtime-keyed parse cache ──────────────────────────────────────────────────
+// Discovery runs every few seconds over every transcript; re-parse only files
+// whose mtime/size changed.
+function cached() {
+    const map = new Map();
+    return async (file, st, parse) => {
+        const sig = `${st.mtimeMs}:${st.size}`;
+        const hit = map.get(file);
+        if (hit && hit.sig === sig)
+            return hit.value;
+        const value = await parse();
+        map.set(file, { sig, value });
+        return value;
+    };
+}
+const claudeMetaCache = cached();
+// ── Discovery ────────────────────────────────────────────────────────────────
+export class SessionDiscovery {
+    dirs;
+    constructor(claudeDir) {
+        this.dirs = claudeDir ? Promise.resolve([claudeDir]) : resolveAllClaudeDirs();
+    }
+    async discoverSessions() {
+        const byId = new Map();
+        for (const dir of await this.dirs) {
+            try {
+                await this.scanDirectory(dir, byId);
+            }
+            catch (e) {
+                log.debug("sessions", `scan ${dir} failed: ${e}`);
+            }
+        }
+        const sessions = [...byId.values()].filter((s) => s.messageCount > 0);
+        sessions.sort((a, b) => Date.parse(b.modifiedTime) - Date.parse(a.modifiedTime));
+        return sessions;
+    }
+    async scanDirectory(claudeDir, byId) {
+        let entries;
+        try {
+            entries = await fs.promises.readdir(claudeDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const dirPath = path.join(claudeDir, entry.name);
+            let files;
+            try {
+                files = await fs.promises.readdir(dirPath);
+            }
+            catch {
+                continue;
+            }
+            for (const fileName of files) {
+                if (!fileName.endsWith(".jsonl"))
+                    continue;
+                const sessionId = fileName.slice(0, -".jsonl".length);
+                const filePath = path.join(dirPath, fileName);
+                let st;
+                try {
+                    st = await fs.promises.stat(filePath);
+                }
+                catch {
+                    continue;
+                }
+                const meta = await claudeMetaCache(filePath, st, () => extractMetadata(filePath));
+                if (!meta)
+                    continue;
+                let s = byId.get(sessionId);
+                if (!s) {
+                    s = { id: sessionId, messageCount: 0, modifiedTime: st.mtime.toISOString() };
+                    byId.set(sessionId, s);
+                }
+                s.jsonlPath = filePath;
+                s.modifiedTime = st.mtime.toISOString();
+                s.messageCount = meta.messageCount;
+                if (!s.firstPrompt)
+                    s.firstPrompt = meta.firstPrompt;
+                if (!s.projectPath)
+                    s.projectPath = meta.projectPath ?? decodeDirectoryName(entry.name);
+                if (!s.gitBranch)
+                    s.gitBranch = meta.gitBranch;
+            }
+        }
+    }
+}
+export function sessionDisplayTitle(s) {
+    if (s.name)
+        return s.name;
+    if (s.firstPrompt)
+        return takeChars(s.firstPrompt, 100);
+    return `${s.id.slice(0, 8)}...`;
+}

package/server-dist/server/settings.js

@@ -0,0 +1,125 @@
+// Port of settings_store.rs. settings.json stays byte-compatible with the
+// macOS app: same camelCase keys, same defaults.
+import fs from "node:fs";
+import path from "node:path";
+import { devboardDataDir, log, writeFileAtomic } from "./util.js";
+export function defaultSelfCompactRules() {
+    return [
+        {
+            id: "ctx-500k",
+            thresholdTokens: 500_000,
+            action: "queuePrompt",
+            message: "You are above the 500k context limit. Whenever it is convenient, use the devboard CLI to send yourself a self-compact.",
+        },
+        {
+            id: "ctx-600k",
+            thresholdTokens: 600_000,
+            action: "queuePrompt",
+            message: "You are above the 600k context limit. Please compact yourself soon using the devboard CLI self-compact command.",
+        },
+        {
+            id: "ctx-700k",
+            thresholdTokens: 700_000,
+            action: "queuePrompt",
+            message: "You are above the 700k context limit. Compact yourself IMMEDIATELY using the devboard CLI self-compact command.",
+        },
+        { id: "ctx-750k", thresholdTokens: 750_000, action: "compactNow", message: "/compact" },
+    ];
+}
+export function defaultSettings() {
+    return {
+        projects: [],
+        globalView: { excludedPaths: [] },
+        github: {
+            defaultFilter: "assignee:@me is:open",
+            pollIntervalSeconds: 60,
+            mergeCommand: "gh pr merge ${number} --squash --delete-branch",
+        },
+        notifications: {
+            notificationsEnabled: true,
+            pushoverEnabled: false,
+            renderMarkdownImage: false,
+        },
+        sessionTimeout: { activeThresholdMinutes: 1440 },
+        terminalSessions: { idleMinutes: 30, maxSessions: 8 },
+        promptTemplate: "",
+        githubIssuePromptTemplate: "#${number}: ${title}\n\n${body}",
+        hasCompletedOnboarding: false,
+        editor: "",
+        terminalFontSize: 15,
+        sessionDetailFontSize: 12,
+        cardDetailMode: "popup",
+        selfCompact: { enabled: false, pollIntervalSeconds: 30, rules: defaultSelfCompactRules() },
+        apiServices: [],
+        defaultAPIServiceIds: {},
+        harness: defaultHarnessSettings(),
+    };
+}
+export function defaultHarnessSettings() {
+    return {
+        pullIntervalMinutes: 10,
+        injectTopK: 8,
+        injectTokenBudget: 600,
+        librarian: { enabled: true, model: "haiku", maxTranscriptChars: 60_000 },
+    };
+}
+function isPlain(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Fill any missing key with its default (serde `#[serde(default)]` behaviour),
+ *  recursing into nested objects but treating arrays as opaque. */
+function withDefaults(value, defaults) {
+    if (!isPlain(value) || !isPlain(defaults))
+        return (value === undefined ? defaults : value);
+    const out = { ...value };
+    for (const [k, d] of Object.entries(defaults)) {
+        out[k] = k in value && value[k] !== undefined ? (isPlain(d) ? withDefaults(value[k], d) : value[k]) : d;
+    }
+    return out;
+}
+let loggedBackfill = false;
+export class SettingsStore {
+    filePath;
+    constructor(base) {
+        this.filePath = path.join(base ?? devboardDataDir(), "settings.json");
+    }
+    async read() {
+        let raw;
+        try {
+            raw = await fs.promises.readFile(this.filePath, "utf8");
+        }
+        catch {
+            const defaults = defaultSettings();
+            await this.write(defaults);
+            return defaults;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return defaultSettings();
+        }
+        if (!loggedBackfill && isPlain(parsed) && !("terminalFontSize" in parsed)) {
+            loggedBackfill = true;
+            log.info("settings", "settings.json missing terminalFontSize — backfilling defaults (file appears to originate from macOS)");
+        }
+        return withDefaults(parsed, defaultSettings());
+    }
+    async write(settings) {
+        await writeFileAtomic(this.filePath, JSON.stringify(settings, null, 2));
+    }
+}
+/** Per-card override → per-assistant default → none (mirrors resolve_api_service). */
+export function resolveApiService(settings, cardOverride, assistantId) {
+    const services = settings.apiServices ?? [];
+    if (cardOverride) {
+        const hit = services.find((s) => s.id === cardOverride);
+        if (hit)
+            return hit;
+    }
+    const defaultId = settings.defaultAPIServiceIds?.[assistantId];
+    if (!defaultId)
+        return undefined;
+    return services.find((s) => s.id === defaultId);
+}

package/server-dist/server/skill.js

@@ -0,0 +1,29 @@
+// Links the bundled devboard skill into ~/.claude/skills so agents can find it.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { log, IS_WINDOWS } from "./util.js";
+export function linkDevboardSkill(repoRoot) {
+    const link = path.join(os.homedir(), ".claude", "skills", "devboard");
+    if (fs.existsSync(path.join(link, "SKILL.md")))
+        return;
+    const candidates = [process.env.DEVBOARD_REPO, repoRoot, path.resolve(repoRoot, "..")].filter((p) => !!p);
+    const src = candidates
+        .map((r) => path.join(r, ".claude", "skills", "devboard"))
+        .find((p) => fs.existsSync(path.join(p, "SKILL.md")));
+    if (!src) {
+        log.warn("bootstrap", "devboard skill source not found; skipping link");
+        return;
+    }
+    try {
+        fs.mkdirSync(path.dirname(link), { recursive: true });
+        if (fs.existsSync(link))
+            fs.rmdirSync(link);
+        // "junction" needs no admin / Developer Mode on Windows; ignored elsewhere.
+        fs.symlinkSync(src, link, IS_WINDOWS ? "junction" : "dir");
+        log.info("bootstrap", `linked devboard skill → ${src}`);
+    }
+    catch (e) {
+        log.warn("bootstrap", `skill link failed: ${e}`);
+    }
+}

package/server-dist/server/tmux.js

@@ -0,0 +1,217 @@
+// tmux adapter. Ports tmux.rs: on Windows every call goes through
+// `wsl.exe -- tmux …`; elsewhere bare `tmux`.
+//
+// All commands are serialised through the async helpers below — tmux ops are
+// quick, and serialising avoids the paste/Enter ordering races seen on macOS.
+import fs from "node:fs";
+import path from "node:path";
+import { psmuxPath } from "./psmux.js";
+import { IS_WINDOWS, devboardDataDir, log, run } from "./util.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const bound = (be) => (args, input) => tmux(args, input, be);
+function tmux(args, input, be = "wsl") {
+    if (be === "psmux") {
+        const exe = psmuxPath();
+        if (!exe)
+            return Promise.resolve({ ok: false, code: null, stdout: "", stderr: "psmux is not installed" });
+        return run(exe, args, { input });
+    }
+    return IS_WINDOWS ? run("wsl.exe", ["--", "tmux", ...args], { input }) : run("tmux", args, { input });
+}
+const errText = (r) => r.stderr.trim();
+export async function isAvailable(be = "wsl") {
+    const tmuxBe = bound(be);
+    return (await tmuxBe(["-V"])).ok;
+}
+export async function hasSession(name, be = "wsl") {
+    const tmuxBe = bound(be);
+    return (await tmuxBe(["has-session", "-t", name])).ok;
+}
+/** `C:\foo` → `/mnt/c/foo` via `wsl wslpath -a`; unchanged for unix-y paths. */
+export async function windowsPathToWsl(p) {
+    if (p.startsWith("/") || !IS_WINDOWS)
+        return p;
+    // wsl.exe runs the command through a shell, which eats backslashes; forward
+    // slashes survive and wslpath accepts them.
+    const r = await run("wsl.exe", ["--", "wslpath", "-a", p.replaceAll("\\", "/")]);
+    const s = r.stdout.trim();
+    return r.ok && s ? s : p;
+}
+/** Idempotent: reuses an existing session, else `new-session -A -d`. */
+export async function ensureSession(name, cwdWsl, command, be = "wsl") {
+    const tmuxBe = bound(be);
+    if (await hasSession(name, be))
+        return;
+    const args = ["new-session", "-A", "-d", "-s", name, "-c", cwdWsl];
+    if (command)
+        args.push(command);
+    const r = await tmuxBe(args);
+    if (!r.ok)
+        throw new Error(`tmux new-session failed: ${errText(r)}`);
+    log.info("tmux", `created session name=${name} cwd=${cwdWsl}`);
+}
+/**
+ * psmux session whose first window runs `inner` (a cmd.exe command line). The line goes through
+ * a script file so no quoting survives to be mangled between node, psmux and cmd.
+ */
+export async function ensureWindowsSession(name, cwd, inner) {
+    if (await hasSession(name, "psmux"))
+        return;
+    const dir = path.join(devboardDataDir(), "launch");
+    await fs.promises.mkdir(dir, { recursive: true });
+    const script = path.join(dir, `${name.replace(/[^\w.-]/g, "_")}.cmd`);
+    // cmd reads batch files in the OEM code page: switch to UTF-8, or non-ASCII prompts (e.g. Vietnamese)
+    // arrive mangled, the session's first prompt stops matching its card and a duplicate card appears.
+    // `%` expands in batch files, so double it.
+    const body = ["@echo off", "chcp 65001 >nul", inner.replaceAll("%", "%%"), ""].join("\r\n");
+    await fs.promises.writeFile(script, body);
+    const r = await tmux(["new-session", "-A", "-d", "-s", name, "-c", cwd, "--", "cmd.exe", "/k", script], undefined, "psmux");
+    if (!r.ok)
+        throw new Error(`psmux new-session failed: ${errText(r)}`);
+    log.info("tmux", `created psmux session name=${name} cwd=${cwd}`);
+}
+export async function killSession(name, be = "wsl") {
+    const tmuxBe = bound(be);
+    if (!(await hasSession(name, be)))
+        return;
+    const r = await tmuxBe(["kill-session", "-t", name]);
+    if (!r.ok)
+        throw new Error(`tmux kill-session failed: ${errText(r)}`);
+    log.info("tmux", `killed session name=${name}`);
+}
+export async function capturePane(target, be = "wsl") {
+    const tmuxBe = bound(be);
+    const r = await tmuxBe(["capture-pane", "-p", "-t", target]);
+    if (!r.ok)
+        throw new Error(errText(r));
+    return r.stdout;
+}
+async function pasteBuffer(target, text, be) {
+    const tmuxBe = bound(be);
+    // Exit copy-mode first (harmless no-op otherwise).
+    await tmuxBe(["send-keys", "-X", "-t", target, "cancel"]);
+    // Via stdin: robust for arbitrary UTF-8, no shell escaping.
+    const load = await tmuxBe(["load-buffer", "-"], text);
+    if (!load.ok)
+        throw new Error(`tmux load-buffer failed: ${errText(load)}`);
+    const paste = await tmuxBe(["paste-buffer", "-p", "-t", target]);
+    if (!paste.ok)
+        throw new Error(`tmux paste-buffer failed: ${errText(paste)}`);
+}
+/** Bracketed-paste `text` into `target` and submit with Enter. */
+export async function sendPrompt(target, text, be = "wsl") {
+    const tmuxBe = bound(be);
+    await pasteBuffer(target, text, be);
+    // Let Claude finish processing the paste event before Enter, or it treats
+    // the Enter as part of the paste and never submits.
+    await sleep(100);
+    const enter = await tmuxBe(["send-keys", "-t", target, "Enter"]);
+    if (!enter.ok)
+        throw new Error(`tmux send-keys Enter failed: ${errText(enter)}`);
+    await ensurePromptSent(target, be);
+}
+/** Paste without submitting. */
+export function pasteText(target, text, be = "wsl") {
+    return pasteBuffer(target, text, be);
+}
+export function needsResubmit(capture) {
+    if (capture.includes("[Pasted text") || capture.includes("[Pasted Text"))
+        return true;
+    const lines = capture.split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const t = lines[i].trimEnd();
+        if (!t)
+            continue;
+        const idx = t.indexOf("❯");
+        if (idx >= 0)
+            return t.slice(idx + 1).trim().length > 0;
+        break;
+    }
+    return false;
+}
+/** Re-fire Enter up to 10× while the pasted text is still in Claude's input box. */
+async function ensurePromptSent(target, be) {
+    const tmuxBe = bound(be);
+    for (let i = 0; i < 10; i++) {
+        await sleep(i === 0 ? 300 : 500);
+        let cap;
+        try {
+            cap = await capturePane(target, be);
+        }
+        catch {
+            return;
+        }
+        if (!needsResubmit(cap))
+            return;
+        await tmuxBe(["send-keys", "-t", target, "Enter"]);
+    }
+    log.warn("tmux", `ensure_prompt_sent gave up after 10 attempts target=${target}`);
+}
+export async function newWindow(session, cwdWsl, command, be = "wsl") {
+    const tmuxBe = bound(be);
+    const args = ["new-window", "-P", "-F", "#I", "-t", session];
+    if (cwdWsl)
+        args.push("-c", cwdWsl);
+    if (command)
+        args.push(command);
+    const r = await tmuxBe(args);
+    if (!r.ok)
+        throw new Error(`tmux new-window failed: ${errText(r)}`);
+    const idx = Number.parseInt(r.stdout.trim(), 10);
+    if (Number.isNaN(idx))
+        throw new Error(`tmux new-window: couldn't parse window index '${r.stdout.trim()}'`);
+    return idx;
+}
+export async function killWindow(target, be = "wsl") {
+    const tmuxBe = bound(be);
+    const r = await tmuxBe(["kill-window", "-t", target]);
+    // Caller-side state may already be gone.
+    if (!r.ok && !r.stderr.includes("can't find"))
+        throw new Error(`tmux kill-window failed: ${errText(r)}`);
+}
+export async function listWindows(session, be = "wsl") {
+    const tmuxBe = bound(be);
+    if (!(await hasSession(session, be)))
+        return [];
+    const r = await tmuxBe(["list-windows", "-t", session, "-F", "#I\t#W\t#{window_active}"]);
+    if (!r.ok)
+        throw new Error(errText(r));
+    const out = [];
+    for (const line of r.stdout.split(/\r?\n/)) {
+        const parts = line.split("\t");
+        if (parts.length < 3)
+            continue;
+        const index = Number.parseInt(parts[0], 10);
+        if (Number.isNaN(index))
+            continue;
+        out.push({ index, name: parts[1], active: parts[2] === "1" });
+    }
+    return out;
+}
+export async function listSessions(be = "wsl") {
+    const tmuxBe = bound(be);
+    if (!(await isAvailable(be)))
+        return [];
+    const r = await tmuxBe([
+        "list-sessions",
+        "-F",
+        "#{session_name}\t#{session_created}\t#{session_attached}\t#{session_windows}",
+    ]);
+    if (!r.ok)
+        return [];
+    const out = [];
+    for (const line of r.stdout.split(/\r?\n/)) {
+        const [name, created, attached, windows] = line.split("\t");
+        const createdAt = Number.parseInt(created ?? "", 10);
+        if (!name || Number.isNaN(createdAt) || attached === undefined)
+            continue;
+        out.push({
+            runtime: be === "psmux" ? "windows" : "wsl",
+            name,
+            createdAt,
+            attached: attached !== "0",
+            windows: Number.parseInt(windows ?? "0", 10) || 0,
+        });
+    }
+    return out;
+}