@ericsanchezok/meta-protocol 0.0.0-dev-202603260727

package/.turbo/turbo-typecheck.log

@@ -0,0 +1 @@
+$ tsc --noEmit

package/dist/bash.d.ts

@@ -0,0 +1,89 @@
+import z from "zod";
+export declare namespace MetaProtocolBash {
+    const ExecutePayload: 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>;
+    type ExecutePayload = z.infer<typeof ExecutePayload>;
+    const ResultMetadata: 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>;
+    type ResultMetadata = z.infer<typeof ResultMetadata>;
+    const 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>;
+    type Result = z.infer<typeof Result>;
+    const ExecuteRequest: 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>;
+    type ExecuteRequest = z.infer<typeof ExecuteRequest>;
+    const ExecuteResult: 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>;
+    type ExecuteResult = z.infer<typeof ExecuteResult>;
+}

package/dist/bash.js

@@ -0,0 +1,40 @@
+import z from "zod";
+import { MetaProtocolEnvelope } from "./envelope";
+import { MetaProtocolEnv } from "./env";
+export var MetaProtocolBash;
+(function (MetaProtocolBash) {
+    MetaProtocolBash.ExecutePayload = z.object({
+        command: z.string(),
+        description: z.string(),
+        timeout: z.number().optional(),
+        workdir: z.string().optional(),
+        background: z.boolean().optional(),
+        yieldMs: z.number().optional(),
+    });
+    MetaProtocolBash.ResultMetadata = z.object({
+        output: z.string().optional(),
+        description: z.string().optional(),
+        exit: z.number().nullable().optional(),
+        processId: MetaProtocolEnv.ProcessID.optional(),
+        background: z.boolean().optional(),
+        timedOut: z.boolean().optional(),
+        durationMs: z.number().optional(),
+        hostSessionID: MetaProtocolEnv.HostSessionID.optional(),
+        envID: MetaProtocolEnv.EnvID.optional(),
+        backend: z.enum(["local", "remote"]).optional(),
+    });
+    MetaProtocolBash.Result = z.object({
+        title: z.string(),
+        metadata: MetaProtocolBash.ResultMetadata,
+        output: z.string(),
+    });
+    MetaProtocolBash.ExecuteRequest = MetaProtocolEnvelope.RequestBase.extend({
+        tool: z.literal("bash"),
+        action: z.literal("execute"),
+        payload: MetaProtocolBash.ExecutePayload,
+    });
+    MetaProtocolBash.ExecuteResult = MetaProtocolEnvelope.ResultBase.extend({
+        ok: z.literal(true),
+        result: MetaProtocolBash.Result,
+    });
+})(MetaProtocolBash || (MetaProtocolBash = {}));

package/dist/client.d.ts

@@ -0,0 +1,9 @@
+import type { MetaProtocolBash } from "./bash";
+import type { MetaProtocolEnv } from "./env";
+import type { MetaProtocolProcess } from "./process";
+export declare namespace MetaProtocolClient {
+    interface ExecutionClient {
+        executeBash(envID: MetaProtocolEnv.EnvID, input: MetaProtocolBash.ExecutePayload): Promise<MetaProtocolBash.Result>;
+        executeProcess(envID: MetaProtocolEnv.EnvID, input: MetaProtocolProcess.ExecutePayload): Promise<MetaProtocolProcess.Result>;
+    }
+}

package/dist/client.js

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

package/dist/env.d.ts

@@ -0,0 +1,16 @@
+import z from "zod";
+export declare namespace MetaProtocolEnv {
+    const EnvID: z.ZodString;
+    type EnvID = z.infer<typeof EnvID>;
+    const ProcessID: z.ZodString;
+    type ProcessID = z.infer<typeof ProcessID>;
+    const HostSessionID: z.ZodString;
+    type HostSessionID = z.infer<typeof HostSessionID>;
+    type Target = {
+        kind: "local";
+    } | {
+        kind: "remote";
+        envID: EnvID;
+    };
+    function resolve(envID?: string): Target;
+}

package/dist/env.js

