@luuthuong/devboard 0.0.0-stage → 1.0.1

package/server-dist/server/coordination.js

@@ -0,0 +1,442 @@
+// Port of coordination_store.rs — links.json, the card store.
+import fs from "node:fs";
+import path from "node:path";
+import { Mutex, devboardDataDir, ksuid, log, writeFileAtomic } from "./util.js";
+const nowIso = () => new Date().toISOString();
+const emptyOverrides = () => ({
+    worktreePath: false,
+    tmuxSession: false,
+    name: false,
+    column: false,
+    prLink: false,
+    issueLink: false,
+});
+function normalizeLink(l) {
+    // serde(default) equivalents so older / macOS-written files load cleanly.
+    l.manualOverrides = Object.assign(emptyOverrides(), l.manualOverrides);
+    l.manuallyArchived ??= false;
+    l.source ??= "discovered";
+    l.prLinks ??= [];
+    l.isRemote ??= false;
+    l.assistantId ??= "claude";
+    // The Waiting lane was merged into In Progress; older files still carry its id.
+    if (l.column === "requires_attention")
+        l.column = "in_progress";
+    return l;
+}
+export function newLinkBase() {
+    const now = nowIso();
+    return {
+        id: ksuid("card"),
+        column: "backlog",
+        createdAt: now,
+        updatedAt: now,
+        manualOverrides: emptyOverrides(),
+        manuallyArchived: false,
+        source: "manual",
+        prLinks: [],
+        isRemote: false,
+        assistantId: "claude",
+    };
+}
+export function displayTitle(link) {
+    if (link.name)
+        return link.name;
+    if (link.promptBody)
+        return Array.from(link.promptBody).slice(0, 100).join("");
+    if (link.worktreeLink?.branch)
+        return link.worktreeLink.branch;
+    const prTitle = link.prLinks[0]?.title;
+    if (prTitle)
+        return prTitle;
+    if (link.sessionLink)
+        return link.sessionLink.sessionId;
+    return link.id;
+}
+export class CoordinationStore {
+    filePath;
+    lock = new Mutex();
+    constructor(base) {
+        this.filePath = path.join(base ?? devboardDataDir(), "links.json");
+    }
+    async readLinks() {
+        let data;
+        try {
+            data = await fs.promises.readFile(this.filePath, "utf8");
+        }
+        catch {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(data);
+            if (parsed && Array.isArray(parsed.links))
+                return parsed.links.map(normalizeLink);
+        }
+        catch {
+            // fall through to corruption recovery
+        }
+        // Corruption recovery: keep the bad file around as .bkp (mirrors macOS).
+        const backup = this.filePath.replace(/\.json$/, ".json.bkp");
+        try {
+            await fs.promises.copyFile(this.filePath, backup);
+            log.warn("coordination", `links.json failed to parse; copied to ${backup} and resetting to empty`);
+        }
+        catch (e) {
+            log.error("coordination", `failed to back up corrupt links.json to ${backup}: ${e}`);
+        }
+        return [];
+    }
+    async writeLinks(links) {
+        await writeFileAtomic(this.filePath, JSON.stringify({ links }, null, 2));
+    }
+    /** Serialised read-modify-write. The callback mutates `links` in place; return
+     *  `false` to skip the write (no-op). */
+    mutate(fn) {
+        return this.lock.run(async () => {
+            const links = await this.readLinks();
+            const result = await fn(links);
+            if (result === false)
+                return undefined;
+            await this.writeLinks(links);
+            return result;
+        });
+    }
+    /** Whole-list read-modify-write for callers that restructure the list. */
+    update(fn) {
+        return this.lock.run(async () => {
+            const links = await this.readLinks();
+            const next = await fn(links);
+            if (next === false)
+                return;
+            await this.writeLinks(next);
+        });
+    }
+    upsertLink(link) {
+        return this.mutate((links) => {
+            const idx = links.findIndex((l) => l.id === link.id);
+            if (idx >= 0)
+                links[idx] = link;
+            else
+                links.push(link);
+        });
+    }
+    moveCard(cardId, column) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            link.column = column;
+            link.manualOverrides.column = true;
+            if (column === "all_sessions") {
+                link.manuallyArchived = true;
+                delete link.pinnedAt;
+                delete link.pinnedSortOrder;
+            }
+            else if (link.manuallyArchived) {
+                link.manuallyArchived = false;
+            }
+            link.updatedAt = nowIso();
+        });
+    }
+    async createCard(args) {
+        const link = newLinkBase();
+        link.name = args.title ?? undefined;
+        link.projectPath = args.project;
+        link.promptBody = args.prompt;
+        link.assistantId = args.assistantId;
+        if (args.promptImagePaths)
+            link.promptImagePaths = args.promptImagePaths;
+        if (args.apiServiceId)
+            link.apiServiceId = args.apiServiceId;
+        await this.upsertLink(link);
+        return link;
+    }
+    async createIssueCard(args) {
+        const link = newLinkBase();
+        link.name = `#${args.issueNumber}: ${args.issueTitle}`;
+        link.projectPath = args.projectPath;
+        link.source = "github_issue";
+        link.promptBody = args.promptBody;
+        link.issueLink = {
+            number: args.issueNumber,
+            url: args.issueUrl,
+            title: args.issueTitle,
+            body: args.issueBody ?? undefined,
+        };
+        await this.upsertLink(link);
+        return link;
+    }
+    setCardApiService(cardId, apiServiceId) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            if (apiServiceId)
+                link.apiServiceId = apiServiceId;
+            else
+                delete link.apiServiceId;
+            link.updatedAt = nowIso();
+        });
+    }
+    setCardRuntime(cardId, runtime) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            if (runtime)
+                link.cardRuntime = runtime;
+            else
+                delete link.cardRuntime;
+            link.updatedAt = nowIso();
+        });
+    }
+    /** Sessions whose card the user deleted; discovery must not resurrect them. */
+    get dismissedPath() {
+        return path.join(path.dirname(this.filePath), "dismissed-sessions.json");
+    }
+    async readDismissedSessions() {
+        try {
+            const parsed = JSON.parse(await fs.promises.readFile(this.dismissedPath, "utf8"));
+            return new Set(Array.isArray(parsed?.sessionIds) ? parsed.sessionIds : []);
+        }
+        catch {
+            return new Set();
+        }
+    }
+    removeLink(cardId) {
+        return this.lock.run(async () => {
+            const links = await this.readLinks();
+            const removed = links.find((l) => l.id === cardId);
+            const sessionId = removed?.sessionLink?.sessionId;
+            if (sessionId) {
+                const dismissed = await this.readDismissedSessions();
+                dismissed.add(sessionId);
+                await writeFileAtomic(this.dismissedPath, JSON.stringify({ sessionIds: [...dismissed] }, null, 2));
+            }
+            await this.writeLinks(links.filter((l) => l.id !== cardId));
+        });
+    }
+    archiveLink(cardId) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            link.manuallyArchived = true;
+            link.column = "all_sessions";
+            delete link.pinnedAt;
+            delete link.pinnedSortOrder;
+            link.updatedAt = nowIso();
+        });
+    }
+    renameLink(cardId, name) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            link.name = name;
+            link.manualOverrides.name = true;
+            link.updatedAt = nowIso();
+        });
+    }
+    /** Edit a card's task: title (empty clears it) and the prompt it launches with. */
+    updateCardTask(cardId, args) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            const name = args.name.trim();
+            if (name) {
+                link.name = name;
+                link.manualOverrides.name = true;
+            }
+            else {
+                delete link.name;
+                link.manualOverrides.name = false;
+            }
+            link.promptBody = args.promptBody;
+            if (args.promptImagePaths && args.promptImagePaths.length > 0)
+                link.promptImagePaths = args.promptImagePaths;
+            else
+                delete link.promptImagePaths;
+            link.updatedAt = nowIso();
+        });
+    }
+    async addQueuedPrompt(cardId, prompt) {
+        await this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            (link.queuedPrompts ??= []).push(prompt);
+            link.updatedAt = nowIso();
+        });
+        return prompt;
+    }
+    /** `imagePaths`: undefined = keep, null/[] = clear, array = replace. */
+    updateQueuedPrompt(cardId, promptId, body, sendAutomatically, imagePaths) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            const p = link.queuedPrompts?.find((q) => q.id === promptId);
+            if (p) {
+                p.body = body;
+                p.sendAutomatically = sendAutomatically;
+                if (imagePaths !== undefined) {
+                    if (imagePaths && imagePaths.length > 0)
+                        p.imagePaths = imagePaths;
+                    else
+                        delete p.imagePaths;
+                }
+            }
+            link.updatedAt = nowIso();
+        });
+    }
+    removeQueuedPrompt(cardId, promptId) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return;
+            if (link.queuedPrompts) {
+                link.queuedPrompts = link.queuedPrompts.filter((p) => p.id !== promptId);
+                if (link.queuedPrompts.length === 0)
+                    delete link.queuedPrompts;
+            }
+            link.updatedAt = nowIso();
+        });
+    }
+    /** Manual ordering; deliberately does not bump updatedAt. */
+    reorderCards(orderedIds) {
+        return this.mutate((links) => {
+            orderedIds.forEach((id, idx) => {
+                const link = links.find((l) => l.id === id);
+                if (link)
+                    link.sortOrder = idx;
+            });
+        });
+    }
+    /** Idempotent self-compact nudge. Returns whether a prompt was added. */
+    async enqueueSelfCompactPrompt(cardId, body, thresholdTokens) {
+        const added = await this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return false;
+            const trimmed = body.trim();
+            for (const p of link.queuedPrompts ?? []) {
+                if (p.selfCompactThresholdTokens === thresholdTokens)
+                    return false;
+                if (p.selfCompactThresholdTokens === undefined && p.body.trim() === trimmed)
+                    return false;
+            }
+            (link.queuedPrompts ??= []).push({
+                id: ksuid("prompt"),
+                body,
+                sendAutomatically: true,
+                selfCompactThresholdTokens: thresholdTokens,
+            });
+            link.updatedAt = nowIso();
+            return true;
+        });
+        return added === true;
+    }
+    async addBrowserTab(cardId, url) {
+        const tab = { id: ksuid("browser"), url };
+        const res = await this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return false;
+            (link.browserTabs ??= []).push(tab);
+            link.updatedAt = nowIso();
+            return true;
+        });
+        return res ? tab : null;
+    }
+    async removeBrowserTab(cardId, tabId) {
+        const res = await this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link?.browserTabs)
+                return false;
+            const before = link.browserTabs.length;
+            link.browserTabs = link.browserTabs.filter((t) => t.id !== tabId);
+            if (link.browserTabs.length === before)
+                return false;
+            if (link.browserTabs.length === 0)
+                delete link.browserTabs;
+            link.updatedAt = nowIso();
+            return true;
+        });
+        return res === true;
+    }
+    reorderBrowserTabs(cardId, orderedIds) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link?.browserTabs)
+                return false;
+            const rank = (id) => {
+                const i = orderedIds.indexOf(id);
+                return i < 0 ? Number.MAX_SAFE_INTEGER : i;
+            };
+            // Array.prototype.sort is stable, so unmentioned tabs keep relative order.
+            link.browserTabs.sort((a, b) => rank(a.id) - rank(b.id));
+        });
+    }
+    /** `title`: undefined = keep, null = clear, string = replace. */
+    async updateBrowserTab(cardId, tabId, url, title) {
+        const res = await this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            const tab = link?.browserTabs?.find((t) => t.id === tabId);
+            if (!link || !tab)
+                return false;
+            if (url)
+                tab.url = url;
+            if (title !== undefined) {
+                if (title === null)
+                    delete tab.title;
+                else
+                    tab.title = title;
+            }
+            link.updatedAt = nowIso();
+            return true;
+        });
+        return res === true;
+    }
+    setCardPinned(cardId, isPinned) {
+        return this.mutate((links) => {
+            const orders = links.map((l) => l.pinnedSortOrder).filter((o) => typeof o === "number");
+            const firstOrder = orders.length ? Math.min(...orders) : 0;
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return false;
+            if (isPinned) {
+                if (link.pinnedAt)
+                    return false;
+                link.pinnedAt = nowIso();
+                link.pinnedSortOrder = firstOrder - 1;
+            }
+            else {
+                if (!link.pinnedAt)
+                    return false;
+                delete link.pinnedAt;
+                delete link.pinnedSortOrder;
+            }
+            link.updatedAt = nowIso();
+        });
+    }
+    /** Stamps lastOpenedAt without bumping updatedAt. */
+    markCardOpened(cardId) {
+        return this.mutate((links) => {
+            const link = links.find((l) => l.id === cardId);
+            if (!link)
+                return false;
+            link.lastOpenedAt = nowIso();
+        });
+    }
+    reorderPinnedCards(orderedIds) {
+        return this.mutate((links) => {
+            orderedIds.forEach((id, idx) => {
+                const link = links.find((l) => l.id === id);
+                if (link?.pinnedAt)
+                    link.pinnedSortOrder = idx;
+            });
+        });
+    }
+}

