feat: multi-folder project scanning (scan roots + individual repos) (#9)

* feat(store): folders list with legacy baseDir migration

* fix(store): explicit empty folders is authoritative; copy on read

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(scanner): scanFolders merges roots + direct repos, dedups by path

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* refactor(scanner): parallelize scanFolders to match walk's Promise.all

* feat(guard): isAllowedPath pure guard over folder list

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* refactor(projects): scan() takes no base, deck spans multiple folders

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(ipc): folders handlers, scanFolders for list/usage, isAllowedPath guard

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(ipc): validate added folder exists; snapshot folders in open loop

- settings:addFolder now stat-checks the path and rejects non-existent
  paths or plain files before storing, preventing garbage/non-directory
  paths from widening the security allow-set.
- projects:open hoists effFolders() to a single call before the loop
  instead of re-evaluating it on every iteration.
- effBaseDir comment clarifies it is legacy/back-compat only.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(ipc): expose folders methods to the renderer

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* i18n: scan-locations list strings (ko/en/ja/zh)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(renderer): scan-locations folder list with add/remove

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* polish(renderer): use Folder type, nowrap kind label, drop dead set.browse key

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* polish(ipc): error message reflects folder allow-set, not single base dir

* test(guard): use OS-native paths in pathGuard test so it passes on POSIX CI

Hardcoded Windows paths (C:\work) made resolve()/sep behave differently on
ubuntu/macOS, failing the under-root assertion. Build paths via node:path so
the test exercises the platform's real separator semantics.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Si Hyeong Lee <writingdeveloper@users.noreply.github.com>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: writingdeveloper

src/main/ipc.ts

@@ -1,11 +1,13 @@
 import { ipcMain, dialog, shell, type BrowserWindow } from 'electron';
 import { homedir } from 'node:os';
-import { join, resolve, sep } from 'node:path';
+import { join } from 'node:path';
+import { stat } from 'node:fs/promises';
 import type { Store } from './store';
-import { scanRepos } from './scanner';
+import { scanFolders, isRepo } from './scanner';
 import { getGitInfo } from './gitInfo';
 import { getProvider, availableAgents } from './agents';
-import type { AgentId } from '../shared/types';
+import type { AgentId, Folder } from '../shared/types';
+import { isAllowedPath } from '../shared/pathGuard';
 import { buildProjectList } from './projects';
 import { openProjects, openInEditor } from './launcher';
 import type { WtTab } from '../shared/wtArgs';
@@ -22,15 +24,14 @@ export interface IpcConfig {
   defaultLanguage: string;
 }
 
-function isUnderBase(base: string, incoming: string): boolean {
-  const r = resolve(incoming);
-  const b = resolve(base);
-  return r === b || r.startsWith(b + sep);
-}
-
 export function registerIpc(cfg: IpcConfig): void {
+  // Legacy single-base value, retained only for the settings:get response (back-compat); not used for scanning or the security guard.
   const effBaseDir = () => cfg.store.getBaseDir() ?? cfg.defaultBaseDir;
   const effThresholds = () => cfg.store.getThresholds() ?? DEFAULT_THRESHOLDS;
+  const effFolders = (): Folder[] => {
+    const f = cfg.store.getFolders();
+    return f.length ? f : [{ path: cfg.defaultBaseDir, kind: 'root' }];
+  };
 
   const activeAgent = (): AgentId => {
     const a = cfg.store.getAgent();
@@ -40,10 +41,9 @@ export function registerIpc(cfg: IpcConfig): void {
 
   ipcMain.handle('projects:list', async () => {
     return buildProjectList({
-      baseDir: effBaseDir(),
       nowMs: Date.now(),
       thresholds: effThresholds(),
-      scan: (base) => scanRepos(base),
+      scan: () => scanFolders(effFolders()),
       git: (dir) => getGitInfo(dir),
       sessions: (p) => agent().listSessions(p),
       resumeCue: (p, sessionId) => agent().lastUserMessage(p, sessionId),
@@ -63,7 +63,7 @@ export function registerIpc(cfg: IpcConfig): void {
 
   ipcMain.handle('usage:report', async (_e, sinceMs: number) => {
     const ms = (Number.isFinite(sinceMs) || sinceMs === Infinity) ? sinceMs : 0;
-    const repos = await scanRepos(effBaseDir());
+    const repos = await scanFolders(effFolders());
     return scanUsage(repos, CLAUDE_PROJECTS, ms);
   });
   ipcMain.handle('settings:getLanguage', () => cfg.store.getLanguage() ?? cfg.defaultLanguage);
@@ -78,6 +78,21 @@ export function registerIpc(cfg: IpcConfig): void {
     baseDir: effBaseDir(), thresholds: effThresholds(), language: cfg.store.getLanguage() ?? cfg.defaultLanguage,
   }));
   ipcMain.handle('settings:setBaseDir', (_e, dir: string) => cfg.store.setBaseDir(String(dir).slice(0, 2000)));
+  ipcMain.handle('settings:getFolders', () => effFolders());
+  ipcMain.handle('settings:addFolder', async (_e, p: string) => {
+    const path = String(p).trim().slice(0, 2000);
+    let isDir = false;
+    try { isDir = (await stat(path)).isDirectory(); } catch { isDir = false; }
+    if (isDir) {
+      const kind: Folder['kind'] = (await isRepo(path)) ? 'repo' : 'root';
+      cfg.store.addFolder({ path, kind });
+    }
+    return effFolders();
+  });
+  ipcMain.handle('settings:removeFolder', (_e, p: string) => {
+    cfg.store.removeFolder(String(p).slice(0, 2000));
+    return effFolders();
+  });
   ipcMain.handle('settings:setThresholds', (_e, t: { freshDays: number; warnDays: number; neglectedDays: number }) => {
     const { freshDays, warnDays, neglectedDays } = t ?? {};
     if (
@@ -93,12 +108,12 @@ export function registerIpc(cfg: IpcConfig): void {
   });
 
   ipcMain.handle('projects:open', (_e, items: { path: string; sessionId: string | null }[]) => {
-    const base = effBaseDir();
     const now = new Date().toISOString();
+    const folders = effFolders();
     const tabs: WtTab[] = [];
     for (const it of items) {
-      if (!isUnderBase(base, it.path)) {
-        cfg.sendError(`Path outside base dir: ${it.path}`);
+      if (!isAllowedPath(folders, it.path)) {
+        cfg.sendError(`Path outside allowed folders: ${it.path}`);
         continue;
       }
       const a = agent();
@@ -119,8 +134,8 @@ export function registerIpc(cfg: IpcConfig): void {
 
   // Open the project folder in the OS file manager.
   ipcMain.handle('project:openFolder', async (_e, p: string) => {
-    if (!isUnderBase(effBaseDir(), p)) {
-      cfg.sendError(`Path outside base dir: ${p}`);
+    if (!isAllowedPath(effFolders(), p)) {
+      cfg.sendError(`Path outside allowed folders: ${p}`);
       return;
     }
     const err = await shell.openPath(p);
@@ -129,8 +144,8 @@ export function registerIpc(cfg: IpcConfig): void {
 
   // Open the project in VS Code (`code <path>`).
   ipcMain.handle('project:openEditor', (_e, p: string) => {
-    if (!isUnderBase(effBaseDir(), p)) {
-      cfg.sendError(`Path outside base dir: ${p}`);
+    if (!isAllowedPath(effFolders(), p)) {
+      cfg.sendError(`Path outside allowed folders: ${p}`);
       return;
     }
     openInEditor(p, { onError: cfg.sendError });

src/main/projects.test.ts

@@ -8,7 +8,6 @@ const DAY = 86_400_000;
 
 function deps(over: Partial<BuildDeps>): BuildDeps {
   return {
-    baseDir: 'C:\\g',
     nowMs: NOW,
     thresholds: DEFAULT_THRESHOLDS,
     scan: async () => [

src/main/projects.ts

@@ -3,10 +3,9 @@ import type { RawProject } from './scanner';
 import { classifyStaleness } from '../shared/staleness';
 
 export interface BuildDeps {
-  baseDir: string;
   nowMs: number;
   thresholds: StaleThresholds;
-  scan: (baseDir: string) => Promise<RawProject[]>;
+  scan: () => Promise<RawProject[]>;
   git: (dir: string) => Promise<GitInfo>;
   sessions: (projectPath: string) => SessionMeta[];
   resumeCue: (projectPath: string, sessionId: string) => string | null;
@@ -20,7 +19,7 @@ function maxMs(a: number | null, b: number | null): number | null {
 }
 
 export async function buildProjectList(deps: BuildDeps): Promise<ProjectViewModel[]> {
-  const raw = await deps.scan(deps.baseDir);
+  const raw = await deps.scan();
   const models = await Promise.all(
     raw.map(async (r): Promise<ProjectViewModel> => {
       const git = await deps.git(r.path);

src/main/scanner.test.ts

@@ -1,8 +1,8 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { scanRepos } from './scanner';
+import { join, basename } from 'node:path';
+import { scanRepos, scanFolders } from './scanner';
 
 let base: string;
 beforeEach(() => {
@@ -40,3 +40,39 @@ describe('scanRepos', () => {
     expect(repos).toEqual(['projA', 'projB']);
   });
 });
+
+describe('scanFolders', () => {
+  it('merges multiple roots, includes a direct repo, and dedupes by path', async () => {
+    // second root
+    const base2 = mkdtempSync(join(tmpdir(), 'devdeck-scan2-'));
+    mkdirSync(join(base2, 'projC', '.git'), { recursive: true });
+    // a standalone repo dir to add directly
+    const repoDir = mkdtempSync(join(tmpdir(), 'devdeck-repo-'));
+    mkdirSync(join(repoDir, '.git'), { recursive: true });
+    try {
+      const out = await scanFolders([
+        { path: base, kind: 'root' },        // projA, projB (from beforeEach)
+        { path: base2, kind: 'root' },       // projC
+        { path: repoDir, kind: 'repo' },     // the standalone repo itself
+        { path: join(base, 'projA'), kind: 'repo' }, // duplicate of projA -> deduped
+      ]);
+      expect(out.map((p) => p.name).sort()).toEqual(['projA', 'projB', 'projC', basename(repoDir)].sort());
+    } finally {
+      rmSync(base2, { recursive: true, force: true });
+      rmSync(repoDir, { recursive: true, force: true });
+    }
+  });
+
+  it('skips a repo entry that has no .git, and a non-existent root', async () => {
+    const noGit = mkdtempSync(join(tmpdir(), 'devdeck-nogit-'));
+    try {
+      const out = await scanFolders([
+        { path: noGit, kind: 'repo' },                 // no .git -> skipped
+        { path: join(noGit, 'does-not-exist'), kind: 'root' }, // missing -> skipped
+      ]);
+      expect(out).toEqual([]);
+    } finally {
+      rmSync(noGit, { recursive: true, force: true });
+    }
+  });
+});

src/main/scanner.ts

@@ -1,5 +1,6 @@
 import { readdir, access } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, basename, resolve } from 'node:path';
+import type { Folder } from '../shared/types';
 
 const IGNORE = new Set(['__pycache__', '.pytest_cache', '.claude', '.playwright-mcp', 'node_modules']);
 
@@ -8,7 +9,7 @@ export interface RawProject {
   name: string;
 }
 
-async function isRepo(dir: string): Promise<boolean> {
+export async function isRepo(dir: string): Promise<boolean> {
   try {
     await access(join(dir, '.git'));
     return true;
@@ -44,3 +45,27 @@ export async function scanRepos(baseDir: string, maxDepth = 2): Promise<RawProje
   await walk(baseDir, 1, maxDepth, out);
   return out;
 }
+
+function dedupeByResolvedPath(items: RawProject[]): RawProject[] {
+  const seen = new Set<string>();
+  const out: RawProject[] = [];
+  for (const it of items) {
+    const key = resolve(it.path);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(it);
+  }
+  return out;
+}
+
+/** Scan every configured folder: roots walked depth-2, repos included directly; deduped by resolved path. */
+export async function scanFolders(folders: Folder[]): Promise<RawProject[]> {
+  const chunks = await Promise.all(
+    folders.map((f) =>
+      f.kind === 'repo'
+        ? isRepo(f.path).then((ok) => (ok ? [{ path: f.path, name: basename(f.path) }] : []))
+        : scanRepos(f.path),
+    ),
+  );
+  return dedupeByResolvedPath(chunks.flat());
+}

src/main/store.test.ts

@@ -65,4 +65,38 @@ describe('Store', () => {
     const re = new Store(file);
     expect(re.getAgent()).toBe('codex');
   });
+
+  it('round-trips folders: add, dedupe, remove', () => {
+    const s = new Store(file);
+    expect(s.getFolders()).toEqual([]);
+    s.addFolder({ path: 'C:\\work', kind: 'root' });
+    s.addFolder({ path: 'C:\\work', kind: 'root' }); // duplicate -> ignored
+    s.addFolder({ path: 'E:\\spike', kind: 'repo' });
+    const re = new Store(file);
+    expect(re.getFolders()).toEqual([
+      { path: 'C:\\work', kind: 'root' },
+      { path: 'E:\\spike', kind: 'repo' },
+    ]);
+    re.removeFolder('C:\\work');
+    expect(new Store(file).getFolders()).toEqual([{ path: 'E:\\spike', kind: 'repo' }]);
+  });
+
+  it('migrates a legacy baseDir into a single root folder', () => {
+    const s = new Store(file);
+    s.setBaseDir('C:\\repos');
+    expect(s.getFolders()).toEqual([{ path: 'C:\\repos', kind: 'root' }]);
+    // first explicit add persists the migrated entry plus the new one
+    s.addFolder({ path: 'D:\\more', kind: 'root' });
+    expect(new Store(file).getFolders()).toEqual([
+      { path: 'C:\\repos', kind: 'root' },
+      { path: 'D:\\more', kind: 'root' },
+    ]);
+  });
+
+  it('keeps a migrated baseDir folder removed after reload', () => {
+    const s = new Store(file);
+    s.setBaseDir('C:\\repos');                 // legacy single base, no explicit folders
+    s.removeFolder('C:\\repos');               // remove the migrated entry
+    expect(new Store(file).getFolders()).toEqual([]); // must stay empty after reload
+  });
 });

src/main/store.ts

@@ -1,9 +1,10 @@
 import { readFileSync, writeFileSync, existsSync, renameSync } from 'node:fs';
-import type { StoreEntry } from '../shared/types';
+import { resolve } from 'node:path';
+import type { StoreEntry, Folder } from '../shared/types';
 
 interface StateFile {
   projects: Record<string, StoreEntry>;
-  settings?: { language?: string; baseDir?: string; thresholds?: { freshDays: number; warnDays: number; neglectedDays: number }; agent?: string };
+  settings?: { language?: string; baseDir?: string; folders?: Folder[]; thresholds?: { freshDays: number; warnDays: number; neglectedDays: number }; agent?: string };
 }
 
 const EMPTY: StoreEntry = {
@@ -56,6 +57,27 @@ export class Store {
 
   getBaseDir(): string | null { return this.state.settings?.baseDir ?? null; }
   setBaseDir(baseDir: string): void { this.state.settings = { ...(this.state.settings ?? {}), baseDir }; this.save(); }
+
+  getFolders(): Folder[] {
+    const f = this.state.settings?.folders;
+    if (f !== undefined) return [...f];
+    const b = this.state.settings?.baseDir;
+    return b ? [{ path: b, kind: 'root' }] : [];
+  }
+  addFolder(folder: Folder): void {
+    const cur = this.state.settings?.folders ?? this.getFolders();
+    const exists = cur.some((x) => resolve(x.path) === resolve(folder.path));
+    const folders = exists ? cur : [...cur, folder];
+    this.state.settings = { ...(this.state.settings ?? {}), folders };
+    this.save();
+  }
+  removeFolder(path: string): void {
+    const cur = this.state.settings?.folders ?? this.getFolders();
+    const folders = cur.filter((x) => resolve(x.path) !== resolve(path));
+    this.state.settings = { ...(this.state.settings ?? {}), folders };
+    this.save();
+  }
+
   getThresholds(): { freshDays: number; warnDays: number; neglectedDays: number } | null { return this.state.settings?.thresholds ?? null; }
   setThresholds(thresholds: { freshDays: number; warnDays: number; neglectedDays: number }): void { this.state.settings = { ...(this.state.settings ?? {}), thresholds }; this.save(); }
 

src/preload/preload.ts

@@ -16,6 +16,9 @@ contextBridge.exposeInMainWorld('devdeck', {
   availableAgents: () => ipcRenderer.invoke('settings:availableAgents'),
   getSettings: () => ipcRenderer.invoke('settings:get'),
   setBaseDir: (dir: string) => ipcRenderer.invoke('settings:setBaseDir', dir),
+  getFolders: () => ipcRenderer.invoke('settings:getFolders'),
+  addFolder: (path: string) => ipcRenderer.invoke('settings:addFolder', path),
+  removeFolder: (path: string) => ipcRenderer.invoke('settings:removeFolder', path),
   setThresholds: (t: { freshDays: number; warnDays: number; neglectedDays: number }) => ipcRenderer.invoke('settings:setThresholds', t),
   pickFolder: () => ipcRenderer.invoke('settings:pickFolder'),
   openFolder: (path: string) => ipcRenderer.invoke('project:openFolder', path),

src/renderer/global.d.ts

@@ -17,6 +17,9 @@ declare global {
       availableAgents(): Promise<import('../shared/types').AgentId[]>;
       getSettings(): Promise<{ baseDir: string; thresholds: { freshDays: number; warnDays: number; neglectedDays: number }; language: string }>;
       setBaseDir(dir: string): Promise<void>;
+      getFolders(): Promise<import('../shared/types').Folder[]>;
+      addFolder(path: string): Promise<import('../shared/types').Folder[]>;
+      removeFolder(path: string): Promise<import('../shared/types').Folder[]>;
       setThresholds(t: { freshDays: number; warnDays: number; neglectedDays: number }): Promise<void>;
       pickFolder(): Promise<string | null>;
       openFolder(path: string): Promise<void>;

src/renderer/locales/en.json

@@ -48,8 +48,11 @@
   "usage.col_project": "Project",
   "usage.col_cost": "Est. cost",
   "usage.disclaimer": "* Some models have no price card — excluded from cost. Cost is a public-rate API-equivalent estimate and may differ from your (subscription) bill.",
-  "set.scan_dir": "Scan folder",
-  "set.browse": "Browse…",
+  "set.scan_locations": "Scan locations",
+  "set.kind_root": "scans for repos",
+  "set.kind_repo": "single repo",
+  "set.add_folder": "+ Add folder…",
+  "set.remove_folder": "Remove",
   "set.thresholds": "Staleness thresholds (days)",
   "set.fresh": "Fresh",
   "set.warn": "Warn",