brainctl 0.1.17 → 0.1.19

package/dist/services/{profile-service.js → profile/profile-service.js}

@@ -1,133 +1,115 @@
-import { readdir, readFile, writeFile, mkdir, stat, unlink } from 'node:fs/promises';
+import { readdir, readFile, writeFile, mkdir, rename, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
-import { ProfileError, ProfileNotFoundError } from '../errors.js';
+import { ProfileError, ProfileNotFoundError } from '../../errors.js';
 const VALID_RUNTIMES = new Set(['node', 'python', 'java', 'go', 'rust', 'binary']);
-const BRAINCTL_DIR = '.brainctl';
 const PROFILES_DIR = '.brainctl/profiles';
-const META_CONFIG = '.brainctl/config.yaml';
+const PROFILE_FILE = 'profile.yaml';
+export function profileDir(cwd, name) {
+    return path.join(cwd, PROFILES_DIR, name);
+}
+export function profileFile(cwd, name) {
+    return path.join(profileDir(cwd, name), PROFILE_FILE);
+}
+function legacyProfileFile(cwd, name) {
+    return path.join(cwd, PROFILES_DIR, `${name}.yaml`);
+}
+async function migrateLegacyProfile(cwd, name) {
+    const legacy = legacyProfileFile(cwd, name);
+    const folder = profileDir(cwd, name);
+    const newFile = profileFile(cwd, name);
+    if (!(await pathExists(legacy)))
+        return;
+    if (await pathExists(newFile))
+        return;
+    await mkdir(folder, { recursive: true });
+    await rename(legacy, newFile);
+}
 export function createProfileService() {
     return {
         async list(options = {}) {
             const cwd = options.cwd ?? process.cwd();
             const profilesDir = path.join(cwd, PROFILES_DIR);
-            let files = [];
+            const names = new Set();
             try {
-                const entries = await readdir(profilesDir);
-                files = entries
-                    .filter((f) => f.endsWith('.yaml'))
-                    .map((f) => f.replace(/\.yaml$/, ''))
-                    .sort();
+                const entries = await readdir(profilesDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        if (await pathExists(path.join(profilesDir, entry.name, PROFILE_FILE))) {
+                            names.add(entry.name);
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.endsWith('.yaml')) {
+                        const bare = entry.name.replace(/\.yaml$/, '');
+                        await migrateLegacyProfile(cwd, bare);
+                        names.add(bare);
+                    }
+                }
             }
             catch {
                 // No profiles directory yet
             }
-            const meta = await loadMetaConfig(cwd);
             return {
-                profiles: files,
-                activeProfile: meta.active_profile || null,
+                profiles: Array.from(names).sort(),
             };
         },
         async get(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            await migrateLegacyProfile(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
             let source;
             try {
-                source = await readFile(profilePath, 'utf8');
+                source = await readFile(filePath, 'utf8');
             }
             catch {
-                throw new ProfileNotFoundError(`Profile "${options.name}" not found at ${profilePath}`);
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found at ${filePath}`);
             }
             return parseProfile(source, options.name);
         },
         async create(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilesDir = path.join(cwd, PROFILES_DIR);
-            const profilePath = path.join(profilesDir, `${options.name}.yaml`);
-            if (await pathExists(profilePath)) {
+            const folder = profileDir(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
+            if ((await pathExists(filePath)) ||
+                (await pathExists(legacyProfileFile(cwd, options.name)))) {
                 throw new ProfileError(`Profile "${options.name}" already exists.`);
             }
             const scaffold = {
                 name: options.name,
                 description: options.description ?? '',
-                skills: {
-                    example: {
-                        description: 'Example skill',
-                        prompt: 'Describe what this skill does...',
-                    },
-                },
                 mcps: {},
-                memory: {
-                    paths: ['./memory'],
-                },
             };
-            await mkdir(profilesDir, { recursive: true });
-            await writeFile(profilePath, YAML.stringify(scaffold), 'utf8');
-            return { profilePath };
+            await mkdir(folder, { recursive: true });
+            await writeFile(filePath, YAML.stringify(scaffold), 'utf8');
+            return { profilePath: filePath };
         },
         async update(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
-            if (!(await pathExists(profilePath))) {
+            await migrateLegacyProfile(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
+            if (!(await pathExists(filePath))) {
                 throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
             }
             const normalized = normalizeProfileConfig(options.config, options.name);
             const data = {
                 name: normalized.name,
                 ...(normalized.description ? { description: normalized.description } : {}),
-                skills: normalized.skills,
                 mcps: normalized.mcps,
-                memory: normalized.memory,
             };
-            await writeFile(profilePath, YAML.stringify(data), 'utf8');
+            await writeFile(filePath, YAML.stringify(data), 'utf8');
         },
         async delete(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
-            if (!(await pathExists(profilePath))) {
-                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
-            }
-            const meta = await loadMetaConfig(cwd);
-            if (meta.active_profile === options.name) {
-                throw new ProfileError('Cannot delete the active profile.');
-            }
-            await unlink(profilePath);
-        },
-        async use(options) {
-            const cwd = options.cwd ?? process.cwd();
-            // Validate profile exists
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
-            if (!(await pathExists(profilePath))) {
+            await migrateLegacyProfile(cwd, options.name);
+            const folder = profileDir(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
+            if (!(await pathExists(filePath))) {
                 throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
             }
-            const meta = await loadMetaConfig(cwd);
-            const previousProfile = meta.active_profile || null;
-            meta.active_profile = options.name;
-            const metaPath = path.join(cwd, META_CONFIG);
-            await mkdir(path.dirname(metaPath), { recursive: true });
-            await writeFile(metaPath, YAML.stringify(meta), 'utf8');
-            return { previousProfile };
-        },
-        async getMetaConfig(options = {}) {
-            const cwd = options.cwd ?? process.cwd();
-            return loadMetaConfig(cwd);
+            await rm(folder, { recursive: true, force: true });
         },
     };
 }
-async function loadMetaConfig(cwd) {
-    const metaPath = path.join(cwd, META_CONFIG);
-    try {
-        const source = await readFile(metaPath, 'utf8');
-        const parsed = YAML.parse(source) ?? {};
-        return {
-            active_profile: typeof parsed.active_profile === 'string' ? parsed.active_profile : '',
-            agents: Array.isArray(parsed.agents) ? parsed.agents : ['claude', 'codex'],
-        };
-    }
-    catch {
-        return { active_profile: '', agents: ['claude', 'codex', 'gemini'] };
-    }
-}
 export function parseProfile(source, name) {
     let parsed;
     try {
@@ -146,38 +128,11 @@ export function normalizeProfileConfig(value, name) {
         throw new ProfileError(`Profile "${name}" has invalid structure.`);
     }
     const data = value;
-    const skills = {};
-    if (data.skills && typeof data.skills === 'object' && !Array.isArray(data.skills)) {
-        for (const [key, value] of Object.entries(data.skills)) {
-            if (value && typeof value === 'object' && !Array.isArray(value)) {
-                const s = value;
-                if (typeof s.prompt === 'string') {
-                    skills[key] = {
-                        prompt: s.prompt,
-                        description: typeof s.description === 'string' ? s.description : undefined,
-                    };
-                }
-            }
-        }
-    }
     const mcps = normalizeMcps(data.mcps, name);
-    const memoryPaths = [];
-    if (data.memory && typeof data.memory === 'object' && !Array.isArray(data.memory)) {
-        const mem = data.memory;
-        if (Array.isArray(mem.paths)) {
-            for (const p of mem.paths) {
-                if (typeof p === 'string') {
-                    memoryPaths.push(p);
-                }
-            }
-        }
-    }
     return {
         name: typeof data.name === 'string' ? data.name : name,
         description: typeof data.description === 'string' ? data.description : undefined,
-        skills,
         mcps,
-        memory: { paths: memoryPaths },
     };
 }
 function normalizeMcps(value, profileName) {

package/dist/services/profile/profile-snapshot-service.d.ts

@@ -0,0 +1,12 @@
+import type { AgentName } from '../../types.js';
+export interface ProfileSnapshotService {
+    execute(options: {
+        cwd: string;
+        agent: AgentName;
+        profileName: string;
+    }): Promise<{
+        profilePath: string;
+    }>;
+}
+export declare function createProfileSnapshotService(): ProfileSnapshotService;
+export declare function defaultBackupProfileName(agent: AgentName): string;

package/dist/services/profile/profile-snapshot-service.js

@@ -0,0 +1,47 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { profileDir } from './profile-service.js';
+import { createPortableProfilePackService } from './portable-profile-pack-service.js';
+export function createProfileSnapshotService() {
+    const packService = createPortableProfilePackService();
+    return {
+        async execute(options) {
+            const outputPath = profileDir(options.cwd, options.profileName);
+            const result = await packService.execute({
+                cwd: options.cwd,
+                source: { source: 'agent', agent: options.agent, cwd: options.cwd },
+                outputPath,
+                format: 'folder',
+                credentialsMode: 'keep',
+            });
+            await renameInsideProfile(outputPath, options.profileName);
+            return { profilePath: result.archivePath };
+        },
+    };
+}
+async function renameInsideProfile(profilePath, name) {
+    const profileFile = path.join(profilePath, 'profile.yaml');
+    const manifestFile = path.join(profilePath, 'manifest.yaml');
+    for (const file of [profileFile, manifestFile]) {
+        try {
+            const source = await readFile(file, 'utf8');
+            const parsed = YAML.parse(source);
+            if (file === profileFile)
+                parsed.name = name;
+            else
+                parsed.profileName = name;
+            await writeFile(file, YAML.stringify(parsed), 'utf8');
+        }
+        catch {
+            // best-effort
+        }
+    }
+}
+export function defaultBackupProfileName(agent) {
+    const ts = new Date()
+        .toISOString()
+        .replace(/[-:T]/g, '')
+        .replace(/\..+$/, '');
+    return `backup-${agent}-${ts}`;
+}

package/dist/types.d.ts

@@ -1,55 +1,6 @@
 export type AgentName = 'claude' | 'codex' | 'gemini';
 export type ErrorCategory = 'user' | 'system';
 export type DiagnosticStatus = 'ok' | 'warn' | 'error';
-export interface SkillConfig {
-    description?: string;
-    prompt: string;
-}
-export interface BrainctlConfig {
-    configPath: string;
-    rootDir: string;
-    memory: {
-        paths: string[];
-    };
-    skills: Record<string, SkillConfig>;
-    mcps: Record<string, unknown>;
-}
-export interface MemoryLoadResult {
-    content: string;
-    files: string[];
-    count: number;
-    entries: Array<{
-        path: string;
-        content: string;
-    }>;
-}
-export interface RunRequest {
-    cwd?: string;
-    skill: string;
-    inputFile: string;
-    primaryAgent: AgentName;
-    fallbackAgent?: AgentName;
-}
-export interface ExecutionStep {
-    skill: string;
-    inputFile: string;
-    primaryAgent: AgentName;
-    fallbackAgent?: AgentName;
-    usePreviousOutput?: boolean;
-}
-export interface ExecutionStepResult {
-    stepIndex: number;
-    requestedAgent: AgentName;
-    agent: AgentName;
-    fallbackUsed: boolean;
-    exitCode: number;
-    output: string;
-}
-export interface ExecutionTrace {
-    steps: ExecutionStepResult[];
-    finalOutput: string;
-    finalExitCode: number;
-}
 export interface DiagnosticCheck {
     label: string;
     status: DiagnosticStatus;
@@ -129,20 +80,14 @@ export type McpServerConfig = LocalMcpServerConfig | RemoteMcpServerConfig;
 export interface ProfileConfig {
     name: string;
     description?: string;
-    skills: Record<string, SkillConfig>;
     mcps: Record<string, McpServerConfig>;
-    memory: {
-        paths: string[];
-    };
-}
-export interface BrainctlMetaConfig {
-    active_profile: string;
-    agents: AgentName[];
 }
 export interface SyncAgentResult {
     agent: AgentName;
     configPath: string;
     backedUpTo: string | null;
     mcpCount: number;
+    pluginsInstalled?: string[];
+    userSkillsInstalled?: string[];
 }
 export type SyncResult = SyncAgentResult[];

package/dist/ui/routes.d.ts

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

package/dist/ui/routes.js

@@ -1,32 +1,26 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { loadConfig } from '../config.js';
-import { parseConfigPayload } from '../config.js';
 import { BrainctlError, ProfileError, ProfileNotFoundError, ValidationError } from '../errors.js';
-import { loadMemory } from '../context/memory.js';
-import { createAgentConfigService } from '../services/agent-config-service.js';
-import { createConfigWriteService } from '../services/config-write-service.js';
-import { createMcpPreflightService } from '../services/mcp-preflight-service.js';
-import { createPluginInstallService } from '../services/plugin-install-service.js';
-import { createProfileExportService } from '../services/profile-export-service.js';
-import { createProfileImportService } from '../services/profile-import-service.js';
-import { createProfileService } from '../services/profile-service.js';
-import { createRunService } from '../services/run-service.js';
-import { createSkillPreflightService } from '../services/skill-preflight-service.js';
-import { createStatusService } from '../services/status-service.js';
-import { createSyncService } from '../services/sync-service.js';
-import { startSseStream, writeSseEvent } from './streaming.js';
+import { createAgentConfigService } from '../services/agent/agent-config-service.js';
+import { createMcpPreflightService } from '../services/platform/mcp-preflight-service.js';
+import { createPluginInstallService } from '../services/plugin/plugin-install-service.js';
+import { createProfileExportService } from '../services/profile/profile-export-service.js';
+import { createProfileImportService } from '../services/profile/profile-import-service.js';
+import { createProfileService } from '../services/profile/profile-service.js';
+import { createSkillPreflightService } from '../services/plugin/skill-preflight-service.js';
+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 path from 'node:path';
 import { fileURLToPath } from 'node:url';
 const uiAssetRoot = resolveUiAssetRoot();
 export function createUiRouteHandler(dependencies) {
     const statusService = dependencies.statusService ?? createStatusService();
-    const runService = dependencies.runService ?? createRunService();
-    const configWriteService = createConfigWriteService();
     const profileService = createProfileService();
     const profileExportService = createProfileExportService({ profileService });
     const profileImportService = createProfileImportService();
-    const syncService = createSyncService({ profileService });
+    const profileApplyService = createProfileApplyService({ profileService });
+    const profileSnapshotService = createProfileSnapshotService();
     const agentConfigService = createAgentConfigService();
     const mcpPreflightService = createMcpPreflightService();
     const pluginInstallService = createPluginInstallService();
@@ -41,71 +35,6 @@ export function createUiRouteHandler(dependencies) {
                 const overview = await statusService.execute({ cwd: dependencies.cwd });
                 return sendJson(response, 200, overview);
             }
-            case '/api/run/stream': {
-                if (request.method !== 'GET') {
-                    return sendJson(response, 405, { error: 'Method not allowed' });
-                }
-                const runRequest = parseRunRequest(url);
-                if (runRequest === null) {
-                    return sendJson(response, 400, {
-                        error: 'Missing skill, inputFile, or primaryAgent'
-                    });
-                }
-                if ('error' in runRequest) {
-                    return sendJson(response, 400, {
-                        error: runRequest.error
-                    });
-                }
-                startSseStream(response);
-                try {
-                    const trace = await runService.execute({
-                        ...runRequest.request,
-                        cwd: dependencies.cwd
-                    }, {
-                        onOutputChunk: (chunk) => {
-                            writeSseEvent(response, 'output', chunk);
-                        },
-                        streamOutput: false
-                    });
-                    writeSseEvent(response, 'result', trace);
-                    response.end();
-                }
-                catch (error) {
-                    writeSseEvent(response, 'run-error', {
-                        error: error instanceof Error ? error.message : 'Unexpected server error'
-                    });
-                    response.end();
-                }
-                return;
-            }
-            case '/api/config': {
-                if (request.method === 'PUT') {
-                    const body = await readJsonBody(request);
-                    if (!body.ok) {
-                        return sendJson(response, 400, { error: 'Invalid JSON body' });
-                    }
-                    const config = parseConfigPayload(body.value);
-                    await configWriteService.execute({
-                        cwd: dependencies.cwd,
-                        config
-                    });
-                    const savedConfig = await loadConfig({ cwd: dependencies.cwd });
-                    return sendJson(response, 200, savedConfig);
-                }
-                if (request.method !== 'GET') {
-                    return sendJson(response, 405, { error: 'Method not allowed' });
-                }
-                const config = await loadConfig({ cwd: dependencies.cwd });
-                return sendJson(response, 200, config);
-            }
-            case '/api/memory': {
-                if (request.method !== 'GET') {
-                    return sendJson(response, 405, { error: 'Method not allowed' });
-                }
-                const config = await loadConfig({ cwd: dependencies.cwd });
-                const memory = await loadMemory({ paths: config.memory.paths });
-                return sendJson(response, 200, memory);
-            }
             case '/api/agents': {
                 if (request.method !== 'GET') {
                     return sendJson(response, 405, { error: 'Method not allowed' });
@@ -207,21 +136,58 @@ export function createUiRouteHandler(dependencies) {
                     return sendProfileError(response, error);
                 }
             }
-            case '/api/sync': {
+            case '/api/profiles/snapshot': {
                 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 data = (body.value ?? {});
+                if (data.agent !== 'claude' && data.agent !== 'codex' && data.agent !== 'gemini') {
+                    return sendJson(response, 400, { error: 'Invalid agent' });
+                }
+                const profileName = data.as ?? defaultBackupProfileName(data.agent);
                 try {
-                    const result = await syncService.execute({ cwd: dependencies.cwd });
-                    return sendJson(response, 200, result);
+                    const result = await profileSnapshotService.execute({
+                        cwd: dependencies.cwd,
+                        agent: data.agent,
+                        profileName,
+                    });
+                    return sendJson(response, 200, { profileName, ...result });
                 }
                 catch (error) {
-                    return sendJson(response, 500, {
-                        error: error instanceof Error ? error.message : 'Sync failed',
-                    });
+                    return sendProfileError(response, error);
                 }
             }
             default: {
+                // Profile apply: POST /api/profiles/:name/apply
+                const applyMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)\/apply$/);
+                if (applyMatch) {
+                    if (request.method !== 'POST') {
+                        return sendJson(response, 405, { error: 'Method not allowed' });
+                    }
+                    const profileName = decodeURIComponent(applyMatch[1]);
+                    const body = await readJsonBody(request);
+                    if (!body.ok) {
+                        return sendJson(response, 400, { error: 'Invalid JSON body' });
+                    }
+                    const data = (body.value ?? {});
+                    try {
+                        const result = await profileApplyService.execute({
+                            cwd: dependencies.cwd,
+                            profileName,
+                            agents: data.agents ?? ['claude', 'codex', 'gemini'],
+                            items: data.items,
+                            backup: data.backup,
+                        });
+                        return sendJson(response, 200, result);
+                    }
+                    catch (error) {
+                        return sendProfileError(response, error);
+                    }
+                }
                 // Agent MCP routes: /api/agents/:name/mcps(/:key)
                 const agentMcpCheckMatch = url.pathname.match(/^\/api\/agents\/(claude|codex|gemini)\/mcps\/check$/);
                 if (agentMcpCheckMatch) {
@@ -450,22 +416,34 @@ export function createUiRouteHandler(dependencies) {
                     }
                     return sendJson(response, 405, { error: 'Method not allowed' });
                 }
-                const profileMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)(\/activate)?$/);
-                if (profileMatch) {
-                    const name = decodeURIComponent(profileMatch[1]);
-                    const isActivate = profileMatch[2] === '/activate';
-                    if (isActivate) {
-                        if (request.method !== 'POST') {
-                            return sendJson(response, 405, { error: 'Method not allowed' });
-                        }
+                // Profile contents: GET /api/profiles/:name/contents
+                const contentsMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)\/contents$/);
+                if (contentsMatch) {
+                    if (request.method !== 'GET') {
+                        return sendJson(response, 405, { error: 'Method not allowed' });
+                    }
+                    const profileName = decodeURIComponent(contentsMatch[1]);
+                    try {
+                        const profile = await profileService.get({ cwd: dependencies.cwd, name: profileName });
+                        const manifestPath = path.join(dependencies.cwd, '.brainctl', 'profiles', profileName, 'manifest.yaml');
+                        let manifest = null;
                         try {
-                            const result = await profileService.use({ cwd: dependencies.cwd, name });
-                            return sendJson(response, 200, result);
+                            const { readFile: readManifest } = await import('node:fs/promises');
+                            const yamlMod = await import('yaml');
+                            manifest = yamlMod.default.parse(await readManifest(manifestPath, 'utf8'));
                         }
-                        catch (error) {
-                            return sendProfileError(response, error);
+                        catch {
+                            manifest = null;
                         }
+                        return sendJson(response, 200, { profile, manifest });
                     }
+                    catch (error) {
+                        return sendProfileError(response, error);
+                    }
+                }
+                const profileMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)$/);
+                if (profileMatch) {
+                    const name = decodeURIComponent(profileMatch[1]);
                     if (request.method === 'GET') {
                         try {
                             const profile = await profileService.get({ cwd: dependencies.cwd, name });
@@ -548,33 +526,6 @@ async function readJsonBody(request) {
         return { ok: false };
     }
 }
-function parseRunRequest(url) {
-    const skill = url.searchParams.get('skill');
-    const inputFile = url.searchParams.get('inputFile');
-    const primaryAgent = parseAgentName(url.searchParams.get('primaryAgent'));
-    const fallbackAgentParam = url.searchParams.get('fallbackAgent');
-    const fallbackAgent = fallbackAgentParam === null ? null : parseAgentName(fallbackAgentParam);
-    if (!skill || !inputFile || !primaryAgent || fallbackAgentParam !== null && !fallbackAgent) {
-        return null;
-    }
-    if (fallbackAgent !== null && fallbackAgent === primaryAgent) {
-        return { error: 'fallbackAgent must differ from primaryAgent' };
-    }
-    return {
-        request: {
-            skill,
-            inputFile,
-            primaryAgent,
-            fallbackAgent: fallbackAgent ?? undefined
-        }
-    };
-}
-function parseAgentName(value) {
-    if (value === 'claude' || value === 'codex') {
-        return value;
-    }
-    return null;
-}
 function sendProfileError(response, error) {
     if (error instanceof ProfileNotFoundError) {
         return sendJson(response, 404, { error: error.message });

package/dist/ui/server.d.ts

@@ -1,5 +1,5 @@
 import { type Server } from 'node:http';
-import type { StatusService } from '../services/status-service.js';
+import type { StatusService } from '../services/platform/status-service.js';
 export interface StartUiServerOptions {
     cwd?: string;
     host?: string;