@harness-control/runner 0.1.0

package/dist/host/provider-registry.js

@@ -0,0 +1,162 @@
+export class ProviderInstanceRegistry {
+    #config;
+    #driversByKind;
+    #driversByProviderId;
+    constructor(config, drivers = []) {
+        this.#config = config;
+        this.#driversByKind = new Map();
+        this.#driversByProviderId = new Map();
+        for (const driver of drivers) {
+            if (driver.provider_instance_id) {
+                this.#driversByProviderId.set(driver.provider_instance_id, driver);
+            }
+            else {
+                this.#driversByKind.set(driver.driver_kind, driver);
+            }
+        }
+    }
+    static fromConfig(config, drivers = []) {
+        return new ProviderInstanceRegistry(config, drivers);
+    }
+    snapshot(now = new Date()) {
+        return {
+            providers: this.#config.provider_instances.map((provider) => this.#snapshotProvider(provider, now)),
+            local_capabilities: this.#config.local_capabilities.map((capability) => ({
+                id: capability.id,
+                status: capability.status,
+                scopes: capability.scopes,
+                approval_required: capability.approval_required,
+                ...(capability.message ? { message: capability.message } : {}),
+            })),
+            workspaces: this.#config.workspaces.map((workspace) => ({
+                id: workspace.id,
+                path: workspace.path,
+                ...(workspace.display_name ? { display_name: workspace.display_name } : {}),
+                ...(workspace.git_remote ? { git_remote: workspace.git_remote } : {}),
+            })),
+            mcp_stdio_profiles: this.#config.mcp_stdio_profiles.map((profile) => ({
+                id: profile.id,
+                provider_instance_ids: profile.provider_instance_ids,
+                ...(profile.allowed_tools ? { allowed_tools: profile.allowed_tools } : {}),
+                ...(profile.denied_tools.length > 0 ? { denied_tools: profile.denied_tools } : {}),
+            })),
+        };
+    }
+    computeContinuationGroups() {
+        const groups = new Map();
+        for (const provider of this.#config.provider_instances) {
+            const key = computeContinuationGroupKey(provider);
+            const existing = groups.get(key);
+            if (existing) {
+                existing.provider_instance_ids.push(provider.id);
+            }
+            else {
+                groups.set(key, {
+                    key,
+                    driver_kind: provider.driver_kind,
+                    provider_instance_ids: [provider.id],
+                });
+            }
+        }
+        return Array.from(groups.values());
+    }
+    #snapshotProvider(provider, now) {
+        const driver = this.#driversByProviderId.get(provider.id) ?? this.#driversByKind.get(provider.driver_kind);
+        const enabled = provider.enabled;
+        const installed = driver?.installed ?? false;
+        const available = enabled && Boolean(driver?.available);
+        const status = enabled
+            ? driver?.status ?? (available ? "ready" : "unavailable")
+            : "disabled";
+        const snapshot = {
+            ...(driver?.execution_capabilities ? { execution_capabilities: driver.execution_capabilities } : {}),
+            provider_instance_id: provider.id,
+            driver_kind: provider.driver_kind,
+            ...(provider.display_name ? { display_name: provider.display_name } : {}),
+            ...(provider.accent_color ? { accent_color: provider.accent_color } : {}),
+            enabled,
+            installed,
+            status,
+            availability: available ? "available" : "unavailable",
+            ...(driver?.version ? { version: driver.version } : {}),
+            ...(available ? {} : { message: this.#unavailableMessage(provider, driver) }),
+            checked_at: now.toISOString(),
+            continuation_group_key: computeContinuationGroupKey(provider),
+            auth: {
+                status: driver?.authStatus ?? (status === "unauthenticated" ? "unauthenticated" : "unknown"),
+            },
+            models: provider.models.length > 0 ? normalizeHarnessModels(provider.models) : driver?.models ?? [],
+            local_capabilities: provider.local_capabilities,
+        };
+        if (provider.hidden_models.length > 0) {
+            snapshot.hidden_models = provider.hidden_models;
+        }
+        if (provider.model_order.length > 0) {
+            snapshot.model_order = provider.model_order;
+        }
+        if (provider.favorite_models.length > 0) {
+            snapshot.favorite_models = provider.favorite_models;
+        }
+        return snapshot;
+    }
+    #unavailableMessage(provider, driver) {
+        if (!provider.enabled) {
+            return "Provider is disabled in runner config.";
+        }
+        if (!driver) {
+            return `Unsupported provider driver '${provider.driver_kind}'.`;
+        }
+        if (driver.message) {
+            return driver.message;
+        }
+        return "Provider is unavailable.";
+    }
+}
+export function computeContinuationGroupKey(provider) {
+    if (provider.continuation_group_key) {
+        return provider.continuation_group_key;
+    }
+    if (provider.driver_kind === "codex" && provider.home) {
+        return `codex:${provider.home}`;
+    }
+    if (provider.driver_kind === "claude" && provider.home) {
+        return `claude:${provider.home}`;
+    }
+    return `driver:${provider.driver_kind}`;
+}
+function normalizeHarnessModels(models) {
+    return models.map((model) => {
+        const result = {
+            id: model.id,
+            label: model.label,
+            capabilities: {
+                option_descriptors: model.capabilities.option_descriptors.map(normalizeHarnessOptionDescriptor),
+            },
+        };
+        if (model.is_default !== undefined) {
+            result.is_default = model.is_default;
+        }
+        return result;
+    });
+}
+function normalizeHarnessOptionDescriptor(option) {
+    const result = {
+        id: option.id,
+        label: option.label,
+        type: option.type,
+    };
+    if (option.values !== undefined) {
+        result.values = option.values;
+    }
+    if (option.default_value !== undefined) {
+        result.default_value = option.default_value;
+    }
+    if (option.current_value !== undefined) {
+        result.current_value = option.current_value;
+    }
+    if (option.prompt_injected_values !== undefined) {
+        result.prompt_injected_values = option.prompt_injected_values;
+    }
+    return result;
+}
+//# sourceMappingURL=provider-registry.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<number>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { HCP_VERSION } from "@harness-control/protocol";
+import { JsonlAuditLogger, defaultAuditLogPath } from "./audit/index.js";
+import { loadRunnerConfig } from "./config/index.js";
+import { RunnerConnection } from "./connection/index.js";
+import { HarnessSessionManager } from "./harnesses/index.js";
+import { consoleLogger } from "./logs/index.js";
+import { createDevelopmentHmacProofSigner } from "./mcp/McpAttachmentClient.js";
+import { JsonRunnerStateStore, defaultRunnerStatePath } from "./state/index.js";
+import { defaultCredentialsPath, loadRunnerCredential, normalizeControlPlaneUrl, pairWithReferenceControlPlane, requestConnectionToken, writeRunnerCredentials, } from "./pairing/index.js";
+const RUNNER_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+export async function main(argv = process.argv.slice(2)) {
+    const command = argv[0];
+    if (command === "version") {
+        console.log(`hcp-runner ${RUNNER_VERSION} (${HCP_VERSION})`);
+        return 0;
+    }
+    if (command === "pair") {
+        let pairOptions;
+        let controlPlaneUrl;
+        try {
+            pairOptions = parsePairOptions(argv.slice(1));
+            controlPlaneUrl = normalizeControlPlaneUrl(pairOptions.controlPlaneUrl);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : "Invalid pair arguments.");
+            console.error("Usage: hcp-runner pair <control-plane-url> [--runner-id id] [--host-id id] [--out path] [--credentials-out path] [--offline]");
+            return 1;
+        }
+        if (pairOptions.offline) {
+            const config = {
+                runner_id: pairOptions.runnerId,
+                host_id: pairOptions.hostId,
+                control_plane_url: controlPlaneUrl,
+                workspaces: [],
+                provider_instances: [],
+            };
+            const serializedConfig = `${JSON.stringify(config, null, 2)}\n`;
+            if (pairOptions.outPath) {
+                await writeFile(pairOptions.outPath, serializedConfig, { mode: 0o600 });
+                console.log(`Wrote offline runner config to ${pairOptions.outPath}`);
+            }
+            else {
+                console.log(serializedConfig.trimEnd());
+            }
+            return 0;
+        }
+        const credentialsPath = pairOptions.credentialsPath ?? defaultCredentialsPath();
+        const pairing = await pairWithReferenceControlPlane({
+            controlPlaneUrl,
+            runnerId: pairOptions.runnerId,
+            hostId: pairOptions.hostId,
+            onPairingCode: (code) => { console.error(`Approve runner pairing at ${code.pairing_url} (code: ${code.pairing_code}). Waiting for approval…`); },
+        });
+        await writeRunnerCredentials(credentialsPath, pairing.credential);
+        const config = {
+            runner_id: pairOptions.runnerId,
+            host_id: pairOptions.hostId,
+            control_plane_url: pairing.controlPlaneUrl,
+            credentials_path: credentialsPath,
+            workspaces: [],
+            provider_instances: [],
+        };
+        const serializedConfig = `${JSON.stringify(config, null, 2)}\n`;
+        if (pairOptions.outPath) {
+            await writeFile(pairOptions.outPath, serializedConfig, { mode: 0o600 });
+            console.log(`Wrote paired runner config to ${pairOptions.outPath}`);
+            console.log(`Stored runner credentials at ${credentialsPath}`);
+        }
+        else {
+            console.log(serializedConfig.trimEnd());
+        }
+        return 0;
+    }
+    if (command === "run") {
+        const configPath = parseConfigPath(argv.slice(1));
+        if (!configPath) {
+            console.error("Usage: hcp-runner run --config <path>");
+            return 1;
+        }
+        const config = await loadRunnerConfig(configPath);
+        const credential = await loadRunnerCredential(config);
+        const stateStore = new JsonRunnerStateStore(config.state_path ?? defaultRunnerStatePath(config.runner_id));
+        const harnessSessions = new HarnessSessionManager(config, {
+            auditLogger: new JsonlAuditLogger(defaultAuditLogPath()),
+            stateStore,
+            ...(credential
+                ? { mcpProofSigner: createDevelopmentHmacProofSigner(credential.mcp_proof_secret) }
+                : {}),
+        });
+        const connection = new RunnerConnection({
+            config,
+            runnerVersion: RUNNER_VERSION,
+            configPath,
+            harnessSessions,
+            ...(credential
+                ? {
+                    connectionTokenProvider: async () => requestConnectionToken(config, credential),
+                }
+                : {}),
+            onLog: (message) => {
+                consoleLogger.info(message);
+            },
+        });
+        await connection.connect();
+        consoleLogger.info(`Runner '${config.runner_id}' connected to ${config.control_plane_url}.`);
+        const close = async () => {
+            await connection.close();
+        };
+        process.once("SIGINT", () => {
+            close().then(() => process.exit(0));
+        });
+        process.once("SIGTERM", () => {
+            close().then(() => process.exit(0));
+        });
+        return new Promise(() => undefined);
+    }
+    console.log("Usage: hcp-runner <version|pair|run>");
+    return command ? 1 : 0;
+}
+function parseConfigPath(args) {
+    const configFlagIndex = args.indexOf("--config");
+    if (configFlagIndex === -1) {
+        return undefined;
+    }
+    return args[configFlagIndex + 1];
+}
+function parsePairOptions(args) {
+    const controlPlaneUrl = args[0];
+    if (!controlPlaneUrl) {
+        throw new Error("Missing control plane URL.");
+    }
+    const defaultHostId = hostname().replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+    let runnerId = `runner-${defaultHostId}`;
+    let hostId = defaultHostId;
+    let outPath;
+    let credentialsPath;
+    let offline = false;
+    for (let index = 1; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === "--runner-id") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--runner-id requires a value.");
+            }
+            runnerId = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--host-id") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--host-id requires a value.");
+            }
+            hostId = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--out") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--out requires a value.");
+            }
+            outPath = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--credentials-out") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--credentials-out requires a value.");
+            }
+            credentialsPath = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--offline") {
+            offline = true;
+            continue;
+        }
+        throw new Error(`Unknown pair argument: ${arg}`);
+    }
+    return {
+        controlPlaneUrl,
+        runnerId,
+        hostId,
+        offline,
+        ...(outPath ? { outPath } : {}),
+        ...(credentialsPath ? { credentialsPath } : {}),
+    };
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+    main().then((exitCode) => {
+        process.exitCode = exitCode;
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/local-actions/dispatcher.d.ts

@@ -0,0 +1,28 @@
+import type { HcpHarnessEventPayload, LocalActionErrorPayload, LocalActionRequestPayload, LocalActionResponsePayload } from "@harness-control/protocol";
+import { LocalCapabilityExecutor, type LocalCapabilityExecutionContext, type LocalCapabilityExecutionEvent } from "./executors.js";
+export type LocalActionContextResolver = (request: LocalActionRequestPayload) => Promise<LocalCapabilityExecutionContext>;
+export type LocalActionEventEmitter = (sessionId: string, turnId: string, events: LocalCapabilityExecutionEvent[]) => HcpHarnessEventPayload[];
+export type LocalActionDispatcherOptions = {
+    executor: LocalCapabilityExecutor;
+    resolveContext: LocalActionContextResolver;
+    emitEvents: LocalActionEventEmitter;
+    now?: () => Date;
+};
+export type LocalActionDispatchOutcome = {
+    type: "response";
+    payload: LocalActionResponsePayload;
+    events: HcpHarnessEventPayload[];
+} | {
+    type: "error";
+    payload: LocalActionErrorPayload;
+    events: HcpHarnessEventPayload[];
+};
+export declare class LocalActionDispatcher {
+    #private;
+    constructor(options: LocalActionDispatcherOptions);
+    dispatch(request: LocalActionRequestPayload): Promise<LocalActionDispatchOutcome>;
+    duplicatePayloadMismatch(request: LocalActionRequestPayload): LocalActionDispatchOutcome;
+    markSessionActive(sessionId: string): void;
+    stopDevServersForSession(sessionId: string): Promise<void>;
+}
+//# sourceMappingURL=dispatcher.d.ts.map