@runneth/cli 0.0.0-sha.3142666bf4dc.production

package/dist/copy.d.ts

@@ -0,0 +1,25 @@
+import type { OAuthTokenResult } from "./oauth.js";
+import type { ResolvedRunnethSshTarget } from "./ssh.js";
+export type RunnethVmCopyOptions = Readonly<{
+    readonly destination: ResolvedRunnethSshTarget;
+    readonly destinationPath: string;
+    readonly ignoredPaths?: readonly string[];
+    readonly oauthToken: OAuthTokenResult;
+    readonly source: ResolvedRunnethSshTarget;
+    readonly sourcePath: string;
+    readonly timeoutMs?: number;
+}>;
+export type RunnethVmCopyResult = Readonly<{
+    readonly bytesCopied: number;
+    readonly destinationPath: string;
+    readonly destinationTargetName?: string;
+    readonly destinationVmName: string;
+    readonly sourcePath: string;
+    readonly sourceTargetName?: string;
+    readonly sourceVmName: string;
+}>;
+export declare const assertRunnethVmCopyTargetsUseSameResource: (input: {
+    readonly destination: ResolvedRunnethSshTarget;
+    readonly source: ResolvedRunnethSshTarget;
+}) => void;
+export declare const runRunnethVmCopy: (options: RunnethVmCopyOptions) => Promise<RunnethVmCopyResult>;

package/dist/copy.js

