nomoreide 0.1.14 → 0.1.16

package/dist/core/port-utils.d.ts

@@ -1,3 +1,8 @@
+export interface PortHolder {
+    pid: number;
+    pgid?: number;
+    command: string;
+}
 export interface PortStatus {
     port: number;
     available: boolean;
@@ -15,3 +20,4 @@ export interface PortBindingStatus {
 export declare function isPortAvailable(port: number, host?: string): Promise<boolean>;
 export declare function getPortStatus(port: number): Promise<PortStatus>;
 export declare function getPortBindingStatus(port: number): Promise<PortBindingStatus>;
+export declare function getPortHolder(port: number): Promise<PortHolder | null>;

package/dist/core/port-utils.js

@@ -1,4 +1,7 @@
+import { exec } from "node:child_process";
 import net from "node:net";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
 export async function isPortAvailable(port, host = "127.0.0.1") {
     return (await checkHostPort(port, host)).available;
 }
@@ -21,6 +24,47 @@ export async function getPortBindingStatus(port) {
         hosts: statuses,
     };
 }
+export async function getPortHolder(port) {
+    try {
+        const { stdout } = await execAsync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`, {
+            timeout: 1500,
+        });
+        const pid = Number(stdout.trim().split(/\s+/)[0]);
+        if (!Number.isFinite(pid) || pid <= 0)
+            return null;
+        return {
+            pid,
+            pgid: await readPgid(pid),
+            command: await readCommand(pid),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function readPgid(pid) {
+    try {
+        const { stdout } = await execAsync(`ps -o pgid= -p ${pid}`, {
+            timeout: 1000,
+        });
+        const pgid = Number(stdout.trim());
+        return Number.isFinite(pgid) && pgid > 0 ? pgid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readCommand(pid) {
+    try {
+        const { stdout } = await execAsync(`ps -o command= -p ${pid}`, {
+            timeout: 1000,
+        });
+        return stdout.trim().split("\n")[0] || `pid ${pid}`;
+    }
+    catch {
+        return `pid ${pid}`;
+    }
+}
 async function checkHostPort(port, host) {
     return new Promise((resolve, reject) => {
         const server = net.createServer();

package/dist/core/port-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"port-utils.js","sourceRoot":"","sources":["../../src/core/port-utils.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,UAAU,CAAC;AAmB3B,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,IAAY,EACZ,IAAI,GAAG,WAAW;IAElB,OAAO,CAAC,MAAM,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AACrD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAAY;IAC9C,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAChD,OAAO;QACL,IAAI;QACJ,SAAS,EAAE,MAAM,CAAC,SAAS;KAC5B,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,IAAY;IAEZ,MAAM,KAAK,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IAC3D,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;QACzB,IAAI;QACJ,GAAG,CAAC,MAAM,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;KACrC,CAAC,CAAC,CACJ,CAAC;IAEF,OAAO;QACL,IAAI;QACJ,SAAS,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC;QACvD,KAAK,EAAE,QAAQ;KAChB,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,aAAa,CAC1B,IAAY,EACZ,IAAY;IAEZ,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,MAAM,GAAG,GAAG,CAAC,YAAY,EAAE,CAAC;QAElC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAA4B,EAAE,EAAE;YACpD,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3D,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;gBACrD,OAAO;YACT,CAAC;YAED,MAAM,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE;YAC7B,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"port-utils.js","sourceRoot":"","sources":["../../src/core/port-utils.ts"],"names":[],"mappings":"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"}

package/dist/core/process-manager.d.ts

@@ -1,31 +1,57 @@
 import type { ConfigStore } from "./config-store.js";
 import type { LogStore } from "./log-store.js";
+import { type PortHolder } from "./port-utils.js";
+import type { TimelineStore } from "./timeline-store.js";
 import type { ServiceStatus } from "./types.js";
 interface ProcessManagerOptions {
     configStore: ConfigStore;
     logStore: LogStore;
     stopTimeoutMs?: number;
+    timelineStore?: TimelineStore;
 }
 export interface NoMoreIdeStatus {
     services: Record<string, ServiceStatus>;
 }
+export interface StartServiceOptions {
+    killHolder?: boolean;
+}
+export declare class PortConflictError extends Error {
+    readonly code = "PORT_IN_USE";
+    readonly service: string;
+    readonly port: number;
+    readonly holder: PortHolder | null;
+    constructor(service: string, port: number, holder: PortHolder | null);
+}
 export declare class ProcessManager {
     private readonly runtimes;
     private readonly configStore;
     private readonly logStore;
     private readonly stopTimeoutMs;
+    private readonly timelineStore?;
     constructor(options: ProcessManagerOptions);
-    startService(name: string): Promise<ServiceStatus>;
+    startService(name: string, options?: StartServiceOptions): Promise<ServiceStatus>;
     stopService(name: string): Promise<ServiceStatus>;
-    restartService(name: string): Promise<ServiceStatus>;
+    restartService(name: string, options?: StartServiceOptions): Promise<ServiceStatus>;
+    setInspectorEnabled(name: string, enabled: boolean): Promise<ServiceStatus>;
+    private maybeStartInspector;
+    private stopInspector;
+    private inspectorStatus;
+    private recordInspectorEvent;
     startBundle(name: string): Promise<ServiceStatus[]>;
     stopBundle(name: string): Promise<ServiceStatus[]>;
     restartBundle(name: string): Promise<ServiceStatus[]>;
     stopAll(): Promise<void>;
+    killAllSync(signal?: NodeJS.Signals): void;
+    installShutdownHandlers(): () => void;
     status(): NoMoreIdeStatus;
     statusWithResources(): Promise<NoMoreIdeStatus>;
+    private startDockerComposeService;
+    private stopDockerComposeService;
+    readDockerServiceLogs(name: string, tail?: number): Promise<string>;
+    readDockerServiceStatus(name: string): Promise<import("./docker-service-runner.js").DockerContainerInfo>;
     private getService;
     private getBundle;
     private captureStream;
+    private appendTimeline;
 }
 export {};

package/dist/core/process-manager.js

@@ -1,53 +1,103 @@
 import { spawn } from "node:child_process";
-import { isPortAvailable } from "./port-utils.js";
+import { readDockerServiceLogs, readDockerServiceStatus, startDockerService, stopDockerService, } from "./docker-service-runner.js";
+import { startHttpInspector, } from "./http-inspector.js";
+import { getPortHolder, isPortAvailable } from "./port-utils.js";
 import { readProcessTree } from "./process-tree.js";
+import { createSshCommand } from "./ssh-service-runner.js";
+export class PortConflictError extends Error {
+    code = "PORT_IN_USE";
+    service;
+    port;
+    holder;
+    constructor(service, port, holder) {
+        const owner = holder ? ` (held by pid ${holder.pid} — ${holder.command})` : "";
+        super(`Port ${port} is already in use for ${service}${owner}.`);
+        this.name = "PortConflictError";
+        this.service = service;
+        this.port = port;
+        this.holder = holder;
+    }
+}
 export class ProcessManager {
     runtimes = new Map();
     configStore;
     logStore;
     stopTimeoutMs;
+    timelineStore;
     constructor(options) {
         this.configStore = options.configStore;
         this.logStore = options.logStore;
         this.stopTimeoutMs = options.stopTimeoutMs ?? 3000;
+        this.timelineStore = options.timelineStore;
     }
-    async startService(name) {
+    async startService(name, options = {}) {
         const service = await this.getService(name);
         const existing = this.runtimes.get(name);
         if (existing?.status.state === "running") {
             return { ...existing.status };
         }
+        const kind = resolveKind(service);
+        if (kind === "docker-compose") {
+            return this.startDockerComposeService(name, service);
+        }
         if (service.port && !(await isPortAvailable(service.port))) {
-            throw new Error(`Port ${service.port} is already in use for ${name}.`);
+            const holder = await getPortHolder(service.port);
+            if (options.killHolder && holder) {
+                await killHolder(holder);
+                if (!(await waitForPortFree(service.port, 3000))) {
+                    throw new PortConflictError(name, service.port, holder);
+                }
+            }
+            else {
+                throw new PortConflictError(name, service.port, holder);
+            }
         }
-        const child = spawn(service.command, {
-            cwd: service.cwd,
-            env: { ...process.env, ...service.env },
-            shell: true,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
+        const child = spawnService(name, service, kind);
         const runtime = {
             child,
             stopping: false,
             status: {
                 name,
                 state: "running",
+                kind,
+                host: kind === "ssh" ? service.host : undefined,
                 pid: child.pid,
                 startedAt: new Date().toISOString(),
             },
         };
         this.runtimes.set(name, runtime);
+        void this.appendTimeline({
+            kind: "service.lifecycle",
+            service: name,
+            severity: "info",
+            title: `${name} started`,
+            data: {
+                pid: child.pid,
+            },
+        });
         this.captureStream(name, "stdout", child.stdout);
         this.captureStream(name, "stderr", child.stderr);
         child.once("exit", (exitCode, signal) => {
+            const nextState = runtime.stopping ? "stopped" : "exited";
             runtime.status = {
                 ...runtime.status,
-                state: runtime.stopping ? "stopped" : "exited",
+                state: nextState,
                 exitedAt: new Date().toISOString(),
                 exitCode,
                 signal,
             };
             runtime.child = undefined;
+            void this.stopInspector(runtime);
+            void this.appendTimeline({
+                kind: "service.lifecycle",
+                service: name,
+                severity: nextState === "exited" && exitCode ? "error" : "info",
+                title: `${name} ${nextState}`,
+                data: {
+                    exitCode,
+                    signal,
+                },
+            });
         });
         child.once("error", (error) => {
             runtime.status = {
@@ -58,14 +108,30 @@ export class ProcessManager {
                 signal: null,
             };
             void this.logStore.append(name, "stderr", error.message);
+            void this.appendTimeline({
+                kind: "service.lifecycle",
+                service: name,
+                severity: "error",
+                title: `${name} failed`,
+                detail: error.message,
+            });
         });
         return { ...runtime.status };
     }
     async stopService(name) {
         const runtime = this.runtimes.get(name);
+        if (runtime?.status.kind === "docker-compose" && runtime.status.state === "running") {
+            return this.stopDockerComposeService(name, runtime);
+        }
         if (!runtime?.child || runtime.status.state !== "running") {
             const stopped = { name, state: "stopped" };
             this.runtimes.set(name, { status: stopped, stopping: false });
+            void this.appendTimeline({
+                kind: "service.lifecycle",
+                service: name,
+                severity: "info",
+                title: `${name} stopped`,
+            });
             return stopped;
         }
         runtime.stopping = true;
@@ -77,11 +143,95 @@ export class ProcessManager {
         };
         runtime.status = stopped;
         runtime.child = undefined;
+        void this.appendTimeline({
+            kind: "service.lifecycle",
+            service: name,
+            severity: "info",
+            title: `${name} stopped`,
+        });
         return { ...stopped };
     }
-    async restartService(name) {
+    async restartService(name, options = {}) {
         await this.stopService(name);
-        return this.startService(name);
+        return this.startService(name, options);
+    }
+    async setInspectorEnabled(name, enabled) {
+        const runtime = this.runtimes.get(name);
+        if (!runtime) {
+            throw new Error(`Service "${name}" is not running.`);
+        }
+        runtime.inspectorEnabled = enabled;
+        if (enabled) {
+            await this.maybeStartInspector(name);
+        }
+        else {
+            await this.stopInspector(runtime);
+        }
+        runtime.status = {
+            ...runtime.status,
+            inspector: this.inspectorStatus(runtime),
+        };
+        return { ...runtime.status };
+    }
+    async maybeStartInspector(name) {
+        const runtime = this.runtimes.get(name);
+        if (!runtime || !runtime.inspectorEnabled || runtime.inspectorHandle)
+            return;
+        const upstreamPort = portFromUrl(runtime.status.url);
+        if (!upstreamPort)
+            return;
+        const handle = await startHttpInspector({
+            upstreamPort,
+            onEvent: (event) => this.recordInspectorEvent(name, event),
+        });
+        runtime.inspectorHandle = handle;
+        runtime.status = {
+            ...runtime.status,
+            inspector: { enabled: true, port: handle.port, upstreamPort },
+        };
+        void this.appendTimeline({
+            kind: "service.lifecycle",
+            service: name,
+            severity: "info",
+            title: `${name} HTTP inspector on :${handle.port}`,
+            detail: `Proxying to upstream :${upstreamPort}`,
+        });
+    }
+    async stopInspector(runtime) {
+        if (!runtime.inspectorHandle)
+            return;
+        const handle = runtime.inspectorHandle;
+        runtime.inspectorHandle = undefined;
+        await handle.stop();
+    }
+    inspectorStatus(runtime) {
+        if (!runtime.inspectorEnabled)
+            return undefined;
+        return {
+            enabled: true,
+            port: runtime.inspectorHandle?.port,
+            upstreamPort: portFromUrl(runtime.status.url),
+        };
+    }
+    recordInspectorEvent(name, event) {
+        const severity = event.status >= 500 ? "error" : event.status >= 400 ? "warning" : "info";
+        void this.appendTimeline({
+            kind: "service.http",
+            service: name,
+            severity,
+            title: `${event.method} ${event.path} → ${event.status}`,
+            detail: `${event.durationMs} ms`,
+            timestamp: event.startedAt,
+            data: {
+                id: event.id,
+                method: event.method,
+                path: event.path,
+                status: event.status,
+                durationMs: event.durationMs,
+                reqBytes: event.reqBytes,
+                resBytes: event.resBytes,
+            },
+        });
     }
     async startBundle(name) {
         const bundle = await this.getBundle(name);
@@ -106,6 +256,38 @@ export class ProcessManager {
     async stopAll() {
         await Promise.all([...this.runtimes.keys()].map((name) => this.stopService(name)));
     }
+    killAllSync(signal = "SIGTERM") {
+        for (const runtime of this.runtimes.values()) {
+            if (!runtime.child || runtime.child.exitCode !== null)
+                continue;
+            signalProcessTree(runtime.child, signal);
+        }
+    }
+    installShutdownHandlers() {
+        let firing = false;
+        const handle = (signal) => () => {
+            if (firing)
+                return;
+            firing = true;
+            this.killAllSync("SIGTERM");
+            // Re-raise the signal with default behavior so the host exits.
+            setTimeout(() => process.kill(process.pid, signal), 50);
+        };
+        const onExit = () => this.killAllSync("SIGTERM");
+        const sigint = handle("SIGINT");
+        const sigterm = handle("SIGTERM");
+        const sighup = handle("SIGHUP");
+        process.once("SIGINT", sigint);
+        process.once("SIGTERM", sigterm);
+        process.once("SIGHUP", sighup);
+        process.once("exit", onExit);
+        return () => {
+            process.removeListener("SIGINT", sigint);
+            process.removeListener("SIGTERM", sigterm);
+            process.removeListener("SIGHUP", sighup);
+            process.removeListener("exit", onExit);
+        };
+    }
     status() {
         return {
             services: Object.fromEntries([...this.runtimes.entries()].map(([name, runtime]) => [
@@ -121,10 +303,63 @@ export class ProcessManager {
             if (status.pid && status.state === "running") {
                 status.processTree = await readProcessTree(status.pid);
             }
+            status.inspector = this.inspectorStatus(runtime);
             services[name] = status;
         }
         return { services };
     }
+    async startDockerComposeService(name, service) {
+        const target = toDockerTarget(name, service);
+        const info = await startDockerService(target);
+        const status = {
+            name,
+            state: "running",
+            kind: "docker-compose",
+            startedAt: new Date().toISOString(),
+            containerId: info.containerId,
+        };
+        this.runtimes.set(name, { status, stopping: false });
+        void this.appendTimeline({
+            kind: "service.lifecycle",
+            service: name,
+            severity: "info",
+            title: `${name} started`,
+            data: { containerId: info.containerId },
+        });
+        return { ...status };
+    }
+    async stopDockerComposeService(name, runtime) {
+        const service = await this.getService(name);
+        runtime.stopping = true;
+        await stopDockerService(toDockerTarget(name, service));
+        const stopped = {
+            ...runtime.status,
+            state: "stopped",
+            exitedAt: new Date().toISOString(),
+        };
+        runtime.status = stopped;
+        void this.appendTimeline({
+            kind: "service.lifecycle",
+            service: name,
+            severity: "info",
+            title: `${name} stopped`,
+        });
+        return { ...stopped };
+    }
+    async readDockerServiceLogs(name, tail = 120) {
+        const service = await this.getService(name);
+        if (resolveKind(service) !== "docker-compose") {
+            throw new Error(`Service "${name}" is not a docker-compose service.`);
+        }
+        return readDockerServiceLogs(toDockerTarget(name, service), tail);
+    }
+    async readDockerServiceStatus(name) {
+        const service = await this.getService(name);
+        if (resolveKind(service) !== "docker-compose") {
+            throw new Error(`Service "${name}" is not a docker-compose service.`);
+        }
+        return readDockerServiceStatus(toDockerTarget(name, service));
+    }
     async getService(name) {
         const config = await this.configStore.load();
         const service = config.services.find((item) => item.name === name);
@@ -157,7 +392,15 @@ export class ProcessManager {
                         const runtime = this.runtimes.get(service);
                         if (runtime) {
                             runtime.status = { ...runtime.status, url };
+                            void this.maybeStartInspector(service);
                         }
+                        void this.appendTimeline({
+                            kind: "service.port",
+                            service,
+                            severity: "info",
+                            title: `${service} reported ${url}`,
+                            detail: url,
+                        });
                     }
                     void this.logStore.append(service, stream, line);
                 }
@@ -170,10 +413,62 @@ export class ProcessManager {
             }
         });
     }
+    async appendTimeline(event) {
+        if (!this.timelineStore)
+            return;
+        await this.timelineStore.append(event);
+    }
+}
+function resolveKind(service) {
+    return service.kind ?? "local";
+}
+function toDockerTarget(name, service) {
+    if (!service.cwd || !service.composeService) {
+        throw new Error(`Service "${name}" is missing docker-compose cwd or composeService.`);
+    }
+    return {
+        cwd: service.cwd,
+        composeFile: service.composeFile,
+        composeService: service.composeService,
+    };
+}
+function spawnService(name, service, kind) {
+    if (kind === "ssh") {
+        if (!service.host || !service.cwd || !service.command) {
+            throw new Error(`Service "${name}" is missing ssh host, cwd, or command.`);
+        }
+        const [bin, args] = createSshCommand({
+            host: service.host,
+            cwd: service.cwd,
+            command: service.command,
+            env: service.env,
+        });
+        return spawn(bin, args, {
+            env: { ...process.env },
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: true,
+        });
+    }
+    if (!service.command || !service.cwd) {
+        throw new Error(`Service "${name}" is missing command or cwd.`);
+    }
+    return spawn(service.command, {
+        cwd: service.cwd,
+        env: { ...process.env, ...service.env },
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true,
+    });
 }
 function localUrlFromLine(line) {
     return line.match(/https?:\/\/(?:localhost|127\.0\.0\.1):\d+\/?/)?.[0];
 }
+function portFromUrl(url) {
+    if (!url)
+        return undefined;
+    const match = url.match(/:(\d+)/);
+    return match ? Number(match[1]) : undefined;
+}
 async function stopChild(child, timeoutMs) {
     if (child.exitCode !== null || child.signalCode !== null) {
         return;
@@ -188,11 +483,69 @@ async function stopChild(child, timeoutMs) {
             }
         };
         const timer = setTimeout(() => {
-            child.kill("SIGKILL");
+            signalProcessTree(child, "SIGKILL");
             finish();
         }, timeoutMs);
         child.once("exit", finish);
-        child.kill("SIGTERM");
+        signalProcessTree(child, "SIGTERM");
     });
 }
+async function killHolder(holder) {
+    const target = holder.pgid ? -holder.pgid : holder.pid;
+    try {
+        process.kill(target, "SIGTERM");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ESRCH")
+            throw error;
+    }
+    // Give the process a moment to exit cleanly before escalating.
+    for (let i = 0; i < 20; i += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        try {
+            process.kill(holder.pid, 0);
+        }
+        catch {
+            return;
+        }
+    }
+    try {
+        process.kill(target, "SIGKILL");
+    }
+    catch {
+        // ignore
+    }
+}
+async function waitForPortFree(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await isPortAvailable(port))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return isPortAvailable(port);
+}
+function signalProcessTree(child, signal) {
+    const pid = child.pid;
+    if (!pid)
+        return;
+    try {
+        // Negative PID = signal the whole process group whose leader is `pid`.
+        // The service was spawned with detached: true so child.pid === PGID.
+        process.kill(-pid, signal);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return;
+        // Fall back to signaling the direct child if the group is gone.
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
 //# sourceMappingURL=process-manager.js.map