@@ -0,0 +1,17 @@
+import z from "zod";
+export var MetaProtocolEnv;
+(function (MetaProtocolEnv) {
+    MetaProtocolEnv.EnvID = z.string().min(1).describe("Execution environment ID");
+    MetaProtocolEnv.ProcessID = z.string().min(1).describe("Opaque process identifier");
+    MetaProtocolEnv.HostSessionID = z.string().min(1).describe("Remote host session identifier");
+    function resolve(envID) {
+        if (!envID) {
+            return { kind: "local" };
+        }
+        return {
+            kind: "remote",
+            envID,
+        };
+    }
+    MetaProtocolEnv.resolve = resolve;
+})(MetaProtocolEnv || (MetaProtocolEnv = {}));

package/dist/envelope.d.ts

@@ -0,0 +1,50 @@
+import z from "zod";
+export declare namespace MetaProtocolEnvelope {
+    const Tool: z.ZodEnum<{
+        bash: "bash";
+        process: "process";
+    }>;
+    type Tool = z.infer<typeof Tool>;
+    const RequestBase: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        requestID: z.ZodString;
+        envID: z.ZodString;
+        tool: z.ZodEnum<{
+            bash: "bash";
+            process: "process";
+        }>;
+        action: z.ZodString;
+    }, z.core.$strip>;
+    type RequestBase = z.infer<typeof RequestBase>;
+    const ResultBase: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        requestID: z.ZodString;
+        ok: z.ZodBoolean;
+    }, z.core.$strip>;
+    type ResultBase = z.infer<typeof ResultBase>;
+    const ErrorResult: 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>;
+    type ErrorResult = z.infer<typeof ErrorResult>;
+}

package/dist/envelope.js

@@ -0,0 +1,23 @@
+import z from "zod";
+import { MetaProtocolEnv } from "./env";
+import { MetaProtocolError } from "./error";
+export var MetaProtocolEnvelope;
+(function (MetaProtocolEnvelope) {
+    MetaProtocolEnvelope.Tool = z.enum(["bash", "process"]);
+    MetaProtocolEnvelope.RequestBase = z.object({
+        version: z.literal(1),
+        requestID: z.string().min(1),
+        envID: MetaProtocolEnv.EnvID,
+        tool: MetaProtocolEnvelope.Tool,
+        action: z.string().min(1),
+    });
+    MetaProtocolEnvelope.ResultBase = z.object({
+        version: z.literal(1),
+        requestID: z.string().min(1),
+        ok: z.boolean(),
+    });
+    MetaProtocolEnvelope.ErrorResult = MetaProtocolEnvelope.ResultBase.extend({
+        ok: z.literal(false),
+        error: MetaProtocolError.Shape,
+    });
+})(MetaProtocolEnvelope || (MetaProtocolEnvelope = {}));

package/dist/error.d.ts

@@ -0,0 +1,39 @@
+import z from "zod";
+export declare namespace MetaProtocolError {
+    const 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";
+    }>;
+    type Code = z.infer<typeof Code>;
+    const Shape: 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>;
+    type Shape = z.infer<typeof Shape>;
+}

package/dist/error.js

@@ -0,0 +1,24 @@
+import z from "zod";
+export var MetaProtocolError;
+(function (MetaProtocolError) {
+    MetaProtocolError.Code = z.enum([
+        "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",
+    ]);
+    MetaProtocolError.Shape = z.object({
+        code: MetaProtocolError.Code,
+        message: z.string(),
+        details: z.unknown().optional(),
+    });
+})(MetaProtocolError || (MetaProtocolError = {}));

package/dist/host.d.ts

