@velum-labs/cursorkit 0.1.0

package/dist/src/agentTools/results.js

@@ -0,0 +1,117 @@
+export function formatCursorToolResult(message) {
+    for (const value of [
+        message.readResult,
+        message.lsResult,
+        message.grepResult,
+        message.shellResult,
+        message.writeResult,
+        message.deleteResult,
+        message.fetchResult,
+        message.mcpResult,
+    ]) {
+        if (value === undefined) {
+            continue;
+        }
+        return JSON.stringify(normalizeToolResult(value), null, 2);
+    }
+    return JSON.stringify({
+        status: "unknown",
+        variant: "exec_client_message",
+        result: summarizeToolResult(message),
+    }, null, 2);
+}
+export function formatCursorToolError(error) {
+    return JSON.stringify({
+        status: "error",
+        error_code: error.code,
+        tool_name: error.toolName,
+        tool_call_id: error.toolCallId,
+        message: error.message,
+        ...(error.details === undefined ? {} : { details: error.details }),
+    }, null, 2);
+}
+export function agentExecClientMessageFields(message) {
+    return [
+        ["shellResult", message.shellResult],
+        ["writeResult", message.writeResult],
+        ["deleteResult", message.deleteResult],
+        ["grepResult", message.grepResult],
+        ["readResult", message.readResult],
+        ["lsResult", message.lsResult],
+        ["diagnosticsResult", message.diagnosticsResult],
+        ["requestContextResult", message.requestContextResult],
+        ["mcpResult", message.mcpResult],
+        ["shellStream", message.shellStream],
+        ["mcpStateExecResult", message.mcpStateExecResult],
+        ["fetchResult", message.fetchResult],
+        ["gitDiffResponse", message.gitDiffResponse],
+    ]
+        .filter(([, value]) => value !== undefined)
+        .map(([name]) => name);
+}
+function normalizeToolResult(value) {
+    const variant = toolResultVariant(value);
+    if (variant === undefined) {
+        return {
+            status: "unknown",
+            variant: "unknown",
+            result: summarizeToolResult(value),
+        };
+    }
+    const status = variant.name === "success" && mcpSuccessIsError(variant.value)
+        ? "error"
+        : variant.status;
+    return {
+        status,
+        variant: variant.name,
+        result: summarizeToolResult(variant.value),
+    };
+}
+function toolResultVariant(value) {
+    if (value === null || typeof value !== "object") {
+        return undefined;
+    }
+    const record = value;
+    for (const [name, status] of [
+        ["success", "success"],
+        ["failure", "error"],
+        ["error", "error"],
+        ["timeout", "timeout"],
+        ["rejected", "rejected"],
+        ["spawnError", "error"],
+        ["permissionDenied", "rejected"],
+        ["fileNotFound", "error"],
+        ["notFile", "error"],
+        ["fileBusy", "error"],
+    ]) {
+        const variantValue = record[name];
+        if (variantValue !== undefined) {
+            return { name, status, value: variantValue };
+        }
+    }
+    return undefined;
+}
+function mcpSuccessIsError(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.isError === true);
+}
+function summarizeToolResult(value) {
+    if (Array.isArray(value)) {
+        return value.slice(0, 40).map((entry) => summarizeToolResult(entry));
+    }
+    if (value === null || typeof value !== "object") {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return typeof value === "string" ? value.slice(0, 20_000) : value;
+    }
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === "$typeName") {
+            continue;
+        }
+        result[key] = summarizeToolResult(entry);
+    }
+    return result;
+}

package/dist/src/agentTools/schemas.d.ts

@@ -0,0 +1,3 @@
+import type { AgentToolPolicy } from "../config.js";
+import type { OpenAIToolDefinition } from "../providers/openai.js";
+export declare function cursorOpenAITools(policy: AgentToolPolicy): OpenAIToolDefinition[];

package/dist/src/agentTools/schemas.js

