@aexol/spectral 0.9.194 → 0.9.196

package/dist/server/dev-process-registry.js

@@ -0,0 +1,421 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { BashJobRegistry, } from "../sdk/coding-agent/core/bash-jobs.js";
+import { waitForChildProcess } from "../sdk/coding-agent/utils/child-process.js";
+import { getShellConfig, getShellEnv, killProcessTree } from "../sdk/coding-agent/utils/shell.js";
+import { OutputAccumulator, } from "../sdk/coding-agent/core/tools/output-accumulator.js";
+import { getTcpPortsByPid } from "./dev-port-detection.js";
+/** Hard cap for the "newest delta" chunk sent over the wire. */
+const MAX_DEV_PROCESS_OUTPUT_CHUNK = 32_000;
+function defaultLabel(command) {
+    const firstLine = command.split("\n").find((line) => line.trim().length > 0);
+    if (!firstLine)
+        return "Background process";
+    const trimmed = firstLine.trim();
+    return trimmed.length > 60 ? `${trimmed.slice(0, 57)}…` : trimmed;
+}
+/**
+ * Machine-level registry for background bash jobs that should be visible in
+ * the landing "Dev servers" settings section.
+ *
+ * Extends the session-scoped `BashJobRegistry` so the existing bash tool
+ * factories accept it unchanged, while adding the list/summary surface and
+ * durable pidfile tracking under `<agentDir>/dev-processes/`.
+ */
+export class DevProcessRegistry extends BashJobRegistry {
+    records = new Map();
+    pidDir;
+    listeners = new Set();
+    portRefresh = null;
+    constructor(agentDir) {
+        super();
+        this.pidDir = join(agentDir, "dev-processes");
+    }
+    /**
+     * Subscribe to registry events. Returns an unsubscribe function.
+     * Listeners are invoked synchronously and are expected to be cheap;
+     * a throwing listener is logged and isolated so it cannot break process
+     * tracking.
+     */
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    create(input) {
+        const job = super.create(input);
+        const record = {
+            id: job.id,
+            definitionId: input.definitionId,
+            label: input.label?.trim() ? input.label : defaultLabel(input.command),
+            command: input.command,
+            cwd: input.cwd,
+            status: job.status,
+            pid: job.pid,
+            ports: [],
+            startedAt: job.startedAt,
+            endedAt: job.endedAt,
+            exitCode: job.exitCode,
+            fullOutputPath: job.fullOutputPath,
+            output: input.output,
+        };
+        this.records.set(job.id, record);
+        this.writePidfile(job.id);
+        this.emit({
+            type: "dev_processes_changed",
+            processId: job.id,
+            process: this.toSummary(record),
+            change: "started",
+        });
+        return job;
+    }
+    markExited(id, exitCode) {
+        super.markExited(id, exitCode);
+        const record = this.records.get(id);
+        if (record) {
+            const changed = record.status !== "exited";
+            record.status = "exited";
+            record.exitCode = exitCode;
+            record.endedAt = Date.now();
+            if (changed) {
+                this.emit({
+                    type: "dev_processes_changed",
+                    processId: id,
+                    process: this.toSummary(record),
+                    change: "exited",
+                });
+            }
+        }
+        this.removePidfile(id);
+    }
+    markKilled(id) {
+        super.markKilled(id);
+        const record = this.records.get(id);
+        if (record) {
+            const changed = record.status !== "killed";
+            record.status = "killed";
+            record.exitCode = null;
+            record.endedAt = Date.now();
+            if (changed) {
+                this.emit({
+                    type: "dev_processes_changed",
+                    processId: id,
+                    process: this.toSummary(record),
+                    change: "killed",
+                });
+            }
+        }
+        this.removePidfile(id);
+    }
+    /** List all tracked processes, newest first. */
+    list() {
+        return [...this.records.values()]
+            .sort((a, b) => b.startedAt - a.startedAt)
+            .map((record) => this.toSummary(record));
+    }
+    /**
+     * Spawn a persistent dev process. Unlike the agent's normal background bash
+     * path, this process is NOT force-killed after the 30-minute hard deadline
+     * (`waitForChildProcess(_, 0)`). It remains killable through the registry.
+     */
+    spawnDaemon(definition) {
+        if (!existsSync(definition.cwd)) {
+            throw new Error(`Working directory does not exist: ${definition.cwd}`);
+        }
+        const { shell, args } = getShellConfig();
+        const output = new OutputAccumulator({
+            tempFilePrefix: "spectral-dev-process",
+            alwaysPersist: true,
+        });
+        const fullOutputPath = output.persist();
+        const child = spawn(shell, [...args, definition.command], {
+            cwd: definition.cwd,
+            detached: process.platform !== "win32",
+            env: getShellEnv(),
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        const kill = () => {
+            if (child.pid)
+                killProcessTree(child.pid);
+        };
+        const job = this.create({
+            pid: child.pid,
+            command: definition.command,
+            cwd: definition.cwd,
+            output,
+            fullOutputPath,
+            kill,
+            definitionId: definition.definitionId,
+            label: definition.label,
+        });
+        child.stdout?.on("data", (data) => {
+            output.append(data);
+            this.emitOutput(job.id, data, output);
+        });
+        child.stderr?.on("data", (data) => {
+            output.append(data);
+            this.emitOutput(job.id, data, output);
+        });
+        const done = waitForChildProcess(child, 0);
+        void done
+            .then(({ code }) => {
+            output.finish();
+            this.markExited(job.id, code);
+        }, () => {
+            output.finish();
+            this.markKilled(job.id);
+        })
+            .finally(() => {
+            void output.closeTempFile();
+        });
+        const record = this.records.get(job.id);
+        if (!record) {
+            throw new Error("Dev process record was not registered");
+        }
+        this.schedulePortRefresh(1_500);
+        this.schedulePortRefresh(5_000);
+        return this.toSummary(record);
+    }
+    /**
+     * Re-scan listening TCP ports and update any live record whose port set
+     * changed. Called automatically after a new daemon binds and at the end of
+     * pidfile reconciliation; `GET /api/dev-processes` also refreshes eagerly.
+     */
+    async refreshPorts() {
+        if (this.portRefresh)
+            return this.portRefresh;
+        const run = (async () => {
+            try {
+                const byPid = await getTcpPortsByPid();
+                for (const record of this.records.values()) {
+                    if ((record.status !== "running" && record.status !== "recovered") ||
+                        record.pid === undefined ||
+                        record.pid === null) {
+                        continue;
+                    }
+                    const ports = byPid.get(record.pid) ?? [];
+                    const current = record.ports ?? [];
+                    const changed = current.length !== ports.length ||
+                        current.some((port, index) => port !== ports[index]);
+                    if (!changed)
+                        continue;
+                    record.ports = ports;
+                    this.emit({
+                        type: "dev_processes_changed",
+                        processId: record.id,
+                        process: this.toSummary(record),
+                        change: "ports",
+                    });
+                }
+            }
+            catch {
+                // Port introspection is best-effort and must never break process
+                // tracking (e.g. lsof/ss missing or a pid exiting mid-scan).
+            }
+        })();
+        this.portRefresh = run;
+        try {
+            await run;
+        }
+        finally {
+            this.portRefresh = null;
+        }
+    }
+    schedulePortRefresh(ms) {
+        const timer = setTimeout(() => {
+            void this.refreshPorts();
+        }, ms);
+        if (typeof timer.unref === "function")
+            timer.unref();
+    }
+    /**
+     * Kill an existing dev process and start a fresh one from its saved
+     * definition. Returns null when the process id is unknown.
+     */
+    restart(id) {
+        const record = this.records.get(id);
+        if (!record)
+            return null;
+        const definition = {
+            definitionId: record.definitionId,
+            label: record.label,
+            command: record.command,
+            cwd: record.cwd,
+        };
+        // Kill the current process tree when it is still alive. For already
+        // exited/killed rows this is a no-op and just clears any stale pidfile.
+        this.kill(id);
+        return this.spawnDaemon(definition);
+    }
+    /**
+     * Rehydrate processes from durable pidfiles after a CLI restart.
+     *
+     * A live PID becomes a killable `recovered` record whose output is no
+     * longer attached; a dead PID has its stale pidfile removed.
+     */
+    reconcile() {
+        let files;
+        try {
+            mkdirSync(this.pidDir, { recursive: true });
+            files = readdirSync(this.pidDir).filter((name) => name.endsWith(".pid"));
+        }
+        catch {
+            return;
+        }
+        for (const file of files) {
+            const id = file.slice(0, -".pid".length);
+            if (this.records.has(id))
+                continue;
+            const metadata = this.readPidfile(id);
+            if (!metadata || metadata.pid === undefined || metadata.pid === null) {
+                this.removePidfile(id);
+                continue;
+            }
+            if (!this.isPidAlive(metadata.pid)) {
+                this.removePidfile(id);
+                continue;
+            }
+            const output = new OutputAccumulator({
+                tempFilePrefix: "spectral-dev-process",
+            });
+            output.append(Buffer.from("recovered — restart to reattach output\n", "utf8"));
+            output.finish();
+            const command = metadata.command?.trim() || "(recovered process)";
+            const label = metadata.label?.trim()
+                ? `${metadata.label} (recovered)`
+                : command !== "(recovered process)"
+                    ? `${defaultLabel(command)} (recovered)`
+                    : "Recovered dev process";
+            this.create({
+                id,
+                pid: metadata.pid,
+                command,
+                cwd: metadata.cwd ?? "",
+                output,
+                fullOutputPath: metadata.fullOutputPath ?? "",
+                kill: () => killProcessTree(metadata.pid),
+                definitionId: metadata.definitionId,
+                label,
+            });
+            const record = this.records.get(id);
+            if (record) {
+                record.status = "recovered";
+                this.emit({
+                    type: "dev_processes_changed",
+                    processId: id,
+                    process: this.toSummary(record),
+                    change: "status",
+                });
+            }
+        }
+        void this.refreshPorts();
+    }
+    toSummary(record) {
+        return {
+            id: record.id,
+            definitionId: record.definitionId,
+            label: record.label,
+            command: record.command,
+            cwd: record.cwd,
+            status: record.status,
+            pid: record.pid,
+            ports: record.ports ?? [],
+            startedAt: record.startedAt,
+            endedAt: record.endedAt,
+            exitCode: record.exitCode,
+            lastOutputTail: record.output.snapshot().content,
+            fullOutputPath: record.fullOutputPath,
+        };
+    }
+    emitOutput(id, chunk, output) {
+        const record = this.records.get(id);
+        if (!record)
+            return;
+        const raw = chunk.toString("utf8");
+        const boundedChunk = raw.length > MAX_DEV_PROCESS_OUTPUT_CHUNK
+            ? raw.slice(0, MAX_DEV_PROCESS_OUTPUT_CHUNK)
+            : raw;
+        this.emit({
+            type: "dev_process_output",
+            processId: id,
+            chunk: boundedChunk,
+            tail: output.snapshot().content,
+        });
+    }
+    emit(event) {
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(event);
+            }
+            catch (err) {
+                console.error(`[spectral] error: dev-process event listener failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    pidfilePath(id) {
+        return join(this.pidDir, `${id}.pid`);
+    }
+    writePidfile(id) {
+        const record = this.records.get(id);
+        if (!record)
+            return;
+        try {
+            mkdirSync(this.pidDir, { recursive: true });
+            const metadata = {
+                pid: record.pid,
+                command: record.command,
+                cwd: record.cwd,
+                label: record.label,
+                fullOutputPath: record.fullOutputPath,
+                definitionId: record.definitionId,
+            };
+            writeFileSync(this.pidfilePath(id), JSON.stringify(metadata), "utf8");
+        }
+        catch {
+            // Pidfiles are best-effort metadata; never break a background job
+            // because the dev-processes directory could not be written.
+        }
+    }
+    readPidfile(id) {
+        try {
+            const raw = readFileSync(this.pidfilePath(id), "utf8").trim();
+            if (!raw)
+                return null;
+            if (raw.startsWith("{")) {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed.pid === "number" &&
+                    Number.isInteger(parsed.pid) &&
+                    parsed.pid > 0) {
+                    return parsed;
+                }
+                return null;
+            }
+            // Backwards-compatible Phase 1 pidfiles contained a bare PID.
+            const pid = Number(raw);
+            return Number.isInteger(pid) && pid > 0 ? { pid } : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    removePidfile(id) {
+        try {
+            unlinkSync(this.pidfilePath(id));
+        }
+        catch {
+            // Already gone is fine.
+        }
+    }
+    isPidAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (err) {
+            return err.code !== "ESRCH";
+        }
+    }
+}

package/dist/server/handlers/dev-processes.d.ts

@@ -0,0 +1,49 @@
+import type { DevProcessRegistry, DevProcessSummary } from "../dev-process-registry.js";
+import type { SessionStore } from "../storage.js";
+import type { DetectedDevServer } from "../wire.js";
+/**
+ * `GET /api/dev-processes` — list machine-level background dev processes.
+ *
+ * Returns an empty list when the registry has not been constructed yet (tests
+ * or a minimal serve setup), matching the MCP-status handler's defensive
+ * no-op pattern.
+ */
+export declare function handleListDevProcesses(registry: DevProcessRegistry | undefined): Promise<DevProcessSummary[]>;
+/**
+ * `DELETE /api/dev-processes/:id` — kill a machine-level dev process.
+ *
+ * Throws `NotFoundError` (404) when the process is not tracked by the
+ * registry, so the relay dispatcher can return the canonical error payload.
+ */
+export declare function handleKillDevProcess(registry: DevProcessRegistry | undefined, id: string): {
+    ok: true;
+};
+/**
+ * `POST /api/dev-processes` — persist a dev-server definition and spawn it.
+ *
+ * Security model for the MVP: `cwd` must be an absolute directory that is
+ * either a known project path or resolves under the serve cwd. `command` must
+ * have no shell metacharacters AND must either be an already-persisted
+ * definition or match a fixed allow-list of dev commands.
+ */
+export declare function handleStartDevProcess(registry: DevProcessRegistry | undefined, store: SessionStore, body: Record<string, unknown>, serveCwd?: string): DevProcessSummary;
+/**
+ * `POST /api/dev-processes/:id/restart` — kill a dev process and re-spawn it
+ * from the definition captured by its live record.
+ */
+export declare function handleRestartDevProcess(registry: DevProcessRegistry | undefined, id: string): DevProcessSummary;
+/**
+ * `GET /api/dev-servers` — scan the machine's listening TCP ports and match
+ * them against known projects. Includes servers the agent did not start.
+ */
+export declare function handleScanDevServers(store: SessionStore, registry?: DevProcessRegistry): Promise<DetectedDevServer[]>;
+/**
+ * `DELETE /api/dev-servers/:pid` — kill a detected dev server.
+ *
+ * Only servers whose cwd resolves to a known project may be killed, mirroring
+ * the project-ownership guard used by the tracked dev-process handlers.
+ */
+export declare function handleKillDetectedDevServer(store: SessionStore, pid: number, port?: number): Promise<{
+    ok: true;
+}>;
+//# sourceMappingURL=dev-processes.d.ts.map

package/dist/server/handlers/dev-processes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-processes.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/dev-processes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,kBAAkB,EAClB,iBAAiB,EACjB,MAAM,4BAA4B,CAAC;AAMpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAmGpD;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC3C,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACtC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAG9B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,EACxC,EAAE,EAAE,MAAM,GACR;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAKd;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,EACxC,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,QAAQ,CAAC,EAAE,MAAM,GACf,iBAAiB,CA+BnB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,EACxC,EAAE,EAAE,MAAM,GACR,iBAAiB,CASnB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACzC,KAAK,EAAE,YAAY,EACnB,QAAQ,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAkB9B;AAED;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAChD,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC,CA8BvB"}

package/dist/server/handlers/dev-processes.js

@@ -0,0 +1,200 @@
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { findProjectForCwd, listDetectedDevServers, resolvePidCwd, } from "../dev-port-detection.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
+const ALLOWED_COMMAND_PREFIXES = [
+    "npm run dev",
+    "npm run start",
+    "npm start",
+    "pnpm dev",
+    "pnpm start",
+    "yarn dev",
+    "yarn start",
+    "bun dev",
+    "bun start",
+    "deno task dev",
+    "cargo run",
+    "go run",
+    "make dev",
+    "python manage.py runserver",
+];
+function hasShellMetacharacters(command) {
+    return (/[;&|`><\r\n]/.test(command) ||
+        command.includes("$(") ||
+        command.includes("${"));
+}
+function isAllowedCommand(command) {
+    return ALLOWED_COMMAND_PREFIXES.some((prefix) => command === prefix || command.startsWith(`${prefix} `));
+}
+function killDetectedServerProcess(pid) {
+    try {
+        if (process.platform === "win32") {
+            process.kill(pid);
+        }
+        else {
+            process.kill(pid, "SIGTERM");
+        }
+    }
+    catch {
+        // Process already exited.
+    }
+}
+function validateCwd(rawCwd, store, serveCwd) {
+    if (typeof rawCwd !== "string" || rawCwd.trim() === "") {
+        throw new BadRequestError("Invalid cwd");
+    }
+    if (!isAbsolute(rawCwd)) {
+        throw new BadRequestError("Invalid cwd");
+    }
+    const resolved = resolve(rawCwd);
+    try {
+        if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+            throw new BadRequestError("Invalid cwd");
+        }
+    }
+    catch (err) {
+        if (err instanceof BadRequestError)
+            throw err;
+        throw new BadRequestError("Invalid cwd");
+    }
+    const isKnownProject = store
+        .listProjects()
+        .some((project) => resolve(project.path) === resolved);
+    if (isKnownProject)
+        return resolved;
+    if (serveCwd) {
+        const base = resolve(serveCwd);
+        const rel = relative(base, resolved);
+        if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))) {
+            return resolved;
+        }
+    }
+    throw new BadRequestError("Invalid cwd");
+}
+function validateCommand(command, store, cwd) {
+    if (typeof command !== "string" || command.trim() === "") {
+        throw new BadRequestError("command is required");
+    }
+    if (hasShellMetacharacters(command)) {
+        throw new BadRequestError("Invalid command");
+    }
+    const persisted = store.getDevProcessDefinitionByCommand(cwd, command);
+    if (!persisted && !isAllowedCommand(command)) {
+        throw new BadRequestError("Invalid command");
+    }
+    return command;
+}
+/**
+ * `GET /api/dev-processes` — list machine-level background dev processes.
+ *
+ * Returns an empty list when the registry has not been constructed yet (tests
+ * or a minimal serve setup), matching the MCP-status handler's defensive
+ * no-op pattern.
+ */
+export async function handleListDevProcesses(registry) {
+    await registry?.refreshPorts();
+    return registry?.list() ?? [];
+}
+/**
+ * `DELETE /api/dev-processes/:id` — kill a machine-level dev process.
+ *
+ * Throws `NotFoundError` (404) when the process is not tracked by the
+ * registry, so the relay dispatcher can return the canonical error payload.
+ */
+export function handleKillDevProcess(registry, id) {
+    if (!registry || !registry.kill(id)) {
+        throw new NotFoundError(`Dev process ${id} not found`);
+    }
+    return { ok: true };
+}
+/**
+ * `POST /api/dev-processes` — persist a dev-server definition and spawn it.
+ *
+ * Security model for the MVP: `cwd` must be an absolute directory that is
+ * either a known project path or resolves under the serve cwd. `command` must
+ * have no shell metacharacters AND must either be an already-persisted
+ * definition or match a fixed allow-list of dev commands.
+ */
+export function handleStartDevProcess(registry, store, body, serveCwd) {
+    if (!registry) {
+        throw new BadRequestError("Dev process registry unavailable");
+    }
+    const cwd = validateCwd(body.cwd, store, serveCwd);
+    const command = validateCommand(body.command, store, cwd);
+    const label = typeof body.label === "string" && body.label.trim() !== ""
+        ? body.label.trim()
+        : undefined;
+    const project = store
+        .listProjects()
+        .find((candidate) => resolve(candidate.path) === cwd);
+    const persisted = store.getDevProcessDefinitionByCommand(cwd, command);
+    const definition = persisted ??
+        store.createDevProcessDefinition({
+            projectId: project?.id ?? null,
+            label: label ?? command,
+            command,
+            cwd,
+        });
+    return registry.spawnDaemon({
+        definitionId: definition.id,
+        label: label ?? definition.label,
+        command,
+        cwd,
+    });
+}
+/**
+ * `POST /api/dev-processes/:id/restart` — kill a dev process and re-spawn it
+ * from the definition captured by its live record.
+ */
+export function handleRestartDevProcess(registry, id) {
+    if (!registry) {
+        throw new NotFoundError(`Dev process ${id} not found`);
+    }
+    const restarted = registry.restart(id);
+    if (!restarted) {
+        throw new NotFoundError(`Dev process ${id} not found`);
+    }
+    return restarted;
+}
+/**
+ * `GET /api/dev-servers` — scan the machine's listening TCP ports and match
+ * them against known projects. Includes servers the agent did not start.
+ */
+export async function handleScanDevServers(store, registry) {
+    const servers = await listDetectedDevServers(store.listProjects());
+    if (!registry)
+        return servers;
+    const trackedPids = new Set(registry
+        .list()
+        .filter((process) => process.status === "running" || process.status === "recovered")
+        .map((process) => process.pid)
+        .filter((pid) => typeof pid === "number"));
+    return servers.filter((server) => server.pid === null || !trackedPids.has(server.pid));
+}
+/**
+ * `DELETE /api/dev-servers/:pid` — kill a detected dev server.
+ *
+ * Only servers whose cwd resolves to a known project may be killed, mirroring
+ * the project-ownership guard used by the tracked dev-process handlers.
+ */
+export async function handleKillDetectedDevServer(store, pid, port) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        throw new BadRequestError("Invalid pid");
+    }
+    const servers = await listDetectedDevServers(store.listProjects());
+    const match = servers.find((server) => server.pid === pid &&
+        (port === undefined || !Number.isFinite(port) || server.port === port));
+    if (!match) {
+        throw new NotFoundError(`Dev server with pid ${pid} not found`);
+    }
+    if (!match.projectId || !match.cwd) {
+        throw new BadRequestError("Only dev servers belonging to a known project can be killed");
+    }
+    const currentCwd = await resolvePidCwd(pid);
+    const currentProject = findProjectForCwd(currentCwd, store.listProjects());
+    if (!currentProject) {
+        throw new BadRequestError("Server process changed or is no longer tied to a known project");
+    }
+    killDetectedServerProcess(pid);
+    return { ok: true };
+}