@ericsanchezok/meta-synergy 0.0.0-dev-202603301142 → 1.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@ericsanchezok/meta-synergy",
-  "version": "0.0.0-dev-202603301142",
+  "version": "1.1.0",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -19,12 +19,12 @@
     "build": "tsc -p tsconfig.json"
   },
   "dependencies": {
-    "@ericsanchezok/meta-protocol": "0.0.0-dev-202603301142",
-    "zod": "4.1.8"
+    "@ericsanchezok/meta-protocol": "workspace:*",
+    "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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/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/meta-protocol/src/client.js

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

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