@luuthuong/devboard 0.0.0-stage → 1.0.1

package/server-dist/server/commands.js

@@ -0,0 +1,390 @@
+// The RPC surface: every command the UI used to `invoke()` through Tauri.
+// Arguments arrive as the same camelCase objects; return values are JSON.
+import { notifyUser } from "./context.js";
+import { emit } from "./events.js";
+import { fsList, fsSearch } from "./fsBrowse.js";
+import { openInEditor, openInTerminal } from "./editor.js";
+import { commandExists, createWorktree, getDiff, ghIsAuthed, githubBaseUrl, listWorktrees, removeWorktree, } from "./git.js";
+import { currentContextTokens, installStatusline, mergeBlocked, mergeIntoTarget, readAllContextUsage, readContextUsage, ensureLauncher, saveAttachmentBytes, saveImageBytes, statuslineInstalled, uninstallStatusline, } from "./integrations.js";
+import { approveGate, createIntent, rejectGate, requestGate } from "./harness/intents.js";
+import { getProcessState, killClaudeProcess } from "./processes.js";
+import { defaultIgnores, deployRemoteShell, ensureDaemon, flushSync, prereqs, rawSyncStatus, resetSync, startSync, stopSync, syncStatus, } from "./remote.js";
+import { installPsmux, psmuxStatus } from "./psmux.js";
+import { killCardSession } from "./sessionReaper.js";
+import * as tmux from "./tmux.js";
+const backendFor = (runtime) => (runtime === "windows" ? "psmux" : "wsl");
+import { forkSession, moveSession, readTranscript, readTranscriptUsage, searchSessions, searchTranscriptTurns, truncateSession, } from "./transcripts.js";
+import { errorMessage, ksuid, log, runShell } from "./util.js";
+const nowIso = () => new Date().toISOString();
+/** Resolve a session's transcript path: the card's link first, then discovery. */
+async function sessionPathFor(ctx, sessionId) {
+    const links = await ctx.store.readLinks();
+    const linked = links.find((l) => l.sessionLink?.sessionId === sessionId)?.sessionLink?.sessionPath;
+    if (linked)
+        return linked;
+    const found = (await ctx.discovery.discoverSessions()).find((s) => s.id === sessionId)?.jsonlPath;
+    if (!found)
+        throw new Error(`Session ${sessionId} not found`);
+    return found;
+}
+async function configuredProjectPaths(settings) {
+    const s = await settings.read().catch(() => null);
+    return (s?.projects ?? []).flatMap((p) => [p.path, p.repoRoot].filter((x) => !!x));
+}
+export function buildCommands(ctx) {
+    const { store, settings, discovery, board, harness } = ctx;
+    return {
+        // ── Board / cards ────────────────────────────────────────────────────────
+        async get_board_state() {
+            await board.refresh(discovery, store, await configuredProjectPaths(settings));
+            return board.toDto();
+        },
+        move_card: ({ cardId, column }) => store.moveCard(cardId, column),
+        reorder_cards: ({ orderedIds }) => store.reorderCards(orderedIds),
+        mark_card_opened: ({ cardId }) => store.markCardOpened(cardId),
+        set_card_pinned: ({ cardId, isPinned }) => store.setCardPinned(cardId, isPinned),
+        reorder_pinned_cards: ({ orderedIds }) => store.reorderPinnedCards(orderedIds),
+        async create_card({ prompt, title, project, promptImagePaths, apiServiceId }) {
+            // Launching is driven client-side: the UI selects the card and starts its terminal.
+            return store.createCard({ prompt, title, project, assistantId: "claude", promptImagePaths, apiServiceId });
+        },
+        update_card_task: ({ cardId, name, promptBody, promptImagePaths }) => store.updateCardTask(cardId, { name: name ?? "", promptBody, promptImagePaths }),
+        set_card_api_service: ({ cardId, apiServiceId }) => store.setCardApiService(cardId, apiServiceId ?? null),
+        set_card_runtime: ({ cardId, runtime }) => store.setCardRuntime(cardId, runtime ?? null),
+        async delete_card({ cardId }) {
+            await killCardSession(ctx, cardId); // before the card (and its runtime) is forgotten
+            return store.removeLink(cardId);
+        },
+        async archive_card({ cardId }) {
+            await killCardSession(ctx, cardId);
+            return store.archiveLink(cardId);
+        },
+        rename_card: ({ cardId, name }) => store.renameLink(cardId, name),
+        async merge_cards({ sourceCardId, targetCardId }) {
+            await store.update((links) => {
+                const source = links.find((l) => l.id === sourceCardId);
+                const target = links.find((l) => l.id === targetCardId);
+                if (!source)
+                    throw new Error(`source card ${sourceCardId} not found`);
+                if (!target)
+                    throw new Error(`target card ${targetCardId} not found`);
+                const blocked = mergeBlocked(source, target);
+                if (blocked)
+                    throw new Error(blocked);
+                if (source.queuedPrompts?.length) {
+                    log.warn("merge", `dropping ${source.queuedPrompts.length} queued prompt(s) from source card ${source.id}`);
+                }
+                mergeIntoTarget(source, target);
+                log.info("merge", `merged ${sourceCardId.slice(0, 8)} → ${targetCardId.slice(0, 8)}`);
+                return links.filter((l) => l.id !== sourceCardId);
+            });
+        },
+        async move_card_to_project({ cardId, targetProjectPath }) {
+            // Move the transcript first (outside the store lock — it touches big files).
+            const link = (await store.readLinks()).find((l) => l.id === cardId);
+            if (!link)
+                throw new Error(`card ${cardId} not found`);
+            let newSessionPath;
+            const sl = link.sessionLink;
+            if (sl?.sessionPath && sl.sessionId) {
+                try {
+                    newSessionPath = await moveSession(sl.sessionId, sl.sessionPath, targetProjectPath);
+                }
+                catch (e) {
+                    // Keep going — the link metadata still gets updated.
+                    log.warn("move-card", `failed to move session jsonl for ${cardId}: ${errorMessage(e)}`);
+                }
+            }
+            await store.update((links) => {
+                const l = links.find((x) => x.id === cardId);
+                if (!l)
+                    throw new Error(`card ${cardId} not found`);
+                l.projectPath = targetProjectPath;
+                if (l.sessionLink && newSessionPath)
+                    l.sessionLink.sessionPath = newSessionPath;
+                l.updatedAt = nowIso();
+                return links;
+            });
+        },
+        // ── Browser tabs (persisted state only; rendering is client-side) ───────
+        add_browser_tab: ({ cardId, url }) => store.addBrowserTab(cardId, url),
+        remove_browser_tab: ({ cardId, tabId }) => store.removeBrowserTab(cardId, tabId),
+        reorder_browser_tabs: ({ cardId, orderedIds }) => store.reorderBrowserTabs(cardId, orderedIds),
+        update_browser_tab: ({ cardId, tabId, url, title }) => store.updateBrowserTab(cardId, tabId, url, title),
+        // ── Queued prompts ──────────────────────────────────────────────────────
+        add_queued_prompt: ({ cardId, body, sendAutomatically, imagePaths }) => store.addQueuedPrompt(cardId, {
+            id: ksuid("prompt"),
+            body,
+            sendAutomatically,
+            ...(imagePaths ? { imagePaths } : {}),
+        }),
+        update_queued_prompt: ({ cardId, promptId, body, sendAutomatically, imagePaths, setImagePaths }) => store.updateQueuedPrompt(cardId, promptId, body, sendAutomatically, 
+        // Without setImagePaths the attachments are left alone.
+        setImagePaths ? (imagePaths && imagePaths.length ? imagePaths : null) : undefined),
+        remove_queued_prompt: ({ cardId, promptId }) => store.removeQueuedPrompt(cardId, promptId),
+        /** True when a self-compact nudge is stale (usage already fell below its
+         *  threshold). False on every uncertainty — a benign nudge beats a lost one. */
+        async should_drop_self_compact_prompt({ cardId, promptId }) {
+            const s = await settings.read().catch(() => null);
+            if (!s?.selfCompact?.enabled)
+                return false;
+            const link = (await store.readLinks()).find((l) => l.id === cardId);
+            const sessionId = link?.sessionLink?.sessionId;
+            const prompt = link?.queuedPrompts?.find((p) => p.id === promptId);
+            if (!sessionId || !prompt)
+                return false;
+            const queueRules = s.selfCompact.rules.filter((r) => r.action === "queuePrompt");
+            let threshold;
+            if (prompt.selfCompactThresholdTokens !== undefined) {
+                threshold = prompt.selfCompactThresholdTokens;
+            }
+            else {
+                const body = prompt.body.trim();
+                if (body)
+                    threshold = queueRules.find((r) => r.message.trim() === body)?.thresholdTokens;
+            }
+            if (threshold === undefined)
+                return false;
+            // No statusline JSON yet → assume stale (matches macOS).
+            const usage = readContextUsage(sessionId);
+            return usage ? currentContextTokens(usage) < threshold : true;
+        },
+        install_self_compact_statusline: () => installStatusline(),
+        uninstall_self_compact_statusline: () => uninstallStatusline(),
+        self_compact_statusline_installed: () => statuslineInstalled(),
+        context_usages: () => readAllContextUsage(),
+        /** Statusline snapshot when there is one, else a transcript-derived estimate. */
+        async session_usage({ sessionId }) {
+            const snap = readAllContextUsage()[sessionId];
+            if (snap)
+                return { ...snap, estimated: false };
+            const u = await readTranscriptUsage(await sessionPathFor(ctx, sessionId));
+            if (!u)
+                return null;
+            // The transcript never records the window size: assume 200k, or 1M once it is exceeded.
+            const contextWindowSize = u.contextTokens > 200_000 ? 1_000_000 : 200_000;
+            return {
+                usedPercentage: (u.contextTokens / contextWindowSize) * 100,
+                tokens: u.contextTokens,
+                contextWindowSize,
+                inputTokens: u.inputTokens,
+                outputTokens: u.outputTokens,
+                costUsd: null,
+                model: u.model,
+                estimated: true,
+            };
+        },
+        // ── Settings / sessions ─────────────────────────────────────────────────
+        get_settings: () => settings.read(),
+        async save_settings({ settings: next }) {
+            await settings.write(next);
+            // Project list gates which discovered sessions show; apply it right away.
+            await board.refresh(discovery, store, await configuredProjectPaths(settings));
+            emit("board-updated", board.toDto());
+            // The harness repo path may have changed.
+            void harness.reload().then(() => emit("harness-updated", {}));
+        },
+        async search_sessions({ query }) {
+            return searchSessions(await discovery.discoverSessions(), query);
+        },
+        async get_transcript({ sessionId, offset, limit }) {
+            return readTranscript(await sessionPathFor(ctx, sessionId), offset, typeof limit === "number" ? limit : undefined);
+        },
+        async search_transcript({ sessionId, query }) {
+            return searchTranscriptTurns(await sessionPathFor(ctx, sessionId), query);
+        },
+        fork_session: ({ sessionPath, targetDir }) => forkSession(sessionPath, targetDir),
+        truncate_session: ({ sessionPath, turnCount }) => truncateSession(sessionPath, turnCount),
+        async discover_projects() {
+            const seen = new Set();
+            for (const s of await discovery.discoverSessions())
+                if (s.projectPath)
+                    seen.add(s.projectPath);
+            return [...seen].sort();
+        },
+        open_in_editor: ({ path: p, editor }) => openInEditor(p, editor),
+        open_in_terminal: ({ wslScript, argv, cmdLine }) => openInTerminal({
+            wslScript: wslScript ? String(wslScript) : undefined,
+            argv: Array.isArray(argv) ? argv.map(String) : undefined,
+            cmdLine: cmdLine ? String(cmdLine) : undefined,
+        }),
+        // ── Git / GitHub ────────────────────────────────────────────────────────
+        resolve_github_base_url: ({ projectPath }) => githubBaseUrl(projectPath),
+        list_worktrees: ({ repoRoot }) => listWorktrees(repoRoot),
+        create_worktree: ({ repoRoot, name }) => createWorktree(repoRoot, name),
+        remove_worktree: ({ path: p, repoRoot, force }) => removeWorktree(p, repoRoot, !!force),
+        get_diff: ({ path: p, isWorktree }) => getDiff(p, !!isWorktree),
+        async merge_pr({ projectPath, number }) {
+            const template = (await settings.read()).github.mergeCommand;
+            const command = template.replaceAll("${number}", String(number));
+            if (!command.trim())
+                throw new Error("merge command template is empty");
+            log.info("merge-pr", `running \`${command}\` in ${projectPath}`);
+            const r = await runShell(command, projectPath);
+            const stdout = r.stdout.trim();
+            const stderr = r.stderr.trim();
+            if (!r.ok) {
+                log.warn("merge-pr", `merge failed (exit ${r.code}): ${r.stderr}`);
+                throw new Error(stderr || stdout || `merge exited with status ${r.code}`);
+            }
+            return stdout || `Merged PR #${number}`;
+        },
+        async check_dependencies() {
+            const [claude, git, gh] = await Promise.all([commandExists("claude"), commandExists("git"), commandExists("gh")]);
+            return {
+                claudeAvailable: claude,
+                gitAvailable: git,
+                ghAvailable: gh,
+                ghAuthenticated: gh ? await ghIsAuthed() : false,
+            };
+        },
+        // ── Processes / tmux ────────────────────────────────────────────────────
+        async get_process_state() {
+            const s = await settings.read();
+            return getProcessState(s.projects.map((p) => p.repoRoot ?? p.path));
+        },
+        kill_claude_process: ({ pid }) => killClaudeProcess(pid),
+        tmux_available: () => tmux.isAvailable(),
+        psmux_status: () => psmuxStatus(),
+        psmux_install: () => installPsmux(),
+        // `runtime: "windows"` runs these against psmux; anything else against tmux in WSL.
+        async tmux_ensure_session({ name, cwdWindows, command, runtime }) {
+            if (backendFor(runtime) === "psmux")
+                return tmux.ensureWindowsSession(name, cwdWindows, command ?? "");
+            return tmux.ensureSession(name, await tmux.windowsPathToWsl(cwdWindows), command ?? "");
+        },
+        tmux_send_prompt: ({ target, text, runtime }) => tmux.sendPrompt(target, text, backendFor(runtime)),
+        tmux_paste: ({ target, text, runtime }) => tmux.pasteText(target, text, backendFor(runtime)),
+        tmux_capture: ({ target, runtime }) => tmux.capturePane(target, backendFor(runtime)),
+        tmux_kill_session: ({ name, runtime }) => tmux.killSession(name, backendFor(runtime)),
+        async tmux_new_window({ session, cwdWindows, command, runtime }) {
+            const be = backendFor(runtime);
+            const cwd = cwdWindows && be === "wsl" ? await tmux.windowsPathToWsl(cwdWindows) : (cwdWindows ?? null);
+            return tmux.newWindow(session, cwd, command, be);
+        },
+        tmux_kill_window: ({ target, runtime }) => tmux.killWindow(target, backendFor(runtime)),
+        tmux_list_windows: ({ session, runtime }) => tmux.listWindows(session, backendFor(runtime)),
+        // ── Remote ──────────────────────────────────────────────────────────────
+        remote_prereqs: () => prereqs(),
+        remote_deploy_shell: () => deployRemoteShell(),
+        mutagen_status: () => syncStatus(),
+        mutagen_raw_status: () => rawSyncStatus(),
+        async mutagen_start() {
+            const remote = (await settings.read()).remote;
+            if (!remote)
+                throw new Error("Remote settings not configured");
+            if (!remote.host || !remote.remotePath || !remote.localPath) {
+                throw new Error("Remote host / remotePath / localPath must all be set");
+            }
+            await ensureDaemon();
+            await startSync(remote.localPath, remote.host, remote.remotePath, remote.syncIgnores ?? defaultIgnores());
+        },
+        mutagen_stop: () => stopSync(),
+        mutagen_reset: () => resetSync(),
+        mutagen_flush: () => flushSync(),
+        // ── Knowledge harness ───────────────────────────────────────────────────
+        kb_status: () => harness.status(),
+        async kb_reload() {
+            await harness.reload();
+            return harness.status();
+        },
+        async kb_sync() {
+            await harness.sync();
+            return harness.status();
+        },
+        kb_search: ({ text, files, cwd, kbIds, onlyKbs, limit }) => harness.searchFrom(cwd ?? undefined, { text, files, kbIds, onlyKbs, limit: limit ?? 10 }),
+        kb_show: ({ id }) => harness.show(id),
+        kb_entries: ({ kbId }) => harness.index.all(kbId ?? undefined),
+        // Called by the SessionStart hook with Claude's own (snake_case) payload.
+        async kb_session_context(args) {
+            const out = await harness.sessionContext(args);
+            // A card that was just given entries now has a Knowledge tab to show.
+            if ("hookSpecificOutput" in out)
+                emit("harness-updated", { injected: true });
+            return out;
+        },
+        kb_project_commands: ({ cwd }) => harness.projectCommands(cwd),
+        /** Which harness project (if any) each board project folder belongs to. */
+        async harness_projects({ paths }) {
+            const out = [];
+            for (const p of (paths ?? []))
+                out.push({ path: p, projectId: (await harness.projectFor(p))?.project?.id });
+            return out;
+        },
+        async kb_propose({ type, title, summary, body, scope, kbId, cwd, source, reason, supersedes }) {
+            const p = await harness.propose({ type, title, summary, body, scope, kbId, cwd, source, reason, supersedes });
+            emit("harness-updated", { proposals: 1 });
+            await notifyUser(ctx, { title: "Knowledge to review", body: p.title, threadId: "knowledge-review" });
+            return p;
+        },
+        kb_proposals: ({ status, cardId }) => harness.proposals.list(status ?? undefined, cardId ? { cardId } : undefined),
+        kb_card_knowledge: ({ cardId }) => harness.cardKnowledge(cardId),
+        kb_pending_by_card: () => harness.pendingByCard(),
+        async kb_proposal_approve({ id, edits }) {
+            const p = await harness.approveProposal(id, edits ?? undefined);
+            emit("harness-updated", {});
+            return p;
+        },
+        async kb_proposal_undo({ id }) {
+            const r = await harness.undoApproval(id);
+            emit("harness-updated", {});
+            return r;
+        },
+        async kb_proposal_reject({ id, note }) {
+            const p = await harness.rejectProposal(id, note);
+            emit("harness-updated", {});
+            return p;
+        },
+        async kb_maintain() {
+            return harness.maintain(await configuredProjectPaths(settings));
+        },
+        harness_init_repo: ({ repoPath }) => harness.initRepo(repoPath),
+        harness_install_pack: () => harness.installPack(),
+        harness_bundle: ({ serverUrl }) => harness.bundle(serverUrl),
+        async project_onboard({ projectPath, commands }) {
+            const r = await harness.onboard(projectPath, commands ?? undefined);
+            emit("harness-updated", {});
+            return r;
+        },
+        // ── AI-DLC ──────────────────────────────────────────────────────────────
+        intent_list: () => harness.intents.list(),
+        intent_get: ({ id }) => harness.intents.get(id),
+        async intent_create({ projectPath, title, body, issueUrl }) {
+            if (!projectPath || !title?.trim())
+                throw new Error("projectPath and title are required");
+            const r = await createIntent({ store, intents: harness.intents }, { projectPath, title, body: body ?? "", issueUrl });
+            emit("harness-updated", {});
+            return r;
+        },
+        async gate_request({ cardId, note }) {
+            const card = await requestGate({ store, intents: harness.intents }, cardId, note);
+            const intent = card.intentId ? await harness.intents.get(card.intentId) : undefined;
+            await notifyUser(ctx, {
+                title: `Review needed: ${card.stage}`,
+                body: `${intent?.title ?? card.name ?? card.id}${card.gate?.note ? ` — ${card.gate.note}` : ""}`,
+                threadId: card.id,
+            });
+            emit("harness-updated", {});
+            return card;
+        },
+        async gate_approve({ cardId }) {
+            const r = await approveGate({ store, intents: harness.intents }, cardId);
+            emit("harness-updated", {});
+            return r;
+        },
+        async gate_reject({ cardId, note }) {
+            const card = await rejectGate({ store, intents: harness.intents }, cardId, note ?? "");
+            emit("harness-updated", {});
+            return card;
+        },
+        // ── Web-only helpers ────────────────────────────────────────────────────
+        fs_list: ({ path: dir }) => fsList(dir),
+        fs_search: ({ query, root }) => fsSearch(String(query ?? ""), root),
+        launcher_info: () => ensureLauncher(),
+    };
+}
+/** Binary-upload endpoints (HTTP, not JSON-RPC). */
+export const uploads = {
+    image: (bytes) => saveImageBytes(bytes),
+    file: (bytes, name) => saveAttachmentBytes(bytes, name),
+};

