@ericsanchezok/meta-synergy 0.0.0-dev-202603260728

package/.turbo/turbo-typecheck.log

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

package/dist/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/client.js

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

package/dist/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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";