driggsby 0.1.11 → 0.1.13

package/dist/broker/client.js

@@ -1,148 +0,0 @@
-import { randomUUID } from "node:crypto";
-import net from "node:net";
-import { readBrokerMetadata, readBrokerLocalAuthToken } from "./installation.js";
-import { decodeResponse, encodeRequest } from "./ipc.js";
-import { hashBrokerPayload, verifyBrokerProof } from "./authentication.js";
-export async function pingBroker(options) {
-    const response = await sendBrokerRequest(options, "ping");
-    if (response?.ok !== true) {
-        return null;
-    }
-    return response.result;
-}
-export async function getBrokerStatus(options) {
-    const response = await sendBrokerRequest(options, "get_status");
-    if (response?.ok !== true) {
-        return null;
-    }
-    return response.result.status;
-}
-export async function shutdownBroker(options) {
-    const response = await sendBrokerRequest(options, "shutdown");
-    return response?.ok === true && response.result.stopped;
-}
-export async function listBrokerTools(options) {
-    const response = await sendBrokerRequest(options, "list_tools");
-    if (response === null) {
-        return null;
-    }
-    if (!response.ok) {
-        throw new Error(response.error);
-    }
-    return response.result;
-}
-export async function callBrokerTool(options, toolName, args) {
-    const response = await sendBrokerRequest(options, "call_tool", {
-        toolName,
-        ...(args === undefined ? {} : { args }),
-    });
-    if (response === null) {
-        return null;
-    }
-    if (!response.ok) {
-        throw new Error(response.error);
-    }
-    return response.result;
-}
-async function sendBrokerRequest(options, method, extraFields) {
-    const metadata = await readBrokerMetadata(options.runtimePaths);
-    if (metadata === null) {
-        return null;
-    }
-    const authToken = await readBrokerLocalAuthToken(options.secretStore, metadata.brokerId);
-    if (authToken === null) {
-        return null;
-    }
-    const challenge = randomUUID();
-    const request = buildBrokerRequest(method, authToken, challenge, extraFields);
-    const response = await new Promise((resolve) => {
-        const socket = net.createConnection(options.runtimePaths.socketPath);
-        let buffer = "";
-        let settled = false;
-        const settle = (value) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            resolve(value);
-        };
-        socket.setEncoding("utf8");
-        socket.setTimeout(1_500);
-        socket.once("connect", () => {
-            socket.write(encodeRequest(request));
-        });
-        socket.on("data", (chunk) => {
-            buffer += chunk;
-            const newlineIndex = buffer.indexOf("\n");
-            if (newlineIndex < 0) {
-                return;
-            }
-            const message = buffer.slice(0, newlineIndex);
-            try {
-                settle(decodeResponse(message));
-            }
-            catch {
-                settle(null);
-            }
-            finally {
-                socket.end();
-            }
-        });
-        socket.once("timeout", () => {
-            settle(null);
-            socket.destroy();
-        });
-        socket.once("error", () => {
-            settle(null);
-        });
-        socket.once("end", () => {
-            if (buffer.length === 0) {
-                settle(null);
-            }
-        });
-    });
-    if (response === null) {
-        return null;
-    }
-    const expectedClaims = buildExpectedClaims(request, response, metadata.brokerId);
-    const proofValid = await verifyBrokerProof(response.brokerProof, metadata.dpop.publicJwk, expectedClaims);
-    return proofValid ? response : null;
-}
-function buildBrokerRequest(method, authToken, challenge, extraFields) {
-    const baseRequest = {
-        authToken,
-        challenge,
-        id: randomUUID(),
-    };
-    if (method === "call_tool") {
-        const toolRequest = {
-            ...baseRequest,
-            method,
-            toolName: extraFields?.toolName ?? "",
-        };
-        if (extraFields?.args !== undefined) {
-            return {
-                ...toolRequest,
-                args: extraFields.args,
-            };
-        }
-        return toolRequest;
-    }
-    return {
-        ...baseRequest,
-        method,
-    };
-}
-function buildExpectedClaims(request, response, brokerId) {
-    const payload = response.ok
-        ? { ok: true, result: response.result }
-        : { ok: false, error: response.error };
-    return {
-        aud: "driggsby-local-shim",
-        challenge: request.challenge,
-        payloadSha256: hashBrokerPayload(payload),
-        requestId: request.id,
-        requestMethod: request.method,
-        sub: brokerId,
-    };
-}

