tide-commander 0.52.0

package/dist/src/packages/server/websocket/handlers/skill-handler.js

@@ -0,0 +1,148 @@
+/**
+ * Skill Handler
+ * Handles skill CRUD operations and assignment to agents
+ */
+import { agentService, skillService } from '../../services/index.js';
+import { createLogger } from '../../utils/index.js';
+const log = createLogger('SkillHandler');
+/**
+ * Handle create_skill message
+ */
+export function handleCreateSkill(ctx, payload) {
+    try {
+        const skill = skillService.createSkill(payload);
+        ctx.broadcast({
+            type: 'skill_created',
+            payload: skill,
+        });
+        log.log(` Created skill: ${skill.name} (${skill.id})`);
+    }
+    catch (err) {
+        log.error(' Failed to create skill:', err);
+        ctx.sendError(err.message);
+    }
+}
+/**
+ * Handle update_skill message
+ */
+export function handleUpdateSkill(ctx, payload) {
+    try {
+        // Check if trying to modify a builtin skill's protected fields
+        const existingSkill = skillService.getSkill(payload.id);
+        if (existingSkill?.builtin) {
+            const allowedKeys = ['assignedAgentIds', 'assignedAgentClasses', 'enabled'];
+            const attemptedKeys = Object.keys(payload.updates);
+            const disallowedKeys = attemptedKeys.filter(k => !allowedKeys.includes(k));
+            if (disallowedKeys.length > 0) {
+                ctx.sendError(`Cannot modify built-in skill "${existingSkill.name}". Only assignments and enabled status can be changed.`);
+                return;
+            }
+        }
+        const skill = skillService.updateSkill(payload.id, payload.updates);
+        if (skill) {
+            ctx.broadcast({
+                type: 'skill_updated',
+                payload: skill,
+            });
+            log.log(` Updated skill: ${skill.name} (${skill.id})`);
+        }
+        else {
+            ctx.sendError(`Skill not found: ${payload.id}`);
+        }
+    }
+    catch (err) {
+        log.error(' Failed to update skill:', err);
+        ctx.sendError(err.message);
+    }
+}
+/**
+ * Handle delete_skill message
+ */
+export function handleDeleteSkill(ctx, payload) {
+    try {
+        // Check if trying to delete a builtin skill
+        const existingSkill = skillService.getSkill(payload.id);
+        if (existingSkill?.builtin) {
+            ctx.sendError(`Cannot delete built-in skill "${existingSkill.name}". Built-in skills are part of Tide Commander.`);
+            return;
+        }
+        const deleted = skillService.deleteSkill(payload.id);
+        if (deleted) {
+            ctx.broadcast({
+                type: 'skill_deleted',
+                payload: { id: payload.id },
+            });
+            log.log(` Deleted skill: ${payload.id}`);
+        }
+        else {
+            ctx.sendError(`Skill not found: ${payload.id}`);
+        }
+    }
+    catch (err) {
+        log.error(' Failed to delete skill:', err);
+        ctx.sendError(err.message);
+    }
+}
+/**
+ * Handle assign_skill message
+ */
+export function handleAssignSkill(ctx, payload) {
+    try {
+        const skill = skillService.assignSkillToAgent(payload.skillId, payload.agentId);
+        if (skill) {
+            ctx.broadcast({
+                type: 'skill_updated',
+                payload: skill,
+            });
+            log.log(` Assigned skill ${skill.name} to agent ${payload.agentId}`);
+        }
+        else {
+            ctx.sendError(`Skill not found: ${payload.skillId}`);
+        }
+    }
+    catch (err) {
+        log.error(' Failed to assign skill:', err);
+        ctx.sendError(err.message);
+    }
+}
+/**
+ * Handle unassign_skill message
+ */
+export function handleUnassignSkill(ctx, payload) {
+    try {
+        const skill = skillService.unassignSkillFromAgent(payload.skillId, payload.agentId);
+        if (skill) {
+            ctx.broadcast({
+                type: 'skill_updated',
+                payload: skill,
+            });
+            log.log(` Unassigned skill ${skill.name} from agent ${payload.agentId}`);
+        }
+        else {
+            ctx.sendError(`Skill not found: ${payload.skillId}`);
+        }
+    }
+    catch (err) {
+        log.error(' Failed to unassign skill:', err);
+        ctx.sendError(err.message);
+    }
+}
+/**
+ * Handle request_agent_skills message
+ */
+export function handleRequestAgentSkills(ctx, payload) {
+    const agent = agentService.getAgent(payload.agentId);
+    if (agent) {
+        const skills = skillService.getSkillsForAgent(agent.id, agent.class);
+        ctx.sendToClient({
+            type: 'agent_skills',
+            payload: {
+                agentId: payload.agentId,
+                skills,
+            },
+        });
+    }
+    else {
+        ctx.sendError(`Agent not found: ${payload.agentId}`);
+    }
+}

