@agent-spaces/server 0.1.2 → 0.2.3

package/dist/routes/workflow.js

@@ -0,0 +1,63 @@
+import { Router } from 'express';
+import * as workflowService from '../services/workflow.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    try {
+        const workflows = workflowService.listWorkflows();
+        res.json(workflows);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/:workflowId', (req, res) => {
+    try {
+        const workflow = workflowService.getWorkflow(req.params.workflowId);
+        if (!workflow) {
+            res.status(404).json({ error: 'Workflow not found' });
+            return;
+        }
+        res.json(workflow);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/', (req, res) => {
+    try {
+        const workflow = workflowService.createWorkflow(req.body);
+        res.status(201).json(workflow);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.put('/:workflowId', (req, res) => {
+    try {
+        const workflow = workflowService.updateWorkflow(req.params.workflowId, req.body);
+        res.json(workflow);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId', (req, res) => {
+    try {
+        workflowService.deleteWorkflow(req.params.workflowId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:workflowId/duplicate', (req, res) => {
+    try {
+        const workflow = workflowService.duplicateWorkflow(req.params.workflowId);
+        res.status(201).json(workflow);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+export default router;
+//# sourceMappingURL=workflow.js.map

package/dist/routes/workspace.js

@@ -73,27 +73,8 @@ router.put('/:id/prompt', (req, res) => {
     }
     res.json({ prompt: saved });
 });
-router.get('/:id/agent-templates', (req, res) => {
-    const ws = wsService.getById(req.params.id);
-    if (!ws) {
-        res.status(404).json({ error: 'Workspace not found' });
-        return;
-    }
-    const workspaceAgentIds = new Set((ws.agents || []).map((agent) => agent.id));
-    res.json(agentService.listTemplates().filter((agent) => !workspaceAgentIds.has(agent.id)));
-});
-router.post('/:id/agents/from-templates', (req, res) => {
-    const { agentIds } = req.body;
-    if (!Array.isArray(agentIds) || agentIds.length === 0) {
-        res.status(400).json({ error: 'agentIds are required' });
-        return;
-    }
-    const added = agentService.addTemplatesToWorkspace(req.params.id, agentIds);
-    if (!added) {
-        res.status(404).json({ error: 'Workspace not found' });
-        return;
-    }
-    res.status(201).json(added);
+router.get('/:id/agent-templates', (_req, res) => {
+    res.json(agentService.listTemplates());
 });
 router.put('/:id', (req, res) => {
     const ws = wsService.update(req.params.id, req.body);

package/dist/services/agent.js

@@ -3,27 +3,23 @@ import { copyFileSync, cpSync, existsSync, readFileSync, readdirSync, rmSync, st
 import { basename, extname, isAbsolute, join, normalize, relative } from 'node:path';
 import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
 import { listAgentSessions, getAgentSession, createAgentSession, updateAgentSession, deleteAgentSession, getAgentUsageDashboard, recordAgentUsage, } from '../storage/agent-store.js';
-import { getWorkspace, updateWorkspace } from '../storage/workspace-store.js';
+import { getWorkspace } from '../storage/workspace-store.js';
 import { listIssues, updateIssue } from '../storage/issue-store.js';
 import { listChannels, updateChannel } from './channel.js';
 import { ensureDir, getDataDir } from '../storage/json-store.js';
 import { extractUsageFromOutput } from '../storage/usage.js';
-const VALID_ROLES = ['scheduler', 'planner', 'executor', 'reviewer', 'commit', 'custom', 'bot'];
+const DEFAULT_AGENT_ROLE = 'agent';
 const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex'];
 const VALID_TOOL_NAMES = new Set(BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
 const ANTHROPIC_BRIDGE_PROVIDERS = [
     'openai-responses-to-anthropic-messages',
     'openai-chat-completions-to-anthropic-messages',
 ];
-export function listPresets(workspaceId) {
-    const ws = getWorkspace(workspaceId);
-    if (!ws)
-        return null;
-    return ws.agents || [];
+export function listPresets(_workspaceId) {
+    return listTemplates();
 }
-export function findEnabledPresetByRoleInMembers(workspaceId, memberIds, role) {
-    const members = new Set(memberIds);
-    return (listPresets(workspaceId) ?? []).find((agent) => members.has(agent.id) && agent.role === role && agent.enabled !== false) ?? null;
+export function isValidRole(role) {
+    return typeof role === 'string' && role.trim().length > 0;
 }
 export function listTemplates() {
     const root = getGlobalAgentTemplatesDir();
@@ -34,39 +30,12 @@ export function listTemplates() {
         .map((entry) => readAgentTemplate(entry.name))
         .filter((template) => Boolean(template));
 }
-export function addTemplatesToWorkspace(workspaceId, templateIds) {
-    const ws = getWorkspace(workspaceId);
-    if (!ws)
-        return null;
-    const existingIds = new Set((ws.agents || []).map((agent) => agent.id));
-    const added = [];
-    for (const templateId of templateIds) {
-        if (existingIds.has(templateId))
-            continue;
-        const template = readAgentTemplate(templateId);
-        if (!template)
-            continue;
-        const workspaceAgentDir = getWorkspaceAgentDir(ws.agentspaceDir, templateId);
-        const preset = {
-            ...template,
-            id: templateId,
-            workingDir: workspaceAgentDir,
-        };
-        writeWorkspaceAgentCopy(preset, ws.agentspaceDir);
-        ws.agents = [...(ws.agents || []), preset];
-        existingIds.add(templateId);
-        added.push(preset);
-    }
-    if (added.length > 0) {
-        ws.updatedAt = new Date().toISOString();
-        updateWorkspace(ws);
-    }
-    return added;
-}
 export async function testConnection(workspaceId, data) {
-    const ws = getWorkspace(workspaceId);
-    if (!ws)
-        return null;
+    if (workspaceId) {
+        const ws = getWorkspace(workspaceId);
+        if (!ws)
+            return null;
+    }
     const apiBase = data.apiBase?.trim();
     const apiKey = data.apiKey?.trim();
     const model = data.modelId?.trim();
@@ -277,11 +246,7 @@ async function readErrorMessage(response) {
         return { message: body, body: body.slice(0, 2000) };
     }
 }
-export function createPreset(workspaceId, data) {
-    const ws = getWorkspace(workspaceId);
-    if (!ws)
-        return null;
-    const now = new Date().toISOString();
+export function createPreset(_workspaceId, data) {
     const id = uuid();
     const workingDir = data.workingDir?.trim();
     const runtimeKind = data.runtimeKind && VALID_RUNTIME_KINDS.includes(data.runtimeKind)
@@ -292,7 +257,7 @@ export function createPreset(workspaceId, data) {
     const preset = {
         id,
         name: data.name?.trim() || 'New Agent',
-        role: data.role && VALID_ROLES.includes(data.role) ? data.role : 'executor',
+        role: isValidRole(data.role) ? data.role.trim() : DEFAULT_AGENT_ROLE,
         description: data.description || '',
         runtimeKind: presetRuntimeKind,
         modelProvider: requestedModelProvider,
@@ -308,25 +273,17 @@ export function createPreset(workspaceId, data) {
         maxTokens: data.maxTokens ?? 4096,
         sandboxDirs: data.sandboxDirs,
         maxRetries: data.maxRetries,
+        templateId: data.templateId,
         enabled: data.enabled ?? true,
     };
     writeAgentTemplate(preset, data.skills);
-    if (!workingDir)
-        writeWorkspaceAgentCopy(preset, ws.agentspaceDir);
-    ws.agents = [...(ws.agents || []), preset];
-    ws.updatedAt = now;
-    updateWorkspace(ws);
     return preset;
 }
-export function updatePreset(workspaceId, presetId, data) {
-    const ws = getWorkspace(workspaceId);
-    if (!ws)
-        return null;
-    const index = (ws.agents || []).findIndex((preset) => preset.id === presetId);
-    if (index === -1)
+export function updatePreset(_workspaceId, presetId, data) {
+    const existing = readAgentTemplate(presetId);
+    if (!existing)
         return null;
-    const existing = ws.agents[index];
-    const role = data.role && VALID_ROLES.includes(data.role) ? data.role : existing.role;
+    const role = isValidRole(data.role) ? data.role.trim() : existing.role;
     const runtimeKind = data.runtimeKind && VALID_RUNTIME_KINDS.includes(data.runtimeKind)
         ? data.runtimeKind
         : existing.runtimeKind || 'open-agent-sdk';
@@ -346,9 +303,6 @@ export function updatePreset(workspaceId, presetId, data) {
         enabled: data.enabled ?? existing.enabled ?? true,
     };
     writeAgentTemplate(updated, data.skills);
-    ws.agents[index] = updated;
-    ws.updatedAt = new Date().toISOString();
-    updateWorkspace(ws);
     return updated;
 }
 export function getAllowedTools(mcps) {
@@ -464,7 +418,15 @@ function writeAgentTemplate(preset, skillInputs) {
     ensureDir(skillsDir);
     writeFileSync(join(dir, 'agent.json'), JSON.stringify(preset, null, 2), 'utf-8');
     writeFileSync(join(dir, 'mcp.json'), JSON.stringify(preset.mcps ?? {}, null, 2), 'utf-8');
-    if (skillInputs?.some((skill) => typeof skill !== 'string')) {
+    const hasObjectSkills = skillInputs?.some((skill) => typeof skill !== 'string');
+    console.log('[writeAgentTemplate]', {
+        agentId: preset.id,
+        skillsCount: preset.skills?.length ?? 0,
+        skills: preset.skills,
+        hasObjectSkills,
+        skillInputTypes: skillInputs?.map((s) => typeof s),
+    });
+    if (hasObjectSkills) {
         rmSync(skillsDir, { recursive: true, force: true });
         ensureDir(skillsDir);
         for (const skill of skillInputs) {
@@ -474,6 +436,41 @@ function writeAgentTemplate(preset, skillInputs) {
             writeFileSync(join(skillsDir, filename), skill.content ?? '', 'utf-8');
         }
     }
+    else if (preset.skills?.length) {
+        const globalSkillsDir = join(getDataDir(), 'skills');
+        const keepFiles = new Set(preset.skills.map((s) => s.endsWith('.md') ? s : `${s}.md`));
+        // Remove skill files no longer in the list
+        if (existsSync(skillsDir)) {
+            for (const existing of readdirSync(skillsDir)) {
+                if (existing.endsWith('.md') && !keepFiles.has(existing)) {
+                    rmSync(join(skillsDir, existing), { force: true });
+                    console.log('[writeAgentTemplate] removed stale skill:', existing);
+                }
+            }
+        }
+        // Copy / ensure skill files
+        for (const filename of keepFiles) {
+            const target = join(skillsDir, filename);
+            const globalSource = join(globalSkillsDir, filename);
+            console.log('[writeAgentTemplate] skill:', filename, 'globalExists:', existsSync(globalSource), 'targetExists:', existsSync(target));
+            if (existsSync(globalSource)) {
+                copyFileSync(globalSource, target);
+            }
+            else if (!existsSync(target)) {
+                writeFileSync(target, '', 'utf-8');
+            }
+        }
+    }
+    else {
+        // No skills — clean skills dir
+        if (existsSync(skillsDir)) {
+            for (const existing of readdirSync(skillsDir)) {
+                if (existing.endsWith('.md')) {
+                    rmSync(join(skillsDir, existing), { force: true });
+                }
+            }
+        }
+    }
 }
 function copyAgentTemplateToWorkspace(agentId, agentspaceDir) {
     const sourceDir = getGlobalAgentTemplateDir(agentId);
@@ -510,7 +507,7 @@ function ensureWorkspaceAgentCopy(preset, agentspaceDir) {
         return;
     writeWorkspaceAgentCopy(preset, agentspaceDir);
 }
-function readAgentTemplate(agentId) {
+export function readAgentTemplate(agentId) {
     const filePath = join(getGlobalAgentTemplateDir(agentId), 'agent.json');
     if (!existsSync(filePath))
         return null;
@@ -530,32 +527,99 @@ export function deletePreset(workspaceId, presetId) {
     const ws = getWorkspace(workspaceId);
     if (!ws)
         return null;
-    const before = (ws.agents || []).length;
-    ws.agents = (ws.agents || []).filter((preset) => preset.id !== presetId);
-    if (ws.agents.length === before)
+    const template = readAgentTemplate(presetId);
+    if (!template)
         return false;
-    ws.updatedAt = new Date().toISOString();
-    updateWorkspace(ws);
+    // Delete global template
+    const templateDir = getGlobalAgentTemplateDir(presetId);
+    if (existsSync(templateDir))
+        rmSync(templateDir, { recursive: true, force: true });
     // Remove agent from all channels' members
     for (const ch of listChannels(workspaceId)) {
         if (ch.members.includes(presetId)) {
             updateChannel(workspaceId, ch.id, { members: ch.members.filter((m) => m !== presetId) });
         }
     }
-    // Remove agent from all issues' members and assignedAgents
+    // Remove agent from all issues' members
     for (const issue of listIssues(workspaceId)) {
         const membersChanged = issue.members.includes(presetId);
-        const assignedChanged = issue.assignedAgents.includes(presetId);
-        if (membersChanged || assignedChanged) {
+        if (membersChanged) {
             updateIssue({
                 ...issue,
-                members: membersChanged ? issue.members.filter((m) => m !== presetId) : issue.members,
-                assignedAgents: assignedChanged ? issue.assignedAgents.filter((a) => a !== presetId) : issue.assignedAgents,
+                members: issue.members.filter((m) => m !== presetId),
             });
         }
     }
     return true;
 }
+export function createGlobalPreset(data) {
+    const id = uuid();
+    const runtimeKind = data.runtimeKind && VALID_RUNTIME_KINDS.includes(data.runtimeKind)
+        ? data.runtimeKind
+        : 'open-agent-sdk';
+    const requestedModelProvider = normalizeModelProvider(data.modelProvider);
+    const presetRuntimeKind = isAnthropicBridgeProvider(requestedModelProvider) ? 'claude-code' : runtimeKind;
+    const preset = {
+        id,
+        name: data.name?.trim() || 'New Agent',
+        role: isValidRole(data.role) ? data.role.trim() : DEFAULT_AGENT_ROLE,
+        description: data.description || '',
+        runtimeKind: presetRuntimeKind,
+        modelProvider: requestedModelProvider,
+        modelId: data.modelId || 'claude-sonnet-4-6',
+        apiBase: data.apiBase || '',
+        apiKey: data.apiKey || '',
+        workingDir: '',
+        mcps: normalizeMcpConfig(data.mcps),
+        skills: normalizeSkillNames(data.skills),
+        tools: normalizeToolNames(data.tools ?? BUILT_IN_AGENT_TOOLS.map((tool) => tool.name)),
+        systemPrompt: data.systemPrompt || '',
+        temperature: data.temperature ?? 0.3,
+        maxTokens: data.maxTokens ?? 4096,
+        sandboxDirs: data.sandboxDirs,
+        maxRetries: data.maxRetries,
+        templateId: data.templateId,
+        enabled: data.enabled ?? true,
+    };
+    writeAgentTemplate(preset, data.skills);
+    return preset;
+}
+export function updateGlobalPreset(presetId, data) {
+    const existing = readAgentTemplate(presetId);
+    if (!existing)
+        return null;
+    const role = isValidRole(data.role) ? data.role.trim() : existing.role;
+    const runtimeKind = data.runtimeKind && VALID_RUNTIME_KINDS.includes(data.runtimeKind)
+        ? data.runtimeKind
+        : existing.runtimeKind || 'open-agent-sdk';
+    const requestedModelProvider = normalizeModelProvider(data.modelProvider);
+    const updatedRuntimeKind = isAnthropicBridgeProvider(requestedModelProvider) ? 'claude-code' : runtimeKind;
+    const updated = {
+        ...existing,
+        ...data,
+        id: existing.id,
+        role,
+        runtimeKind: updatedRuntimeKind,
+        name: data.name?.trim() || existing.name || 'New Agent',
+        modelProvider: requestedModelProvider,
+        mcps: normalizeMcpConfig(data.mcps),
+        skills: normalizeSkillNames(data.skills),
+        tools: normalizeToolNames(data.tools ?? existing.tools),
+        enabled: data.enabled ?? existing.enabled ?? true,
+    };
+    writeAgentTemplate(updated, data.skills);
+    return updated;
+}
+export function deleteGlobalPreset(presetId) {
+    const templateDir = getGlobalAgentTemplateDir(presetId);
+    if (!existsSync(templateDir))
+        return false;
+    rmSync(templateDir, { recursive: true, force: true });
+    return true;
+}
+export function listGlobalPresets() {
+    return listTemplates();
+}
 export function list(workspaceId) {
     return listAgentSessions(workspaceId);
 }

package/dist/services/builtin-tools.js

@@ -4,6 +4,8 @@ import * as issueCommentService from './issue-comment.js';
 import * as channelService from './channel.js';
 import * as taskService from './task.js';
 import * as agentService from './agent.js';
+import * as commandService from './command.js';
+import * as commandProcessManager from './command-process-manager.js';
 const currentChannelInputSchema = {
     type: 'object',
     properties: {
@@ -181,4 +183,74 @@ function assertCurrentChannelId(channel, input) {
     }
     return data;
 }
+export function createCommandFunctionTools(workspaceId) {
+    return [
+        {
+            name: 'ListQuickCommands',
+            description: 'List all quick commands for the workspace with running status.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    workspaceId: { type: 'string', description: 'The workspace ID' },
+                },
+                required: ['workspaceId'],
+                additionalProperties: false,
+            },
+            annotations: { readOnly: true, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                const commands = commandService.listCommands(workspaceId);
+                const processes = commandProcessManager.getCommandProcesses(workspaceId);
+                const processMap = new Map(processes.map(p => [p.commandId, p]));
+                return commands.map(cmd => ({
+                    ...cmd,
+                    running: processMap.has(cmd.id) ? processMap.get(cmd.id).status : false,
+                }));
+            },
+        },
+        {
+            name: 'RunQuickCommand',
+            description: 'Run a quick command by ID. Returns sessionId.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    workspaceId: { type: 'string' },
+                    commandId: { type: 'string' },
+                },
+                required: ['workspaceId', 'commandId'],
+                additionalProperties: false,
+            },
+            annotations: { destructive: false, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                return { sessionId: commandProcessManager.runCommand(workspaceId, data.commandId) };
+            },
+        },
+        {
+            name: 'StopQuickCommand',
+            description: 'Stop a running quick command by ID.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    workspaceId: { type: 'string' },
+                    commandId: { type: 'string' },
+                },
+                required: ['workspaceId', 'commandId'],
+                additionalProperties: false,
+            },
+            annotations: { destructive: false, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                commandProcessManager.stopCommand(workspaceId, data.commandId);
+                return { stopped: true };
+            },
+        },
+    ];
+}
 //# sourceMappingURL=builtin-tools.js.map

package/dist/services/channel.js

@@ -2,7 +2,7 @@ import { v4 as uuid } from 'uuid';
 import { join } from 'node:path';
 import { readJsonFile, writeJsonFile, ensureDir, getDataDir } from '../storage/json-store.js';
 import { rmSync } from 'node:fs';
-import { getWorkspace } from '../storage/workspace-store.js';
+import * as agentService from '../services/agent.js';
 function workspaceDir(workspaceId) {
     return join(getDataDir(), 'workspaces', workspaceId);
 }
@@ -56,19 +56,19 @@ export function updateChannel(workspaceId, channelId, data) {
     writeJsonFile(channelsPath(workspaceId), channels);
     return channels[idx];
 }
-function normalizeMembers(workspaceId, members = ['user']) {
-    const agentIds = new Set((getWorkspace(workspaceId)?.agents || []).map((agent) => agent.id));
+function normalizeMembers(workspaceId, members = []) {
+    const agentIds = new Set(agentService.listPresets(workspaceId).map((agent) => agent.id));
     const normalized = [];
     const seen = new Set();
     for (const member of members) {
-        if (member !== 'user' && !agentIds.has(member))
+        if (!agentIds.has(member))
             continue;
         if (seen.has(member))
             continue;
         seen.add(member);
         normalized.push(member);
     }
-    return normalized.includes('user') ? normalized : ['user', ...normalized];
+    return normalized;
 }
 export function deleteChannel(workspaceId, channelId) {
     const channels = listChannels(workspaceId);

package/dist/services/command-process-manager.js

@@ -0,0 +1,136 @@
+import * as ptyService from './pty.js';
+import * as commandService from './command.js';
+import { getWorkspace } from '../storage/workspace-store.js';
+import { broadcastToWorkspace } from '../ws/connection-manager.js';
+const processes = new Map();
+const sessionIndex = new Map();
+const restartTimers = new Map();
+export function runCommand(workspaceId, commandId) {
+    const existing = processes.get(commandId);
+    if (existing) {
+        console.log(`[command] reuse existing session=${existing.sessionId} for command=${commandId}`);
+        return existing.sessionId;
+    }
+    const command = commandService.getCommand(workspaceId, commandId);
+    if (!command)
+        throw new Error('Command not found');
+    const workspace = getWorkspace(workspaceId);
+    const cwd = command.cwd || workspace?.boundDirs[0] || process.env.HOME || '/tmp';
+    const shell = command.shell;
+    const env = command.env;
+    console.log(`[command] runCommand: workspace=${workspaceId} command=${commandId} cwd=${cwd} shell=${shell} cmd=${command.command}`);
+    let sessionId;
+    try {
+        sessionId = ptyService.createSession(workspaceId, cwd, (id, output) => {
+            broadcastToWorkspace(workspaceId, 'terminal.output', { sessionId: id, data: output });
+        }, (id, exitCode) => {
+            handlePtyExit(id, exitCode);
+        }, shell, env);
+    }
+    catch (err) {
+        console.error(`[command] pty.spawn failed: ${err.message}`);
+        throw new Error(`Failed to spawn terminal: ${err.message}`);
+    }
+    const now = new Date().toISOString();
+    const cmdProcess = {
+        commandId,
+        workspaceId,
+        sessionId,
+        status: 'running',
+        startedAt: now,
+        restartCount: 0,
+    };
+    processes.set(commandId, cmdProcess);
+    sessionIndex.set(sessionId, commandId);
+    ptyService.write(sessionId, command.command + '\r');
+    broadcastToWorkspace(workspaceId, 'terminal.created', { sessionId, cwd, shell });
+    console.log(`[command] broadcasted terminal.created: session=${sessionId} cwd=${cwd}`);
+    broadcastToWorkspace(workspaceId, 'command.started', {
+        commandId,
+        sessionId,
+        workspaceId,
+    });
+    return sessionId;
+}
+export function stopCommand(workspaceId, commandId) {
+    const cmdProcess = processes.get(commandId);
+    if (!cmdProcess)
+        throw new Error('Command not running');
+    console.log(`[command] stopCommand: command=${commandId} session=${cmdProcess.sessionId}`);
+    const timer = restartTimers.get(commandId);
+    if (timer) {
+        clearTimeout(timer);
+        restartTimers.delete(commandId);
+    }
+    ptyService.write(cmdProcess.sessionId, '\x03');
+    cmdProcess.status = 'stopping';
+}
+function handlePtyExit(sessionId, exitCode) {
+    const commandId = sessionIndex.get(sessionId);
+    if (!commandId)
+        return;
+    console.log(`[command] handlePtyExit: session=${sessionId} command=${commandId} exitCode=${exitCode}`);
+    const cmdProcess = processes.get(commandId);
+    if (!cmdProcess)
+        return;
+    processes.delete(commandId);
+    sessionIndex.delete(sessionId);
+    const timer = restartTimers.get(commandId);
+    if (timer) {
+        clearTimeout(timer);
+        restartTimers.delete(commandId);
+    }
+    const { workspaceId } = cmdProcess;
+    const command = commandService.getCommand(workspaceId, commandId);
+    if (command?.autoRestart === true && cmdProcess.status !== 'stopping') {
+        const restartCount = cmdProcess.restartCount + 1;
+        broadcastToWorkspace(workspaceId, 'command.restarted', {
+            commandId,
+            sessionId: cmdProcess.sessionId,
+            restartCount,
+            workspaceId,
+        });
+        const t = setTimeout(() => {
+            restartTimers.delete(commandId);
+            try {
+                runCommand(workspaceId, commandId);
+            }
+            catch {
+                // Command may have been deleted during delay
+            }
+        }, 1000);
+        restartTimers.set(commandId, t);
+    }
+    else {
+        broadcastToWorkspace(workspaceId, 'terminal.closed', { sessionId, exitCode });
+        broadcastToWorkspace(workspaceId, 'command.stopped', {
+            commandId,
+            exitCode,
+            workspaceId,
+        });
+    }
+}
+export function getCommandProcess(commandId) {
+    return processes.get(commandId);
+}
+export function getCommandProcesses(workspaceId) {
+    const result = [];
+    for (const cmdProcess of processes.values()) {
+        if (cmdProcess.workspaceId === workspaceId)
+            result.push(cmdProcess);
+    }
+    return result;
+}
+export function cleanup(workspaceId) {
+    for (const [commandId, cmdProcess] of processes) {
+        if (cmdProcess.workspaceId === workspaceId) {
+            const timer = restartTimers.get(commandId);
+            if (timer)
+                clearTimeout(timer);
+            restartTimers.delete(commandId);
+            sessionIndex.delete(cmdProcess.sessionId);
+            processes.delete(commandId);
+        }
+    }
+}
+//# sourceMappingURL=command-process-manager.js.map