@sikuligo/sikuligo 0.1.4

package/README.md

@@ -0,0 +1,53 @@
+# sikuligo (Node.js)
+
+This package provides a Node.js SDK that can launch a local `sikuligrpc` process and execute automation with a small API surface.
+
+## Prerequisites
+
+- Node.js 20+
+- npm
+- `sikuligrpc` binary available from one of:
+  - this package's `optionalDependencies` (`@sikuligo/bin-*`) after binary packages are published
+  - `SIKULIGO_BINARY_PATH`
+  - a manually installed platform package (for example `@sikuligo/bin-darwin-arm64`)
+  - `sikuligrpc` in `PATH`
+
+## Setup
+
+```bash
+cd clients/node
+npm install
+npm run generate
+npm run build
+```
+
+## Environment
+
+- `SIKULIGO_BINARY_PATH` (optional explicit path to `sikuligrpc`)
+- `SIKULI_GRPC_ADDR` (used by `Sikuli.connect`; default `127.0.0.1:50051`)
+- `SIKULI_GRPC_AUTH_TOKEN` (optional; sent as `x-api-key` for spawned/connected sessions)
+- `SIKULI_APP_NAME` (optional; used by `examples/app.ts`)
+
+## Quickstart User Flow
+
+```ts
+import { Sikuli } from "@sikuligo/sikuligo";
+
+const bot = await Sikuli.launch();
+await bot.click({ x: 300, y: 220 });
+await bot.typeText("hello");
+await bot.hotkey(["cmd", "enter"]);
+await bot.close();
+```
+
+## Run Examples
+
+```bash
+cd clients/node
+npm run example:find
+npm run example:ocr
+npm run example:input
+npm run example:app
+npm run example:user-flow
+npm run doctor
+```

