@ericsanchezok/meta-protocol 0.0.0-dev-202603301142 → 1.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@ericsanchezok/meta-protocol",
-  "version": "0.0.0-dev-202603301142",
+  "version": "1.1.1",
   "type": "module",
   "license": "MIT",
   "types": "./src/index.ts",
@@ -20,11 +20,11 @@
     "build": "tsc -p tsconfig.json"
   },
   "dependencies": {
-    "zod": "4.1.8"
+    "zod": "catalog:"
   },
   "devDependencies": {
-    "@tsconfig/node22": "22.0.2",
-    "@types/node": "22.13.9",
-    "typescript": "5.8.2"
+    "@tsconfig/node22": "catalog:",
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
   }
 }

package/.turbo/turbo-typecheck.log

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

package/dist/bash.d.ts

@@ -1,89 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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

package/dist/env.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,274 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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 = {}));