package/dist/src/packages/server/websocket/handlers/supervisor-handler.js

@@ -0,0 +1,44 @@
+import { supervisorService } from '../../services/index.js';
+import { createLogger, logger } from '../../utils/index.js';
+const log = logger.ws;
+const supervisorLog = createLogger('Supervisor');
+export function handleSetSupervisorConfig(_ctx, payload) {
+    supervisorService.setConfig(payload);
+}
+export async function handleRequestSupervisorReport(ctx, _payload) {
+    supervisorLog.log('Report requested by frontend');
+    try {
+        const report = await supervisorService.generateReport();
+        ctx.sendToClient({
+            type: 'supervisor_report',
+            payload: report,
+        });
+    }
+    catch (err) {
+        log.error(' Supervisor report failed:', err);
+        ctx.sendError(`Supervisor report failed: ${err.message}`);
+    }
+}
+export function handleRequestAgentSupervisorHistory(ctx, payload) {
+    const history = supervisorService.getAgentSupervisorHistory(payload.agentId);
+    ctx.sendToClient({
+        type: 'agent_supervisor_history',
+        payload: history,
+    });
+}
+export async function handleRequestGlobalUsage(ctx, _payload) {
+    const cachedUsage = supervisorService.getGlobalUsage();
+    if (cachedUsage) {
+        ctx.sendToClient({
+            type: 'global_usage',
+            payload: cachedUsage,
+        });
+    }
+    const agentId = await supervisorService.requestUsageRefresh();
+    if (!agentId && !cachedUsage) {
+        ctx.sendToClient({
+            type: 'global_usage',
+            payload: null,
+        });
+    }
+}

package/dist/src/packages/server/websocket/handlers/sync-handler.js

@@ -0,0 +1,19 @@
+import { saveAreas, saveBuildings } from '../../data/index.js';
+import { buildingService } from '../../services/index.js';
+import { logger } from '../../utils/index.js';
+const log = logger.ws;
+function handleSyncMessage(ctx, payload, entityName, saveFn, updateType) {
+    saveFn(payload);
+    log.log(` Saved ${payload.length} ${entityName}`);
+    ctx.broadcastToOthers({
+        type: updateType,
+        payload,
+    });
+}
+export function handleSyncAreas(ctx, payload) {
+    handleSyncMessage(ctx, payload, 'areas', saveAreas, 'areas_update');
+}
+export async function handleSyncBuildings(ctx, payload) {
+    await buildingService.handleBuildingSync(payload, ctx.broadcast);
+    handleSyncMessage(ctx, payload, 'buildings', saveBuildings, 'buildings_update');
+}

package/dist/src/packages/server/websocket/handlers/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared types for WebSocket handlers
+ */
+export {};

package/dist/src/packages/server/websocket/listeners/boss-listeners.js

@@ -0,0 +1,21 @@
+import { bossService } from '../../services/index.js';
+export function setupBossListeners(ctx) {
+    bossService.subscribe((event, data) => {
+        switch (event) {
+            case 'delegation_decision':
+                ctx.broadcast({
+                    type: 'delegation_decision',
+                    payload: data,
+                });
+                break;
+            case 'subordinates_updated': {
+                const { bossId, subordinateIds } = data;
+                ctx.broadcast({
+                    type: 'boss_subordinates_updated',
+                    payload: { bossId, subordinateIds },
+                });
+                break;
+            }
+        }
+    });
+}