@@ -0,0 +1,89 @@
+import { toolEnabledByPolicy } from "./policy.js";
+import { CURSOR_TOOL_SURFACE } from "./surface.js";
+export function cursorOpenAITools(policy) {
+    return CURSOR_TOOL_SURFACE.filter((entry) => toolEnabledByPolicy(entry, policy)).flatMap((entry) => {
+        switch (entry.openAIToolName) {
+            case "read_file":
+                return [
+                    tool("read_file", "Read a file from the Cursor workspace using Cursor's native file tool.", {
+                        path: { type: "string" },
+                        offset: { type: "integer" },
+                        limit: { type: "integer" },
+                    }, ["path"]),
+                ];
+            case "list_dir":
+                return [
+                    tool("list_dir", "List a directory from the Cursor workspace using Cursor's native ls tool.", { path: { type: "string" } }, ["path"]),
+                ];
+            case "grep":
+                return [
+                    tool("grep", "Search workspace files using Cursor's native grep tool.", {
+                        pattern: { type: "string" },
+                        path: { type: "string" },
+                        glob: { type: "string" },
+                        head_limit: { type: "integer" },
+                    }, ["pattern"]),
+                ];
+            case "run_shell":
+                return [
+                    tool("run_shell", "Run a shell command through Cursor's native shell tool. Cursor handles permissions and approval.", {
+                        command: { type: "string" },
+                        working_directory: { type: "string" },
+                        timeout: { type: "integer" },
+                        description: { type: "string" },
+                    }, ["command"]),
+                ];
+            case "write_file":
+                return [
+                    tool("write_file", "Write a file through Cursor's native write tool. Cursor handles permissions and approval.", {
+                        path: { type: "string" },
+                        content: { type: "string" },
+                        return_file_content_after_write: { type: "boolean" },
+                    }, ["path", "content"]),
+                ];
+            case "apply_patch":
+                return [
+                    tool("apply_patch", "Apply a targeted edit to a file by replacing old_string with new_string. Cursor reads the file, applies the change, writes it back, and returns a unified diff. Include enough surrounding context in old_string to match exactly once, or set replace_all. To create a new file, pass an empty old_string and the full file content as new_string.", {
+                        path: { type: "string" },
+                        old_string: { type: "string" },
+                        new_string: { type: "string" },
+                        replace_all: { type: "boolean" },
+                    }, ["path", "old_string", "new_string"]),
+                ];
+            case "delete_path":
+                return [
+                    tool("delete_path", "Delete a path through Cursor's native delete tool. Cursor handles permissions and approval.", { path: { type: "string" } }, ["path"]),
+                ];
+            case "fetch_url":
+                return [
+                    tool("fetch_url", "Fetch a URL through Cursor's native fetch tool.", { url: { type: "string" } }, ["url"]),
+                ];
+            case "mcp_tool":
+                return [
+                    tool("mcp_tool", "Call an MCP tool through Cursor's native MCP execution path.", {
+                        provider_identifier: { type: "string" },
+                        tool_name: { type: "string" },
+                        name: { type: "string" },
+                        arguments: { type: "object" },
+                    }, ["provider_identifier", "tool_name"]),
+                ];
+            default:
+                return [];
+        }
+    });
+}
+function tool(name, description, properties, required) {
+    return {
+        type: "function",
+        function: {
+            name,
+            description,
+            parameters: {
+                type: "object",
+                properties,
+                required,
+                additionalProperties: false,
+            },
+        },
+    };
+}

package/dist/src/agentTools/surface.d.ts

@@ -0,0 +1,11 @@
+export type CursorToolSupport = "supported" | "policy-gated" | "internal" | "not-supported";
+export interface CursorToolSurfaceEntry {
+    execServerField: string;
+    execClientField: string;
+    openAIToolName?: string;
+    support: CursorToolSupport;
+    safety: "read" | "network" | "interactive" | "mutating" | "destructive" | "subagent" | "internal";
+    notes: string;
+}
+export declare const CURSOR_TOOL_SURFACE: CursorToolSurfaceEntry[];
+export declare function supportedOpenAIToolNames(): string[];

package/dist/src/agentTools/surface.js

