@luuthuong/devboard 1.0.0 → 1.0.1

package/dist/assets/plus-Cecrm8sZ.js

@@ -0,0 +1 @@
+import{Ct as e}from"./index-CQnL8JJ5.js";var t={name:`plus`,size:24,node:[[`path`,{d:`M5 12h14`,key:`1ays0h`}],[`path`,{d:`M12 5v14`,key:`s699le`}]]};t.node;var n=e(t);export{n as t};

package/dist/assets/x-B6wVesqk.js

@@ -0,0 +1 @@
+import{Ct as e}from"./index-CQnL8JJ5.js";var t={name:`x`,size:24,node:[[`path`,{d:`M18 6 6 18`,key:`1bl5f8`}],[`path`,{d:`m6 6 12 12`,key:`d8bk6v`}]]};t.node;var n=e(t);export{n as t};

package/dist/index.html

@@ -10,11 +10,11 @@
       rel="stylesheet"
     />
     <title>DevBoard</title>
-    <script type="module" crossorigin src="/assets/index-gWSenOqD.js"></script>
+    <script type="module" crossorigin src="/assets/index-CQnL8JJ5.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/jsx-runtime-QmcfnBgR.js">
     <link rel="modulepreload" crossorigin href="/assets/react-dom-DjtJUrx3.js">
     <link rel="modulepreload" crossorigin href="/assets/Surface-BQKeigoq.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-DNKB6XwG.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BtXUncAU.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luuthuong/devboard",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "DevBoard — a local devboard board for orchestrating Claude Code sessions",
   "keywords": [
     "agents",
@@ -33,7 +33,7 @@
     "build": "tsc && vite build",
     "start": "tsx server/index.ts",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.server.json",
-    "test": "tsx --test --test-reporter=spec 'server/**/*.test.ts'",
+    "test": "tsx --test --test-reporter=spec 'server/**/*.test.ts' 'src/**/*.test.ts'",
     "preview": "vite preview",
     "prepack": "node scripts/prepack.mjs",
     "build:server": "node scripts/build-server.mjs"

package/server-dist/server/commands.js

@@ -1,10 +1,8 @@
 // The RPC surface: every command the UI used to `invoke()` through Tauri.
 // Arguments arrive as the same camelCase objects; return values are JSON.
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 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";
@@ -16,7 +14,7 @@ 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, IS_WINDOWS } from "./util.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) {
@@ -29,39 +27,6 @@ async function sessionPathFor(ctx, sessionId) {
         throw new Error(`Session ${sessionId} not found`);
     return found;
 }