package/dist/examples/app.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/app.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../src/client");
+async function main() {
+    const client = new client_1.SikuliGrpcClient();
+    const appName = process.env.SIKULI_APP_NAME ?? "Calculator";
+    try {
+        await client.openApp({
+            name: appName,
+            args: []
+        });
+        const running = await client.isAppRunning({ name: appName });
+        console.log("isAppRunning", JSON.stringify(running, null, 2));
+        const windows = await client.listWindows({ name: appName });
+        console.log("listWindows", JSON.stringify(windows, null, 2));
+        await client.focusApp({ name: appName });
+        await client.closeApp({ name: appName });
+        console.log("app control actions sent");
+    }
+    finally {
+        client.close();
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/examples/find.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/find.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../src/client");
+function grayImageFromRows(name, rows) {
+    const height = rows.length;
+    const width = rows[0].length;
+    const pix = rows.flat().map((v) => v & 0xff);
+    return {
+        name,
+        width,
+        height,
+        pix: Buffer.from(pix)
+    };
+}
+async function main() {
+    const client = new client_1.SikuliGrpcClient();
+    const source = grayImageFromRows("source", [
+        [10, 10, 10, 10, 10, 10, 10, 10],
+        [10, 0, 255, 10, 10, 10, 10, 10],
+        [10, 255, 0, 10, 0, 255, 10, 10],
+        [10, 10, 10, 10, 255, 0, 10, 10],
+        [10, 10, 10, 10, 10, 10, 10, 10]
+    ]);
+    const needle = grayImageFromRows("needle", [
+        [0, 255],
+        [255, 0]
+    ]);
+    try {
+        const response = await client.find({
+            source,
+            pattern: {
+                image: needle,
+                exact: true
+            }
+        });
+        console.log(JSON.stringify(response, null, 2));
+    }
+    finally {
+        client.close();
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/examples/input.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/input.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../src/client");
+async function main() {
+    const client = new client_1.SikuliGrpcClient();
+    try {
+        await client.moveMouse({
+            x: 200,
+            y: 180,
+            opts: { delay_millis: 30 }
+        });
+        await client.click({
+            x: 200,
+            y: 180,
+            opts: { button: "left", delay_millis: 20 }
+        });
+        await client.typeText({
+            text: "hello from node grpc",
+            opts: { delay_millis: 15 }
+        });
+        await client.hotkey({ keys: ["cmd", "a"] });
+        console.log("input actions sent");
+    }
+    finally {
+        client.close();
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/examples/ocr.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/ocr.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../src/client");
+function grayImageFromRows(name, rows) {
+    const height = rows.length;
+    const width = rows[0].length;
+    const pix = rows.flat().map((v) => v & 0xff);
+    return {
+        name,
+        width,
+        height,
+        pix: Buffer.from(pix)
+    };
+}
+async function main() {
+    const client = new client_1.SikuliGrpcClient();
+    const source = grayImageFromRows("ocr-source", [
+        [220, 220, 220, 220],
+        [220, 20, 20, 220],
+        [220, 220, 220, 220]
+    ]);
+    try {
+        const readText = await client.readText({
+            source,
+            params: {
+                language: "eng"
+            }
+        });
+        console.log("readText", JSON.stringify(readText, null, 2));
+        const findText = await client.findText({
+            source,
+            query: "example",
+            params: {
+                language: "eng",
+                case_sensitive: false
+            }
+        });
+        console.log("findText", JSON.stringify(findText, null, 2));
+    }
+    finally {
+        client.close();
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/examples/user-flow.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/user-flow.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+async function main() {
+    const bot = await src_1.Sikuli.launch({
+        startupTimeoutMs: 10_000
+    });
+    try {
+        await bot.click({ x: 300, y: 220 });
+        await bot.typeText("hello from sikuligo");
+        await bot.hotkey(["cmd", "enter"]);
+        console.log("automation actions sent");
+    }
+    finally {
+        await bot.close();
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/binary.d.ts

@@ -0,0 +1 @@
+export declare function resolveSikuliGrpcBinary(explicitPath?: string): string;

package/dist/src/binary.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSikuliGrpcBinary = resolveSikuliGrpcBinary;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const DEFAULT_BINARY_NAME = process.platform === "win32" ? "sikuligrpc.exe" : "sikuligrpc";
+const PLATFORM_BINARY_PACKAGES = {
+    "darwin-arm64": ["@sikuligo/bin-darwin-arm64"],
+    "darwin-x64": ["@sikuligo/bin-darwin-x64"],
+    "linux-x64": ["@sikuligo/bin-linux-x64"],
+    "win32-x64": ["@sikuligo/bin-win32-x64"]
+};
+function isExecutable(candidatePath) {
+    try {
+        if (!candidatePath) {
+            return false;
+        }
+        if (process.platform === "win32") {
+            node_fs_1.default.accessSync(candidatePath, node_fs_1.default.constants.F_OK);
+        }
+        else {
+            node_fs_1.default.accessSync(candidatePath, node_fs_1.default.constants.F_OK | node_fs_1.default.constants.X_OK);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function candidateBinaryPaths(rootDir) {
+    const names = [DEFAULT_BINARY_NAME];
+    if (process.platform !== "win32") {
+        names.push("sikuligrpc");
+    }
+    return [
+        ...names.map((name) => node_path_1.default.join(rootDir, name)),
+        ...names.map((name) => node_path_1.default.join(rootDir, "bin", name)),
+        ...names.map((name) => node_path_1.default.join(rootDir, "dist", name))
+    ];
+}
+function resolveOptionalPackageBinary() {
+    const key = `${process.platform}-${process.arch}`;
+    const packages = PLATFORM_BINARY_PACKAGES[key] ?? [];
+    for (const pkgName of packages) {
+        try {
+            const packageJsonPath = require.resolve(`${pkgName}/package.json`);
+            const packageRoot = node_path_1.default.dirname(packageJsonPath);
+            for (const candidate of candidateBinaryPaths(packageRoot)) {
+                if (isExecutable(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        catch {
+            // Optional package not installed for this platform.
+        }
+    }
+    return undefined;
+}
+function resolveFromPath() {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const result = (0, node_child_process_1.spawnSync)(cmd, [DEFAULT_BINARY_NAME], { encoding: "utf8" });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    const first = result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!first) {
+        return undefined;
+    }
+    return isExecutable(first) ? first : undefined;
+}
+function resolveLocalRepoFallback() {
+    const candidates = [
+        node_path_1.default.resolve(process.cwd(), DEFAULT_BINARY_NAME),
+        node_path_1.default.resolve(process.cwd(), "bin", DEFAULT_BINARY_NAME),
+        node_path_1.default.resolve(__dirname, "..", "..", "..", "sikuligrpc"),
+        node_path_1.default.resolve(__dirname, "..", "..", "..", "bin", DEFAULT_BINARY_NAME)
+    ];
+    return candidates.find((candidate) => isExecutable(candidate));
+}
+function errorWithResolutionHelp(detail) {
+    return new Error(`${detail}\n` +
+        "Set SIKULIGO_BINARY_PATH or install a platform binary package (for example @sikuligo/bin-darwin-arm64), " +
+        "or place sikuligrpc in PATH.");
+}
+function resolveSikuliGrpcBinary(explicitPath) {
+    const manual = explicitPath || process.env.SIKULIGO_BINARY_PATH || "";
+    if (manual) {
+        if (!isExecutable(manual)) {
+            throw errorWithResolutionHelp(`Configured binary path is not executable: ${manual}`);
+        }
+        return manual;
+    }
+    const optionalPackageBinary = resolveOptionalPackageBinary();
+    if (optionalPackageBinary) {
+        return optionalPackageBinary;
+    }
+    const pathBinary = resolveFromPath();
+    if (pathBinary) {
+        return pathBinary;
+    }
+    const localFallback = resolveLocalRepoFallback();
+    if (localFallback) {
+        return localFallback;
+    }
+    throw errorWithResolutionHelp(`Unable to resolve sikuligrpc binary for platform ${process.platform}/${process.arch}`);
+}

package/dist/src/client.d.ts

@@ -0,0 +1,45 @@
+import * as grpc from "@grpc/grpc-js";
+export type RpcMessage = Record<string, unknown>;
+export interface SikuliClientOptions {
+    address?: string;
+    authToken?: string;
+    traceId?: string;
+    timeoutMs?: number;
+    protoPath?: string;
+    credentials?: grpc.ChannelCredentials;
+}
+export interface UnaryCallOptions {
+    timeoutMs?: number;
+    metadata?: Record<string, string>;
+}
+export declare class SikuliGrpcError extends Error {
+    readonly code: number;
+    readonly details: string;
+    readonly traceId?: string;
+    constructor(code: number, details: string, traceId?: string);
+}
+export declare class SikuliGrpcClient {
+    private readonly client;
+    private readonly authToken;
+    private readonly traceId;
+    private readonly defaultTimeoutMs;
+    constructor(opts?: SikuliClientOptions);
+    close(): void;
+    waitForReady(timeoutMs?: number): Promise<void>;
+    private buildMetadata;
+    private grpcError;
+    private unary;
+    find(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    findAll(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    readText(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    findText(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    moveMouse(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    click(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    typeText(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    hotkey(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    openApp(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    focusApp(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    closeApp(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    isAppRunning(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+    listWindows(request: RpcMessage, opts?: UnaryCallOptions): Promise<RpcMessage>;
+}

package/dist/src/client.js

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SikuliGrpcClient = exports.SikuliGrpcError = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const DEFAULT_ADDR = "127.0.0.1:50051";
+const DEFAULT_TIMEOUT_MS = 5000;
+const TRACE_HEADER = "x-trace-id";
+class SikuliGrpcError extends Error {
+    constructor(code, details, traceId) {
+        const suffix = traceId ? ` trace_id=${traceId}` : "";
+        super(`grpc_code=${code} details=${details}${suffix}`);
+        this.code = code;
+        this.details = details;
+        this.traceId = traceId;
+    }
+}
+exports.SikuliGrpcError = SikuliGrpcError;
+function resolveDefaultProtoPath() {
+    const candidates = [
+        node_path_1.default.resolve(__dirname, "../../../proto/sikuli/v1/sikuli.proto"),
+        node_path_1.default.resolve(__dirname, "../../../../proto/sikuli/v1/sikuli.proto"),
+        node_path_1.default.resolve(process.cwd(), "proto/sikuli/v1/sikuli.proto"),
+        node_path_1.default.resolve(process.cwd(), "../../proto/sikuli/v1/sikuli.proto")
+    ];
+    for (const candidate of candidates) {
+        if (node_fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function serviceConstructorFromProto(protoPath) {
+    const packageDefinition = protoLoader.loadSync(protoPath, {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true
+    });
+    const root = grpc.loadPackageDefinition(packageDefinition);
+    const serviceCtor = root?.sikuli?.v1?.SikuliService;
+    if (!serviceCtor) {
+        throw new Error(`SikuliService not found in proto: ${protoPath}`);
+    }
+    return serviceCtor;
+}
+class SikuliGrpcClient {
+    constructor(opts = {}) {
+        const address = opts.address ?? process.env.SIKULI_GRPC_ADDR ?? DEFAULT_ADDR;
+        this.authToken = opts.authToken ?? process.env.SIKULI_GRPC_AUTH_TOKEN ?? "";
+        this.traceId = opts.traceId ?? "";
+        this.defaultTimeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const protoPath = opts.protoPath ?? resolveDefaultProtoPath();
+        const ctor = serviceConstructorFromProto(protoPath);
+        const credentials = opts.credentials ?? grpc.credentials.createInsecure();
+        this.client = new ctor(address, credentials);
+    }
+    close() {
+        this.client.close();
+    }
+    waitForReady(timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const deadline = new Date(Date.now() + timeoutMs);
+        return new Promise((resolve, reject) => {
+            this.client.waitForReady(deadline, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    buildMetadata(extra = {}) {
+        const md = new grpc.Metadata();
+        if (this.authToken) {
+            md.set("x-api-key", this.authToken);
+        }
+        if (this.traceId) {
+            md.set(TRACE_HEADER, this.traceId);
+        }
+        for (const [k, v] of Object.entries(extra)) {
+            if (v) {
+                md.set(k, v);
+            }
+        }
+        return md;
+    }
+    grpcError(err) {
+        const traceValues = err.metadata?.get(TRACE_HEADER) ?? [];
+        const traceId = traceValues.length > 0 ? String(traceValues[0]) : undefined;
+        return new SikuliGrpcError(err.code ?? grpc.status.UNKNOWN, err.details || err.message, traceId);
+    }
+    unary(methodName, request, opts = {}) {
+        const callFn = this.client[methodName];
+        if (typeof callFn !== "function") {
+            return Promise.reject(new Error(`unknown gRPC method: ${methodName}`));
+        }
+        const timeoutMs = opts.timeoutMs ?? this.defaultTimeoutMs;
+        const deadline = new Date(Date.now() + timeoutMs);
+        const metadata = this.buildMetadata(opts.metadata);
+        return new Promise((resolve, reject) => {
+            callFn.call(this.client, request, metadata, { deadline }, (err, response) => {
+                if (err) {
+                    reject(this.grpcError(err));
+                    return;
+                }
+                resolve(response);
+            });
+        });
+    }
+    find(request, opts) {
+        return this.unary("Find", request, opts);
+    }
+    findAll(request, opts) {
+        return this.unary("FindAll", request, opts);
+    }
+    readText(request, opts) {
+        return this.unary("ReadText", request, opts);
+    }
+    findText(request, opts) {
+        return this.unary("FindText", request, opts);
+    }
+    moveMouse(request, opts) {
+        return this.unary("MoveMouse", request, opts);
+    }
+    click(request, opts) {
+        return this.unary("Click", request, opts);
+    }
+    typeText(request, opts) {
+        return this.unary("TypeText", request, opts);
+    }
+    hotkey(request, opts) {
+        return this.unary("Hotkey", request, opts);
+    }
+    openApp(request, opts) {
+        return this.unary("OpenApp", request, opts);
+    }
+    focusApp(request, opts) {
+        return this.unary("FocusApp", request, opts);
+    }
+    closeApp(request, opts) {
+        return this.unary("CloseApp", request, opts);
+    }
+    isAppRunning(request, opts) {
+        return this.unary("IsAppRunning", request, opts);
+    }
+    listWindows(request, opts) {
+        return this.unary("ListWindows", request, opts);
+    }
+}
+exports.SikuliGrpcClient = SikuliGrpcClient;

package/dist/src/doctor.d.ts

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

package/dist/src/doctor.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const binary_1 = require("./binary");
+function run() {
+    try {
+        const binary = (0, binary_1.resolveSikuliGrpcBinary)();
+        console.log("sikuligo doctor: ok");
+        console.log(`binary: ${binary}`);
+        console.log(`platform: ${process.platform}/${process.arch}`);
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error("sikuligo doctor: failed");
+        console.error(message);
+        return 1;
+    }
+}
+process.exitCode = run();

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export { Sikuli } from "./sikuli";
+export { resolveSikuliGrpcBinary } from "./binary";
+export { launchClient, stopSpawnedProcess } from "./launcher";
+export { SikuliGrpcClient, SikuliGrpcError } from "./client";
+export type { LaunchOptions, LaunchResult } from "./launcher";
+export type { InputOptions, MoveMouseRequest, ClickRequest, TypeTextRequest, LaunchResultMeta } from "./sikuli";
+export type { RpcMessage, SikuliClientOptions, UnaryCallOptions } from "./client";

package/dist/src/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SikuliGrpcError = exports.SikuliGrpcClient = exports.stopSpawnedProcess = exports.launchClient = exports.resolveSikuliGrpcBinary = exports.Sikuli = void 0;
+var sikuli_1 = require("./sikuli");
+Object.defineProperty(exports, "Sikuli", { enumerable: true, get: function () { return sikuli_1.Sikuli; } });
+var binary_1 = require("./binary");
+Object.defineProperty(exports, "resolveSikuliGrpcBinary", { enumerable: true, get: function () { return binary_1.resolveSikuliGrpcBinary; } });
+var launcher_1 = require("./launcher");
+Object.defineProperty(exports, "launchClient", { enumerable: true, get: function () { return launcher_1.launchClient; } });
+Object.defineProperty(exports, "stopSpawnedProcess", { enumerable: true, get: function () { return launcher_1.stopSpawnedProcess; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "SikuliGrpcClient", { enumerable: true, get: function () { return client_1.SikuliGrpcClient; } });
+Object.defineProperty(exports, "SikuliGrpcError", { enumerable: true, get: function () { return client_1.SikuliGrpcError; } });

package/dist/src/launcher.d.ts

@@ -0,0 +1,19 @@
+import { ChildProcess } from "node:child_process";
+import { SikuliGrpcClient, SikuliClientOptions } from "./client";
+export interface LaunchOptions extends SikuliClientOptions {
+    spawnServer?: boolean;
+    startupTimeoutMs?: number;
+    binaryPath?: string;
+    adminListen?: string;
+    serverArgs?: string[];
+    stdio?: "ignore" | "pipe" | "inherit";
+}
+export interface LaunchResult {
+    address: string;
+    authToken: string;
+    client: SikuliGrpcClient;
+    child?: ChildProcess;
+    spawnedServer: boolean;
+}
+export declare function stopSpawnedProcess(child?: ChildProcess, timeoutMs?: number): Promise<void>;
+export declare function launchClient(opts?: LaunchOptions): Promise<LaunchResult>;