@@ -0,0 +1,251 @@
+export const CURSOR_TOOL_SURFACE = [
+    {
+        execServerField: "requestContextArgs",
+        execClientField: "requestContextResult",
+        support: "internal",
+        safety: "internal",
+        notes: "Bridge uses this to collect native Cursor request context before model execution.",
+    },
+    {
+        execServerField: "readArgs",
+        execClientField: "readResult",
+        openAIToolName: "read_file",
+        support: "supported",
+        safety: "read",
+        notes: "Read file contents through Cursor permissions.",
+    },
+    {
+        execServerField: "redactedReadArgs",
+        execClientField: "redactedReadResult",
+        openAIToolName: "redacted_read_file",
+        support: "not-supported",
+        safety: "read",
+        notes: "Same arg/result shape as read, but redaction semantics need live traffic validation.",
+    },
+    {
+        execServerField: "lsArgs",
+        execClientField: "lsResult",
+        openAIToolName: "list_dir",
+        support: "supported",
+        safety: "read",
+        notes: "List directory tree through Cursor permissions.",
+    },
+    {
+        execServerField: "grepArgs",
+        execClientField: "grepResult",
+        openAIToolName: "grep",
+        support: "supported",
+        safety: "read",
+        notes: "Search workspace files through Cursor grep.",
+    },
+    {
+        execServerField: "diagnosticsArgs",
+        execClientField: "diagnosticsResult",
+        openAIToolName: "read_diagnostics",
+        support: "not-supported",
+        safety: "read",
+        notes: "Needs result formatting for diagnostics severity/ranges.",
+    },
+    {
+        execServerField: "shellArgs",
+        execClientField: "shellResult",
+        openAIToolName: "run_shell",
+        support: "policy-gated",
+        safety: "destructive",
+        notes: "Mapped, but exposed only through policy because shell execution can mutate state.",
+    },
+    {
+        execServerField: "shellStreamArgs",
+        execClientField: "shellStream",
+        openAIToolName: "stream_shell",
+        support: "not-supported",
+        safety: "destructive",
+        notes: "Streaming shell requires incremental result forwarding and lifecycle management.",
+    },
+    {
+        execServerField: "backgroundShellSpawnArgs",
+        execClientField: "backgroundShellSpawnResult",
+        openAIToolName: "spawn_background_shell",
+        support: "not-supported",
+        safety: "destructive",
+        notes: "Requires background process tracking and cleanup.",
+    },
+    {
+        execServerField: "writeShellStdinArgs",
+        execClientField: "writeShellStdinResult",
+        openAIToolName: "write_shell_stdin",
+        support: "not-supported",
+        safety: "destructive",
+        notes: "Requires pairing to a running shell id.",
+    },
+    {
+        execServerField: "writeArgs",
+        execClientField: "writeResult",
+        openAIToolName: "write_file",
+        support: "policy-gated",
+        safety: "mutating",
+        notes: "Mapped, but exposed only through policy because it mutates files.",
+    },
+    {
+        execServerField: "writeArgs",
+        execClientField: "writeResult",
+        openAIToolName: "apply_patch",
+        support: "policy-gated",
+        safety: "mutating",
+        notes: "Targeted search/replace edit synthesized from a read + write round trip; returns a unified diff. Policy-gated because it mutates files.",
+    },
+    {
+        execServerField: "deleteArgs",
+        execClientField: "deleteResult",
+        openAIToolName: "delete_path",
+        support: "policy-gated",
+        safety: "destructive",
+        notes: "Mapped, but exposed only through policy because it deletes files.",
+    },
+    {
+        execServerField: "fetchArgs",
+        execClientField: "fetchResult",
+        openAIToolName: "fetch_url",
+        support: "supported",
+        safety: "network",
+        notes: "Fetch URL through Cursor network/tool policy.",
+    },
+    {
+        execServerField: "mcpArgs",
+        execClientField: "mcpResult",
+        openAIToolName: "mcp_tool",
+        support: "policy-gated",
+        safety: "interactive",
+        notes: "Mapped, but real MCP auth/approval/result variants need per-provider validation.",
+    },
+    {
+        execServerField: "listMcpResourcesExecArgs",
+        execClientField: "listMcpResourcesExecResult",
+        openAIToolName: "list_mcp_resources",
+        support: "not-supported",
+        safety: "interactive",
+        notes: "Needs MCP resource result schema formatting.",
+    },
+    {
+        execServerField: "readMcpResourceExecArgs",
+        execClientField: "readMcpResourceExecResult",
+        openAIToolName: "read_mcp_resource",
+        support: "not-supported",
+        safety: "interactive",
+        notes: "Needs download-path handling and resource payload formatting.",
+    },
+    {
+        execServerField: "mcpStateExecArgs",
+        execClientField: "mcpStateExecResult",
+        openAIToolName: "mcp_state",
+        support: "not-supported",
+        safety: "interactive",
+        notes: "Needs state-specific result handling.",
+    },
+    {
+        execServerField: "recordScreenArgs",
+        execClientField: "recordScreenResult",
+        openAIToolName: "record_screen",
+        support: "not-supported",
+        safety: "interactive",
+        notes: "Requires media artifact capture/formatting.",
+    },
+    {
+        execServerField: "computerUseArgs",
+        execClientField: "computerUseResult",
+        openAIToolName: "computer_use",
+        support: "not-supported",
+        safety: "interactive",
+        notes: "Requires UI input action policy and screenshot/result formatting.",
+    },
+    {
+        execServerField: "executeHookArgs",
+        execClientField: "executeHookResult",
+        openAIToolName: "execute_hook",
+        support: "not-supported",
+        safety: "mutating",
+        notes: "Requires hook policy and side-effect accounting.",
+    },
+    {
+        execServerField: "subagentArgs",
+        execClientField: "subagentResult",
+        openAIToolName: "subagent",
+        support: "not-supported",
+        safety: "subagent",
+        notes: "Requires subagent lifecycle, model selection, and background handling.",
+    },
+    {
+        execServerField: "forceBackgroundSubagentArgs",
+        execClientField: "forceBackgroundSubagentResult",
+        openAIToolName: "force_background_subagent",
+        support: "not-supported",
+        safety: "subagent",
+        notes: "Requires existing subagent state.",
+    },
+    {
+        execServerField: "subagentAwaitArgs",
+        execClientField: "subagentAwaitResult",
+        openAIToolName: "subagent_await",
+        support: "not-supported",
+        safety: "subagent",
+        notes: "Requires existing subagent state.",
+    },
+    {
+        execServerField: "gitDiffRequest",
+        execClientField: "gitDiffResponse",
+        openAIToolName: "git_diff",
+        support: "not-supported",
+        safety: "read",
+        notes: "Needs aiserver git diff request/result formatting.",
+    },
+    {
+        execServerField: "shellAllowlistPrecheckArgs",
+        execClientField: "shellAllowlistPrecheckResult",
+        support: "not-supported",
+        safety: "internal",
+        notes: "Precheck flow for shell tools, not exposed directly to model.",
+    },
+    {
+        execServerField: "mcpAllowlistPrecheckArgs",
+        execClientField: "mcpAllowlistPrecheckResult",
+        support: "not-supported",
+        safety: "internal",
+        notes: "Precheck flow for MCP tools, not exposed directly to model.",
+    },
+    {
+        execServerField: "webFetchAllowlistPrecheckArgs",
+        execClientField: "webFetchAllowlistPrecheckResult",
+        support: "not-supported",
+        safety: "internal",
+        notes: "Precheck flow for web fetch, not exposed directly to model.",
+    },
+    {
+        execServerField: "smartModeClassifierArgs",
+        execClientField: "smartModeClassifierResult",
+        support: "not-supported",
+        safety: "internal",
+        notes: "Classifier/precheck flow, not exposed directly to model.",
+    },
+    {
+        execServerField: "canvasDiagnosticsArgs",
+        execClientField: "canvasDiagnosticsResult",
+        openAIToolName: "canvas_diagnostics",
+        support: "not-supported",
+        safety: "read",
+        notes: "Needs canvas-specific result formatting.",
+    },
+    {
+        execServerField: "forceBackgroundShellArgs",
+        execClientField: "forceBackgroundShellResult",
+        support: "not-supported",
+        safety: "destructive",
+        notes: "Requires existing shell state.",
+    },
+];
+export function supportedOpenAIToolNames() {
+    return CURSOR_TOOL_SURFACE.flatMap((entry) => entry.support === "supported" || entry.support === "policy-gated"
+        ? entry.openAIToolName === undefined
+            ? []
+            : [entry.openAIToolName]
+        : []);
+}

