@nogataka/smart-edit 1.0.2 → 1.0.4

package/dist/smart-edit/dashboard.js

@@ -7,6 +7,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { createSmartEditLogger } from './util/logging.js';
 import { SMART_EDIT_DASHBOARD_DIR } from './constants.js';
+import { getInstances } from './instance-registry.js';
 const { logger } = createSmartEditLogger({ name: 'smart-edit.dashboard', emitToConsole: false, level: 'info' });
 const DEFAULT_DASHBOARD_PORT = 0x5eda;
 const DASHBOARD_HOST = '127.0.0.1';
@@ -292,6 +293,16 @@ export class SmartEditDashboardAPI {
         const method = req.method?.toUpperCase() ?? 'GET';
         const url = parseUrl(req.url ?? '/', true);
         const pathname = url.pathname ?? '/';
+        // Add CORS headers for cross-origin requests from multi-instance dashboard
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        // Handle CORS preflight
+        if (method === 'OPTIONS') {
+            res.statusCode = 204;
+            res.end();
+            return;
+        }
         try {
             if (pathname.startsWith('/dashboard')) {
                 if (method !== 'GET') {
@@ -356,6 +367,24 @@ export class SmartEditDashboardAPI {
                     this.shutdown();
                     this.sendJson(res, 200, { status: 'shutting down' });
                     return;
+                // Multi-instance dashboard APIs
+                case '/api/instances':
+                    if (method !== 'GET') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.sendJson(res, 200, { instances: getInstances() });
+                    return;
+                case '/api/instance-info':
+                    if (method !== 'GET') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.sendJson(res, 200, {
+                        port: this.listeningPort,
+                        project: this.agent.getActiveProject()?.projectName ?? null
+                    });
+                    return;
                 default:
                     this.respondNotFound(res);
             }

package/dist/smart-edit/instance-registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Instance Registry for Multi-Instance Dashboard
+ *
+ * Manages registration of multiple Smart Edit MCP server instances.
+ * Each instance registers itself when starting and unregisters when stopping.
+ * The dashboard reads this registry to discover and connect to all running instances.
+ */
+export declare const DEFAULT_DASHBOARD_PORT = 24282;
+export interface InstanceInfo {
+    id: string;
+    port: number;
+    project: string | null;
+    pid: number;
+    startedAt: string;
+    transport: 'stdio' | 'sse' | 'streamable-http';
+}
+export declare function generateInstanceId(): string;
+/**
+ * Register a new MCP server instance in the registry.
+ * This function is designed to be non-fatal - if registration fails, the instance
+ * will still work, just won't be visible in the multi-instance dashboard.
+ */
+export declare function registerInstance(info: Omit<InstanceInfo, 'id' | 'startedAt'>): InstanceInfo;
+/**
+ * Unregister an MCP server instance from the registry.
+ */
+export declare function unregisterInstance(instanceId: string): void;
+/**
+ * Get all registered instances (with cleanup of dead processes).
+ */
+export declare function getInstances(): InstanceInfo[];
+/**
+ * Get a specific instance by ID.
+ */
+export declare function getInstance(instanceId: string): InstanceInfo | null;
+/**
+ * Find an available port for the dashboard, starting from the default port.
+ */
+export declare function findAvailablePort(startPort?: number): number;
+/**
+ * Update instance info (e.g., when project changes).
+ */
+export declare function updateInstance(instanceId: string, updates: Partial<Pick<InstanceInfo, 'project'>>): void;

package/dist/smart-edit/instance-registry.js

@@ -0,0 +1,272 @@
+/**
+ * Instance Registry for Multi-Instance Dashboard
+ *
+ * Manages registration of multiple Smart Edit MCP server instances.
+ * Each instance registers itself when starting and unregisters when stopping.
+ * The dashboard reads this registry to discover and connect to all running instances.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import crypto from 'node:crypto';
+import { SMART_EDIT_MANAGED_DIR_NAME } from './constants.js';
+import { createSmartEditLogger } from './util/logging.js';
+const { logger } = createSmartEditLogger({ name: 'smart-edit.instance-registry', emitToConsole: false, level: 'info' });
+export const DEFAULT_DASHBOARD_PORT = 0x5eda; // 24282
+// Compute paths dynamically to respect runtime HOME changes (important for testing)
+// Use process.env.HOME/USERPROFILE first as os.homedir() may cache the value
+function getSmartEditDir() {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+    return path.join(home, SMART_EDIT_MANAGED_DIR_NAME);
+}
+function getInstancesFilePath() {
+    return path.join(getSmartEditDir(), 'instances.json');
+}
+function getLockFilePath() {
+    return path.join(getSmartEditDir(), 'instances.lock');
+}
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_INTERVAL_MS = 50;
+function ensureDirectoryExists(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function acquireLock() {
+    try {
+        const lockFile = getLockFilePath();
+        ensureDirectoryExists(lockFile);
+        const startTime = Date.now();
+        while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+            try {
+                fs.writeFileSync(lockFile, String(process.pid), { flag: 'wx' });
+                return true;
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === 'EEXIST') {
+                    // Lock file exists, check if the process is still alive
+                    try {
+                        const lockPid = Number.parseInt(fs.readFileSync(lockFile, 'utf-8').trim(), 10);
+                        if (!Number.isNaN(lockPid)) {
+                            try {
+                                // Check if process is alive (signal 0 doesn't kill, just checks)
+                                process.kill(lockPid, 0);
+                            }
+                            catch {
+                                // Process is dead, remove stale lock
+                                try {
+                                    fs.unlinkSync(lockFile);
+                                    continue;
+                                }
+                                catch {
+                                    // Ignore unlink errors
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Can't read lock file, try to remove it
+                        try {
+                            fs.unlinkSync(lockFile);
+                            continue;
+                        }
+                        catch {
+                            // Ignore unlink errors
+                        }
+                    }
+                    // Brief busy-wait before retry
+                    const waitUntil = Date.now() + Math.min(LOCK_RETRY_INTERVAL_MS, LOCK_TIMEOUT_MS - (Date.now() - startTime));
+                    while (Date.now() < waitUntil) {
+                        // Busy wait - acceptable since lock contention should be rare
+                    }
+                    continue;
+                }
+                // For other errors (EACCES, ENOENT, etc.), give up on locking
+                logger.warn(`Lock acquisition failed with error: ${err.code}`, err);
+                return false;
+            }
+        }
+        logger.warn('Failed to acquire lock for instance registry (timeout)');
+        return false;
+    }
+    catch (error) {
+        // Catch any unexpected errors (e.g., from ensureDirectoryExists)
+        logger.warn('Unexpected error during lock acquisition', error instanceof Error ? error : undefined);
+        return false;
+    }
+}
+function releaseLock() {
+    try {
+        fs.unlinkSync(getLockFilePath());
+    }
+    catch {
+        // Ignore errors when releasing lock
+    }
+}
+function readRegistry() {
+    const instancesFile = getInstancesFilePath();
+    ensureDirectoryExists(instancesFile);
+    try {
+        if (fs.existsSync(instancesFile)) {
+            const content = fs.readFileSync(instancesFile, 'utf-8');
+            const data = JSON.parse(content);
+            if (data && typeof data === 'object' && Array.isArray(data.instances)) {
+                return data;
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to read instance registry, starting fresh', error instanceof Error ? error : undefined);
+    }
+    return { instances: [] };
+}
+function writeRegistry(data) {
+    const instancesFile = getInstancesFilePath();
+    ensureDirectoryExists(instancesFile);
+    // Atomic write: write to temp file first, then rename
+    const tempFile = `${instancesFile}.tmp`;
+    fs.writeFileSync(tempFile, JSON.stringify(data, null, 2), 'utf-8');
+    fs.renameSync(tempFile, instancesFile);
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cleanupDeadInstances(data) {
+    const aliveInstances = data.instances.filter((instance) => isProcessAlive(instance.pid));
+    if (aliveInstances.length !== data.instances.length) {
+        logger.info(`Cleaned up ${data.instances.length - aliveInstances.length} dead instance(s) from registry`);
+    }
+    return { instances: aliveInstances };
+}
+export function generateInstanceId() {
+    return crypto.randomBytes(6).toString('hex');
+}
+/**
+ * Register a new MCP server instance in the registry.
+ * This function is designed to be non-fatal - if registration fails, the instance
+ * will still work, just won't be visible in the multi-instance dashboard.
+ */
+export function registerInstance(info) {
+    const id = generateInstanceId();
+    const instance = {
+        ...info,
+        id,
+        startedAt: new Date().toISOString()
+    };
+    try {
+        if (!acquireLock()) {
+            logger.warn('Failed to acquire lock for registering instance, continuing without registration');
+            return instance;
+        }
+        try {
+            let data = readRegistry();
+            data = cleanupDeadInstances(data);
+            // Check for duplicate port (shouldn't happen, but just in case)
+            const existingIndex = data.instances.findIndex((i) => i.port === info.port);
+            if (existingIndex !== -1) {
+                data.instances.splice(existingIndex, 1);
+            }
+            data.instances.push(instance);
+            writeRegistry(data);
+            logger.info(`Registered instance ${id} on port ${info.port} for project: ${info.project ?? '(none)'}`);
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to register instance in registry', error instanceof Error ? error : undefined);
+    }
+    return instance;
+}
+/**
+ * Unregister an MCP server instance from the registry.
+ */
+export function unregisterInstance(instanceId) {
+    if (!acquireLock()) {
+        logger.error('Failed to acquire lock for unregistering instance');
+        return;
+    }
+    try {
+        const data = readRegistry();
+        const index = data.instances.findIndex((i) => i.id === instanceId);
+        if (index !== -1) {
+            const removed = data.instances.splice(index, 1)[0];
+            writeRegistry(data);
+            logger.info(`Unregistered instance ${instanceId} (port: ${removed.port})`);
+        }
+    }
+    finally {
+        releaseLock();
+    }
+}
+/**
+ * Get all registered instances (with cleanup of dead processes).
+ */
+export function getInstances() {
+    if (!acquireLock()) {
+        // Even if we can't acquire lock, try to read
+        const data = readRegistry();
+        return data.instances.filter((instance) => isProcessAlive(instance.pid));
+    }
+    try {
+        let data = readRegistry();
+        data = cleanupDeadInstances(data);
+        writeRegistry(data);
+        return data.instances;
+    }
+    finally {
+        releaseLock();
+    }
+}
+/**
+ * Get a specific instance by ID.
+ */
+export function getInstance(instanceId) {
+    const instances = getInstances();
+    return instances.find((i) => i.id === instanceId) ?? null;
+}
+/**
+ * Find an available port for the dashboard, starting from the default port.
+ */
+export function findAvailablePort(startPort = DEFAULT_DASHBOARD_PORT) {
+    const instances = getInstances();
+    const usedPorts = new Set(instances.map((i) => i.port));
+    let port = startPort;
+    while (usedPorts.has(port) && port <= 65535) {
+        port++;
+    }
+    return port;
+}
+/**
+ * Update instance info (e.g., when project changes).
+ */
+export function updateInstance(instanceId, updates) {
+    if (!acquireLock()) {
+        logger.error('Failed to acquire lock for updating instance');
+        return;
+    }
+    try {
+        const data = readRegistry();
+        const instance = data.instances.find((i) => i.id === instanceId);
+        if (instance) {
+            if (updates.project !== undefined) {
+                instance.project = updates.project;
+            }
+            writeRegistry(data);
+            logger.info(`Updated instance ${instanceId}`);
+        }
+    }
+    finally {
+        releaseLock();
+    }
+}