package/dist/src/packages/server/websocket/listeners/index.js

@@ -0,0 +1,32 @@
+import { agentService } from '../../services/index.js';
+import { setupBossListeners } from './boss-listeners.js';
+import { setupPermissionListeners } from './permission-listeners.js';
+import { setupRuntimeListeners } from './runtime-listeners.js';
+import { setupSkillListeners } from './skill-listeners.js';
+import { setupSupervisorListeners } from './supervisor-listeners.js';
+export function setupServiceListeners(ctx) {
+    agentService.subscribe((event, data) => {
+        switch (event) {
+            case 'created':
+                break;
+            case 'updated':
+                ctx.broadcast({
+                    type: 'agent_updated',
+                    payload: data,
+                });
+                break;
+            case 'deleted':
+                ctx.broadcast({
+                    type: 'agent_deleted',
+                    payload: { id: data },
+                });
+                ctx.sendActivity(data, 'Agent terminated');
+                break;
+        }
+    });
+    setupRuntimeListeners(ctx);
+    setupPermissionListeners(ctx);
+    setupSupervisorListeners(ctx);
+    setupBossListeners(ctx);
+    setupSkillListeners(ctx);
+}

package/dist/src/packages/server/websocket/listeners/permission-listeners.js

@@ -0,0 +1,19 @@
+import { agentService, permissionService } from '../../services/index.js';
+import { logger } from '../../utils/index.js';
+const log = logger.ws;
+export function setupPermissionListeners(ctx) {
+    permissionService.subscribe((request) => {
+        log.log(` Broadcasting permission_request: ${request.id} for tool ${request.tool}`);
+        ctx.broadcast({
+            type: 'permission_request',
+            payload: request,
+        });
+        const agent = agentService.getAgent(request.agentId);
+        if (agent) {
+            agentService.updateAgent(request.agentId, {
+                status: 'waiting',
+                currentTask: `Waiting for permission: ${request.tool}`,
+            });
+        }
+    });
+}

package/dist/src/packages/server/websocket/listeners/runtime-listeners.js