-/** Directories-only listing for the in-browser folder picker. */
-async function fsList(dir) {
-    if (!dir) {
-        const roots = IS_WINDOWS
-            ? "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                .split("")
-                .map((l) => `${l}:\\`)
-                .filter((r) => fs.existsSync(r))
-            : ["/"];
-        return {
-            path: "",
-            parent: null,
-            home: os.homedir(),
-            entries: roots.map((r) => ({ name: r, path: r, isDir: true })),
-        };
-    }
-    const resolved = path.resolve(dir);
-    const parent = path.dirname(resolved);
-    const dirents = await fs.promises.readdir(resolved, { withFileTypes: true });
-    const entries = dirents
-        .filter((d) => d.isDirectory() || (d.isSymbolicLink() && safeIsDir(path.join(resolved, d.name))))
-        .map((d) => ({ name: d.name, path: path.join(resolved, d.name), isDir: true }))
-        .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }));
-    return { path: resolved, parent: parent === resolved ? "" : parent, home: os.homedir(), entries };
-}
-function safeIsDir(p) {
-    try {
-        return fs.statSync(p).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
 async function configuredProjectPaths(settings) {
     const s = await settings.read().catch(() => null);
     return (s?.projects ?? []).flatMap((p) => [p.path, p.repoRoot].filter((x) => !!x));
@@ -222,8 +187,8 @@ export function buildCommands(ctx) {
         async search_sessions({ query }) {
             return searchSessions(await discovery.discoverSessions(), query);
         },
-        async get_transcript({ sessionId, offset }) {
-            return readTranscript(await sessionPathFor(ctx, sessionId), offset);
+        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);
@@ -414,6 +379,7 @@ export function buildCommands(ctx) {
         },
         // ── Web-only helpers ────────────────────────────────────────────────────
         fs_list: ({ path: dir }) => fsList(dir),
+        fs_search: ({ query, root }) => fsSearch(String(query ?? ""), root),
         launcher_info: () => ensureLauncher(),
     };
 }

package/server-dist/server/fsBrowse.js

@@ -0,0 +1,143 @@
+// Directory browsing for the in-browser folder picker: listing, quick places
+// and a bounded name search. Directories only; never reads file contents.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const IS_WINDOWS = process.platform === "win32";
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function hasGit(dir) {
+    return fs.promises.access(path.join(dir, ".git")).then(() => true, () => false);
+}
+const PLACE_NAMES = ["Desktop", "Documents", "Downloads", "repos", "source", "code", "dev", "projects", "workspace"];
+function places() {
+    const home = os.homedir();
+    const out = [{ name: "Home", path: home }];
+    const seen = new Set();
+    for (const name of PLACE_NAMES) {
+        const p = path.join(home, name);
+        // Case-insensitive filesystems report "Repos" and "repos" as the same folder.
+        if (seen.has(p.toLowerCase()) || !isDir(p))
+            continue;
+        seen.add(p.toLowerCase());
+        out.push({ name, path: p });
+    }
+    return out;
+}
+function roots() {
+    const list = IS_WINDOWS
+        ? "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            .split("")
+            .map((l) => `${l}:\\`)
+            .filter((r) => fs.existsSync(r))
+        : ["/"];
+    return list.map((r) => ({ name: r, path: r, isDir: true }));
+}
+/** `~`, `~/x` and an empty path resolve against the user's home; anything else is taken as given. */
+function expand(dir) {
+    if (dir === "~")
+        return os.homedir();
+    if (dir.startsWith("~/") || dir.startsWith("~\\"))
+        return path.join(os.homedir(), dir.slice(2));
+    return dir;
+}
+/**
+ * List the subfolders of `dir`. A missing `dir` is the home folder (so the
+ * picker opens where the user works); `""` is the machine's roots (drives).
+ */
+export async function fsList(dir) {
+    const home = os.homedir();
+    if (dir === "")
+        return { path: "", parent: null, home, places: places(), entries: roots() };
+    const resolved = path.resolve(expand(dir || home));
+    const dirents = await fs.promises.readdir(resolved, { withFileTypes: true });
+    const entries = dirents
+        .filter((d) => d.isDirectory() || (d.isSymbolicLink() && isDir(path.join(resolved, d.name))))
+        .map((d) => ({ name: d.name, path: path.join(resolved, d.name), isDir: true }))
+        .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }));
+    if (entries.length <= 400) {
+        await Promise.all(entries.map(async (e) => {
+            if (await hasGit(e.path))
+                e.isRepo = true;
+        }));
+    }
+    const parent = path.dirname(resolved);
+    return { path: resolved, parent: parent === resolved ? "" : parent, home, places: places(), entries };
+}
+const SKIP = new Set([
+    "node_modules",
+    "appdata",
+    "library",
+    "target",
+    "dist",
+    "build",
+    "venv",
+    "__pycache__",
+    "vendor",
+    "windows",
+    "program files",
+    "program files (x86)",
+    "programdata",
+    "$recycle.bin",
+    "system volume information",
+]);
+/**
+ * Find folders under `root` (default: home) whose name contains every word of
+ * `query`. Breadth-first, so shallow matches win, and bounded by depth, folder
+ * count and time so a huge disk can't stall the server.
+ */
+export async function fsSearch(query, root) {
+    const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return [];
+    const start = path.resolve(expand(root || os.homedir()));
+    const deadline = Date.now() + 1500;
+    const MAX_VISITED = 8000;
+    const MAX_DEPTH = 5;
+    const hits = [];
+    let level = [start];
+    let visited = 0;
+    for (let depth = 0; depth <= MAX_DEPTH && level.length > 0; depth++) {
+        const next = [];
+        // Read one level in small parallel batches, checking the clock between them.
+        for (let i = 0; i < level.length; i += 24) {
+            if (Date.now() > deadline || visited > MAX_VISITED)
+                break;
+            const batch = level.slice(i, i + 24);
+            const results = await Promise.all(batch.map((d) => fs.promises.readdir(d, { withFileTypes: true }).catch(() => [])));
+            results.forEach((dirents, j) => {
+                for (const d of dirents) {
+                    if (!d.isDirectory())
+                        continue;
+                    const lower = d.name.toLowerCase();
+                    if (d.name.startsWith(".") || SKIP.has(lower))
+                        continue;
+                    visited++;
+                    const full = path.join(batch[j], d.name);
+                    if (tokens.every((t) => lower.includes(t))) {
+                        const score = (lower === tokens.join(" ") ? 0 : lower.startsWith(tokens[0]) ? 1 : 2) + depth * 0.25;
+                        hits.push({ name: d.name, path: full, parent: batch[j], isRepo: false, score });
+                    }
+                    next.push(full);
+                }
+            });
+        }
+        if (hits.length >= 60 || Date.now() > deadline || visited > MAX_VISITED)
+            break;
+        level = next;
+    }
+    hits.sort((a, b) => a.score - b.score || a.name.localeCompare(b.name));
+    const top = hits.slice(0, 30);
+    await Promise.all(top.map(async (h) => {
+        h.isRepo = await hasGit(h.path);
+    }));
+    // Project roots first within the same relevance band.
+    top.sort((a, b) => Math.floor(a.score) - Math.floor(b.score) || Number(b.isRepo) - Number(a.isRepo) || a.score - b.score);
+    return top.map(({ score: _score, ...h }) => h);
+}

