@ericsanchezok/meta-synergy 0.0.0-dev-202603260728

package/dist/meta-synergy/src/platform.d.ts

@@ -0,0 +1,25 @@
+import { MetaProtocolHost } from "@ericsanchezok/meta-protocol";
+export type ProcessEnv = Record<string, string | undefined>;
+export type ChildLike = {
+    pid?: number;
+    kill(signal?: number | NodeJS.Signals): boolean;
+};
+export declare namespace Platform {
+    function runtime(): MetaProtocolHost.Runtime;
+    function defaultShell(): MetaProtocolHost.Shell;
+    function supportedShells(): MetaProtocolHost.Shell[];
+    function detectCapabilities(): MetaProtocolHost.Capabilities;
+    function normalizeEnv(env: ProcessEnv): ProcessEnv;
+    function resolveShellLaunch(command: string): {
+        shell: MetaProtocolHost.Shell;
+        file: string;
+        args: string[];
+    };
+    function killTree(child: ChildLike, exited?: () => boolean): Promise<void>;
+    function encodeKeySequence(keys: string[]): {
+        data: string;
+        warnings: string[];
+    };
+    function resolveWorkdir(workdir?: string): string;
+    function sleep(ms: number): Promise<void>;
+}

package/dist/meta-synergy/src/platform.js