package/dist/broker/daemon.js

@@ -1,65 +0,0 @@
-import { buildBrokerStatus, ensureBrokerInstallation, readBrokerDpopKeyPair, readBrokerLocalAuthToken, readBrokerPrivateJwk, } from "./installation.js";
-import { BrokerRemoteSessionManager } from "./remote-session.js";
-import { callRemoteTool, listRemoteTools } from "./remote-mcp.js";
-import { resolveSecretStore } from "./resolve-secret-store.js";
-import { LocalBrokerServer } from "./server.js";
-import { buildReauthenticationRequiredMessage } from "../lib/user-guidance.js";
-export async function runBrokerDaemon(runtimePaths) {
-    const secretStore = (await resolveSecretStore(runtimePaths)).store;
-    const metadata = await ensureBrokerInstallation(runtimePaths, secretStore);
-    const localAuthToken = await readRequiredLocalAuthToken(secretStore, metadata.brokerId);
-    const privateJwk = await readRequiredPrivateJwk(secretStore, metadata.brokerId);
-    const dpopKeyPair = await readRequiredDpopKeyPair(runtimePaths, secretStore, metadata.brokerId);
-    const remoteSessionManager = new BrokerRemoteSessionManager({
-        brokerId: metadata.brokerId,
-        runtimePaths,
-        secretStore,
-    });
-    const server = new LocalBrokerServer({
-        brokerId: metadata.brokerId,
-        callTool: async (toolName, args) => {
-            const session = await remoteSessionManager.ensureFreshSession();
-            return await callRemoteTool(session, dpopKeyPair, toolName, args);
-        },
-        localAuthToken,
-        listTools: async () => {
-            const session = await remoteSessionManager.ensureFreshSession();
-            return await listRemoteTools(session, dpopKeyPair);
-        },
-        privateJwk,
-        runtimePaths,
-        statusProvider: async () => await buildBrokerStatus(runtimePaths, secretStore, true),
-    });
-    await server.listen();
-    await new Promise((resolve, reject) => {
-        const shutdown = () => {
-            void server
-                .close()
-                .then(resolve)
-                .catch(reject);
-        };
-        process.once("SIGINT", shutdown);
-        process.once("SIGTERM", shutdown);
-    });
-}
-async function readRequiredLocalAuthToken(secretStore, brokerId) {
-    const localAuthToken = await readBrokerLocalAuthToken(secretStore, brokerId);
-    if (localAuthToken === null) {
-        throw new Error(buildReauthenticationRequiredMessage("The local broker auth state is incomplete"));
-    }
-    return localAuthToken;
-}
-async function readRequiredPrivateJwk(secretStore, brokerId) {
-    const privateJwkRaw = await readBrokerPrivateJwk(secretStore, brokerId);
-    if (privateJwkRaw === null) {
-        throw new Error(buildReauthenticationRequiredMessage("The local broker signing key is missing"));
-    }
-    return JSON.parse(privateJwkRaw);
-}
-async function readRequiredDpopKeyPair(runtimePaths, secretStore, brokerId) {
-    const dpopKeyPair = await readBrokerDpopKeyPair(runtimePaths, secretStore, brokerId);
-    if (dpopKeyPair === null) {
-        throw new Error(buildReauthenticationRequiredMessage("The local broker DPoP key is missing"));
-    }
-    return dpopKeyPair;
-}

package/dist/broker/file-secret-store.js