@@ -0,0 +1,90 @@
+import z from "zod";
+export declare namespace MetaProtocolHost {
+    const Shell: z.ZodEnum<{
+        none: "none";
+        sh: "sh";
+        cmd: "cmd";
+        powershell: "powershell";
+        pwsh: "pwsh";
+    }>;
+    type Shell = z.infer<typeof Shell>;
+    const Runtime: z.ZodEnum<{
+        unknown: "unknown";
+        node: "node";
+        bun: "bun";
+    }>;
+    type Runtime = z.infer<typeof Runtime>;
+    const Capabilities: z.ZodObject<{
+        platform: z.ZodString;
+        arch: z.ZodString;
+        hostname: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodEnum<{
+            unknown: "unknown";
+            node: "node";
+            bun: "bun";
+        }>;
+        defaultShell: z.ZodEnum<{
+            none: "none";
+            sh: "sh";
+            cmd: "cmd";
+            powershell: "powershell";
+            pwsh: "pwsh";
+        }>;
+        supportedShells: z.ZodArray<z.ZodEnum<{
+            none: "none";
+            sh: "sh";
+            cmd: "cmd";
+            powershell: "powershell";
+            pwsh: "pwsh";
+        }>>;
+        supportsPty: z.ZodBoolean;
+        supportsSendKeys: z.ZodBoolean;
+        supportsSoftKill: z.ZodBoolean;
+        supportsProcessGroups: z.ZodBoolean;
+        envCaseInsensitive: z.ZodBoolean;
+        lineEndings: z.ZodEnum<{
+            lf: "lf";
+            crlf: "crlf";
+        }>;
+    }, z.core.$strip>;
+    type Capabilities = z.infer<typeof Capabilities>;
+    const Hello: z.ZodObject<{
+        type: z.ZodLiteral<"host.hello">;
+        envID: z.ZodString;
+        hostSessionID: z.ZodString;
+        capabilities: z.ZodObject<{
+            platform: z.ZodString;
+            arch: z.ZodString;
+            hostname: z.ZodOptional<z.ZodString>;
+            runtime: z.ZodEnum<{
+                unknown: "unknown";
+                node: "node";
+                bun: "bun";
+            }>;
+            defaultShell: z.ZodEnum<{
+                none: "none";
+                sh: "sh";
+                cmd: "cmd";
+                powershell: "powershell";
+                pwsh: "pwsh";
+            }>;
+            supportedShells: z.ZodArray<z.ZodEnum<{
+                none: "none";
+                sh: "sh";
+                cmd: "cmd";
+                powershell: "powershell";
+                pwsh: "pwsh";
+            }>>;
+            supportsPty: z.ZodBoolean;
+            supportsSendKeys: z.ZodBoolean;
+            supportsSoftKill: z.ZodBoolean;
+            supportsProcessGroups: z.ZodBoolean;
+            envCaseInsensitive: z.ZodBoolean;
+            lineEndings: z.ZodEnum<{
+                lf: "lf";
+                crlf: "crlf";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    type Hello = z.infer<typeof Hello>;
+}

package/dist/host.js

@@ -0,0 +1,27 @@
+import z from "zod";
+import { MetaProtocolEnv } from "./env";
+export var MetaProtocolHost;
+(function (MetaProtocolHost) {
+    MetaProtocolHost.Shell = z.enum(["none", "sh", "cmd", "powershell", "pwsh"]);
+    MetaProtocolHost.Runtime = z.enum(["node", "bun", "unknown"]);
+    MetaProtocolHost.Capabilities = z.object({
+        platform: z.string(),
+        arch: z.string(),
+        hostname: z.string().optional(),
+        runtime: MetaProtocolHost.Runtime,
+        defaultShell: MetaProtocolHost.Shell,
+        supportedShells: z.array(MetaProtocolHost.Shell),
+        supportsPty: z.boolean(),
+        supportsSendKeys: z.boolean(),
+        supportsSoftKill: z.boolean(),
+        supportsProcessGroups: z.boolean(),
+        envCaseInsensitive: z.boolean(),
+        lineEndings: z.enum(["lf", "crlf"]),
+    });
+    MetaProtocolHost.Hello = z.object({
+        type: z.literal("host.hello"),
+        envID: MetaProtocolEnv.EnvID,
+        hostSessionID: MetaProtocolEnv.HostSessionID,
+        capabilities: MetaProtocolHost.Capabilities,
+    });
+})(MetaProtocolHost || (MetaProtocolHost = {}));

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./env";
+export * from "./error";
+export * from "./envelope";
+export * from "./bash";
+export * from "./process";
+export * from "./client";
+export * from "./host";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./env";
+export * from "./error";
+export * from "./envelope";
+export * from "./bash";
+export * from "./process";
+export * from "./client";
+export * from "./host";

package/dist/process.d.ts

@@ -0,0 +1,274 @@
+import z from "zod";
+export declare namespace MetaProtocolProcess {
+    const Action: z.ZodEnum<{
+        list: "list";
+        poll: "poll";
+        log: "log";
+        write: "write";
+        "send-keys": "send-keys";
+        kill: "kill";
+        clear: "clear";
+        remove: "remove";
+    }>;
+    type Action = z.infer<typeof Action>;
+    const ProcessState: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        killed: "killed";
+    }>;
+    type ProcessState = z.infer<typeof ProcessState>;
+    const ActionStatus: z.ZodEnum<{
+        error: "error";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        killed: "killed";
+        not_found: "not_found";
+        cleared: "cleared";
+        removed: "removed";
+    }>;
+    type ActionStatus = z.infer<typeof ActionStatus>;
+    const ProcessInfo: 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>;
+    type ProcessInfo = z.infer<typeof ProcessInfo>;
+    const ExecutePayload: 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">;
+    type ExecutePayload = z.infer<typeof ExecutePayload>;
+    const ResultMetadata: 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>;
+    type ResultMetadata = z.infer<typeof ResultMetadata>;
+    const 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>;
+    type Result = z.infer<typeof Result>;
+    const ExecuteRequest: 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>;
+    type ExecuteRequest = z.infer<typeof ExecuteRequest>;
+    const ExecuteResult: 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>;
+    type ExecuteResult = z.infer<typeof ExecuteResult>;
+}

package/dist/process.js

@@ -0,0 +1,89 @@
+import z from "zod";
+import { MetaProtocolEnvelope } from "./envelope";
+import { MetaProtocolEnv } from "./env";
+export var MetaProtocolProcess;
+(function (MetaProtocolProcess) {
+    MetaProtocolProcess.Action = z.enum(["list", "poll", "log", "write", "send-keys", "kill", "clear", "remove"]);
+    MetaProtocolProcess.ProcessState = z.enum(["running", "completed", "failed", "killed"]);
+    MetaProtocolProcess.ActionStatus = z.enum([
+        "running",
+        "completed",
+        "failed",
+        "killed",
+        "not_found",
+        "error",
+        "cleared",
+        "removed",
+    ]);
+    MetaProtocolProcess.ProcessInfo = z.object({
+        processId: MetaProtocolEnv.ProcessID,
+        status: MetaProtocolProcess.ProcessState,
+        command: z.string(),
+        description: z.string().optional(),
+        runtimeMs: z.number(),
+    });
+    MetaProtocolProcess.ExecutePayload = z.discriminatedUnion("action", [
+        z.object({ action: z.literal("list") }),
+        z.object({
+            action: z.literal("poll"),
+            processId: MetaProtocolEnv.ProcessID,
+            block: z.boolean().optional(),
+            timeout: z.number().optional(),
+        }),
+        z.object({
+            action: z.literal("log"),
+            processId: MetaProtocolEnv.ProcessID,
+            offset: z.number().optional(),
+            limit: z.number().optional(),
+        }),
+        z.object({
+            action: z.literal("write"),
+            processId: MetaProtocolEnv.ProcessID,
+            data: z.string(),
+        }),
+        z.object({
+            action: z.literal("send-keys"),
+            processId: MetaProtocolEnv.ProcessID,
+            keys: z.array(z.string()),
+        }),
+        z.object({
+            action: z.literal("kill"),
+            processId: MetaProtocolEnv.ProcessID,
+        }),
+        z.object({
+            action: z.literal("clear"),
+            processId: MetaProtocolEnv.ProcessID,
+        }),
+        z.object({
+            action: z.literal("remove"),
+            processId: MetaProtocolEnv.ProcessID,
+        }),
+    ]);
+    MetaProtocolProcess.ResultMetadata = z.object({
+        action: MetaProtocolProcess.Action,
+        processId: MetaProtocolEnv.ProcessID.optional(),
+        status: MetaProtocolProcess.ActionStatus.optional(),
+        exitCode: z.number().optional(),
+        command: z.string().optional(),
+        description: z.string().optional(),
+        nextOffset: z.number().optional(),
+        hostSessionID: MetaProtocolEnv.HostSessionID.optional(),
+        envID: MetaProtocolEnv.EnvID.optional(),
+        backend: z.enum(["local", "remote"]).optional(),
+        processes: z.array(MetaProtocolProcess.ProcessInfo).optional(),
+    });
+    MetaProtocolProcess.Result = z.object({
+        title: z.string(),
+        metadata: MetaProtocolProcess.ResultMetadata,
+        output: z.string(),
+    });
+    MetaProtocolProcess.ExecuteRequest = MetaProtocolEnvelope.RequestBase.extend({
+        tool: z.literal("process"),
+        action: MetaProtocolProcess.Action,
+        payload: MetaProtocolProcess.ExecutePayload,
+    });
+    MetaProtocolProcess.ExecuteResult = MetaProtocolEnvelope.ResultBase.extend({
+        ok: z.literal(true),
+        result: MetaProtocolProcess.Result,
+    });
+})(MetaProtocolProcess || (MetaProtocolProcess = {}));

package/package.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@ericsanchezok/meta-protocol",
+  "version": "0.0.0-dev-202603260727",
+  "type": "module",
+  "license": "MIT",
+  "types": "./src/index.ts",
+  "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": {
+    "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/bash.ts

@@ -0,0 +1,49 @@
+import z from "zod"
+import { MetaProtocolEnvelope } from "./envelope"
+import { MetaProtocolEnv } from "./env"
+
+export namespace MetaProtocolBash {
+  export const ExecutePayload = z.object({
+    command: z.string(),
+    description: z.string(),
+    timeout: z.number().optional(),
+    workdir: z.string().optional(),
+    background: z.boolean().optional(),
+    yieldMs: z.number().optional(),
+  })
+  export type ExecutePayload = z.infer<typeof ExecutePayload>
+
+  export const ResultMetadata = z.object({
+    output: z.string().optional(),
+    description: z.string().optional(),
+    exit: z.number().nullable().optional(),
+    processId: MetaProtocolEnv.ProcessID.optional(),
+    background: z.boolean().optional(),
+    timedOut: z.boolean().optional(),
+    durationMs: z.number().optional(),
+    hostSessionID: MetaProtocolEnv.HostSessionID.optional(),
+    envID: MetaProtocolEnv.EnvID.optional(),
+    backend: z.enum(["local", "remote"]).optional(),
+  })
+  export type ResultMetadata = z.infer<typeof ResultMetadata>
+
+  export const Result = z.object({
+    title: z.string(),
+    metadata: ResultMetadata,
+    output: z.string(),
+  })
+  export type Result = z.infer<typeof Result>
+
+  export const ExecuteRequest = MetaProtocolEnvelope.RequestBase.extend({
+    tool: z.literal("bash"),
+    action: z.literal("execute"),
+    payload: ExecutePayload,
+  })
+  export type ExecuteRequest = z.infer<typeof ExecuteRequest>
+
+  export const ExecuteResult = MetaProtocolEnvelope.ResultBase.extend({
+    ok: z.literal(true),
+    result: Result,
+  })
+  export type ExecuteResult = z.infer<typeof ExecuteResult>
+}

package/src/client.ts

@@ -0,0 +1,13 @@
+import type { MetaProtocolBash } from "./bash"
+import type { MetaProtocolEnv } from "./env"
+import type { MetaProtocolProcess } from "./process"
+
+export namespace MetaProtocolClient {
+  export interface ExecutionClient {
+    executeBash(envID: MetaProtocolEnv.EnvID, input: MetaProtocolBash.ExecutePayload): Promise<MetaProtocolBash.Result>
+    executeProcess(
+      envID: MetaProtocolEnv.EnvID,
+      input: MetaProtocolProcess.ExecutePayload,
+    ): Promise<MetaProtocolProcess.Result>
+  }
+}

package/src/env.ts

@@ -0,0 +1,24 @@
+import z from "zod"
+
+export namespace MetaProtocolEnv {
+  export const EnvID = z.string().min(1).describe("Execution environment ID")
+  export type EnvID = z.infer<typeof EnvID>
+
+  export const ProcessID = z.string().min(1).describe("Opaque process identifier")
+  export type ProcessID = z.infer<typeof ProcessID>
+
+  export const HostSessionID = z.string().min(1).describe("Remote host session identifier")
+  export type HostSessionID = z.infer<typeof HostSessionID>
+
+  export type Target = { kind: "local" } | { kind: "remote"; envID: EnvID }
+
+  export function resolve(envID?: string): Target {
+    if (!envID) {
+      return { kind: "local" }
+    }
+    return {
+      kind: "remote",
+      envID,
+    }
+  }
+}

package/src/envelope.ts

@@ -0,0 +1,30 @@
+import z from "zod"
+import { MetaProtocolEnv } from "./env"
+import { MetaProtocolError } from "./error"
+
+export namespace MetaProtocolEnvelope {
+  export const Tool = z.enum(["bash", "process"])
+  export type Tool = z.infer<typeof Tool>
+
+  export const RequestBase = z.object({
+    version: z.literal(1),
+    requestID: z.string().min(1),
+    envID: MetaProtocolEnv.EnvID,
+    tool: Tool,
+    action: z.string().min(1),
+  })
+  export type RequestBase = z.infer<typeof RequestBase>
+
+  export const ResultBase = z.object({
+    version: z.literal(1),
+    requestID: z.string().min(1),
+    ok: z.boolean(),
+  })
+  export type ResultBase = z.infer<typeof ResultBase>
+
+  export const ErrorResult = ResultBase.extend({
+    ok: z.literal(false),
+    error: MetaProtocolError.Shape,
+  })
+  export type ErrorResult = z.infer<typeof ErrorResult>
+}

package/src/error.ts

@@ -0,0 +1,27 @@
+import z from "zod"
+
+export namespace MetaProtocolError {
+  export const Code = z.enum([
+    "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",
+  ])
+  export type Code = z.infer<typeof Code>
+
+  export const Shape = z.object({
+    code: Code,
+    message: z.string(),
+    details: z.unknown().optional(),
+  })
+  export type Shape = z.infer<typeof Shape>
+}

package/src/host.ts

@@ -0,0 +1,34 @@
+import z from "zod"
+import { MetaProtocolEnv } from "./env"
+
+export namespace MetaProtocolHost {
+  export const Shell = z.enum(["none", "sh", "cmd", "powershell", "pwsh"])
+  export type Shell = z.infer<typeof Shell>
+
+  export const Runtime = z.enum(["node", "bun", "unknown"])
+  export type Runtime = z.infer<typeof Runtime>
+
+  export const Capabilities = z.object({
+    platform: z.string(),
+    arch: z.string(),
+    hostname: z.string().optional(),
+    runtime: Runtime,
+    defaultShell: Shell,
+    supportedShells: z.array(Shell),
+    supportsPty: z.boolean(),
+    supportsSendKeys: z.boolean(),
+    supportsSoftKill: z.boolean(),
+    supportsProcessGroups: z.boolean(),
+    envCaseInsensitive: z.boolean(),
+    lineEndings: z.enum(["lf", "crlf"]),
+  })
+  export type Capabilities = z.infer<typeof Capabilities>
+
+  export const Hello = z.object({
+    type: z.literal("host.hello"),
+    envID: MetaProtocolEnv.EnvID,
+    hostSessionID: MetaProtocolEnv.HostSessionID,
+    capabilities: Capabilities,
+  })
+  export type Hello = z.infer<typeof Hello>
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./env"
+export * from "./error"
+export * from "./envelope"
+export * from "./bash"
+export * from "./process"
+export * from "./client"
+export * from "./host"

package/src/process.ts

@@ -0,0 +1,106 @@
+import z from "zod"
+import { MetaProtocolEnvelope } from "./envelope"
+import { MetaProtocolEnv } from "./env"
+
+export namespace MetaProtocolProcess {
+  export const Action = z.enum(["list", "poll", "log", "write", "send-keys", "kill", "clear", "remove"])
+  export type Action = z.infer<typeof Action>
+
+  export const ProcessState = z.enum(["running", "completed", "failed", "killed"])
+  export type ProcessState = z.infer<typeof ProcessState>
+
+  export const ActionStatus = z.enum([
+    "running",
+    "completed",
+    "failed",
+    "killed",
+    "not_found",
+    "error",
+    "cleared",
+    "removed",
+  ])
+  export type ActionStatus = z.infer<typeof ActionStatus>
+
+  export const ProcessInfo = z.object({
+    processId: MetaProtocolEnv.ProcessID,
+    status: ProcessState,
+    command: z.string(),
+    description: z.string().optional(),
+    runtimeMs: z.number(),
+  })
+  export type ProcessInfo = z.infer<typeof ProcessInfo>
+
+  export const ExecutePayload = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("list") }),
+    z.object({
+      action: z.literal("poll"),
+      processId: MetaProtocolEnv.ProcessID,
+      block: z.boolean().optional(),
+      timeout: z.number().optional(),
+    }),
+    z.object({
+      action: z.literal("log"),
+      processId: MetaProtocolEnv.ProcessID,
+      offset: z.number().optional(),
+      limit: z.number().optional(),
+    }),
+    z.object({
+      action: z.literal("write"),
+      processId: MetaProtocolEnv.ProcessID,
+      data: z.string(),
+    }),
+    z.object({
+      action: z.literal("send-keys"),
+      processId: MetaProtocolEnv.ProcessID,
+      keys: z.array(z.string()),
+    }),
+    z.object({
+      action: z.literal("kill"),
+      processId: MetaProtocolEnv.ProcessID,
+    }),
+    z.object({
+      action: z.literal("clear"),
+      processId: MetaProtocolEnv.ProcessID,
+    }),
+    z.object({
+      action: z.literal("remove"),
+      processId: MetaProtocolEnv.ProcessID,
+    }),
+  ])
+  export type ExecutePayload = z.infer<typeof ExecutePayload>
+
+  export const ResultMetadata = z.object({
+    action: Action,
+    processId: MetaProtocolEnv.ProcessID.optional(),
+    status: ActionStatus.optional(),
+    exitCode: z.number().optional(),
+    command: z.string().optional(),
+    description: z.string().optional(),
+    nextOffset: z.number().optional(),
+    hostSessionID: MetaProtocolEnv.HostSessionID.optional(),
+    envID: MetaProtocolEnv.EnvID.optional(),
+    backend: z.enum(["local", "remote"]).optional(),
+    processes: z.array(ProcessInfo).optional(),
+  })
+  export type ResultMetadata = z.infer<typeof ResultMetadata>
+
+  export const Result = z.object({
+    title: z.string(),
+    metadata: ResultMetadata,
+    output: z.string(),
+  })
+  export type Result = z.infer<typeof Result>
+
+  export const ExecuteRequest = MetaProtocolEnvelope.RequestBase.extend({
+    tool: z.literal("process"),
+    action: Action,
+    payload: ExecutePayload,
+  })
+  export type ExecuteRequest = z.infer<typeof ExecuteRequest>
+
+  export const ExecuteResult = MetaProtocolEnvelope.ResultBase.extend({
+    ok: z.literal(true),
+    result: Result,
+  })
+  export type ExecuteResult = z.infer<typeof ExecuteResult>
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext", "DOM"],
+    "types": ["node"],
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "declaration": true,
+    "noEmit": false,
+    "strict": true,
+    "isolatedModules": true
+  },
+  "include": ["src"]
+}