@mako10k/shell-server 0.1.0

package/dist/core/server-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-manager.d.ts","sourceRoot":"","sources":["../../src/core/server-manager.ts"],"names":[],"mappings":"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"}

package/dist/core/server-manager.js

@@ -0,0 +1,680 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { MCPShellError } from '../utils/errors.js';
+const NOT_IMPLEMENTED_MESSAGE = 'Server management layer is not implemented yet.';
+const DEFAULT_BRANCH = 'main';
+const SOCKET_FILE_NAME = 'daemon.sock';
+const SOCKET_CONNECT_TIMEOUT_MS = 250;
+const SOCKET_READY_TIMEOUT_MS = 1000;
+const SOCKET_READY_INTERVAL_MS = 50;
+const SOCKET_REQUEST_TIMEOUT_MS = 1000;
+export class StubServerManager {
+    createdAt = new Date().toISOString();
+    servers = new Map();
+    getBranch() {
+        return process.env['MCP_SHELL_SERVER_BRANCH'] || DEFAULT_BRANCH;
+    }
+    getRuntimeRoot() {
+        const runtimeDir = process.env['XDG_RUNTIME_DIR'] || os.tmpdir();
+        return path.join(runtimeDir, 'mcp-shell');
+    }
+    isDaemonEnabled() {
+        // Default ON to enable auto-start/reattach behavior.
+        // Opt-out explicitly with MCP_SHELL_DAEMON_ENABLED=false.
+        return process.env['MCP_SHELL_DAEMON_ENABLED'] !== 'false';
+    }
+    hashCwd(cwd) {
+        return crypto.createHash('sha256').update(path.resolve(cwd)).digest('hex');
+    }
+    buildSocketPath(cwd, branch) {
+        const runtimeRoot = this.getRuntimeRoot();
+        const cwdHash = this.hashCwd(cwd);
+        return path.join(runtimeRoot, cwdHash, branch, SOCKET_FILE_NAME);
+    }
+    parseServerId(serverId) {
+        const [hash, branch] = serverId.split(':');
+        if (!hash || !branch) {
+            return null;
+        }
+        return { hash, branch };
+    }
+    buildSocketPathFromServerId(serverId) {
+        const parsed = this.parseServerId(serverId);
+        if (!parsed) {
+            return null;
+        }
+        return path.join(this.getRuntimeRoot(), parsed.hash, parsed.branch, SOCKET_FILE_NAME);
+    }
+    resolveDaemonEntry() {
+        const override = process.env['MCP_SHELL_DAEMON_ENTRY'];
+        if (override) {
+            return override;
+        }
+        const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+        const packagedCandidate = path.resolve(moduleDir, '../daemon/server.js');
+        const candidates = [
+            // When running from a packaged build (e.g., node_modules), daemon lives next to dist/*.
+            packagedCandidate,
+            // When running from this mono-repo build output.
+            path.resolve(process.cwd(), 'dist/packages/shell-server/src/daemon/server.js'),
+            path.resolve(process.cwd(), 'dist/packages/shell-server/daemon/server.js'),
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Best guess (will be validated by fs.access at call site).
+        return packagedCandidate;
+    }
+    async socketExists(socketPath) {
+        try {
+            const stat = await fs.stat(socketPath);
+            return stat.isSocket();
+        }
+        catch {
+            return false;
+        }
+    }
+    async canConnectSocket(socketPath) {
+        return new Promise((resolve) => {
+            const socket = net.connect({ path: socketPath }, () => {
+                socket.end();
+                resolve(true);
+            });
+            const cleanup = () => {
+                socket.removeAllListeners();
+            };
+            socket.setTimeout(SOCKET_CONNECT_TIMEOUT_MS, () => {
+                socket.destroy();
+                cleanup();
+                resolve(false);
+            });
+            socket.on('error', () => {
+                cleanup();
+                resolve(false);
+            });
+        });
+    }
+    async waitForSocketReady(socketPath) {
+        const deadline = Date.now() + SOCKET_READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (await this.canConnectSocket(socketPath)) {
+                return true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, SOCKET_READY_INTERVAL_MS));
+        }
+        return false;
+    }
+    async requestDaemon(socketPath, request) {
+        return new Promise((resolve, reject) => {
+            const socket = net.connect({ path: socketPath }, () => {
+                socket.write(`${JSON.stringify(request)}\n`);
+            });
+            let buffer = '';
+            const timeout = setTimeout(() => {
+                socket.destroy();
+                reject(new MCPShellError('SYSTEM_013', 'Daemon request timed out', 'SYSTEM', {
+                    socketPath,
+                    action: request.action,
+                }));
+            }, SOCKET_REQUEST_TIMEOUT_MS);
+            const cleanup = () => {
+                clearTimeout(timeout);
+                socket.removeAllListeners();
+            };
+            socket.setEncoding('utf-8');
+            socket.on('data', (chunk) => {
+                buffer += chunk;
+                if (buffer.includes('\n')) {
+                    socket.end();
+                }
+            });
+            socket.on('end', () => {
+                cleanup();
+                const line = buffer.trim();
+                if (!line) {
+                    reject(new MCPShellError('SYSTEM_013', 'Daemon response was empty', 'SYSTEM', {
+                        socketPath,
+                        action: request.action,
+                    }));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(line));
+                }
+                catch (error) {
+                    reject(new MCPShellError('SYSTEM_013', 'Failed to parse daemon response', 'SYSTEM', {
+                        socketPath,
+                        action: request.action,
+                        error: String(error),
+                    }));
+                }
+            });
+            socket.on('error', (error) => {
+                cleanup();
+                reject(new MCPShellError('SYSTEM_013', 'Daemon request failed', 'SYSTEM', {
+                    socketPath,
+                    action: request.action,
+                    error: String(error),
+                }));
+            });
+        });
+    }
+    async openAttachConnection(socketPath) {
+        return new Promise((resolve, reject) => {
+            const socket = net.connect({ path: socketPath }, () => {
+                socket.write(`${JSON.stringify({ action: 'attach' })}\n`);
+            });
+            let buffer = '';
+            let responseSent = false;
+            const timeout = setTimeout(() => {
+                socket.destroy();
+                reject(new MCPShellError('SYSTEM_013', 'Attach request timed out', 'SYSTEM', {
+                    socketPath,
+                }));
+            }, SOCKET_REQUEST_TIMEOUT_MS);
+            const cleanup = () => {
+                clearTimeout(timeout);
+            };
+            const handleHeartbeat = (message) => {
+                if (message.type === 'ping') {
+                    try {
+                        socket.write(`${JSON.stringify({ type: 'pong' })}\n`);
+                    }
+                    catch {
+                        // Ignore write failures on heartbeat.
+                    }
+                }
+            };
+            socket.setEncoding('utf-8');
+            socket.on('data', (chunk) => {
+                buffer += chunk;
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed) {
+                        continue;
+                    }
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(trimmed);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!responseSent && 'ok' in parsed) {
+                        responseSent = true;
+                        cleanup();
+                        const response = parsed;
+                        if (!response.ok) {
+                            socket.end();
+                            reject(new MCPShellError('SYSTEM_013', 'Daemon attach failed', 'SYSTEM', {
+                                socketPath,
+                                error: response.error,
+                            }));
+                            return;
+                        }
+                        resolve({ socket, response });
+                        continue;
+                    }
+                    handleHeartbeat(parsed);
+                }
+            });
+            socket.on('error', (error) => {
+                cleanup();
+                reject(new MCPShellError('SYSTEM_013', 'Attach connection failed', 'SYSTEM', {
+                    socketPath,
+                    error: String(error),
+                }));
+            });
+        });
+    }
+    deriveStatus(attached, detached) {
+        if (detached) {
+            return 'detached';
+        }
+        if (attached) {
+            return 'running';
+        }
+        return 'running';
+    }
+    async removeIfEmpty(dirPath) {
+        try {
+            const entries = await fs.readdir(dirPath);
+            if (entries.length === 0) {
+                await fs.rmdir(dirPath);
+            }
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+    async cleanupStaleSocket(socketPath) {
+        try {
+            await fs.unlink(socketPath);
+        }
+        catch {
+            return;
+        }
+        const branchDir = path.dirname(socketPath);
+        const hashDir = path.dirname(branchDir);
+        await this.removeIfEmpty(branchDir);
+        await this.removeIfEmpty(hashDir);
+    }
+    async listSocketsForCwd(cwd) {
+        const runtimeRoot = this.getRuntimeRoot();
+        const cwdHash = this.hashCwd(cwd);
+        const cwdRoot = path.join(runtimeRoot, cwdHash);
+        let branchEntries = [];
+        try {
+            branchEntries = await fs.readdir(cwdRoot, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const servers = [];
+        for (const entry of branchEntries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const branch = entry.name;
+            const socketPath = path.join(cwdRoot, branch, SOCKET_FILE_NAME);
+            if (!(await this.socketExists(socketPath))) {
+                continue;
+            }
+            if (!(await this.canConnectSocket(socketPath))) {
+                await this.cleanupStaleSocket(socketPath);
+                continue;
+            }
+            let status = 'running';
+            if (this.isDaemonEnabled()) {
+                try {
+                    const response = await this.requestDaemon(socketPath, { action: 'status' });
+                    status = this.deriveStatus(response.attached, response.detached);
+                }
+                catch {
+                    status = 'unknown';
+                }
+            }
+            servers.push({
+                serverId: `${cwdHash}:${branch}`,
+                status,
+                cwd,
+                socketPath,
+                createdAt: this.createdAt,
+                lastSeenAt: new Date().toISOString(),
+            });
+        }
+        return servers;
+    }
+    async current() {
+        const cwd = process.cwd();
+        const branch = this.getBranch();
+        const socketPath = this.buildSocketPath(cwd, branch);
+        const socketReady = await this.socketExists(socketPath)
+            ? await this.canConnectSocket(socketPath)
+            : false;
+        if (!socketReady && (await this.socketExists(socketPath))) {
+            await this.cleanupStaleSocket(socketPath);
+        }
+        let status = 'running';
+        if (socketReady && this.isDaemonEnabled()) {
+            try {
+                const response = await this.requestDaemon(socketPath, { action: 'status' });
+                status = this.deriveStatus(response.attached, response.detached);
+            }
+            catch {
+                status = 'unknown';
+            }
+        }
+        return {
+            serverId: 'local',
+            status,
+            cwd,
+            ...(socketReady ? { socketPath } : {}),
+            createdAt: this.createdAt,
+            lastSeenAt: new Date().toISOString(),
+            pid: process.pid,
+        };
+    }
+    async listAttachable(_options) {
+        const resolvedCurrent = path.resolve(process.cwd());
+        const resolvedTarget = path.resolve(_options.cwd);
+        const discovered = await this.listSocketsForCwd(resolvedTarget);
+        if (discovered.length > 0) {
+            const attachable = await Promise.all(discovered.map(async (server) => {
+                if (!this.isDaemonEnabled() || !server.socketPath) {
+                    return { ...server, attachable: true };
+                }
+                try {
+                    const response = await this.requestDaemon(server.socketPath, { action: 'status' });
+                    const canAttach = response.attached !== true || response.detached === true;
+                    return {
+                        ...server,
+                        status: this.deriveStatus(response.attached, response.detached),
+                        attachable: canAttach,
+                        ...(canAttach ? {} : { reason: 'Already attached' }),
+                    };
+                }
+                catch {
+                    return {
+                        ...server,
+                        attachable: false,
+                        reason: 'Failed to query daemon status',
+                    };
+                }
+            }));
+            return attachable;
+        }
+        if (resolvedCurrent === resolvedTarget) {
+            const current = await this.current();
+            if (current) {
+                return [
+                    {
+                        ...current,
+                        attachable: true,
+                    },
+                ];
+            }
+        }
+        return [];
+    }
+    async start(options) {
+        const cwd = options.cwd;
+        const branch = this.getBranch();
+        const socketPath = options.socketPath ?? this.buildSocketPath(cwd, branch);
+        const serverId = `${this.hashCwd(cwd)}:${branch}`;
+        if (await this.socketExists(socketPath)) {
+            if (await this.canConnectSocket(socketPath)) {
+                if (options.allowExisting) {
+                    return {
+                        serverId,
+                        status: 'running',
+                        cwd,
+                        socketPath,
+                        createdAt: this.createdAt,
+                        lastSeenAt: new Date().toISOString(),
+                    };
+                }
+                throw new MCPShellError('RESOURCE_006', 'Server is already running', 'RESOURCE', {
+                    socketPath,
+                });
+            }
+            await this.cleanupStaleSocket(socketPath);
+        }
+        await fs.mkdir(path.dirname(socketPath), { recursive: true });
+        if (this.isDaemonEnabled()) {
+            const daemonEntry = this.resolveDaemonEntry();
+            try {
+                await fs.access(daemonEntry);
+            }
+            catch (error) {
+                throw new MCPShellError('SYSTEM_011', 'Daemon entry not found', 'SYSTEM', {
+                    daemonEntry,
+                    error: String(error),
+                });
+            }
+            const child = spawn(process.execPath, [daemonEntry, '--socket', socketPath, '--cwd', cwd, '--branch', branch], {
+                detached: true,
+                stdio: 'ignore',
+                env: {
+                    ...process.env,
+                    MCP_SHELL_DAEMON_SOCKET: socketPath,
+                    MCP_SHELL_DAEMON_CWD: cwd,
+                    MCP_SHELL_DAEMON_BRANCH: branch,
+                },
+            });
+            child.unref();
+            if (!(await this.waitForSocketReady(socketPath))) {
+                throw new MCPShellError('SYSTEM_012', 'Daemon socket did not become ready', 'SYSTEM', {
+                    socketPath,
+                });
+            }
+            this.servers.set(serverId, { socketPath, child, attached: false, detached: false });
+        }
+        else {
+            const server = net.createServer((socket) => {
+                socket.destroy();
+            });
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(socketPath, () => resolve());
+            });
+            await fs.chmod(socketPath, 0o600);
+            this.servers.set(serverId, { socketPath, server, attached: false, detached: false });
+        }
+        return {
+            serverId,
+            status: 'running',
+            cwd,
+            socketPath,
+            createdAt: this.createdAt,
+            lastSeenAt: new Date().toISOString(),
+            pid: process.pid,
+        };
+    }
+    async stop(options) {
+        const entry = this.servers.get(options.serverId);
+        if (entry) {
+            if (this.isDaemonEnabled()) {
+                try {
+                    await this.requestDaemon(entry.socketPath, { action: 'stop' });
+                }
+                catch {
+                    // Best-effort shutdown only.
+                }
+            }
+            if (entry.server) {
+                await new Promise((resolve) => {
+                    entry.server?.close(() => resolve());
+                });
+            }
+            if (entry.child?.pid) {
+                try {
+                    process.kill(entry.child.pid);
+                }
+                catch {
+                    // Best-effort shutdown only.
+                }
+            }
+            this.servers.delete(options.serverId);
+            await this.cleanupStaleSocket(entry.socketPath);
+            return;
+        }
+        const parsed = this.parseServerId(options.serverId);
+        if (!parsed) {
+            throw new MCPShellError('RESOURCE_001', 'Server not found', 'RESOURCE', {
+                serverId: options.serverId,
+            });
+        }
+        const socketPath = path.join(this.getRuntimeRoot(), parsed.hash, parsed.branch, SOCKET_FILE_NAME);
+        if (await this.socketExists(socketPath)) {
+            if (this.isDaemonEnabled() && (await this.canConnectSocket(socketPath))) {
+                const response = await this.requestDaemon(socketPath, { action: 'stop' });
+                if (!response.ok) {
+                    throw new MCPShellError('SYSTEM_013', 'Daemon stop failed', 'SYSTEM', {
+                        serverId: options.serverId,
+                        error: response.error,
+                    });
+                }
+                return;
+            }
+            await this.cleanupStaleSocket(socketPath);
+            return;
+        }
+        if (options.force) {
+            return;
+        }
+        throw new MCPShellError('RESOURCE_001', 'Server not found', 'RESOURCE', {
+            serverId: options.serverId,
+        });
+    }
+    async get(options) {
+        const entry = this.servers.get(options.serverId);
+        if (entry) {
+            // When daemon mode is enabled, prefer querying the daemon for richer info
+            // (including mcpSocketPath) even if we have a local cache entry.
+            if (this.isDaemonEnabled()) {
+                try {
+                    const response = await this.requestDaemon(entry.socketPath, { action: 'info' });
+                    if (response.ok) {
+                        return {
+                            serverId: options.serverId,
+                            status: this.deriveStatus(response.attached, response.detached),
+                            cwd: response.cwd || process.cwd(),
+                            ...(response.socketPath ? { socketPath: response.socketPath } : { socketPath: entry.socketPath }),
+                            ...(response.mcpSocketPath ? { mcpSocketPath: response.mcpSocketPath } : {}),
+                            createdAt: response.startedAt || this.createdAt,
+                            lastSeenAt: new Date().toISOString(),
+                            ...(typeof response.pid === 'number'
+                                ? { pid: response.pid }
+                                : { pid: entry.child?.pid ?? process.pid }),
+                        };
+                    }
+                }
+                catch {
+                    // Fall back to cached info.
+                }
+            }
+            return {
+                serverId: options.serverId,
+                status: this.deriveStatus(entry.attached, entry.detached),
+                cwd: process.cwd(),
+                socketPath: entry.socketPath,
+                createdAt: this.createdAt,
+                lastSeenAt: new Date().toISOString(),
+                pid: entry.child?.pid ?? process.pid,
+            };
+        }
+        const socketPath = this.buildSocketPathFromServerId(options.serverId);
+        if (!socketPath || !(await this.socketExists(socketPath))) {
+            return null;
+        }
+        if (this.isDaemonEnabled()) {
+            if (!(await this.canConnectSocket(socketPath))) {
+                await this.cleanupStaleSocket(socketPath);
+                return null;
+            }
+            const response = await this.requestDaemon(socketPath, { action: 'info' });
+            if (!response.ok) {
+                return null;
+            }
+            return {
+                serverId: options.serverId,
+                status: this.deriveStatus(response.attached, response.detached),
+                cwd: response.cwd || process.cwd(),
+                ...(response.socketPath ? { socketPath: response.socketPath } : { socketPath }),
+                ...(response.mcpSocketPath ? { mcpSocketPath: response.mcpSocketPath } : {}),
+                createdAt: response.startedAt || this.createdAt,
+                lastSeenAt: new Date().toISOString(),
+                ...(typeof response.pid === 'number' ? { pid: response.pid } : {}),
+            };
+        }
+        return {
+            serverId: options.serverId,
+            status: 'running',
+            cwd: process.cwd(),
+            socketPath,
+            createdAt: this.createdAt,
+            lastSeenAt: new Date().toISOString(),
+            pid: process.pid,
+        };
+    }
+    async detach(options) {
+        const entry = this.servers.get(options.serverId);
+        if (entry) {
+            entry.attached = false;
+            entry.detached = true;
+            if (entry.attachSocket) {
+                entry.attachSocket.end();
+                entry.attachSocket.destroy();
+                delete entry.attachSocket;
+            }
+            return;
+        }
+        const socketPath = this.buildSocketPathFromServerId(options.serverId);
+        if (!socketPath || !(await this.socketExists(socketPath))) {
+            throw new MCPShellError('RESOURCE_001', 'Server not found', 'RESOURCE', {
+                serverId: options.serverId,
+            });
+        }
+        if (this.isDaemonEnabled()) {
+            const response = await this.requestDaemon(socketPath, { action: 'detach' });
+            if (!response.ok) {
+                throw new MCPShellError('SYSTEM_013', 'Daemon detach failed', 'SYSTEM', {
+                    serverId: options.serverId,
+                    error: response.error,
+                });
+            }
+            return;
+        }
+        throw new MCPShellError('SYSTEM_010', NOT_IMPLEMENTED_MESSAGE, 'SYSTEM', {
+            operation: 'detach',
+            serverId: options.serverId,
+        });
+    }
+    async reattach(options) {
+        const entry = this.servers.get(options.serverId);
+        if (entry) {
+            if (entry.attached && !entry.detached) {
+                throw new MCPShellError('RESOURCE_006', 'Server is already attached', 'RESOURCE', {
+                    serverId: options.serverId,
+                });
+            }
+            entry.attached = true;
+            entry.detached = false;
+            return {
+                serverId: options.serverId,
+                status: 'running',
+                cwd: process.cwd(),
+                socketPath: entry.socketPath,
+                createdAt: this.createdAt,
+                lastSeenAt: new Date().toISOString(),
+                pid: entry.child?.pid ?? process.pid,
+            };
+        }
+        const socketPath = this.buildSocketPathFromServerId(options.serverId);
+        if (!socketPath || !(await this.socketExists(socketPath))) {
+            throw new MCPShellError('RESOURCE_001', 'Server not found', 'RESOURCE', {
+                serverId: options.serverId,
+            });
+        }
+        if (this.isDaemonEnabled()) {
+            const { socket, response } = await this.openAttachConnection(socketPath);
+            if (response.error === 'already_attached') {
+                socket.end();
+                throw new MCPShellError('RESOURCE_006', 'Server is already attached', 'RESOURCE', {
+                    serverId: options.serverId,
+                });
+            }
+            this.servers.set(options.serverId, {
+                socketPath,
+                attached: response.attached === true,
+                detached: response.detached === true,
+                attachSocket: socket,
+            });
+            return {
+                serverId: options.serverId,
+                status: this.deriveStatus(response.attached, response.detached),
+                cwd: response.cwd || process.cwd(),
+                socketPath,
+                createdAt: this.createdAt,
+                lastSeenAt: new Date().toISOString(),
+                ...(typeof response.pid === 'number' ? { pid: response.pid } : {}),
+            };
+        }
+        throw new MCPShellError('SYSTEM_010', NOT_IMPLEMENTED_MESSAGE, 'SYSTEM', {
+            operation: 'reattach',
+            serverId: options.serverId,
+        });
+    }
+}
+//# sourceMappingURL=server-manager.js.map