@@ -1,130 +0,0 @@
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { readJsonFile, removeFileIfPresent, writeJsonFile, } from "../lib/json-file.js";
-const FILE_SECRET_KEY_BYTES = 32;
-const FILE_SECRET_STORE_INCOMPLETE_MESSAGE = "The local Driggsby file-backed secret store is incomplete. Run `driggsby logout` and then `driggsby login`.";
-const FILE_SECRET_STORE_INVALID_MESSAGE = "The local Driggsby file-backed secret store is invalid. Run `driggsby logout` and then `driggsby login`.";
-const FILE_SECRET_STORE_SCHEMA_VERSION = 1;
-const FILE_SECRET_IV_BYTES = 12;
-export class FileSecretStore {
-    encryptionKeyPath;
-    secretsPath;
-    constructor(runtimePaths) {
-        this.encryptionKeyPath = path.join(runtimePaths.stateDir, "broker-secrets.key");
-        this.secretsPath = path.join(runtimePaths.configDir, "broker-secrets.json");
-    }
-    async hasStoredSecrets() {
-        const storedSecrets = await this.readStoredSecretsFile();
-        return Object.keys(storedSecrets?.secrets ?? {}).length > 0;
-    }
-    async setSecret(account, secret) {
-        const encryptionKey = await this.readOrCreateEncryptionKey();
-        const storedSecrets = (await this.readStoredSecretsFile()) ?? {
-            schemaVersion: FILE_SECRET_STORE_SCHEMA_VERSION,
-            secrets: {},
-        };
-        storedSecrets.secrets[account] = encryptSecret(secret, encryptionKey);
-        await writeJsonFile(this.secretsPath, storedSecrets);
-    }
-    async getSecret(account) {
-        const storedSecrets = await this.readStoredSecretsFile();
-        const encryptedSecret = storedSecrets?.secrets[account];
-        if (encryptedSecret === undefined) {
-            return null;
-        }
-        const encryptionKey = await this.readEncryptionKey(true);
-        if (encryptionKey === null) {
-            throw new Error(FILE_SECRET_STORE_INCOMPLETE_MESSAGE);
-        }
-        return decryptSecret(encryptedSecret, encryptionKey);
-    }
-    async deleteSecret(account) {
-        const storedSecrets = await this.readStoredSecretsFile();
-        if (storedSecrets?.secrets[account] === undefined) {
-            return false;
-        }
-        const remainingSecrets = Object.fromEntries(Object.entries(storedSecrets.secrets).filter(([storedAccount]) => storedAccount !== account));
-        if (Object.keys(remainingSecrets).length === 0) {
-            await Promise.all([
-                removeFileIfPresent(this.secretsPath),
-                removeFileIfPresent(this.encryptionKeyPath),
-            ]);
-            return true;
-        }
-        await writeJsonFile(this.secretsPath, {
-            ...storedSecrets,
-            secrets: remainingSecrets,
-        });
-        return true;
-    }
-    async readStoredSecretsFile() {
-        return await readJsonFile(this.secretsPath);
-    }
-    async readEncryptionKey(errorIfMissing) {
-        try {
-            const encodedKey = await fs.readFile(this.encryptionKeyPath, "utf8");
-            const encryptionKey = Buffer.from(encodedKey.trim(), "base64");
-            if (encryptionKey.length !== FILE_SECRET_KEY_BYTES) {
-                throw new Error(FILE_SECRET_STORE_INVALID_MESSAGE);
-            }
-            return encryptionKey;
-        }
-        catch (error) {
-            if (!errorIfMissing &&
-                error instanceof Error &&
-                "code" in error &&
-                error.code === "ENOENT") {
-                return null;
-            }
-            if (errorIfMissing &&
-                error instanceof Error &&
-                "code" in error &&
-                error.code === "ENOENT") {
-                throw new Error(FILE_SECRET_STORE_INCOMPLETE_MESSAGE);
-            }
-            throw error;
-        }
-    }
-    async readOrCreateEncryptionKey() {
-        const existingKey = await this.readEncryptionKey(false);
-        if (existingKey !== null) {
-            return existingKey;
-        }
-        await fs.mkdir(path.dirname(this.secretsPath), {
-            recursive: true,
-            mode: 0o700,
-        });
-        await fs.mkdir(path.dirname(this.encryptionKeyPath), {
-            recursive: true,
-            mode: 0o700,
-        });
-        const encryptionKey = randomBytes(FILE_SECRET_KEY_BYTES);
-        await fs.writeFile(this.encryptionKeyPath, encryptionKey.toString("base64"), {
-            encoding: "utf8",
-            mode: 0o600,
-        });
-        return encryptionKey;
-    }
-}
-function encryptSecret(secret, encryptionKey) {
-    const iv = randomBytes(FILE_SECRET_IV_BYTES);
-    const cipher = createCipheriv("aes-256-gcm", encryptionKey, iv);
-    const ciphertext = Buffer.concat([
-        cipher.update(secret, "utf8"),
-        cipher.final(),
-    ]);
-    return {
-        authTagBase64: cipher.getAuthTag().toString("base64"),
-        ciphertextBase64: ciphertext.toString("base64"),
-        ivBase64: iv.toString("base64"),
-    };
-}
-function decryptSecret(encryptedSecret, encryptionKey) {
-    const decipher = createDecipheriv("aes-256-gcm", encryptionKey, Buffer.from(encryptedSecret.ivBase64, "base64"));
-    decipher.setAuthTag(Buffer.from(encryptedSecret.authTagBase64, "base64"));
-    return Buffer.concat([
-        decipher.update(Buffer.from(encryptedSecret.ciphertextBase64, "base64")),
-        decipher.final(),
-    ]).toString("utf8");
-}