@@ -0,0 +1,196 @@
+import { parseContextOutput } from '../../claude/backend.js';
+import { agentService, runtimeService } from '../../services/index.js';
+import { logger, formatToolActivity } from '../../utils/index.js';
+import { parseBossDelegation, parseBossSpawn, getBossForSubordinate, clearDelegation } from '../handlers/boss-response-handler.js';
+const log = logger.ws;
+export function setupRuntimeListeners(ctx) {
+    runtimeService.on('event', (agentId, event) => {
+        if (event.type === 'init') {
+            ctx.sendActivity(agentId, `Session initialized (${event.model})`);
+        }
+        else if (event.type === 'tool_start') {
+            const details = formatToolActivity(event.toolName, event.toolInput);
+            ctx.sendActivity(agentId, details);
+            if (event.toolName === 'Task' && event.toolUseId && event.subagentName) {
+                const subagent = runtimeService.getActiveSubagentByToolUseId(event.toolUseId);
+                if (subagent) {
+                    const parentAgent = agentService.getAgent(agentId);
+                    const parentPos = parentAgent?.position || { x: 0, y: 0, z: 0 };
+                    const activeSubagents = runtimeService.getActiveSubagentsForAgent(agentId);
+                    const angle = (activeSubagents.length - 1) * (Math.PI * 2 / Math.max(activeSubagents.length, 3));
+                    const radius = 3;
+                    const subagentPayload = {
+                        id: subagent.id,
+                        parentAgentId: agentId,
+                        toolUseId: subagent.toolUseId,
+                        name: subagent.name,
+                        description: subagent.description,
+                        subagentType: subagent.subagentType,
+                        model: subagent.model,
+                        status: 'working',
+                        startedAt: subagent.startedAt,
+                        position: {
+                            x: parentPos.x + Math.cos(angle) * radius,
+                            y: parentPos.y,
+                            z: parentPos.z + Math.sin(angle) * radius,
+                        },
+                    };
+                    ctx.broadcast({
+                        type: 'subagent_started',
+                        payload: subagentPayload,
+                    });
+                    ctx.sendActivity(agentId, `Spawned subagent: ${subagent.name} (${subagent.subagentType})`);
+                    log.log(`[Subagent] Broadcast subagent_started: ${subagent.name} (${subagent.id})`);
+                }
+            }
+        }
+        else if (event.type === 'tool_result' && event.toolName === 'Task' && event.toolUseId) {
+            let cleanPreview;
+            if (event.toolOutput) {
+                try {
+                    const parsed = JSON.parse(event.toolOutput);
+                    if (Array.isArray(parsed)) {
+                        cleanPreview = parsed
+                            .filter((b) => b.type === 'text' && b.text)
+                            .map((b) => b.text)
+                            .join(' ')
+                            .slice(0, 200);
+                    }
+                    else {
+                        cleanPreview = event.toolOutput.slice(0, 200);
+                    }
+                }
+                catch {
+                    cleanPreview = event.toolOutput.slice(0, 200);
+                }
+            }
+            ctx.broadcast({
+                type: 'subagent_completed',
+                payload: {
+                    subagentId: event.toolUseId,
+                    parentAgentId: agentId,
+                    success: true,
+                    resultPreview: cleanPreview,
+                    subagentName: event.subagentName,
+                },
+            });
+            log.log(`[Subagent] Broadcast subagent_completed for toolUseId=${event.toolUseId}, name=${event.subagentName || 'unknown'}`);
+        }
+        else if (event.type === 'error') {
+            ctx.sendActivity(agentId, `Error: ${event.errorMessage}`);
+        }
+        if (event.type === 'step_complete' && event.resultText) {
+            const agent = agentService.getAgent(agentId);
+            if (agent?.isBoss || agent?.class === 'boss') {
+                parseBossDelegation(agentId, agent.name, event.resultText, ctx.broadcast);
+                parseBossSpawn(agentId, agent.name, event.resultText, ctx.broadcast, ctx.sendActivity);
+            }
+        }
+        if (event.type === 'context_stats' && event.contextStatsRaw) {
+            log.log(`[context_stats] Received for agent ${agentId}, raw length: ${event.contextStatsRaw.length}`);
+            const stats = parseContextOutput(event.contextStatsRaw);
+            if (stats) {
+                log.log(`[context_stats] Parsed: ${stats.usedPercent}% used, ${stats.totalTokens}/${stats.contextWindow} tokens`);
+                agentService.updateAgent(agentId, {
+                    contextStats: stats,
+                    contextUsed: stats.totalTokens,
+                    contextLimit: stats.contextWindow,
+                }, false);
+                ctx.broadcast({
+                    type: 'context_stats',
+                    payload: { agentId, stats },
+                });
+            }
+            else {
+                log.log(`[context_stats] Failed to parse context output for agent ${agentId}`);
+            }
+        }
+        ctx.broadcast({
+            type: 'event',
+            payload: { ...event, agentId },
+        });
+    });
+    runtimeService.on('output', (agentId, text, isStreaming, subagentName, uuid, toolMeta) => {
+        const textPreview = text.slice(0, 80).replace(/\n/g, '\\n');
+        log.log(`[OUTPUT] agent=${agentId.slice(0, 4)} streaming=${isStreaming} text="${textPreview}" uuid=${uuid || 'none'}`);
+        const payload = {
+            agentId,
+            text,
+            isStreaming: isStreaming || false,
+            timestamp: Date.now(),
+            ...(subagentName ? { subagentName } : {}),
+            ...(uuid ? { uuid } : {}),
+        };
+        if (toolMeta?.toolName) {
+            payload.toolName = toolMeta.toolName;
+        }
+        if (toolMeta?.toolInput) {
+            payload.toolInput = toolMeta.toolInput;
+        }
+        if (text.startsWith('Using tool:') && !payload.toolName) {
+            payload.toolName = text.replace('Using tool:', '').trim();
+        }
+        else if (text.startsWith('Tool input:')) {
+            try {
+                const jsonStr = text.replace('Tool input:', '').trim();
+                payload.toolInput = JSON.parse(jsonStr);
+            }
+            catch {
+                payload.toolInputRaw = text.replace('Tool input:', '').trim();
+            }
+        }
+        else if (text.startsWith('Bash output:')) {
+            payload.toolOutput = text.replace('Bash output:', '').trim();
+        }
+        else if (text.startsWith('Tool result:')) {
+            payload.toolOutput = text.replace('Tool result:', '').trim();
+        }
+        ctx.broadcast({
+            type: 'output',
+            payload,
+        });
+        const delegation = getBossForSubordinate(agentId);
+        if (delegation) {
+            ctx.broadcast({
+                type: 'agent_task_output',
+                payload: {
+                    bossId: delegation.bossId,
+                    subordinateId: agentId,
+                    output: text.slice(0, 500),
+                },
+            });
+        }
+    });
+    runtimeService.on('complete', (agentId, success) => {
+        ctx.sendActivity(agentId, success ? 'Task completed' : 'Task failed');
+        const delegation = getBossForSubordinate(agentId);
+        log.log(`[COMPLETE] Agent ${agentId} completed (success=${success}), delegation=${delegation ? `bossId=${delegation.bossId}` : 'none'}`);
+        if (delegation) {
+            log.log(`[COMPLETE] Broadcasting agent_task_completed for subordinate ${agentId} to boss ${delegation.bossId}`);
+            ctx.broadcast({
+                type: 'agent_task_completed',
+                payload: {
+                    bossId: delegation.bossId,
+                    subordinateId: agentId,
+                    success,
+                },
+            });
+            clearDelegation(agentId);
+        }
+    });
+    runtimeService.on('error', (agentId, error) => {
+        ctx.sendActivity(agentId, `Error: ${error}`);
+    });
+    runtimeService.setCommandStartedCallback((agentId, command) => {
+        ctx.broadcast({
+            type: 'command_started',
+            payload: { agentId, command },
+        });
+    });
+    runtimeService.setSessionUpdateCallback((agentId) => {
+        ctx.broadcast({
+            type: 'session_updated',
+            payload: { agentId },
+        });
+    });
+}

