@tapicker/bridge 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tapicker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# Tapicker Bridge
+
+Tapicker Bridge connects external tools and AI agents to a Tapicker browser Extension. Use it to run and control Workflows, access extracted data, or receive Workflow status updates through the CLI, HTTP, or MCP.
+
+The Bridge routes commands; browser automation runs in the connected Tapicker Extension.
+
+## Quick Start
+
+**Requirements:** Node.js 22 or later and the Tapicker Extension installed in a supported browser.
+
+```bash
+npm install --global @tapicker/bridge
+tapicker bridge start
+```
+
+Keep the terminal open. Bridge prints a WebSocket endpoint and a four-digit pairing code. In the Extension, open **Settings > General**, enable **Bridge**, then click **Scan** or enter the endpoint and click **Connect**. Enter the pairing code when prompted.
+
+Copy a Workflow ID in Tapicker and run it:
+
+```bash
+tapicker workflow start <workflowId> --watch
+```
+
+Bridge listens on `127.0.0.1` by default and tries ports `9520`–`9530`. If it selects a port other than `9520`, pass the actual port with `--port` to CLI commands.
+
+## Learn the User Flows
+
+- [Getting Started](https://www.tapicker.com/docs/bridge-getting-started) — install Bridge, pair an Extension, and run your first Workflow.
+- [Control Workflows](https://www.tapicker.com/docs/bridge-workflows) — start, pause, resume, stop, and watch Workflows.
+- [Connect an AI Agent](https://www.tapicker.com/docs/bridge-ai-agents) — use MCP or the HTTP API.
+- [Remote Deployment](https://www.tapicker.com/docs/bridge-remote-deployment) — configure TLS and a Bearer Token.
+- [API Reference](https://www.tapicker.com/docs/bridge-reference) — CLI commands, HTTP endpoints, MCP tools, and status events.
+
+## Documentation in This Package
+
+- [CLI reference](docs/cli.md)
+- [HTTP API reference](docs/http-api.md)
+- [MCP setup and tools](docs/mcp.md)
+- [Pairing, configuration, and security](docs/operations.md)
+- [Workflow status WebSocket](docs/workflow-watch.md)
+
+## Security
+
+Keep Bridge on its default loopback address unless remote access is required. Local mode has no Bearer Token by default, and HTTP CORS defaults to `*`; restrict `--cors-origin` when browser pages should not access the local API. Non-loopback binding requires TLS and a Bearer Token.
+
+Bridge does not manage Tapicker accounts. See the [remote deployment guide](https://www.tapicker.com/docs/bridge-remote-deployment) before exposing it to a network.

package/dist/bridge/bridge-service.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'node:events';
+import type { WebSocket } from 'ws';
+import type { WorkflowStatusData } from '../protocol/schema.js';
+import { ExtensionSession } from './extension-session.js';
+import type { ExtensionSessionStatus } from './extension-session.js';
+import type { PairingStatePersistence } from './pairing-state.js';
+export type BridgeServiceOptions = {
+    pairingCode: string;
+    capabilities: string[];
+    pairingState?: PairingStatePersistence;
+};
+export type BridgeWorkflowStatusEvent = WorkflowStatusData & {
+    clientId: string;
+};
+export declare class BridgeService extends EventEmitter {
+    private readonly options;
+    private readonly sessions;
+    private readonly sessionsByClientId;
+    private readonly pairedCredentials;
+    private readonly pairingAttempts;
+    private pairingCode;
+    private pairingFailures;
+    private pairingLocked;
+    private pairingInProgress;
+    private initialization;
+    constructor(options: BridgeServiceOptions);
+    initialize(): Promise<void>;
+    attachExtension(socket: WebSocket, remoteAddress?: string): ExtensionSession;
+    sendCommand<T>(type: string, data: unknown, clientId?: string): Promise<T>;
+    sendCommandWithClientId<T>(type: string, data: unknown, clientId?: string): Promise<{
+        clientId: string;
+        result: Awaited<T>;
+    }>;
+    assertExtensionCapability(type: string, clientId: string): void;
+    resolveCommandClientId(type: string, clientId?: string): string;
+    private selectCommandSession;
+    getExtensionStatuses(): ExtensionSessionStatus[];
+    getPairingCode(): string | undefined;
+    refreshPairingCode(): string;
+    close(): void;
+    private verifyCredential;
+    private pair;
+    private rotatePairingCode;
+    private restorePairingState;
+}
+//# sourceMappingURL=bridge-service.d.ts.map

package/dist/bridge/bridge-service.js

@@ -0,0 +1,245 @@
+import { randomInt, randomUUID, timingSafeEqual } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { BridgeError } from '../errors.js';
+import { WorkflowStatusDataSchema } from '../protocol/schema.js';
+import { VERSION, PROTOCOL_VERSION } from '../constants.js';
+import { ExtensionSession } from './extension-session.js';
+const PAIRING_WINDOW_MS = 60_000;
+const MAX_PAIRING_ATTEMPTS_PER_IP = 5;
+const MAX_PAIRING_FAILURES_PER_CODE = 5;
+export class BridgeService extends EventEmitter {
+    options;
+    sessions = new Set();
+    sessionsByClientId = new Map();
+    pairedCredentials = new Map();
+    pairingAttempts = new Map();
+    pairingCode;
+    pairingFailures = 0;
+    pairingLocked = false;
+    pairingInProgress = false;
+    initialization;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.pairingCode = options.pairingCode;
+    }
+    initialize() {
+        if (!this.initialization) {
+            this.initialization = this.restorePairingState();
+        }
+        return this.initialization;
+    }
+    attachExtension(socket, remoteAddress = 'unknown') {
+        const session = new ExtensionSession(socket, {
+            bridgeVersion: VERSION,
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: this.options.capabilities,
+            remoteAddress,
+            verifyCredential: (clientId, credential) => this.verifyCredential(clientId, credential),
+            pair: (input, address) => this.pair(input, address),
+        });
+        this.sessions.add(session);
+        session.on('ready', (hello) => {
+            const previousSession = this.sessionsByClientId.get(hello.clientId);
+            this.sessionsByClientId.set(hello.clientId, session);
+            if (previousSession && previousSession !== session) {
+                previousSession.close(1000, 'Replaced by a newer connection for this Extension');
+            }
+            this.emit('extension.ready', hello);
+        });
+        session.on('message', (message) => {
+            const status = session.getStatus();
+            if (status.ready && status.clientId && message.type === 'workflow.status') {
+                const parsed = WorkflowStatusDataSchema.safeParse(message.data);
+                if (parsed.success) {
+                    this.emit('workflow.status', {
+                        clientId: status.clientId,
+                        ...parsed.data,
+                    });
+                }
+            }
+            this.emit('extension.message', message);
+        });
+        session.on('error', (error) => this.emit('extension.error', error));
+        session.on('close', (details) => {
+            this.sessions.delete(session);
+            const clientId = session.getStatus().clientId;
+            if (clientId && this.sessionsByClientId.get(clientId) === session) {
+                this.sessionsByClientId.delete(clientId);
+            }
+            this.emit('extension.close', details);
+        });
+        session.start();
+        return session;
+    }
+    async sendCommand(type, data, clientId) {
+        const session = this.selectCommandSession(type, clientId);
+        return session.request(type, data);
+    }
+    async sendCommandWithClientId(type, data, clientId) {
+        const session = this.selectCommandSession(type, clientId);
+        const selectedClientId = session.getStatus().clientId;
+        if (!selectedClientId) {
+            throw new BridgeError('ExtensionUnavailable', 'The selected Tapicker Extension has no client ID', { status: 503 });
+        }
+        return {
+            clientId: selectedClientId,
+            result: await session.request(type, data),
+        };
+    }
+    assertExtensionCapability(type, clientId) {
+        this.selectCommandSession(type, clientId);
+    }
+    resolveCommandClientId(type, clientId) {
+        const selectedClientId = this.selectCommandSession(type, clientId).getStatus().clientId;
+        if (!selectedClientId) {
+            throw new BridgeError('ExtensionUnavailable', 'The selected Tapicker Extension has no client ID', { status: 503 });
+        }
+        return selectedClientId;
+    }
+    selectCommandSession(type, clientId) {
+        const readySessions = [...this.sessionsByClientId.entries()].filter(([, session]) => {
+            const status = session.getStatus();
+            return status.connected && status.ready;
+        });
+        let session;
+        if (clientId) {
+            session = this.sessionsByClientId.get(clientId);
+            const status = session?.getStatus();
+            if (!status?.connected || !status.ready) {
+                throw new BridgeError('ExtensionNotConnected', `Tapicker Extension ${clientId} is not connected`, {
+                    status: 409,
+                    details: { clientId },
+                });
+            }
+        }
+        else if (readySessions.length === 0) {
+            throw new BridgeError('ExtensionUnavailable', 'No paired Tapicker Extension is connected', { status: 503 });
+        }
+        else if (readySessions.length > 1) {
+            throw new BridgeError('ClientIdRequired', 'Specify clientId when multiple Extensions are connected', {
+                status: 409,
+                details: {
+                    extensions: readySessions.map(([clientId, readySession]) => ({
+                        clientId,
+                        clientName: readySession.getStatus().clientName,
+                    })),
+                },
+            });
+        }
+        else {
+            session = readySessions[0]?.[1];
+        }
+        if (!session) {
+            throw new BridgeError('ExtensionUnavailable', 'No paired Tapicker Extension is connected', { status: 503 });
+        }
+        const status = session.getStatus();
+        if (!status.capabilities.includes(type)) {
+            throw new BridgeError('ExtensionCapabilityUnavailable', `Tapicker Extension does not support ${type}`, {
+                status: 409,
+                details: { clientId: status.clientId, clientName: status.clientName, command: type },
+            });
+        }
+        return session;
+    }
+    getExtensionStatuses() {
+        return [...this.sessions]
+            .map((session) => session.getStatus())
+            .filter((status) => status.connected)
+            .sort((left, right) => (left.clientName || '').localeCompare(right.clientName || ''));
+    }
+    getPairingCode() {
+        return this.pairingLocked ? undefined : this.pairingCode;
+    }
+    refreshPairingCode() {
+        if (this.pairingInProgress) {
+            throw new BridgeError('PairingUnavailable', 'An Extension is currently being paired; try again shortly', {
+                status: 409,
+            });
+        }
+        this.rotatePairingCode();
+        return this.pairingCode;
+    }
+    close() {
+        for (const session of this.sessions) {
+            session.close(1000, 'Bridge shutting down');
+        }
+        this.sessions.clear();
+        this.sessionsByClientId.clear();
+    }
+    verifyCredential(clientId, credential) {
+        const savedCredential = this.pairedCredentials.get(clientId);
+        if (!savedCredential)
+            return false;
+        return constantTimeEqual(credential, savedCredential);
+    }
+    async pair(input, remoteAddress) {
+        if (this.pairingLocked) {
+            throw new BridgeError('PairingRateLimited', 'Pairing is locked after too many incorrect codes; run tapicker bridge code --refresh locally', { status: 429, details: { refreshCommand: 'tapicker bridge code --refresh' } });
+        }
+        if (this.pairingInProgress) {
+            throw new BridgeError('PairingUnavailable', 'Another Extension is currently being paired', { status: 409 });
+        }
+        const now = Date.now();
+        for (const [address, attemptWindow] of this.pairingAttempts) {
+            if (now - attemptWindow.startedAt >= PAIRING_WINDOW_MS) {
+                this.pairingAttempts.delete(address);
+            }
+        }
+        const current = this.pairingAttempts.get(remoteAddress);
+        const window = !current || now - current.startedAt >= PAIRING_WINDOW_MS ? { startedAt: now, attempts: 0 } : current;
+        if (window.attempts >= MAX_PAIRING_ATTEMPTS_PER_IP) {
+            throw new BridgeError('PairingRateLimited', 'Too many pairing attempts; try again in one minute', {
+                status: 429,
+            });
+        }
+        window.attempts += 1;
+        this.pairingAttempts.set(remoteAddress, window);
+        if (!constantTimeEqual(input.pairingCode, this.pairingCode)) {
+            this.pairingFailures += 1;
+            if (this.pairingFailures >= MAX_PAIRING_FAILURES_PER_CODE) {
+                this.pairingLocked = true;
+                throw new BridgeError('PairingRateLimited', 'Pairing is locked after too many incorrect codes; run tapicker bridge code --refresh locally', { status: 429, details: { refreshCommand: 'tapicker bridge code --refresh' } });
+            }
+            throw new BridgeError('InvalidPairingCode', 'The pairing code is incorrect', { status: 401 });
+        }
+        this.pairingInProgress = true;
+        try {
+            const credential = randomUUID();
+            const identities = [...this.pairedCredentials.entries()]
+                .filter(([clientId]) => clientId !== input.clientId)
+                .map(([clientId, savedCredential]) => ({ clientId, credential: savedCredential }));
+            identities.push({ clientId: input.clientId, credential });
+            await this.options.pairingState?.save(identities);
+            this.pairedCredentials.set(input.clientId, credential);
+            this.rotatePairingCode();
+            return credential;
+        }
+        finally {
+            this.pairingInProgress = false;
+        }
+    }
+    rotatePairingCode() {
+        const previousCode = this.pairingCode;
+        do {
+            this.pairingCode = String(randomInt(0, 10_000)).padStart(4, '0');
+        } while (this.pairingCode === previousCode);
+        this.pairingFailures = 0;
+        this.pairingLocked = false;
+        this.pairingAttempts.clear();
+    }
+    async restorePairingState() {
+        const pairedIdentities = (await this.options.pairingState?.load()) ?? [];
+        for (const identity of pairedIdentities) {
+            this.pairedCredentials.set(identity.clientId, identity.credential);
+        }
+    }
+}
+function constantTimeEqual(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    if (leftBuffer.length !== rightBuffer.length)
+        return false;
+    return timingSafeEqual(leftBuffer, rightBuffer);
+}
+//# sourceMappingURL=bridge-service.js.map

package/dist/bridge/control.d.ts

@@ -0,0 +1,7 @@
+export type BridgeControlAction = 'code.get' | 'code.refresh' | 'extensions.list' | 'bridge.stop';
+export declare function getBridgeControlPath(dataDir: string): string;
+export declare function startBridgeControlServer(dataDir: string, handle: (action: BridgeControlAction) => Promise<unknown>): Promise<{
+    close(): Promise<void>;
+}>;
+export declare function sendBridgeControlRequest<T>(dataDir: string, action: BridgeControlAction): Promise<T>;
+//# sourceMappingURL=control.d.ts.map

package/dist/bridge/control.js

@@ -0,0 +1,211 @@
+import { createHash } from 'node:crypto';
+import { chmod, mkdir, unlink } from 'node:fs/promises';
+import { createConnection, createServer } from 'node:net';
+import { join, resolve } from 'node:path';
+import { BridgeError, toBridgeError } from '../errors.js';
+const CONTROL_ACTIONS = new Set(['code.get', 'code.refresh', 'extensions.list', 'bridge.stop']);
+const MAX_CONTROL_MESSAGE_BYTES = 4096;
+export function getBridgeControlPath(dataDir) {
+    const normalizedDataDir = resolve(dataDir);
+    if (process.platform === 'win32') {
+        const suffix = createHash('sha256').update(normalizedDataDir.toLowerCase()).digest('hex').slice(0, 24);
+        return `\\\\.\\pipe\\tapicker-bridge-${suffix}`;
+    }
+    return join(normalizedDataDir, 'bridge.sock');
+}
+export async function startBridgeControlServer(dataDir, handle) {
+    await mkdir(dataDir, { recursive: true, mode: 0o700 });
+    const endpoint = getBridgeControlPath(dataDir);
+    const server = createServer((socket) => handleControlSocket(socket, handle));
+    try {
+        await listenControlServer(server, endpoint);
+        if (process.platform !== 'win32') {
+            await chmod(endpoint, 0o600);
+        }
+    }
+    catch (error) {
+        await closeServer(server);
+        throw error;
+    }
+    return {
+        async close() {
+            await closeServer(server);
+            if (process.platform !== 'win32') {
+                await unlink(endpoint).catch((error) => {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                });
+            }
+        },
+    };
+}
+export async function sendBridgeControlRequest(dataDir, action) {
+    const endpoint = getBridgeControlPath(dataDir);
+    return new Promise((resolveResponse, rejectResponse) => {
+        const socket = createConnection(endpoint);
+        let buffer = '';
+        let settled = false;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            socket.destroy();
+            callback();
+        };
+        const timeout = setTimeout(() => {
+            finish(() => rejectResponse(new BridgeError('BridgeControlTimeout', 'Timed out communicating with Tapicker Bridge', { status: 504 })));
+        }, 3000);
+        socket.setEncoding('utf8');
+        socket.once('connect', () => socket.write(`${JSON.stringify({ action })}\n`));
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            if (Buffer.byteLength(buffer) > MAX_CONTROL_MESSAGE_BYTES) {
+                finish(() => rejectResponse(new BridgeError('InvalidBridgeControlResponse', 'Bridge control response is too large')));
+                return;
+            }
+            const newline = buffer.indexOf('\n');
+            if (newline < 0)
+                return;
+            let response;
+            try {
+                response = JSON.parse(buffer.slice(0, newline));
+            }
+            catch (cause) {
+                finish(() => rejectResponse(new BridgeError('InvalidBridgeControlResponse', 'Bridge returned an invalid control response', {
+                    status: 502,
+                    cause,
+                })));
+                return;
+            }
+            if (!response || typeof response !== 'object') {
+                finish(() => rejectResponse(new BridgeError('InvalidBridgeControlResponse', 'Bridge returned an invalid control response', {
+                    status: 502,
+                })));
+                return;
+            }
+            const result = response;
+            if (result.ok === true) {
+                finish(() => resolveResponse(result.data));
+                return;
+            }
+            const error = result.error;
+            finish(() => rejectResponse(new BridgeError(typeof error?.code === 'string' ? error.code : 'BridgeControlFailed', typeof error?.message === 'string' ? error.message : 'Bridge control request failed', { status: typeof error?.status === 'number' ? error.status : 500 })));
+        });
+        socket.once('error', (cause) => {
+            const code = cause.code;
+            const isUnavailable = code === 'ENOENT' || code === 'ECONNREFUSED' || code === 'EINVAL';
+            finish(() => rejectResponse(new BridgeError(isUnavailable ? 'BridgeControlUnavailable' : 'BridgeControlFailed', isUnavailable
+                ? 'No Tapicker Bridge control service is available'
+                : 'Could not communicate with Tapicker Bridge', { status: isUnavailable ? 503 : 500, cause })));
+        });
+        socket.once('end', () => {
+            if (!settled) {
+                finish(() => rejectResponse(new BridgeError('InvalidBridgeControlResponse', 'Bridge closed the control connection without a response', {
+                    status: 502,
+                })));
+            }
+        });
+    });
+}
+function handleControlSocket(socket, handle) {
+    let buffer = '';
+    socket.setEncoding('utf8');
+    socket.setTimeout(5000, () => socket.destroy());
+    socket.on('data', (chunk) => {
+        buffer += chunk;
+        if (Buffer.byteLength(buffer) > MAX_CONTROL_MESSAGE_BYTES) {
+            socket.destroy();
+            return;
+        }
+        const newline = buffer.indexOf('\n');
+        if (newline < 0)
+            return;
+        socket.removeAllListeners('data');
+        let action;
+        try {
+            const message = JSON.parse(buffer.slice(0, newline));
+            action = message?.action;
+        }
+        catch (cause) {
+            sendControlError(socket, new BridgeError('InvalidBridgeControlRequest', 'Control request is not valid JSON', { status: 400, cause }));
+            return;
+        }
+        if (typeof action !== 'string' || !CONTROL_ACTIONS.has(action)) {
+            sendControlError(socket, new BridgeError('InvalidBridgeControlRequest', 'Unsupported Bridge control action', { status: 400 }));
+            return;
+        }
+        void handle(action)
+            .then((data) => socket.end(`${JSON.stringify({ ok: true, data })}\n`))
+            .catch((error) => sendControlError(socket, error));
+    });
+}
+function sendControlError(socket, error) {
+    const bridgeError = toBridgeError(error);
+    socket.end(`${JSON.stringify({
+        ok: false,
+        error: {
+            code: bridgeError.code,
+            message: bridgeError.message,
+            status: bridgeError.status,
+        },
+    })}\n`);
+}
+function listenControlServer(server, endpoint) {
+    return listen(server, endpoint).catch(async (error) => {
+        if (error.code !== 'EADDRINUSE')
+            throw error;
+        if (await canConnect(endpoint)) {
+            throw new BridgeError('BridgeControlInUse', 'A Tapicker Bridge control service is already using this data directory', {
+                status: 409,
+                cause: error,
+            });
+        }
+        if (process.platform === 'win32')
+            throw error;
+        await unlink(endpoint).catch((unlinkError) => {
+            if (unlinkError.code !== 'ENOENT')
+                throw unlinkError;
+        });
+        await listen(server, endpoint);
+    });
+}
+function listen(server, endpoint) {
+    return new Promise((resolveListen, rejectListen) => {
+        const onError = (error) => {
+            server.off('listening', onListening);
+            rejectListen(error);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolveListen();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(endpoint);
+    });
+}
+function canConnect(endpoint) {
+    return new Promise((resolveProbe) => {
+        const socket = createConnection(endpoint);
+        const timeout = setTimeout(() => {
+            socket.destroy();
+            resolveProbe(false);
+        }, 300);
+        socket.once('connect', () => {
+            clearTimeout(timeout);
+            socket.end();
+            resolveProbe(true);
+        });
+        socket.once('error', () => {
+            clearTimeout(timeout);
+            resolveProbe(false);
+        });
+    });
+}
+function closeServer(server) {
+    if (!server.listening)
+        return Promise.resolve();
+    return new Promise((resolveClose) => server.close(() => resolveClose()));
+}
+//# sourceMappingURL=control.js.map

package/dist/bridge/daemon.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+declare const BridgeDaemonStateSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    bridgeId: z.ZodUUID;
+    httpUrl: z.ZodURL;
+    startedAt: z.ZodNumber;
+}, z.core.$strict>;
+export type BridgeDaemonState = z.infer<typeof BridgeDaemonStateSchema>;
+export declare function getBridgeDaemonStatePath(dataDir: string): string;
+export declare function getBridgeDaemonLogPath(dataDir: string): string;
+export declare function readBridgeDaemonState(dataDir: string): Promise<BridgeDaemonState | undefined>;
+export declare function writeBridgeDaemonState(dataDir: string, state: BridgeDaemonState): Promise<void>;
+export declare function removeBridgeDaemonState(dataDir: string, expectedPid: number): Promise<void>;
+export declare function isProcessRunning(pid: number): boolean;
+export {};
+//# sourceMappingURL=daemon.d.ts.map