brainctl 0.1.23 → 0.1.26

package/dist/services/platform/recent-projects-service.d.ts

@@ -0,0 +1,16 @@
+interface FsLike {
+    readFile(p: string): Promise<string>;
+    writeFile(p: string, content: string): Promise<void>;
+    mkdir(p: string, opts?: {
+        recursive: boolean;
+    }): Promise<unknown>;
+}
+export interface RecentProjectsService {
+    read(): Promise<string[]>;
+    addRecent(cwd: string): Promise<string[]>;
+}
+export declare function createRecentProjectsService(deps: {
+    filePath: string;
+    fs?: FsLike;
+}): RecentProjectsService;
+export {};

package/dist/services/platform/recent-projects-service.js

@@ -0,0 +1,51 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const MAX_RECENTS = 20;
+const FILE_VERSION = 1;
+const defaultFs = {
+    readFile: (p) => readFile(p, 'utf8'),
+    writeFile: (p, content) => writeFile(p, content, 'utf8'),
+    mkdir: (p, opts) => mkdir(p, opts),
+};
+export function createRecentProjectsService(deps) {
+    const { filePath, fs: fsImpl = defaultFs } = deps;
+    async function readFile_() {
+        try {
+            const content = await fsImpl.readFile(filePath);
+            const parsed = JSON.parse(content);
+            if (typeof parsed === 'object' && parsed !== null && 'recents' in parsed) {
+                return parsed;
+            }
+            return null;
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async function persist(recents) {
+        const dir = path.dirname(filePath);
+        await fsImpl.mkdir(dir, { recursive: true });
+        const data = { version: FILE_VERSION, recents };
+        await fsImpl.writeFile(filePath, JSON.stringify(data, null, 2));
+    }
+    async function read() {
+        const data = await readFile_();
+        if (!data)
+            return [];
+        return (data.recents ?? []).filter((e) => typeof e === 'string');
+    }
+    async function addRecent(cwd) {
+        if (!path.isAbsolute(cwd)) {
+            throw new Error(`cwd must be an absolute path, got: ${cwd}`);
+        }
+        const current = await read();
+        const deduplicated = current.filter((p) => p !== cwd);
+        const updated = [cwd, ...deduplicated].slice(0, MAX_RECENTS);
+        await persist(updated);
+        return updated;
+    }
+    return { read, addRecent };
+}

package/dist/ui/routes.d.ts

@@ -3,6 +3,8 @@ import type { StatusService } from '../services/platform/status-service.js';
 export interface UiRouteDependencies {
     cwd: string;
     statusService?: StatusService;
+    recentsFilePath?: string;
+    claudeJsonPath?: string;
 }
 export type UiRouteHandler = (request: IncomingMessage, response: ServerResponse) => Promise<void>;
 export declare function createUiRouteHandler(dependencies: UiRouteDependencies): UiRouteHandler;

package/dist/ui/routes.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { readFile, readdir, stat } from 'node:fs/promises';
 import { BrainctlError, ProfileError, ProfileNotFoundError, ValidationError } from '../errors.js';
 import { createAgentConfigService } from '../services/agent/agent-config-service.js';
 import { createMcpPreflightService } from '../services/platform/mcp-preflight-service.js';
@@ -11,9 +11,31 @@ import { createSkillPreflightService } from '../services/plugin/skill-preflight-
 import { createStatusService } from '../services/platform/status-service.js';
 import { createProfileApplyService, } from '../services/profile/profile-apply-service.js';
 import { createProfileSnapshotService, defaultBackupProfileName, } from '../services/profile/profile-snapshot-service.js';
+import { createRecentProjectsService } from '../services/platform/recent-projects-service.js';
 import path from 'node:path';
+import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
+function revealInFileManager(targetPath) {
+    if (process.platform === 'darwin') {
+        spawn('open', ['-R', targetPath], { detached: true, stdio: 'ignore' }).unref();
+        return;
+    }
+    if (process.platform === 'win32') {
+        spawn('explorer', [`/select,${targetPath}`], { detached: true, stdio: 'ignore' }).unref();
+        return;
+    }
+    spawn('xdg-open', [path.dirname(targetPath)], { detached: true, stdio: 'ignore' }).unref();
+}
+function resolveCwd(req, fallback) {
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    const raw = url.searchParams.get('cwd');
+    if (!raw)
+        return fallback;
+    if (!path.isAbsolute(raw))
+        return fallback;
+    return raw;
+}
 const uiAssetRoot = resolveUiAssetRoot();
 export function createUiRouteHandler(dependencies) {
     const statusService = dependencies.statusService ?? createStatusService();
@@ -26,6 +48,19 @@ export function createUiRouteHandler(dependencies) {
     const mcpPreflightService = createMcpPreflightService();
     const pluginInstallService = createPluginInstallService();
     const skillPreflightService = createSkillPreflightService();
+    const recentsFilePath = dependencies.recentsFilePath ?? path.join(os.homedir(), '.brainctl', 'recents.json');
+    const claudeJsonPath = dependencies.claudeJsonPath ?? path.join(os.homedir(), '.claude.json');
+    const recentProjectsService = createRecentProjectsService({ filePath: recentsFilePath });
+    async function readClaudeProjectPaths() {
+        try {
+            const raw = await readFile(claudeJsonPath, 'utf8');
+            const data = JSON.parse(raw);
+            return Object.keys(data.projects ?? {}).sort();
+        }
+        catch {
+            return [];
+        }
+    }
     return async (request, response) => {
         const url = new URL(request.url ?? '/', 'http://localhost');
         switch (url.pathname) {
@@ -47,7 +82,7 @@ export function createUiRouteHandler(dependencies) {
                 if (request.method !== 'GET') {
                     return sendJson(response, 405, { error: 'Method not allowed' });
                 }
-                const configs = await agentConfigService.readAll({ cwd: dependencies.cwd });
+                const configs = await agentConfigService.readAll({ cwd: resolveCwd(request, dependencies.cwd) });
                 return sendJson(response, 200, configs);
             }
             case '/api/open-folder': {
@@ -65,13 +100,8 @@ export function createUiRouteHandler(dependencies) {
                 if (!existsSync(folderPath)) {
                     return sendJson(response, 404, { error: `Path not found: ${folderPath}` });
                 }
-                const opener = process.platform === 'darwin'
-                    ? 'open'
-                    : process.platform === 'win32'
-                        ? 'explorer'
-                        : 'xdg-open';
                 try {
-                    spawn(opener, [folderPath], { detached: true, stdio: 'ignore' }).unref();
+                    revealInFileManager(folderPath);
                     return sendJson(response, 200, { ok: true, path: folderPath });
                 }
                 catch (error) {
@@ -167,6 +197,79 @@ export function createUiRouteHandler(dependencies) {
                     return sendProfileError(response, error);
                 }
             }
+            case '/api/projects': {
+                if (request.method !== 'GET') {
+                    return sendJson(response, 405, { error: 'Method not allowed' });
+                }
+                const [claudeProjects, recents] = await Promise.all([
+                    readClaudeProjectPaths(),
+                    recentProjectsService.read(),
+                ]);
+                return sendJson(response, 200, {
+                    current: dependencies.cwd,
+                    claudeProjects,
+                    recents,
+                });
+            }
+            case '/api/projects/recent': {
+                if (request.method !== 'POST') {
+                    return sendJson(response, 405, { error: 'Method not allowed' });
+                }
+                const body = await readJsonBody(request);
+                if (!body.ok) {
+                    return sendJson(response, 400, { error: 'Invalid JSON body' });
+                }
+                const value = body.value;
+                const cwd = typeof value?.cwd === 'string' ? value.cwd : '';
+                if (!path.isAbsolute(cwd)) {
+                    return sendJson(response, 400, { error: 'cwd must be an absolute path' });
+                }
+                const recents = await recentProjectsService.addRecent(cwd);
+                return sendJson(response, 200, { recents });
+            }
+            case '/api/fs/browse': {
+                if (request.method !== 'GET') {
+                    return sendJson(response, 405, { error: 'Method not allowed' });
+                }
+                const raw = url.searchParams.get('path');
+                const mode = url.searchParams.get('mode') === 'file' ? 'file' : 'dir';
+                const startPath = raw && path.isAbsolute(raw) ? raw : os.homedir();
+                try {
+                    const stats = await stat(startPath);
+                    if (!stats.isDirectory()) {
+                        return sendJson(response, 400, { error: 'Path is not a directory' });
+                    }
+                    const entries = await readdir(startPath, { withFileTypes: true });
+                    const items = entries
+                        .filter((entry) => !entry.name.startsWith('.'))
+                        .filter((entry) => {
+                        if (mode === 'file')
+                            return entry.isDirectory() || entry.isFile();
+                        return entry.isDirectory();
+                    })
+                        .map((entry) => ({
+                        name: entry.name,
+                        isDir: entry.isDirectory(),
+                    }))
+                        .sort((a, b) => {
+                        if (a.isDir !== b.isDir)
+                            return a.isDir ? -1 : 1;
+                        return a.name.localeCompare(b.name);
+                    });
+                    const parent = path.dirname(startPath);
+                    return sendJson(response, 200, {
+                        path: startPath,
+                        parent: parent === startPath ? null : parent,
+                        home: os.homedir(),
+                        entries: items,
+                    });
+                }
+                catch (error) {
+                    return sendJson(response, 404, {
+                        error: error instanceof Error ? error.message : 'Cannot read path',
+                    });
+                }
+            }
             case '/api/profiles/snapshot': {
                 if (request.method !== 'POST') {
                     return sendJson(response, 405, { error: 'Method not allowed' });
@@ -204,13 +307,8 @@ export function createUiRouteHandler(dependencies) {
                     if (!existsSync(folderPath)) {
                         return sendJson(response, 404, { error: `Profile folder not found: ${folderPath}` });
                     }
-                    const opener = process.platform === 'darwin'
-                        ? 'open'
-                        : process.platform === 'win32'
-                            ? 'explorer'
-                            : 'xdg-open';
                     try {
-                        spawn(opener, [folderPath], { detached: true, stdio: 'ignore' }).unref();
+                        revealInFileManager(folderPath);
                         return sendJson(response, 200, { ok: true, path: folderPath });
                     }
                     catch (error) {
@@ -261,7 +359,7 @@ export function createUiRouteHandler(dependencies) {
                         return sendJson(response, 400, { error: 'Missing key and MCP payload' });
                     }
                     const result = await mcpPreflightService.execute({
-                        cwd: dependencies.cwd,
+                        cwd: resolveCwd(request, dependencies.cwd),
                         agent: agentName,
                         key: data.key,
                         entry: data.entry,
@@ -284,7 +382,7 @@ export function createUiRouteHandler(dependencies) {
                         }
                         try {
                             await agentConfigService.addMcp({
-                                cwd: dependencies.cwd,
+                                cwd: resolveCwd(request, dependencies.cwd),
                                 agent: agentName,
                                 key: data.key,
                                 entry: data.entry,
@@ -301,7 +399,7 @@ export function createUiRouteHandler(dependencies) {
                         const scope = url.searchParams.get('scope') === 'project' ? 'project' : 'global';
                         try {
                             await agentConfigService.removeMcp({
-                                cwd: dependencies.cwd,
+                                cwd: resolveCwd(request, dependencies.cwd),
                                 agent: agentName,
                                 key: mcpKey,
                                 scope,
@@ -400,7 +498,7 @@ export function createUiRouteHandler(dependencies) {
                     if (!data.name || !data.sourceAgent) {
                         return sendJson(response, 400, { error: 'Missing name or sourceAgent' });
                     }
-                    const sourcePlugin = await resolveSourcePlugin(agentConfigService, dependencies.cwd, {
+                    const sourcePlugin = await resolveSourcePlugin(agentConfigService, resolveCwd(request, dependencies.cwd), {
                         sourceAgent: data.sourceAgent,
                         name: data.name,
                     });
@@ -410,7 +508,7 @@ export function createUiRouteHandler(dependencies) {
                         });
                     }
                     const result = await pluginInstallService.plan({
-                        cwd: dependencies.cwd,
+                        cwd: resolveCwd(request, dependencies.cwd),
                         targetAgent: agentName,
                         sourceAgent: data.sourceAgent,
                         plugin: sourcePlugin,
@@ -430,7 +528,7 @@ export function createUiRouteHandler(dependencies) {
                         if (!data.name || !data.sourceAgent) {
                             return sendJson(response, 400, { error: 'Missing name or sourceAgent' });
                         }
-                        const sourcePlugin = await resolveSourcePlugin(agentConfigService, dependencies.cwd, {
+                        const sourcePlugin = await resolveSourcePlugin(agentConfigService, resolveCwd(request, dependencies.cwd), {
                             sourceAgent: data.sourceAgent,
                             name: data.name,
                         });
@@ -441,7 +539,7 @@ export function createUiRouteHandler(dependencies) {
                         }
                         try {
                             const result = await pluginInstallService.execute({
-                                cwd: dependencies.cwd,
+                                cwd: resolveCwd(request, dependencies.cwd),
                                 targetAgent: agentName,
                                 sourceAgent: data.sourceAgent,
                                 plugin: sourcePlugin,
@@ -453,7 +551,7 @@ export function createUiRouteHandler(dependencies) {
                         }
                     }
                     if (request.method === 'DELETE' && pluginName) {
-                        const targetPlugin = await resolveTargetPlugin(agentConfigService, dependencies.cwd, {
+                        const targetPlugin = await resolveTargetPlugin(agentConfigService, resolveCwd(request, dependencies.cwd), {
                             targetAgent: agentName,
                             name: pluginName,
                         });
@@ -464,7 +562,7 @@ export function createUiRouteHandler(dependencies) {
                         }
                         try {
                             const result = await pluginInstallService.remove({
-                                cwd: dependencies.cwd,
+                                cwd: resolveCwd(request, dependencies.cwd),
                                 targetAgent: agentName,
                                 plugin: targetPlugin,
                             });