package/server-dist/server/editor.js

@@ -0,0 +1,101 @@
+// Open a path in the user's editor on the machine the server runs on.
+// Ports shell_command.rs::open_in_editor (the terminal-launching halves of that
+// module are gone: terminals now live in the browser).
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { IS_WINDOWS, run, spawnDetached } from "./util.js";
+import { isWsl } from "./sessions.js";
+const isWslUncPath = (p) => p.startsWith("\\\\wsl") || p.includes("\\wsl$\\") || p.includes("\\wsl.localhost\\");
+/** `\\wsl$\Distro\home\u` or `\\wsl.localhost\Distro\home\u` → `/home/u`. */
+export function uncToLinuxPath(p) {
+    const n = p.replaceAll("\\", "/");
+    for (const prefix of ["//wsl.localhost/", "//wsl$/"]) {
+        if (n.startsWith(prefix)) {
+            const rest = n.slice(prefix.length);
+            const slash = rest.indexOf("/");
+            if (slash >= 0)
+                return rest.slice(slash);
+        }
+    }
+    return p;
+}
+const cmdQuote = (a) => (/[\s;&|<>^"]/.test(a) ? `"${a.replaceAll('"', '""')}"` : a);
+/** Open a new terminal window (outside the browser) running the given command. */
+export function openInTerminal(spec) {
+    if (!IS_WINDOWS)
+        throw new Error("opening an external terminal is only supported on Windows");
+    let args;
+    if (spec.wslScript) {
+        // Base64 sidesteps every layer of quoting between the terminal, wsl.exe and bash.
+        const b64 = Buffer.from(spec.wslScript, "utf8").toString("base64");
+        args = ["wsl.exe", "--", "bash", "-lc", `echo ${b64} | base64 -d | bash`];
+    }
+    else if (spec.argv?.length) {
+        args = spec.argv;
+    }
+    else if (spec.cmdLine) {
+        // A script file avoids cmd.exe's quote-stripping rules for `/k "…"`.
+        const file = path.join(os.tmpdir(), `devboard-term-${randomUUID()}.cmd`);
+        fs.writeFileSync(file, `@echo off\r\n${spec.cmdLine}\r\n`);
+        args = ["cmd.exe", "/k", file];
+    }
+    else {
+        throw new Error("nothing to run in the terminal");
+    }
+    // Preferred: a tab in one shared, named Windows Terminal window. `;` is wt's
+    // own command separator, so escape it.
+    const wt = spawn("wt.exe", ["-w", "devboard", "new-tab", ...args.map((a) => a.replaceAll(";", "\\;"))], {
+        detached: true,
+        stdio: "ignore",
+    });
+    wt.on("error", () => {
+        // No Windows Terminal: `start` gives the child its own console window.
+        const child = spawn("cmd.exe", ["/c", "start", '""', ...args.map(cmdQuote)], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+            windowsVerbatimArguments: true,
+        });
+        child.on("error", () => { });
+        child.unref();
+    });
+    wt.unref();
+}
+export async function openInEditor(target, editor) {
+    const editorCmd = editor || process.env.EDITOR || "code";
+    if (!IS_WINDOWS && isWsl()) {
+        // Windows-side editor, with the Linux path converted via wslpath.
+        const conv = await run("wslpath", ["-w", target]);
+        const openPath = conv.ok && conv.stdout.trim() ? conv.stdout.trim() : target;
+        if (spawnDetached(`${editorCmd}.cmd`, [openPath]) || spawnDetached(editorCmd, [openPath]))
+            return;
+        throw new Error(`open in editor '${editorCmd}' failed`);
+    }
+    if (IS_WINDOWS) {
+        const local = process.env.LOCALAPPDATA ?? "";
+        const programFiles = process.env.ProgramFiles ?? String.raw `C:\Program Files`;
+        const editors = [
+            `${local}\\Programs\\cursor\\resources\\app\\bin\\cursor.cmd`,
+            `${programFiles}\\Microsoft VS Code\\bin\\code.cmd`,
+            `${local}\\Programs\\Microsoft VS Code\\bin\\code.cmd`,
+        ].filter((p) => fs.existsSync(p));
+        if (isWslUncPath(target) || target.startsWith("/")) {
+            const linuxPath = target.startsWith("/") ? target : uncToLinuxPath(target);
+            const folderUri = `vscode-remote://wsl+Ubuntu${linuxPath}`;
+            for (const ed of editors) {
+                if (spawnDetached("cmd", ["/c", ed, "--folder-uri", folderUri]))
+                    return;
+            }
+        }
+        for (const ed of editors) {
+            if (spawnDetached("cmd", ["/c", ed, target]))
+                return;
+        }
+        throw new Error("could not open editor; install Cursor or VS Code");
+    }
+    if (!spawnDetached(editorCmd, [target]))
+        throw new Error(`open in editor '${editorCmd}' failed`);
+}

package/server-dist/server/events.js

@@ -0,0 +1,17 @@
+// In-process event bus. The HTTP layer subscribes once and fans every event
+// out to connected browsers over WebSocket (replaces Tauri's app.emit).
+const listeners = new Set();
+export function emit(event, payload) {
+    for (const l of listeners) {
+        try {
+            l(event, payload);
+        }
+        catch {
+            // a broken subscriber must not stop the others
+        }
+    }
+}
+export function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}