package/dist/src/certs.d.ts

@@ -0,0 +1,8 @@
+import type { BridgeConfig } from "./config.js";
+export interface TlsMaterial {
+    cert: string;
+    key: string;
+    generated: boolean;
+}
+export declare function loadTlsMaterial(config: BridgeConfig): Promise<TlsMaterial>;
+export declare function generateTlsMaterial(hostnames: string[]): Promise<TlsMaterial>;

package/dist/src/certs.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import { isIP } from "node:net";
+import { generate } from "selfsigned";
+export async function loadTlsMaterial(config) {
+    if (config.certPath !== undefined || config.keyPath !== undefined) {
+        if (config.certPath === undefined || config.keyPath === undefined) {
+            throw new Error("Both BRIDGE_CERT_PATH and BRIDGE_KEY_PATH must be set when using custom TLS material");
+        }
+        return {
+            cert: fs.readFileSync(config.certPath, "utf8"),
+            key: fs.readFileSync(config.keyPath, "utf8"),
+            generated: false,
+        };
+    }
+    return generateTlsMaterial(config.tlsHostnames);
+}
+export async function generateTlsMaterial(hostnames) {
+    const primaryHostname = hostnames[0] ?? "localhost";
+    const attrs = [{ name: "commonName", value: primaryHostname }];
+    const pem = await generate(attrs, {
+        notAfterDate: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
+        keySize: 2048,
+        algorithm: "sha256",
+        extensions: [
+            {
+                name: "subjectAltName",
+                altNames: hostnames.map((hostname) => isIP(hostname) === 0
+                    ? { type: 2, value: hostname }
+                    : { type: 7, ip: hostname }),
+            },
+        ],
+    });
+    return { cert: pem.cert, key: pem.private, generated: true };
+}