package/dist/src/packages/server/websocket/listeners/skill-listeners.js

@@ -0,0 +1,51 @@
+import { agentLifecycleService, customClassService, skillService } from '../../services/index.js';
+export function setupSkillListeners(ctx) {
+    skillService.subscribe((event, data) => {
+        switch (event) {
+            case 'created':
+                ctx.broadcast({
+                    type: 'skill_created',
+                    payload: data,
+                });
+                break;
+            case 'updated':
+                ctx.broadcast({
+                    type: 'skill_updated',
+                    payload: data,
+                });
+                agentLifecycleService.restartAgentsWithSkill(data, ctx.sendActivity);
+                break;
+            case 'deleted':
+                ctx.broadcast({
+                    type: 'skill_deleted',
+                    payload: { id: data },
+                });
+                break;
+            case 'assigned':
+                ctx.broadcast({
+                    type: 'skill_updated',
+                    payload: data,
+                });
+                break;
+        }
+    });
+    customClassService.customClassEvents.on('created', (customClass) => {
+        ctx.broadcast({
+            type: 'custom_agent_class_created',
+            payload: customClass,
+        });
+    });
+    customClassService.customClassEvents.on('updated', (customClass) => {
+        ctx.broadcast({
+            type: 'custom_agent_class_updated',
+            payload: customClass,
+        });
+        agentLifecycleService.restartAgentsWithClass(customClass.id, ctx.sendActivity);
+    });
+    customClassService.customClassEvents.on('deleted', (id) => {
+        ctx.broadcast({
+            type: 'custom_agent_class_deleted',
+            payload: { id },
+        });
+    });
+}