package/dist/broker/installation.js

@@ -1,154 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { promises as fs } from "node:fs";
-import { generateDpopKeyMaterial } from "../auth/dpop.js";
-import { readJsonFile, removeFileIfPresent, writeJsonFile } from "../lib/json-file.js";
-import { generateLocalAuthToken } from "./authentication.js";
-import { inspectRemoteSessionReadiness } from "./remote-session.js";
-import { buildNotConnectedReadiness } from "./remote-session.js";
-import { clearBrokerRemoteSession, readBrokerRemoteSession, } from "./session.js";
-const LOCAL_AUTH_TOKEN_ACCOUNT_SUFFIX = "local-auth-token";
-const PRIVATE_KEY_ACCOUNT_SUFFIX = "dpop-private-jwk";
-export async function ensureBrokerInstallation(runtimePaths, secretStore) {
-    const readiness = await inspectBrokerReadiness(runtimePaths, secretStore);
-    if (readiness.installed && readiness.privateKeyPresent) {
-        const metadata = await readBrokerMetadata(runtimePaths);
-        if (metadata !== null) {
-            return metadata;
-        }
-    }
-    const brokerId = randomUUID();
-    const dpop = await generateDpopKeyMaterial();
-    const metadata = {
-        schemaVersion: 1,
-        brokerId,
-        createdAt: new Date().toISOString(),
-        dpop: {
-            algorithm: dpop.algorithm,
-            publicJwk: dpop.publicJwk,
-            thumbprint: dpop.thumbprint,
-        },
-    };
-    await secretStore.setSecret(localAuthTokenAccountName(brokerId), generateLocalAuthToken());
-    await secretStore.setSecret(privateKeyAccountName(brokerId), JSON.stringify(dpop.privateJwk));
-    await writeJsonFile(runtimePaths.metadataPath, metadata);
-    return metadata;
-}
-export async function inspectBrokerReadiness(runtimePaths, secretStore) {
-    const metadata = await readBrokerMetadata(runtimePaths);
-    if (metadata === null) {
-        return {
-            installed: false,
-            localAuthTokenPresent: false,
-            privateKeyPresent: false,
-            remoteSessionPresent: false,
-        };
-    }
-    const localAuthTokenPresent = (await secretStore.getSecret(localAuthTokenAccountName(metadata.brokerId))) !== null;
-    const privateKeyPresent = (await secretStore.getSecret(privateKeyAccountName(metadata.brokerId))) !== null;
-    const remoteSessionPresent = (await readBrokerRemoteSession(secretStore, metadata.brokerId)) !== null;
-    return {
-        installed: localAuthTokenPresent && privateKeyPresent,
-        brokerId: metadata.brokerId,
-        dpopThumbprint: metadata.dpop.thumbprint,
-        localAuthTokenPresent,
-        privateKeyPresent,
-        remoteSessionPresent,
-    };
-}
-export async function buildBrokerStatus(runtimePaths, secretStore, brokerRunning) {
-    const readiness = await inspectBrokerReadiness(runtimePaths, secretStore);
-    const remoteReadiness = readiness.brokerId === undefined
-        ? buildNotConnectedReadiness()
-        : await inspectRemoteSessionReadiness({
-            brokerId: readiness.brokerId,
-            refreshIfNeeded: true,
-            runtimePaths,
-            secretStore,
-        });
-    const status = {
-        installed: readiness.installed && readiness.privateKeyPresent,
-        brokerRunning,
-        ...(remoteReadiness.nextStepCommand === undefined
-            ? {}
-            : { nextStepCommand: remoteReadiness.nextStepCommand }),
-        remoteAccessDetail: remoteReadiness.detail,
-        remoteAccessState: remoteReadiness.state,
-        remoteMcpReady: remoteReadiness.ready,
-        socketPath: runtimePaths.socketPath,
-        ...(readiness.brokerId === undefined ? {} : { brokerId: readiness.brokerId }),
-        ...(readiness.dpopThumbprint === undefined
-            ? {}
-            : { dpopThumbprint: readiness.dpopThumbprint }),
-        ...(remoteReadiness.session === undefined
-            ? {}
-            : { remoteSession: remoteReadiness.session }),
-    };
-    return status;
-}
-export async function resolveBrokerStatusForDisplay(runtimePaths, secretStore, liveStatus) {
-    const brokerRunning = liveStatus !== null;
-    if (hasActionableRemoteStatus(liveStatus)) {
-        return liveStatus;
-    }
-    return await buildBrokerStatus(runtimePaths, secretStore, brokerRunning);
-}
-export async function clearBrokerInstallation(runtimePaths, secretStore) {
-    const metadata = await readBrokerMetadata(runtimePaths);
-    if (metadata !== null) {
-        await clearBrokerRemoteSession(secretStore, metadata.brokerId);
-        await secretStore.deleteSecret(localAuthTokenAccountName(metadata.brokerId));
-        await secretStore.deleteSecret(privateKeyAccountName(metadata.brokerId));
-    }
-    await removeFileIfPresent(runtimePaths.metadataPath);
-    if (process.platform !== "win32") {
-        await removeFileIfPresent(runtimePaths.socketPath);
-    }
-    await removeEmptyDirectory(runtimePaths.configDir);
-    await removeEmptyDirectory(runtimePaths.stateDir);
-}
-export async function readBrokerMetadata(runtimePaths) {
-    return await readJsonFile(runtimePaths.metadataPath);
-}
-export async function readBrokerLocalAuthToken(secretStore, brokerId) {
-    return await secretStore.getSecret(localAuthTokenAccountName(brokerId));
-}
-export async function readBrokerPrivateJwk(secretStore, brokerId) {
-    return await secretStore.getSecret(privateKeyAccountName(brokerId));
-}
-export async function readBrokerDpopKeyPair(runtimePaths, secretStore, brokerId) {
-    const metadata = await readBrokerMetadata(runtimePaths);
-    if (metadata?.brokerId !== brokerId) {
-        return null;
-    }
-    const privateJwkRaw = await readBrokerPrivateJwk(secretStore, brokerId);
-    if (privateJwkRaw === null) {
-        return null;
-    }
-    return {
-        privateJwk: JSON.parse(privateJwkRaw),
-        publicJwk: metadata.dpop.publicJwk,
-    };
-}
-function localAuthTokenAccountName(brokerId) {
-    return `${brokerId}:${LOCAL_AUTH_TOKEN_ACCOUNT_SUFFIX}`;
-}
-function privateKeyAccountName(brokerId) {
-    return `${brokerId}:${PRIVATE_KEY_ACCOUNT_SUFFIX}`;
-}
-async function removeEmptyDirectory(directoryPath) {
-    try {
-        await fs.rmdir(directoryPath);
-    }
-    catch (error) {
-        if (!(error instanceof Error) ||
-            !("code" in error) ||
-            (error.code !== "ENOENT" && error.code !== "ENOTEMPTY")) {
-            throw error;
-        }
-    }
-}
-function hasActionableRemoteStatus(status) {
-    return (status !== null &&
-        typeof status.remoteAccessDetail === "string" &&
-        typeof status.remoteAccessState === "string");
-}