package/dist/src/ck.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/ck.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runCk } from "./ckLauncher.js";
+runCk().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/src/ckLauncher.d.ts

@@ -0,0 +1,150 @@
+import { type ChildProcess } from "node:child_process";
+import fs from "node:fs";
+import { type LocalModelConfig } from "./config.js";
+import { type DesktopConnectProxy } from "./desktopConnectProxy.js";
+export type CkCommand = "launch" | "test" | "doctor" | "cert" | "route" | "stop" | "help";
+export type CkProfileMode = "isolated" | "default";
+export type CkRouteMethod = "pf" | "direct";
+export type CkRouteAction = "plan" | "status" | "rollback";
+export interface CkArgs {
+    command: CkCommand;
+    dryRun: boolean;
+    profileMode: CkProfileMode;
+    timeoutMs: number;
+    routeMethod: CkRouteMethod;
+    routeAction: CkRouteAction;
+    debugPort?: number;
+    instanceId?: string;
+    seedAuthFromDefault?: boolean;
+}
+export interface CommandSpec {
+    executable: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface CkLaunchPlan {
+    bridge: CommandSpec;
+    cursor: CommandSpec;
+    bridgePort: number;
+    connectProxyPort?: number;
+    agentHttpPort?: number;
+    stateDir: string;
+    statePath: string;
+    logPath: string;
+    connectProxyLogPath?: string;
+    userDataDir: string | undefined;
+    extensionsDir: string;
+    workspacePath: string;
+    profileMode: CkProfileMode;
+    debugPort?: number;
+    instanceId?: string;
+    seedAuthFromDefault: boolean;
+    authSeedStatus?: CursorAuthSeedStatus;
+    localModelSeedStatus?: CursorLocalModelSeedStatus;
+}
+export type CursorAuthSeedStatus = "not-requested" | "not-isolated" | "sqlite-unavailable" | "source-missing" | "no-auth-rows" | "seeded";
+export type CursorLocalModelSeedStatus = "not-isolated" | "sqlite-unavailable" | "state-missing" | "no-local-models" | "seeded";
+export interface CkRoutePlan {
+    method: CkRouteMethod;
+    hostname: string;
+    hostnames: string[];
+    bridgePort: number;
+    upstreamConnectHost: string | undefined;
+    warnings: string[];
+    setupCommands: CommandSpec[];
+    verificationCommands: CommandSpec[];
+    rollbackCommands: CommandSpec[];
+}
+export interface RouteInventoryObservation {
+    method: string;
+    path: string;
+    contentType: string;
+    status: number;
+    framing: string;
+    policy: string;
+    outcome: string;
+}
+export interface RouteInventoryPathSummary {
+    path: string;
+    count: number;
+    methods: string[];
+    statuses: number[];
+    framings: string[];
+    policies: string[];
+    outcomes: string[];
+}
+export type DesktopRouteCategory = "model-metadata" | "local-agent-candidate" | "pass-through" | "decoded-only" | "unsupported" | "unknown";
+export interface DesktopRouteCategorySummary {
+    path: string;
+    category: DesktopRouteCategory;
+    reason: string;
+}
+export interface DesktopTestReport {
+    routeInventorySeen: boolean;
+    modelRoutesSeen: string[];
+    missingModelRoutes: string[];
+    observedPaths: string[];
+    routeSummary: RouteInventoryPathSummary[];
+    routeCategories: DesktopRouteCategorySummary[];
+    failedRoutes: RouteInventoryObservation[];
+    passThroughRoutes: RouteInventoryObservation[];
+    diagnosis: string[];
+}
+export interface CkProcessGroup {
+    bridge: ChildProcess;
+    log: fs.WriteStream;
+    connectProxy?: DesktopConnectProxy;
+}
+interface CkState {
+    bridgePid?: number;
+    bridgeCommand?: string;
+    bridgePort?: number;
+    connectProxyPort?: number;
+    agentHttpPort?: number;
+    logPath?: string;
+    connectProxyLogPath?: string;
+    profileMode?: CkProfileMode;
+    userDataDir?: string;
+    extensionsDir?: string;
+    workspacePath?: string;
+    debugPort?: number;
+    instanceId?: string;
+    seedAuthFromDefault?: boolean;
+    authSeedStatus?: CursorAuthSeedStatus;
+    localModelSeedStatus?: CursorLocalModelSeedStatus;
+    startedAt?: string;
+}
+export declare const CK_STATE_DIR: string;
+export declare const CK_STATE_PATH: string;
+export declare function parseCkArgs(argv: string[]): CkArgs;
+export declare function buildCkLaunchPlan(options: {
+    env: NodeJS.ProcessEnv;
+    bridgePort: number;
+    connectProxyPort?: number;
+    agentHttpPort?: number;
+    profileMode?: CkProfileMode;
+    debugPort?: number;
+    instanceId?: string;
+    seedAuthFromDefault?: boolean;
+    cwd?: string;
+}): CkLaunchPlan;
+export declare function commandForDisplay(spec: CommandSpec): string;
+export declare function buildCkRoutePlan(options?: {
+    method?: CkRouteMethod;
+    bridgePort?: number;
+    upstreamConnectHost?: string;
+    cwd?: string;
+}): Promise<CkRoutePlan>;
+export declare function containsPrivilegedCommand(spec: CommandSpec): boolean;
+export declare function routeInventoryTimeoutDiagnosis(): string[];
+export declare function analyzeRouteInventoryLog(logText: string): DesktopTestReport;
+export declare function runCk(argv?: string[]): Promise<void>;
+export declare function chooseBridgePort(): Promise<number>;
+export declare function seedCursorAuthFromDefault(plan: Pick<CkLaunchPlan, "profileMode" | "userDataDir" | "seedAuthFromDefault">): CursorAuthSeedStatus;
+export declare function seedLocalModelsIntoCursorState(plan: Pick<CkLaunchPlan, "agentHttpPort" | "bridge" | "profileMode" | "userDataDir">): CursorLocalModelSeedStatus;
+export declare function mergeLocalAgentBackendUrlsIntoApplicationUser(applicationUser: Record<string, unknown>, agentOrigin: string): void;
+export declare function mergeLocalDesktopModelsIntoApplicationUser(applicationUser: Record<string, unknown>, models: LocalModelConfig[]): void;
+export declare function buildLocalDesktopModelEntry(model: LocalModelConfig): Record<string, unknown>;
+export declare function cleanupIsolatedCursorProcesses(userDataDir: string): number[];
+export declare function bridgeProcessMatchesState(command: string, state?: Pick<CkState, "bridgeCommand">): boolean;
+export {};