portless-studio 0.1.4 → 0.1.5

package/dist/server/application/stop-process.js

@@ -5,7 +5,7 @@ import { appError } from "./app-error.js";
  * Stops a dev server from its row. Only a process of the current user that listens on a port the
  * UI shows can be stopped, so the endpoint cannot be used to kill anything else on the machine.
  */
-export async function stopProcess(input, deps) {
+export async function stopProcess(input, deps, all = false) {
     if (!/^\d+$/.test(input) || Number(input) < 1) {
         return err(appError("invalid_request", "The pid must be a whole number above 0."));
     }
@@ -19,6 +19,47 @@ export async function stopProcess(input, deps) {
         const who = owner === "root" ? "root" : owner === "other" ? "another user" : "an unknown user";
         return err(appError("process_not_allowed", `Process ${pid} on port ${port} belongs to ${who}; stop it from a terminal.`, killCommand(deps.platform ?? process.platform, [pid], true)));
     }
-    const stopped = await deps.processes.terminate(pid);
-    return stopped.ok ? ok({ pid, port }) : stopped;
+    const targets = all ? await deps.processes.devTree?.(pid) : [pid];
+    if (!targets?.length) {
+        return err(appError("unsupported", "Could not identify the development command tree. Stop it from its terminal."));
+    }
+    // Check the entire plan before sending any signal. A tree must never include Studio.
+    for (const target of targets) {
+        if (target === deps.selfPid || (await deps.processes.ownerOf(target)) !== "you") {
+            return err(appError("process_not_allowed", "The development command tree includes a protected process. Stop it from its terminal."));
+        }
+    }
+    const watchedPorts = new Set([port]);
+    for (const listener of (await deps.listeners?.()) ?? []) {
+        if (listener.pid !== null && targets.includes(listener.pid))
+            watchedPorts.add(listener.port);
+    }
+    try {
+        for (const target of targets) {
+            const stopped = await deps.processes.terminate(target);
+            if (!stopped.ok)
+                return stopped;
+        }
+        if (deps.listeners || deps.portClosed) {
+            // Observe a settling window too: a supervisor may immediately restart the listener.
+            await new Promise((resolve) => setTimeout(resolve, deps.settleMs ?? 750));
+            const listeners = (await deps.listeners?.()) ?? [];
+            for (const watchedPort of watchedPorts) {
+                const survivor = listeners.find((item) => item.port === watchedPort);
+                const closed = deps.portClosed ? await deps.portClosed(watchedPort) : !survivor;
+                if (!closed) {
+                    const reason = !survivor
+                        ? "The port could not be confirmed closed"
+                        : targets.includes(survivor.pid ?? -1)
+                            ? `Process ${survivor.pid} is still listening`
+                            : `Process ${survivor.pid ?? "unknown"} is now listening; a parent or another program may have restarted the server`;
+                    return err(appError("port_in_use", `Port ${watchedPort} did not stay closed. ${reason}. Try Stop all to stop the development command, or stop it from its terminal.`));
+                }
+            }
+        }
+        return ok({ pid, port });
+    }
+    finally {
+        await deps.refresh?.();
+    }
 }

package/dist/server/application/studio-runtime.js

@@ -196,6 +196,15 @@ export class StudioRuntime {
      * pid -> port for every process listening on a detected or routed port, from a fresh scan.
      * These are the only processes the UI may stop.
      */
+    /** Refresh listeners and health immediately after a process action and broadcast the snapshot. */
+    async refreshProcesses() {
+        // A scan started before the stop may still contain the listener that just exited.
+        await this.#scanning;
+        const state = await this.#registry.readSnapshot();
+        await this.#detect(state, await this.#currentConfig(), true);
+        await this.#probeRoutes(state.routes);
+        this.#notify();
+    }
     async stoppablePids() {
         const state = await this.#registry.readSnapshot();
         const found = await this.#detect(state, await this.#currentConfig(), true);

package/dist/server/application/terminals.js

@@ -208,6 +208,7 @@ export class TerminalManager {
         const entry = this.#entries.get(id);
         if (!entry)
             return notFound(id);
+        entry.restartGeneration += 1;
         if (!entry.process || entry.info.status !== "running")
             return ok({ ...entry.info });
         entry.stoppedOnPurpose = true;
@@ -215,10 +216,36 @@ export class TerminalManager {
         return ok({ ...entry.info });
     }
     /** Runs the same command again; stops the current one first and waits for it to end. */
-    async restart(id) {
+    restart(id) {
         const entry = this.#entries.get(id);
         if (!entry)
-            return notFound(id);
+            return Promise.resolve(notFound(id));
+        if (this.#closing)
+            return Promise.resolve(err(appError("command_failed", "Studio is stopping.")));
+        if (entry.restartPromise)
+            return entry.restartPromise;
+        let resolve;
+        let reject;
+        const pending = new Promise((done, failed) => {
+            resolve = done;
+            reject = failed;
+        });
+        // Register before interrupting: an exit callback can synchronously request another restart.
+        entry.restartPromise = pending;
+        void this.#restartEntry(entry, entry.restartGeneration).then((result) => {
+            entry.restartPromise = null;
+            resolve(result);
+        }, (error) => {
+            entry.restartPromise = null;
+            reject(error);
+        });
+        return pending;
+    }
+    async #restartEntry(entry, generation) {
+        const stillWanted = () => !this.#closing &&
+            this.#entries.get(entry.info.id) === entry &&
+            entry.restartGeneration === generation;
+        const cancelled = () => err(appError("terminal_not_running", "The restart was cancelled."));
         const current = entry.process;
         if (current && entry.info.status === "running") {
             const ended = new Promise((resolve) => current.onExit(() => resolve()));
@@ -226,6 +253,8 @@ export class TerminalManager {
             this.#escalate(entry, current);
             await ended;
         }
+        if (!stillWanted())
+            return cancelled();
         this.#append(entry, `\r\n[Studio] restarted: ${entry.info.command || "shell"}\r\n`);
         if (entry.info.project === null) {
             const project = await this.#projectOf(entry.info.cwd);
@@ -238,9 +267,16 @@ export class TerminalManager {
                 };
             }
         }
-        const started = await this.#spawn(entry);
+        if (!stillWanted())
+            return cancelled();
+        const started = await this.#spawn(entry, stillWanted);
         if (!started.ok)
             return started;
+        if (!stillWanted()) {
+            entry.process?.kill();
+            entry.process = null;
+            return cancelled();
+        }
         entry.stoppedOnPurpose = false;
         entry.info = {
             ...entry.info,
@@ -311,7 +347,7 @@ export class TerminalManager {
         this.#stopWorkspaceWatch?.();
         this.#stopWorkspaceWatch = undefined;
     }
-    async #spawn(entry) {
+    async #spawn(entry, stillWanted) {
         let child;
         try {
             child = await this.#spawner.spawn(entry.request);
@@ -319,6 +355,10 @@ export class TerminalManager {
         catch (error) {
             return err(appError("command_failed", `Could not start it: ${error.message}`));
         }
+        if (stillWanted && !stillWanted()) {
+            child.kill();
+            return err(appError("terminal_not_running", "The restart was cancelled."));
+        }
         entry.process = child;
         entry.info.pid = child.pid;
         entry.info.mode = this.#spawner.mode;
@@ -393,6 +433,8 @@ export class TerminalManager {
             baseline: null,
             namingTimer: undefined,
             stoppedOnPurpose: false,
+            restartPromise: null,
+            restartGeneration: 0,
         };
     }
     #recentCommands() {

package/dist/server/infrastructure/system/dev-process-tree.js

@@ -0,0 +1,70 @@
+function devRunner(command) {
+    const words = command.match(/"[^"]*"|'[^']*'|[^\s]+/g) ?? [];
+    const basename = (word) => word
+        .replace(/^['"]|['"]$/g, "")
+        .split(/[/\\]/)
+        .pop() ?? "";
+    const executable = basename(words[0] ?? "");
+    const script = /^(?:node|node.exe|bun|bun.exe)$/.test(executable)
+        ? basename(words[1] ?? "")
+        : executable;
+    return /^(?:pnpm|npm(?:-cli)?|npx(?:-cli)?|yarn|bun|bunx|turbo|vite|next|astro|wrangler|ng|nuxt|remix|nodemon|tsx)(?:\.(?:c?js|mjs|exe|cmd))?$/i.test(script);
+}
+function commandShell(command) {
+    const words = command.match(/"[^"]*"|'[^']*'|[^\s]+/g) ?? [];
+    const name = (words[0] ?? "")
+        .replace(/^['"]|['"]$/g, "")
+        .split(/[/\\]/)
+        .pop()
+        ?.toLowerCase();
+    if (name === "cmd.exe" || name === "cmd") {
+        const commandAt = words.findIndex((word) => /^\/c$/i.test(word));
+        return (commandAt > 0 &&
+            commandAt < words.length - 1 &&
+            words.slice(1, commandAt).every((word) => /^\/[dsq]$/i.test(word)));
+    }
+    return /^(?:sh|bash|zsh|dash)$/.test(name ?? "") && words[1] === "-c";
+}
+/** Root first prevents supervisors restarting children; the remaining children are deepest first. */
+export function devProcessTree(pid, table) {
+    const byPid = new Map(table.map((entry) => [entry.pid, entry]));
+    let root = byPid.get(pid);
+    if (!root)
+        return [];
+    const seen = new Set([pid]);
+    for (let depth = 0; depth < 64; depth++) {
+        let parent = byPid.get(root.parent);
+        if (!parent || parent.pid <= 1 || seen.has(parent.pid))
+            break;
+        seen.add(parent.pid);
+        if (commandShell(parent.command)) {
+            parent = byPid.get(parent.parent);
+            if (!parent || parent.pid <= 1 || seen.has(parent.pid))
+                break;
+            seen.add(parent.pid);
+        }
+        if (!devRunner(parent.command))
+            break;
+        root = parent;
+    }
+    const descendants = new Set([root.pid]);
+    const ordered = [root.pid];
+    for (let depth = 0; depth < 64; depth++) {
+        const added = table.filter((entry) => !descendants.has(entry.pid) && descendants.has(entry.parent));
+        if (!added.length)
+            break;
+        for (const entry of added) {
+            descendants.add(entry.pid);
+            ordered.push(entry.pid);
+        }
+    }
+    return [root.pid, ...ordered.slice(1).reverse()];
+}
+export function parseProcessTable(output) {
+    return output.split(/\r?\n/).flatMap((line) => {
+        const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+        return match
+            ? [{ pid: Number(match[1]), parent: Number(match[2]), command: match[3] ?? "" }]
+            : [];
+    });
+}

package/dist/server/infrastructure/system/port-closed.js

@@ -0,0 +1,15 @@
+import { createConnection } from "node:net";
+/** A refused TCP connection confirms closure; timeouts and unexpected errors do not. */
+export async function portClosed(port) {
+    const answers = await Promise.all(["127.0.0.1", "::1"].map((host) => new Promise((resolve) => {
+        const socket = createConnection({ host, port });
+        const finish = (closed) => {
+            socket.destroy();
+            resolve(closed);
+        };
+        socket.once("connect", () => finish(false));
+        socket.once("error", (error) => finish(error.code === "ECONNREFUSED" || error.code === "EAFNOSUPPORT"));
+        socket.setTimeout(800, () => finish(false));
+    })));
+    return answers.every(Boolean);
+}

package/dist/server/infrastructure/system/system-process-control.js

@@ -1,6 +1,8 @@
 import { err, ok } from "../../../core/result.js";
 import { appError } from "../../application/app-error.js";
 import { isProcessAlive } from "../portless/state-files.js";
+import { parseStatParent } from "../terminal/process-tree.js";
+import { devProcessTree, parseProcessTable } from "./dev-process-tree.js";
 /** How long a dev server gets to shut down cleanly before it is forced. */
 const GRACE_MS = 5000;
 const POLL_MS = 100;
@@ -40,6 +42,48 @@ export class SystemProcessControl {
     constructor(options) {
         this.#options = options;
     }
+    async devTree(pid) {
+        const { platform, io } = this.#options;
+        let table;
+        if (platform === "linux") {
+            table = io
+                .readDir("/proc")
+                .filter((name) => /^\d+$/.test(name))
+                .flatMap((name) => {
+                const stat = io.readFile(`/proc/${name}/stat`);
+                const command = io.readFile(`/proc/${name}/cmdline`);
+                const parent = stat === null ? null : parseStatParent(stat);
+                return parent === null || !command
+                    ? []
+                    : [{ pid: Number(name), parent, command: command.replaceAll("\0", " ").trim() }];
+            });
+        }
+        else if (platform === "darwin") {
+            const answer = await io.run("ps", ["-ww", "-axo", "pid=,ppid=,args="]);
+            table = answer.exitCode === 0 ? parseProcessTable(answer.stdout) : [];
+        }
+        else {
+            const answer = await io.run("powershell.exe", [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Json -Compress",
+            ]);
+            try {
+                const rows = JSON.parse(answer.stdout);
+                table = (Array.isArray(rows) ? rows : [rows]).flatMap((row) => row &&
+                    typeof row.ProcessId === "number" &&
+                    typeof row.ParentProcessId === "number" &&
+                    typeof row.CommandLine === "string"
+                    ? [{ pid: row.ProcessId, parent: row.ParentProcessId, command: row.CommandLine }]
+                    : []);
+            }
+            catch {
+                table = [];
+            }
+        }
+        return devProcessTree(pid, table);
+    }
     async ownerOf(pid) {
         const { platform, io, uid, userName } = this.#options;
         if (platform === "win32") {

package/dist/server/interface/http/http-server.js

@@ -172,7 +172,7 @@ export function createHttpServer(options) {
         if (stop?.[1] && method === "POST") {
             if (!options.stopProcess)
                 return sendAppError(res, unsupported);
-            const result = await options.stopProcess(stop[1]);
+            const result = await options.stopProcess(stop[1], query.get("scope") === "tree");
             if (!result.ok)
                 return sendAppError(res, result.error);
             res.writeHead(204, { "Cache-Control": "no-store" }).end();

package/dist/server/main.js

@@ -29,6 +29,7 @@ import { ephemeralRangeReader } from "./infrastructure/system/ephemeral-ports.js
 import { FaviconFetcher } from "./infrastructure/system/favicon-fetcher.js";
 import { fetchLatestVersion } from "./infrastructure/system/npm-registry.js";
 import { OsNotifier } from "./infrastructure/system/os-notifier.js";
+import { portClosed } from "./infrastructure/system/port-closed.js";
 import { startForwarder } from "./infrastructure/system/port-forwarder.js";
 import { ProjectInfoReader } from "./infrastructure/system/project-info.js";
 import { nodeSystemIo } from "./infrastructure/system/system-io.js";
@@ -154,11 +155,14 @@ export function createStudioServices(options = {}) {
         detectPorts: () => runtime.detectPorts(),
         doctor,
         controlProxy: proxy,
-        stopProcess: (pid) => stopProcess(pid, {
+        stopProcess: (pid, all) => stopProcess(pid, {
             processes,
             stoppablePids: () => runtime.stoppablePids(),
             selfPid: process.pid,
-        }),
+            listeners: () => scanner.scan(),
+            portClosed,
+            refresh: () => runtime.refreshProcesses(),
+        }, all),
         stopContainer: (name) => stopContainer(name, containers),
         studioService,
         openWith,