@@ -0,0 +1,492 @@
+import path from "node:path";
+const DEFAULT_IGNORED_PATHS = ["node_modules"];
+const DESTINATION_CLEANUP_TIMEOUT_MS = 30_000;
+const SSH_APP_ARCHIVE_PATH = "/api/files/archive";
+const SSH_APP_ARCHIVE_APPLY_PATH = "/api/files/archive/apply";
+const SSH_APP_ARCHIVE_UPLOAD_CLEANUP_PATH = "/api/files/archive/uploads/cleanup";
+const SSH_APP_ARCHIVE_UPLOAD_PREPARE_PATH = "/api/files/archive/uploads/prepare";
+const SPAWNBOX_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const normalizeResourceUrl = (value) => {
+    const url = new URL(value);
+    url.hash = "";
+    url.search = "";
+    if (url.pathname !== "/") {
+        url.pathname = url.pathname.replace(/\/+$/u, "");
+    }
+    return url.toString();
+};
+export const assertRunnethVmCopyTargetsUseSameResource = (input) => {
+    if (normalizeResourceUrl(input.source.resourceUrl) !==
+        normalizeResourceUrl(input.destination.resourceUrl)) {
+        throw new Error("Source and destination targets must use the same resource");
+    }
+};
+const normalizeRemotePath = (value, label) => {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must be a non-empty absolute path`);
+    }
+    if (trimmed.includes("\0")) {
+        throw new Error(`${label} must not contain NUL bytes`);
+    }
+    const normalized = path.posix.normalize(trimmed);
+    if (!normalized.startsWith("/")) {
+        throw new Error(`${label} must be an absolute path`);
+    }
+    if (normalized === "/") {
+        throw new Error(`${label} must not be the filesystem root`);
+    }
+    return normalized;
+};
+const normalizeIgnoredPath = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Ignored path must be non-empty");
+    }
+    if (trimmed.includes("\0")) {
+        throw new Error("Ignored path must not contain NUL bytes");
+    }
+    if (path.posix.isAbsolute(trimmed)) {
+        throw new Error("Ignored path must be relative");
+    }
+    const normalized = path.posix.normalize(trimmed);
+    if (normalized === "." ||
+        normalized === ".." ||
+        normalized.startsWith("../")) {
+        throw new Error("Ignored path must stay within the copied path");
+    }
+    return normalized;
+};
+const resolveIgnoredPaths = (ignoredPaths) => {
+    const normalized = new Set();
+    for (const ignoredPath of DEFAULT_IGNORED_PATHS) {
+        normalized.add(normalizeIgnoredPath(ignoredPath));
+    }
+    for (const ignoredPath of ignoredPaths ?? []) {
+        normalized.add(normalizeIgnoredPath(ignoredPath));
+    }
+    return [...normalized].sort();
+};
+const resolveBearerAuthorizationHeader = (token) => {
+    if (token.tokenType.toLowerCase() !== "bearer") {
+        throw new Error(`Unsupported OAuth token type for copy: ${token.tokenType}`);
+    }
+    return `Bearer ${token.accessToken}`;
+};
+const buildSshAppApiUrl = (sshUrl, apiPath) => {
+    const url = new URL(sshUrl);
+    url.pathname = `${url.pathname.replace(/\/+$/u, "")}${apiPath}`;
+    url.search = "";
+    url.hash = "";
+    return url;
+};
+const buildSshAppArchiveUrl = (sshUrl, remotePath, ignoredPaths) => {
+    const url = buildSshAppApiUrl(sshUrl, SSH_APP_ARCHIVE_PATH);
+    url.searchParams.set("path", remotePath);
+    for (const ignoredPath of ignoredPaths) {
+        url.searchParams.append("ignore", ignoredPath);
+    }
+    return url.toString();
+};
+const resolveTargetVmName = (target, label) => {
+    const host = new URL(target.sshUrl).hostname;
+    const firstLabel = host.split(".")[0] ?? "";
+    if (SPAWNBOX_ID_PATTERN.test(firstLabel)) {
+        return firstLabel;
+    }
+    if (target.targetName !== undefined) {
+        return target.targetName;
+    }
+    throw new Error(`Cannot derive ${label} VM name from SSH URL host: ${host}`);
+};
+const parseNumberField = (record, key) => {
+    const value = record[key];
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new Error(`Copy response ${key} must be a non-negative number`);
+    }
+    return value;
+};
+const parseArchiveUploadResponse = (payload) => {
+    if (!isRecord(payload) || payload.ok !== true) {
+        throw new Error("Archive upload response must be an ok JSON object");
+    }
+    return {
+        bytesWritten: parseNumberField(payload, "bytesWritten"),
+        entriesWritten: parseNumberField(payload, "entriesWritten"),
+    };
+};
+const parsePreparedUploadHeaders = (payload) => {
+    if (!isRecord(payload)) {
+        throw new Error("Prepared upload headers must be a JSON object");
+    }
+    const headers = {};
+    for (const [headerName, headerValue] of Object.entries(payload)) {
+        if (typeof headerValue !== "string") {
+            throw new Error("Prepared upload headers must be string values");
+        }
+        headers[headerName] = headerValue;
+    }
+    return headers;
+};
+const parseAzureFileSharePreparedUpload = (payload) => {
+    if (!isRecord(payload)) {
+        throw new Error("Prepared upload must be a JSON object");
+    }
+    if (payload.strategy !== "azure_file_share" || payload.method !== "PUT") {
+        throw new Error("Prepared upload must be an Azure File Share PUT upload");
+    }
+    if (typeof payload.url !== "string" || payload.url.length === 0) {
+        throw new Error("Prepared upload url must be a non-empty string");
+    }
+    if (typeof payload.rangeSize !== "number" ||
+        !Number.isInteger(payload.rangeSize) ||
+        payload.rangeSize <= 0) {
+        throw new Error("Prepared upload rangeSize must be a positive integer");
+    }
+    return {
+        headers: parsePreparedUploadHeaders(payload.headers),
+        method: "PUT",
+        rangeSize: payload.rangeSize,
+        strategy: "azure_file_share",
+        url: payload.url,
+    };
+};
+const parseArchiveUploadPrepareResponse = (payload) => {
+    if (!isRecord(payload) || payload.ok !== true) {
+        throw new Error("Archive upload prepare response must be an ok JSON object");
+    }
+    if (typeof payload.archivePath !== "string" || payload.archivePath.length === 0) {
+        throw new Error("Archive upload prepare response archivePath must be a non-empty string");
+    }
+    return {
+        archivePath: payload.archivePath,
+        upload: parseAzureFileSharePreparedUpload(payload.upload),
+    };
+};
+const parseResponseHeaderNumber = (headers, name) => {
+    const value = headers.get(name);
+    if (value === null) {
+        throw new Error(`Archive download response missing ${name}`);
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`Archive download response ${name} must be a non-negative integer`);
+    }
+    return parsed;
+};
+const downloadSourceArchive = async (input) => {
+    const response = await fetch(buildSshAppArchiveUrl(input.sourceSshUrl, input.sourcePath, input.ignoredPaths), {
+        headers: {
+            Accept: "application/vnd.runneth.file-archive",
+            Authorization: input.authorizationHeader,
+        },
+        method: "GET",
+        signal: input.signal,
+    });
+    if (!response.ok) {
+        throw new Error(`Runneth VM source download failed with HTTP ${String(response.status)}: ${await response.text()}`);
+    }
+    if (response.body === null) {
+        throw new Error("Runneth VM source download response body is missing");
+    }
+    return {
+        archiveByteLength: parseResponseHeaderNumber(response.headers, "content-length"),
+        bytesArchived: parseResponseHeaderNumber(response.headers, "x-runneth-archive-bytes"),
+        entriesArchived: parseResponseHeaderNumber(response.headers, "x-runneth-archive-entries"),
+        stream: response.body,
+    };
+};
+const prepareDestinationArchiveUpload = async (input) => {
+    const response = await fetch(buildSshAppApiUrl(input.destinationSshUrl, SSH_APP_ARCHIVE_UPLOAD_PREPARE_PATH), {
+        body: JSON.stringify({
+            destinationPath: input.destinationPath,
+            size: input.archiveByteLength,
+        }),
+        headers: {
+            Accept: "application/json",
+            Authorization: input.authorizationHeader,
+            "Content-Type": "application/json",
+        },
+        method: "POST",
+        signal: input.signal,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new Error(`Runneth VM destination upload prepare failed with HTTP ${String(response.status)}: ${responseBody}`);
+    }
+    return parseArchiveUploadPrepareResponse(JSON.parse(responseBody));
+};
+const buildAzureFileShareRangeUploadUrl = (uploadUrl) => {
+    const url = new URL(uploadUrl);
+    url.searchParams.set("comp", "range");
+    return url.toString();
+};
+const combineUploadChunks = (chunks, byteLength) => {
+    if (chunks.length === 1 && chunks[0]?.byteLength === byteLength) {
+        return chunks[0];
+    }
+    const combined = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return combined;
+};
+async function* readUploadChunks(input) {
+    const reader = input.stream.getReader();
+    let pending = [];
+    let pendingByteLength = 0;
+    let offset = 0;
+    try {
+        while (offset < input.size) {
+            if (input.signal.aborted) {
+                throw new DOMException("Upload aborted", "AbortError");
+            }
+            const targetByteLength = Math.min(input.rangeSize, input.size - offset);
+            while (pendingByteLength < targetByteLength) {
+                const next = await reader.read();
+                if (next.done) {
+                    throw new Error("Source archive stream ended before declared size");
+                }
+                if (next.value.byteLength > 0) {
+                    pending = [...pending, next.value];
+                    pendingByteLength += next.value.byteLength;
+                }
+            }
+            const combined = combineUploadChunks(pending, pendingByteLength);
+            const bytes = combined.subarray(0, targetByteLength);
+            const remainder = combined.subarray(targetByteLength);
+            const endExclusive = offset + targetByteLength;
+            yield {
+                bytes,
+                endExclusive,
+                offset,
+            };
+            pending = remainder.byteLength === 0 ? [] : [remainder];
+            pendingByteLength = remainder.byteLength;
+            offset = endExclusive;
+        }
+        if (pendingByteLength > 0) {
+            throw new Error("Source archive stream exceeded declared size");
+        }
+        const next = await reader.read();
+        if (!next.done && next.value.byteLength > 0) {
+            throw new Error("Source archive stream exceeded declared size");
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+const uploadArchiveToAzureFileShare = async (input) => {
+    const rangeUrl = buildAzureFileShareRangeUploadUrl(input.upload.url);
+    const baseHeaders = new Headers(input.upload.headers);
+    baseHeaders.set("x-ms-write", "update");
+    for await (const chunk of readUploadChunks({
+        rangeSize: input.upload.rangeSize,
+        signal: input.signal,
+        size: input.archiveByteLength,
+        stream: input.stream,
+    })) {
+        const headers = new Headers(baseHeaders);
+        headers.set("content-length", String(chunk.bytes.byteLength));
+        headers.set("x-ms-range", `bytes=${String(chunk.offset)}-${String(chunk.endExclusive - 1)}`);
+        // Node fetch accepts typed arrays; this BodyInit type does not.
+        const requestBody = chunk.bytes;
+        const response = await fetch(rangeUrl, {
+            body: requestBody,
+            headers,
+            method: input.upload.method,
+            signal: input.signal,
+        });
+        const responseBody = await response.text();
+        if (!response.ok) {
+            throw new Error(`Runneth VM destination file-share upload failed with HTTP ${String(response.status)}: ${responseBody}`);
+        }
+    }
+};
+const applyDestinationArchive = async (input) => {
+    const response = await fetch(buildSshAppApiUrl(input.destinationSshUrl, SSH_APP_ARCHIVE_APPLY_PATH), {
+        body: JSON.stringify({
+            archivePath: input.archivePath,
+            destinationPath: input.destinationPath,
+        }),
+        headers: {
+            Accept: "application/json",
+            Authorization: input.authorizationHeader,
+            "Content-Type": "application/json",
+        },
+        method: "POST",
+        signal: input.signal,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new Error(`Runneth VM destination archive apply failed with HTTP ${String(response.status)}: ${responseBody}`);
+    }
+    return parseArchiveUploadResponse(JSON.parse(responseBody));
+};
+const cleanupDestinationArchiveUpload = async (input) => {
+    const response = await fetch(buildSshAppApiUrl(input.destinationSshUrl, SSH_APP_ARCHIVE_UPLOAD_CLEANUP_PATH), {
+        body: JSON.stringify({
+            archivePath: input.archivePath,
+        }),
+        headers: {
+            Accept: "application/json",
+            Authorization: input.authorizationHeader,
+            "Content-Type": "application/json",
+        },
+        method: "POST",
+        signal: input.signal,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new Error(`Runneth VM destination archive cleanup failed with HTTP ${String(response.status)}: ${responseBody}`);
+    }
+};
+const formatErrorMessage = (error) => {
+    return error instanceof Error ? error.message : String(error);
+};
+const assertUploadedByteCount = (input) => {
+    if (input.bytesWritten !== input.bytesArchived) {
+        throw new Error(`Runneth VM copy byte count mismatch: archived ${String(input.bytesArchived)}, wrote ${String(input.bytesWritten)}`);
+    }
+};
+const assertUploadedEntryCount = (input) => {
+    if (input.entriesWritten !== input.entriesArchived) {
+        throw new Error(`Runneth VM copy entry count mismatch: archived ${String(input.entriesArchived)}, wrote ${String(input.entriesWritten)}`);
+    }
+};
+const copyViaSshApps = async (input) => {
+    const archive = await downloadSourceArchive({
+        authorizationHeader: input.authorizationHeader,
+        ignoredPaths: input.ignoredPaths,
+        signal: input.signal,
+        sourcePath: input.sourcePath,
+        sourceSshUrl: input.sourceSshUrl,
+    });
+    let preparedUpload = null;
+    let copyCompleted = false;
+    let copyError = null;
+    try {
+        preparedUpload = await prepareDestinationArchiveUpload({
+            authorizationHeader: input.authorizationHeader,
+            archiveByteLength: archive.archiveByteLength,
+            destinationPath: input.destinationPath,
+            destinationSshUrl: input.destinationSshUrl,
+            signal: input.signal,
+        });
+        await uploadArchiveToAzureFileShare({
+            archiveByteLength: archive.archiveByteLength,
+            signal: input.signal,
+            stream: archive.stream,
+            upload: preparedUpload.upload,
+        });
+        const upload = await applyDestinationArchive({
+            archivePath: preparedUpload.archivePath,
+            authorizationHeader: input.authorizationHeader,
+            destinationPath: input.destinationPath,
+            destinationSshUrl: input.destinationSshUrl,
+            signal: input.signal,
+        });
+        assertUploadedByteCount({
+            bytesArchived: archive.bytesArchived,
+            bytesWritten: upload.bytesWritten,
+        });
+        assertUploadedEntryCount({
+            entriesArchived: archive.entriesArchived,
+            entriesWritten: upload.entriesWritten,
+        });
+        copyCompleted = true;
+        return upload.bytesWritten;
+    }
+    catch (error) {
+        copyError = error;
+        throw error;
+    }
+    finally {
+        if (preparedUpload !== null && !copyCompleted) {
+            const cleanupAbortController = new AbortController();
+            const cleanupTimeout = setTimeout(() => {
+                cleanupAbortController.abort();
+            }, DESTINATION_CLEANUP_TIMEOUT_MS);
+            try {
+                await cleanupDestinationArchiveUpload({
+                    archivePath: preparedUpload.archivePath,
+                    authorizationHeader: input.authorizationHeader,
+                    destinationSshUrl: input.destinationSshUrl,
+                    signal: cleanupAbortController.signal,
+                });
+            }
+            catch (cleanupError) {
+                if (copyError !== null) {
+                    throw new Error(`Runneth VM copy failed: ${formatErrorMessage(copyError)}; cleanup failed: ${formatErrorMessage(cleanupError)}`);
+                }
+                throw cleanupError;
+            }
+            finally {
+                clearTimeout(cleanupTimeout);
+            }
+        }
+    }
+};
+const runCopyRequest = async (input) => {
+    try {
+        return await copyViaSshApps(input);
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+            throw new Error("Runneth VM copy timed out");
+        }
+        throw error;
+    }
+};
+export const runRunnethVmCopy = async (options) => {
+    assertRunnethVmCopyTargetsUseSameResource({
+        destination: options.destination,
+        source: options.source,
+    });
+    const sourcePath = normalizeRemotePath(options.sourcePath, "Source path");
+    const destinationPath = normalizeRemotePath(options.destinationPath, "Destination path");
+    const ignoredPaths = resolveIgnoredPaths(options.ignoredPaths);
+    const sourceVmName = resolveTargetVmName(options.source, "source");
+    const destinationVmName = resolveTargetVmName(options.destination, "destination");
+    const abortController = new AbortController();
+    const timeout = options.timeoutMs === undefined
+        ? null
+        : setTimeout(() => {
+            abortController.abort();
+        }, options.timeoutMs);
+    try {
+        const bytesCopied = await runCopyRequest({
+            authorizationHeader: resolveBearerAuthorizationHeader(options.oauthToken),
+            destinationPath,
+            destinationSshUrl: options.destination.sshUrl,
+            ignoredPaths,
+            signal: abortController.signal,
+            sourcePath,
+            sourceSshUrl: options.source.sshUrl,
+        });
+        return {
+            bytesCopied,
+            destinationPath,
+            destinationVmName,
+            ...(options.destination.targetName === undefined
+                ? {}
+                : { destinationTargetName: options.destination.targetName }),
+            sourcePath,
+            sourceVmName,
+            ...(options.source.targetName === undefined
+                ? {}
+                : { sourceTargetName: options.source.targetName }),
+        };
+    }
+    finally {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+export { assertRunnethVmCopyTargetsUseSameResource, runRunnethVmCopy, type RunnethVmCopyOptions, type RunnethVmCopyResult, } from "./copy.js";
+export { getOAuthAccessToken, loginWithOAuth, logoutOAuthCredential, readOAuthCredential, readOAuthCredentialStatus, resolveOAuthCredentialPath, type OAuthClientRegistration, type OAuthCredentialStatus, type OAuthLoginOptions, type OAuthServerMetadata, type OAuthStoredCredential, type OAuthStoredToken, type OAuthTokenEndpointAuthMethod, type OAuthTokenResult, } from "./oauth.js";
+export { resolveRunnethCliHome, resolveSocketPath } from "./paths.js";
+export { installRunnethSshAccess, normalizeRunnethSshTargetName, readRunnethSshTargetStore, removeRunnethSshTarget, resolveRunnethSshTarget, resolveRunnethSshAppUrl, resolveRunnethSshSharedKeyPaths, resolveRunnethSshTargetsPath, resolveRunnethSshTargetPaths, runOpenSsh, runRunnethSshProxy, saveRunnethSshTarget, setDefaultRunnethSshTarget, type OpenSshOptions, type ResolvedRunnethSshTarget, type RunnethSshAppMetadata, type RunnethSshGeneratedKeyMode, type RunnethSshInstallResponse, type RunnethSshKeyMode, type RunnethSshKeyPaths, type RunnethSshProxyOptions, type RunnethSshProxyStreams, type RunnethSshSetupOptions, type RunnethSshSetupResult, type RunnethSshTarget, type RunnethSshTargetPaths, type RunnethSshTargetStore, } from "./ssh.js";
+export { installRunnethSkills, resolveBundledRunnethSkillPath, type RunnethSkillAgent, type RunnethSkillInstallOptions, type RunnethSkillInstallResult, type RunnethSkillInstallTarget, } from "./skills.js";
+export type RunnethCliRequest = Readonly<{
+    cwd: string;
+    name: string;
+    op: "open";
+    shell?: string;
+}> | Readonly<{
+    command: string;
+    cwd: string;
+    name: string;
+    op: "send";
+    shell?: string;
+}> | Readonly<{
+    name: string;
+    op: "status";
+}> | Readonly<{
+    op: "list";
+}> | Readonly<{
+    name: string;
+    op: "close";
+}> | Readonly<{
+    op: "ping";
+}> | Readonly<{
+    op: "shutdown";
+}>;
+export type RunnethCliPublicSession = Readonly<{
+    busy: boolean;
+    cwd: string;
+    name: string;
+    pid: number;
+    running: boolean;
+    sessionId: string;
+    shell: string;
+    startedAt: string;
+}>;
+export type RunnethCliResponse = Readonly<{
+    ok: true;
+    op: "open";
+    session: RunnethCliPublicSession;
+}> | Readonly<{
+    exitCode: number;
+    ok: true;
+    op: "send";
+    session: RunnethCliPublicSession;
+    stderr: string;
+    stdout: string;
+}> | Readonly<{
+    ok: true;
+    op: "status";
+    session: RunnethCliPublicSession | null;
+}> | Readonly<{
+    ok: true;
+    op: "list";
+    sessions: readonly RunnethCliPublicSession[];
+}> | Readonly<{
+    ok: true;
+    op: "close";
+    session: RunnethCliPublicSession;
+}> | Readonly<{
+    ok: true;
+    op: "ping";
+}> | Readonly<{
+    ok: true;
+    op: "shutdown";
+}> | Readonly<{
+    error: string;
+    ok: false;
+}>;
+export type RunnethCliDaemonOptions = Readonly<{
+    socketPath: string;
+}>;
+type ExtractedCommandResult = Readonly<{
+    consumedStdoutBytes: number;
+    exitCode: number;
+    stdout: string;
+}>;
+export declare const normalizeSessionName: (value: string | undefined) => string;
+export declare const parseRunnethCliRequest: (value: unknown) => RunnethCliRequest;
+export declare const createCommandEnvelope: (command: string) => Readonly<{
+    input: string;
+    marker: string;
+}>;
+export declare const extractCommandResult: (input: {
+    readonly marker: string;
+    readonly stdout: Buffer;
+}) => ExtractedCommandResult | null;
+export declare class RunnethCliDaemon {
+    #private;
+    start(options: RunnethCliDaemonOptions): Promise<void>;
+    stop(): Promise<void>;
+    handleRequest(request: RunnethCliRequest): Promise<RunnethCliResponse>;
+}
+export declare const sendRunnethCliRequest: (input: {
+    readonly request: RunnethCliRequest;
+    readonly socketPath: string;
+    readonly timeoutMs?: number;
+}) => Promise<RunnethCliResponse>;
+export declare const startDaemonProcess: (input: {
+    readonly cliPath: string;
+    readonly socketPath: string;
+}) => Promise<void>;
+export declare const ensureDaemon: (input: {
+    readonly cliPath: string;
+    readonly socketPath: string;
+}) => Promise<void>;