package/server-dist/server/transcripts.js

@@ -54,33 +54,32 @@ async function* turnObjects(filePath) {
             yield obj;
     }
 }
-export async function readTranscript(filePath, offset) {
+/** Turns `offset`..`offset + limit` of a transcript. Only that window is materialised; the rest is just counted. */
+export async function readTranscript(filePath, offset, limit = PAGE_SIZE) {
     if (!fs.existsSync(filePath))
         return { turns: [], totalTurns: 0, hasMore: false, nextOffset: 0 };
-    const all = [];
+    const turns = [];
     let index = 0;
     for await (const obj of turnObjects(filePath)) {
-        const contentBlocks = parseContentBlocks(obj);
-        const textPreview = takeChars(contentBlocks
-            .filter((b) => b.kind === "text")
-            .map((b) => b.text)
-            .join(" "), 200);
-        all.push({
-            index: index++,
-            role: obj.type,
-            textPreview,
-            timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-            contentBlocks,
-        });
+        if (index >= offset && index < offset + limit) {
+            const contentBlocks = parseContentBlocks(obj);
+            const textPreview = takeChars(contentBlocks
+                .filter((b) => b.kind === "text")
+                .map((b) => b.text)
+                .join(" "), 200);
+            turns.push({
+                index,
+                role: obj.type,
+                textPreview,
+                timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
+                contentBlocks,
+            });
+        }
+        index++;
     }
-    const total = all.length;
-    const hasMore = offset + PAGE_SIZE < total;
-    return {
-        turns: all.slice(offset, offset + PAGE_SIZE),
-        totalTurns: total,
-        hasMore,
-        nextOffset: hasMore ? offset + PAGE_SIZE : total,
-    };
+    const total = index;
+    const hasMore = offset + limit < total;
+    return { turns, totalTurns: total, hasMore, nextOffset: hasMore ? offset + limit : total };
 }
 export async function searchTranscriptTurns(filePath, query) {
     if (!fs.existsSync(filePath))