@@ -0,0 +1,230 @@
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+const SIGKILL_TIMEOUT_MS = 200;
+const ESC = "\u001b";
+export var Platform;
+(function (Platform) {
+    function runtime() {
+        if (typeof process.versions?.bun === "string")
+            return "bun";
+        if (typeof process.versions?.node === "string")
+            return "node";
+        return "unknown";
+    }
+    Platform.runtime = runtime;
+    function defaultShell() {
+        if (process.platform === "win32") {
+            const comspec = (process.env.ComSpec || process.env.COMSPEC || "").toLowerCase();
+            if (comspec.includes("pwsh"))
+                return "pwsh";
+            if (comspec.includes("powershell"))
+                return "powershell";
+            return "cmd";
+        }
+        return "sh";
+    }
+    Platform.defaultShell = defaultShell;
+    function supportedShells() {
+        return process.platform === "win32" ? ["cmd", "powershell", "pwsh"] : ["sh"];
+    }
+    Platform.supportedShells = supportedShells;
+    function detectCapabilities() {
+        return {
+            platform: process.platform,
+            arch: process.arch,
+            hostname: safeHostname(),
+            runtime: runtime(),
+            defaultShell: defaultShell(),
+            supportedShells: supportedShells(),
+            supportsPty: false,
+            supportsSendKeys: true,
+            supportsSoftKill: process.platform !== "win32",
+            supportsProcessGroups: process.platform !== "win32",
+            envCaseInsensitive: process.platform === "win32",
+            lineEndings: process.platform === "win32" ? "crlf" : "lf",
+        };
+    }
+    Platform.detectCapabilities = detectCapabilities;
+    function normalizeEnv(env) {
+        if (process.platform !== "win32") {
+            return { ...env };
+        }
+        const result = {};
+        const entries = Object.entries(env).sort(([left], [right]) => left.localeCompare(right));
+        const seen = new Set();
+        for (const [key, value] of entries) {
+            const upper = key.toUpperCase();
+            if (seen.has(upper) && key !== "Path")
+                continue;
+            seen.add(upper);
+            result[key === "PATH" ? "Path" : key] = value;
+        }
+        return result;
+    }
+    Platform.normalizeEnv = normalizeEnv;
+    function resolveShellLaunch(command) {
+        if (process.platform === "win32") {
+            return {
+                shell: "cmd",
+                file: process.env.ComSpec || process.env.COMSPEC || "cmd.exe",
+                args: ["/d", "/s", "/c", command],
+            };
+        }
+        return {
+            shell: "sh",
+            file: "/bin/sh",
+            args: ["-c", command],
+        };
+    }
+    Platform.resolveShellLaunch = resolveShellLaunch;
+    async function killTree(child, exited) {
+        const pid = child.pid;
+        if (!pid || exited?.())
+            return;
+        if (process.platform === "win32") {
+            await new Promise((resolve) => {
+                const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
+                    stdio: "ignore",
+                    windowsHide: true,
+                });
+                killer.once("exit", () => resolve());
+                killer.once("error", () => resolve());
+            });
+            return;
+        }
+        try {
+            process.kill(-pid, "SIGTERM");
+            await sleep(SIGKILL_TIMEOUT_MS);
+            if (!exited?.())
+                process.kill(-pid, "SIGKILL");
+            return;
+        }
+        catch { }
+        child.kill("SIGTERM");
+        await sleep(SIGKILL_TIMEOUT_MS);
+        if (!exited?.())
+            child.kill("SIGKILL");
+    }
+    Platform.killTree = killTree;
+    function encodeKeySequence(keys) {
+        const warnings = [];
+        let data = "";
+        for (const token of keys) {
+            data += encodeKeyToken(token, warnings);
+        }
+        return { data, warnings };
+    }
+    Platform.encodeKeySequence = encodeKeySequence;
+    function resolveWorkdir(workdir) {
+        if (!workdir)
+            return process.cwd();
+        if (path.isAbsolute(workdir))
+            return workdir;
+        return path.resolve(process.cwd(), workdir);
+    }
+    Platform.resolveWorkdir = resolveWorkdir;
+    function sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    Platform.sleep = sleep;
+})(Platform || (Platform = {}));
+function encodeKeyToken(raw, warnings) {
+    const token = raw.trim();
+    if (!token)
+        return "";
+    if (token.length === 2 && token.startsWith("^")) {
+        const ctrl = toCtrlChar(token[1]);
+        if (ctrl)
+            return ctrl;
+    }
+    const parsed = parseModifiers(token);
+    const named = namedKey(parsed.base.toLowerCase());
+    if (named) {
+        return parsed.alt ? `${ESC}${named}` : named;
+    }
+    if (parsed.base.length === 1) {
+        let value = parsed.shift && /[a-z]/.test(parsed.base) ? parsed.base.toUpperCase() : parsed.base;
+        if (parsed.ctrl)
+            value = toCtrlChar(value) || value;
+        if (parsed.alt)
+            value = `${ESC}${value}`;
+        return value;
+    }
+    if (parsed.hasModifiers) {
+        warnings.push(`Unknown key \"${parsed.base}\" for modifiers; sending literal.`);
+    }
+    return parsed.base;
+}
+function parseModifiers(token) {
+    let rest = token;
+    let ctrl = false;
+    let alt = false;
+    let shift = false;
+    let hasModifiers = false;
+    while (rest.length > 2 && rest[1] === "-") {
+        const mod = rest[0].toLowerCase();
+        if (mod === "c")
+            ctrl = true;
+        else if (mod === "m")
+            alt = true;
+        else if (mod === "s")
+            shift = true;
+        else
+            break;
+        hasModifiers = true;
+        rest = rest.slice(2);
+    }
+    return { base: rest, ctrl, alt, shift, hasModifiers };
+}
+function namedKey(input) {
+    const map = new Map([
+        ["enter", "\r"],
+        ["return", "\r"],
+        ["tab", "\t"],
+        ["escape", ESC],
+        ["esc", ESC],
+        ["space", " "],
+        ["backspace", process.platform === "win32" ? "\b" : "\u007f"],
+        ["up", `${ESC}[A`],
+        ["down", `${ESC}[B`],
+        ["right", `${ESC}[C`],
+        ["left", `${ESC}[D`],
+        ["home", `${ESC}[1~`],
+        ["end", `${ESC}[4~`],
+        ["pageup", `${ESC}[5~`],
+        ["pagedown", `${ESC}[6~`],
+        ["insert", `${ESC}[2~`],
+        ["delete", `${ESC}[3~`],
+        ["f1", `${ESC}OP`],
+        ["f2", `${ESC}OQ`],
+        ["f3", `${ESC}OR`],
+        ["f4", `${ESC}OS`],
+        ["f5", `${ESC}[15~`],
+        ["f6", `${ESC}[17~`],
+        ["f7", `${ESC}[18~`],
+        ["f8", `${ESC}[19~`],
+        ["f9", `${ESC}[20~`],
+        ["f10", `${ESC}[21~`],
+        ["f11", `${ESC}[23~`],
+        ["f12", `${ESC}[24~`],
+    ]);
+    return map.get(input);
+}
+function toCtrlChar(char) {
+    if (char.length !== 1)
+        return null;
+    if (char === "?")
+        return "\u007f";
+    const code = char.toUpperCase().charCodeAt(0);
+    return code >= 64 && code <= 95 ? String.fromCharCode(code & 0x1f) : null;
+}
+function safeHostname() {
+    try {
+        return os.hostname();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/meta-synergy/src/rpc/handler.d.ts

@@ -0,0 +1,66 @@
+import { ProcessRegistry } from "../exec/process-registry";
+import { MetaSynergyHost, type MetaSynergyHostOptions } from "../host";
+import { BashRunner } from "../exec/bash-runner";
+export declare class RPCHandler {
+    readonly host: MetaSynergyHost;
+    readonly processRegistry: ProcessRegistry;
+    readonly bashRunner: BashRunner;
+    constructor(options?: MetaSynergyHostOptions);
+    handle(input: unknown): Promise<{
+        version: 1;
+        requestID: string;
+        ok: false;
+        error: {
+            code: "env_not_found" | "env_inactive" | "device_offline" | "request_timeout" | "request_cancelled" | "remote_execution_error" | "invalid_request" | "unsupported_tool" | "unsupported_action" | "unsupported_capability" | "host_internal_error" | "stale_process_handle" | "stdin_unavailable";
+            message: string;
+            details?: unknown;
+        };
+    } | {
+        readonly version: 1;
+        readonly requestID: string;
+        readonly ok: true;
+        readonly result: {
+            title: string;
+            metadata: {
+                output?: string | undefined;
+                description?: string | undefined;
+                exit?: number | null | undefined;
+                processId?: string | undefined;
+                background?: boolean | undefined;
+                timedOut?: boolean | undefined;
+                durationMs?: number | undefined;
+                hostSessionID?: string | undefined;
+                envID?: string | undefined;
+                backend?: "local" | "remote" | undefined;
+            };
+            output: string;
+        };
+    } | {
+        readonly version: 1;
+        readonly requestID: string;
+        readonly ok: true;
+        readonly result: {
+            title: string;
+            metadata: {
+                action: "list" | "poll" | "log" | "write" | "send-keys" | "kill" | "clear" | "remove";
+                processId?: string | undefined;
+                status?: "error" | "running" | "completed" | "failed" | "killed" | "not_found" | "cleared" | "removed" | undefined;
+                exitCode?: number | undefined;
+                command?: string | undefined;
+                description?: string | undefined;
+                nextOffset?: number | undefined;
+                hostSessionID?: string | undefined;
+                envID?: string | undefined;
+                backend?: "local" | "remote" | undefined;
+                processes?: {
+                    processId: string;
+                    status: "running" | "completed" | "failed" | "killed";
+                    command: string;
+                    runtimeMs: number;
+                    description?: string | undefined;
+                }[] | undefined;
+            };
+            output: string;
+        };
+    }>;
+}

package/dist/meta-synergy/src/rpc/handler.js

@@ -0,0 +1,60 @@
+import { ProcessRegistry } from "../exec/process-registry";
+import { MetaSynergyHost } from "../host";
+import { BashRunner } from "../exec/bash-runner";
+import { RPCRequestSchema } from "./schema";
+export class RPCHandler {
+    host;
+    processRegistry;
+    bashRunner;
+    constructor(options = {}) {
+        this.host = new MetaSynergyHost(options);
+        this.processRegistry = new ProcessRegistry(this.host);
+        this.bashRunner = new BashRunner(this.processRegistry);
+    }
+    async handle(input) {
+        try {
+            const request = RPCRequestSchema.parse(input);
+            this.host.assertEnv(request.envID);
+            if (request.tool === "bash") {
+                const result = await this.bashRunner.run(request.payload, request.envID);
+                return {
+                    version: 1,
+                    requestID: request.requestID,
+                    ok: true,
+                    result,
+                };
+            }
+            if (request.tool === "process") {
+                const result = await this.processRegistry.execute(request.payload, request.envID);
+                return {
+                    version: 1,
+                    requestID: request.requestID,
+                    ok: true,
+                    result,
+                };
+            }
+            return errorResult(undefined, "unsupported_tool", "Unsupported tool");
+        }
+        catch (error) {
+            if (isEnvelopeError(error)) {
+                return errorResult(error.requestID, error.code, error.message, error.details);
+            }
+            return errorResult(undefined, "host_internal_error", error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+function errorResult(requestID, code, message, details) {
+    return {
+        version: 1,
+        requestID: requestID || crypto.randomUUID(),
+        ok: false,
+        error: {
+            code,
+            message,
+            details,
+        },
+    };
+}
+function isEnvelopeError(error) {
+    return typeof error === "object" && error !== null && "code" in error && "message" in error;
+}

package/dist/meta-synergy/src/rpc/schema.d.ts

@@ -0,0 +1,163 @@
+import z from "zod";
+export declare const RPCRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    requestID: z.ZodString;
+    envID: z.ZodString;
+    tool: z.ZodLiteral<"bash">;
+    action: z.ZodLiteral<"execute">;
+    payload: z.ZodObject<{
+        command: z.ZodString;
+        description: z.ZodString;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        workdir: z.ZodOptional<z.ZodString>;
+        background: z.ZodOptional<z.ZodBoolean>;
+        yieldMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    requestID: z.ZodString;
+    envID: z.ZodString;
+    tool: z.ZodLiteral<"process">;
+    action: z.ZodEnum<{
+        list: "list";
+        poll: "poll";
+        log: "log";
+        write: "write";
+        "send-keys": "send-keys";
+        kill: "kill";
+        clear: "clear";
+        remove: "remove";
+    }>;
+    payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"list">;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"poll">;
+        processId: z.ZodString;
+        block: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"log">;
+        processId: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"write">;
+        processId: z.ZodString;
+        data: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"send-keys">;
+        processId: z.ZodString;
+        keys: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"kill">;
+        processId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"clear">;
+        processId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"remove">;
+        processId: z.ZodString;
+    }, z.core.$strip>], "action">;
+}, z.core.$strip>], "tool">;
+export declare const RPCResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    requestID: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    result: z.ZodObject<{
+        title: z.ZodString;
+        metadata: z.ZodObject<{
+            output: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            exit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            processId: z.ZodOptional<z.ZodString>;
+            background: z.ZodOptional<z.ZodBoolean>;
+            timedOut: z.ZodOptional<z.ZodBoolean>;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            hostSessionID: z.ZodOptional<z.ZodString>;
+            envID: z.ZodOptional<z.ZodString>;
+            backend: z.ZodOptional<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+        }, z.core.$strip>;
+        output: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    requestID: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    result: z.ZodObject<{
+        title: z.ZodString;
+        metadata: z.ZodObject<{
+            action: z.ZodEnum<{
+                list: "list";
+                poll: "poll";
+                log: "log";
+                write: "write";
+                "send-keys": "send-keys";
+                kill: "kill";
+                clear: "clear";
+                remove: "remove";
+            }>;
+            processId: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodEnum<{
+                error: "error";
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                killed: "killed";
+                not_found: "not_found";
+                cleared: "cleared";
+                removed: "removed";
+            }>>;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            command: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            nextOffset: z.ZodOptional<z.ZodNumber>;
+            hostSessionID: z.ZodOptional<z.ZodString>;
+            envID: z.ZodOptional<z.ZodString>;
+            backend: z.ZodOptional<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+            processes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                processId: z.ZodString;
+                status: z.ZodEnum<{
+                    running: "running";
+                    completed: "completed";
+                    failed: "failed";
+                    killed: "killed";
+                }>;
+                command: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                runtimeMs: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        output: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    requestID: z.ZodString;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            env_not_found: "env_not_found";
+            env_inactive: "env_inactive";
+            device_offline: "device_offline";
+            request_timeout: "request_timeout";
+            request_cancelled: "request_cancelled";
+            remote_execution_error: "remote_execution_error";
+            invalid_request: "invalid_request";
+            unsupported_tool: "unsupported_tool";
+            unsupported_action: "unsupported_action";
+            unsupported_capability: "unsupported_capability";
+            host_internal_error: "host_internal_error";
+            stale_process_handle: "stale_process_handle";
+            stdin_unavailable: "stdin_unavailable";
+        }>;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "ok">;
+export type RPCRequest = z.infer<typeof RPCRequestSchema>;
+export type RPCResult = z.infer<typeof RPCResultSchema>;

package/dist/meta-synergy/src/rpc/schema.js

@@ -0,0 +1,11 @@
+import z from "zod";
+import { MetaProtocolBash, MetaProtocolEnvelope, MetaProtocolProcess } from "@ericsanchezok/meta-protocol";
+export const RPCRequestSchema = z.discriminatedUnion("tool", [
+    MetaProtocolBash.ExecuteRequest,
+    MetaProtocolProcess.ExecuteRequest,
+]);
+export const RPCResultSchema = z.discriminatedUnion("ok", [
+    MetaProtocolBash.ExecuteResult,
+    MetaProtocolProcess.ExecuteResult,
+    MetaProtocolEnvelope.ErrorResult,
+]);

package/dist/meta-synergy/src/types.d.ts

@@ -0,0 +1,14 @@
+import type { MetaProtocolEnv, MetaProtocolHost } from "@ericsanchezok/meta-protocol";
+export type EnvID = MetaProtocolEnv.EnvID;
+export type RequestID = string;
+export interface RemoteHostIdentity {
+    envID: EnvID;
+    hostSessionID: MetaProtocolEnv.HostSessionID;
+    capabilities: MetaProtocolHost.Capabilities;
+    label?: string;
+}
+export interface HostTransport {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(message: unknown): Promise<void>;
+}

package/dist/meta-synergy/src/types.js

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

package/package.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@ericsanchezok/meta-synergy",
+  "version": "0.0.0-dev-202603260728",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@ericsanchezok/meta-protocol": "0.0.0-dev-202603260728",
+    "zod": "4.1.8"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "22.0.2",
+    "@types/node": "22.13.9",
+    "typescript": "5.8.2"
+  }
+}

package/script/publish.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env bun
+import { Script } from "@ericsanchezok/synergy-script"
+import { $ } from "bun"
+
+const dir = new URL("..", import.meta.url).pathname
+process.chdir(dir)
+
+await $`bun tsc`
+const pkg = await import("../package.json").then((m) => m.default)
+const original = JSON.parse(JSON.stringify(pkg))
+for (const [key, value] of Object.entries(pkg.exports)) {
+  const source = typeof value === "string" ? value : (value as { import?: string }).import
+  if (!source || typeof source !== "string") continue
+  const file = source.replace("./src/", "./dist/").replace(".ts", "").replace(".js", "")
+  // @ts-ignore
+  pkg.exports[key] = {
+    import: file + ".js",
+    types: file + ".d.ts",
+  }
+}
+await Bun.write("package.json", JSON.stringify(pkg, null, 2))
+
+try {
+  const NPM_REGISTRY = "https://registry.npmjs.org"
+  await $`rm -f *.tgz`.nothrow()
+  await $`bun pm pack`
+  const tgz = (await $`ls *.tgz`.text()).trim()
+  const authFlag = process.env.NPM_TOKEN ? `--//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}` : ""
+  await $`npm publish ${tgz} --tag ${Script.channel} --registry ${NPM_REGISTRY} --access public ${authFlag}`
+} finally {
+  await Bun.write("package.json", JSON.stringify(original, null, 2))
+}

package/src/client/holos-client.ts

@@ -0,0 +1,49 @@
+import { MetaSynergyHost, type MetaSynergyHostOptions } from "../host"
+import type { HostTransport, RemoteHostIdentity } from "../types"
+
+export interface HolosClientOptions extends MetaSynergyHostOptions {
+  transport?: HostTransport
+  label?: string
+}
+
+export class HolosClient {
+  readonly host: MetaSynergyHost
+  readonly transport?: HostTransport
+  readonly label?: string
+
+  constructor(options: HolosClientOptions = {}) {
+    this.host = new MetaSynergyHost(options)
+    this.transport = options.transport
+    this.label = options.label
+  }
+
+  identity(): RemoteHostIdentity {
+    if (!this.host.envID) {
+      throw new Error("HolosClient requires envID to build identity")
+    }
+
+    return {
+      envID: this.host.envID,
+      hostSessionID: this.host.hostSessionID,
+      capabilities: this.host.capabilities,
+      label: this.label,
+    }
+  }
+
+  async connect(): Promise<void> {
+    if (!this.transport) {
+      return
+    }
+
+    await this.transport.connect()
+    await this.transport.send(this.host.hello())
+  }
+
+  async disconnect(): Promise<void> {
+    if (!this.transport) {
+      return
+    }
+
+    await this.transport.disconnect()
+  }
+}