package/server-dist/server/context.js

@@ -0,0 +1,34 @@
+// Shared application context + notification dispatch.
+import { BoardState } from "./board.js";
+import { HarnessService } from "./harness/service.js";
+import { CoordinationStore } from "./coordination.js";
+import { emit } from "./events.js";
+import { pushoverSend } from "./integrations.js";
+import { SessionDiscovery } from "./sessions.js";
+import { SettingsStore } from "./settings.js";
+import { log } from "./util.js";
+/** `serverUrl` / `token`: how hooks on this machine reach this server. */
+export function createContext(opts) {
+    const store = new CoordinationStore();
+    const settings = new SettingsStore();
+    return {
+        store,
+        settings,
+        discovery: new SessionDiscovery(),
+        board: new BoardState(),
+        harness: new HarnessService({ store, settings, serverUrl: opts.serverUrl, token: opts.token }),
+    };
+}
+/** Browser notification (via the `notification` event) + Pushover, each gated
+ *  by the same settings toggles the desktop app honoured. */
+export async function notifyUser(ctx, opts) {
+    const settings = await ctx.settings.read().catch(() => null);
+    const osEnabled = settings?.notifications.notificationsEnabled ?? true;
+    if (osEnabled)
+        emit("notification", { title: opts.title, body: opts.body, tag: opts.threadId ?? undefined });
+    const n = settings?.notifications;
+    if (n?.pushoverEnabled && n.pushoverToken && n.pushoverUserKey) {
+        // Fire-and-forget: Pushover is best-effort and must not block callers.
+        pushoverSend(n.pushoverToken, n.pushoverUserKey, opts.title, opts.body, opts.threadId ?? undefined).then(() => log.info("pushover", `sent (${opts.threadId ?? "-"})`), (e) => log.warn("pushover", `send failed (${opts.threadId ?? "-"}): ${e}`));
+    }
+}