package/dist/src/packages/server/websocket/listeners/supervisor-listeners.js

@@ -0,0 +1,37 @@
+import { supervisorService } from '../../services/index.js';
+export function setupSupervisorListeners(ctx) {
+    supervisorService.subscribe((event, data) => {
+        switch (event) {
+            case 'report':
+                ctx.broadcast({
+                    type: 'supervisor_report',
+                    payload: data,
+                });
+                break;
+            case 'agent_analysis':
+                ctx.broadcast({
+                    type: 'agent_analysis',
+                    payload: data,
+                });
+                break;
+            case 'narrative':
+                ctx.broadcast({
+                    type: 'narrative_update',
+                    payload: data,
+                });
+                break;
+            case 'config_changed':
+                ctx.broadcast({
+                    type: 'supervisor_status',
+                    payload: supervisorService.getStatus(),
+                });
+                break;
+            case 'global_usage':
+                ctx.broadcast({
+                    type: 'global_usage',
+                    payload: data,
+                });
+                break;
+        }
+    });
+}

package/dist/src/packages/shared/agent-types.js

@@ -0,0 +1,54 @@
+// ============================================================================
+// Agent Classes - built-in types
+// ============================================================================
+export const BUILT_IN_AGENT_CLASSES = {
+    scout: { icon: '🔍', color: '#4a9eff', description: 'Codebase exploration, file discovery' },
+    builder: { icon: '🔨', color: '#ff9e4a', description: 'Feature implementation, writing code' },
+    debugger: { icon: '🐛', color: '#ff4a4a', description: 'Bug hunting, fixing issues' },
+    architect: { icon: '📐', color: '#9e4aff', description: 'Planning, design decisions' },
+    warrior: { icon: '⚔️', color: '#ff4a9e', description: 'Aggressive refactoring, migrations' },
+    support: { icon: '💚', color: '#4aff9e', description: 'Documentation, tests, cleanup' },
+    boss: { icon: '👑', color: '#ffd700', description: 'Team leader, delegates tasks to subordinates' },
+};
+// For backwards compatibility
+export const AGENT_CLASSES = BUILT_IN_AGENT_CLASSES;
+export const PERMISSION_MODES = {
+    bypass: { label: 'Permissionless', description: 'Skip all permission prompts (less safe, faster)' },
+    interactive: { label: 'Interactive', description: 'Ask for approval before sensitive operations' },
+};
+export const CODEX_MODELS = {
+    'gpt-5.3-codex': {
+        label: 'GPT-5.3 Codex',
+        description: 'Latest frontier agentic coding model',
+        icon: '⚙️',
+    },
+    'gpt-5.2-codex': {
+        label: 'GPT-5.2 Codex',
+        description: 'Frontier agentic coding model',
+        icon: '🧠',
+    },
+    'gpt-5.1-codex-max': {
+        label: 'GPT-5.1 Codex Max',
+        description: 'Codex-optimized flagship for deep and fast reasoning',
+        icon: '🚀',
+    },
+    'gpt-5.1-codex-mini': {
+        label: 'GPT-5.1 Codex Mini',
+        description: 'Optimized for codex, cheaper and faster',
+        icon: '⚡',
+    },
+    'gpt-5.2': {
+        label: 'GPT-5.2',
+        description: 'General frontier model with strong reasoning and coding',
+        icon: '🧩',
+    },
+};
+export const CLAUDE_MODELS = {
+    sonnet: { label: 'Sonnet', description: 'Balanced performance and cost (recommended)', icon: '⚡' },
+    opus: { label: 'Opus', description: 'Most capable, higher cost', icon: '🧠' },
+    haiku: { label: 'Haiku', description: 'Fast and economical', icon: '🚀' },
+};
+// Boss context delimiters - used to inject subordinate context at the beginning of user messages
+// The frontend detects these to collapse/hide the context section in the UI
+export const BOSS_CONTEXT_START = '<<<BOSS_CONTEXT_START>>>';
+export const BOSS_CONTEXT_END = '<<<BOSS_CONTEXT_END>>>';