package/dist/broker/ipc.js

@@ -1,12 +0,0 @@
-export function encodeRequest(request) {
-    return `${JSON.stringify(request)}\n`;
-}
-export function decodeResponse(raw) {
-    return JSON.parse(raw);
-}
-export function decodeRequest(raw) {
-    return JSON.parse(raw);
-}
-export function encodeResponse(response) {
-    return `${JSON.stringify(response)}\n`;
-}

package/dist/broker/keyring-secret-store.js

@@ -1,34 +0,0 @@
-import { randomBytes } from "node:crypto";
-export class KeyringSecretStore {
-    serviceName;
-    constructor(serviceName = "driggsby.local-broker") {
-        this.serviceName = serviceName;
-    }
-    async isAvailable() {
-        try {
-            const AsyncEntry = await loadAsyncEntry();
-            await new AsyncEntry(this.serviceName, `driggsby-probe-${randomBytes(12).toString("hex")}`).getPassword();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async setSecret(account, secret) {
-        const AsyncEntry = await loadAsyncEntry();
-        await new AsyncEntry(this.serviceName, account).setPassword(secret);
-    }
-    async getSecret(account) {
-        const AsyncEntry = await loadAsyncEntry();
-        const secret = await new AsyncEntry(this.serviceName, account).getPassword();
-        return secret ?? null;
-    }
-    async deleteSecret(account) {
-        const AsyncEntry = await loadAsyncEntry();
-        return await new AsyncEntry(this.serviceName, account).deleteCredential();
-    }
-}
-async function loadAsyncEntry() {
-    const keyringModule = await import("@napi-rs/keyring");
-    return keyringModule.AsyncEntry;
-}

package/dist/broker/launch.js

@@ -1,35 +0,0 @@
-import { spawn } from "node:child_process";
-import { setTimeout as sleep } from "node:timers/promises";
-import { buildBrokerInvestigationMessage } from "../lib/user-guidance.js";
-import { getBrokerStatus, pingBroker } from "./client.js";
-export async function ensureBrokerRunning(options) {
-    if ((await pingBroker({
-        runtimePaths: options.runtimePaths,
-        secretStore: options.secretStore,
-    })) !== null) {
-        return;
-    }
-    spawnBrokerDaemon(options.entrypointPath);
-    const started = await waitForBroker(options.runtimePaths, options.secretStore, 4_000);
-    if (!started) {
-        throw new Error(buildBrokerInvestigationMessage("The local Driggsby broker did not start cleanly"));
-    }
-}
-export async function waitForBroker(runtimePaths, secretStore, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if ((await getBrokerStatus({ runtimePaths, secretStore })) !== null) {
-            return true;
-        }
-        await sleep(100);
-    }
-    return false;
-}
-function spawnBrokerDaemon(entrypointPath) {
-    const child = spawn(process.execPath, [...process.execArgv, entrypointPath, "broker-daemon"], {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
-    });
-    child.unref();
-}

package/dist/broker/lock.js

@@ -1,84 +0,0 @@
-import { promises as fs } from "node:fs";
-export async function acquireBrokerLock(lockPath) {
-    const initialHandle = await tryOpenExclusive(lockPath);
-    if (initialHandle !== null) {
-        return await createLease(lockPath, initialHandle);
-    }
-    if (!(await removeStaleLock(lockPath))) {
-        return null;
-    }
-    const recoveredHandle = await tryOpenExclusive(lockPath);
-    if (recoveredHandle === null) {
-        return null;
-    }
-    return await createLease(lockPath, recoveredHandle);
-}
-async function createLease(lockPath, handle) {
-    let released = false;
-    await handle.truncate(0);
-    await handle.writeFile(JSON.stringify({ pid: process.pid }));
-    return {
-        async release() {
-            if (released) {
-                return;
-            }
-            released = true;
-            await handle.close();
-            await removeFileIfPresent(lockPath);
-        },
-    };
-}
-async function tryOpenExclusive(lockPath) {
-    try {
-        return await fs.open(lockPath, "wx", 0o600);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "EEXIST") {
-            return null;
-        }
-        throw error;
-    }
-}
-async function removeStaleLock(lockPath) {
-    const stalePid = await readLockPid(lockPath);
-    if (stalePid === null || processAlive(stalePid)) {
-        return false;
-    }
-    await removeFileIfPresent(lockPath);
-    return true;
-}
-async function readLockPid(lockPath) {
-    try {
-        const contents = await fs.readFile(lockPath, "utf8");
-        const parsed = JSON.parse(contents);
-        return typeof parsed.pid === "number" ? parsed.pid : null;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return null;
-        }
-        return null;
-    }
-}
-function processAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function removeFileIfPresent(filePath) {
-    try {
-        await fs.rm(filePath);
-    }
-    catch (error) {
-        if (!(isErrnoException(error) && error.code === "ENOENT")) {
-            throw error;
-        }
-    }
-}
-function isErrnoException(error) {
-    return error instanceof Error && "code" in error;
-}