@ericsanchezok/meta-synergy 0.0.0-dev-202603260728

package/dist/meta-protocol/src/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/meta-protocol/src/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/dist/meta-synergy/src/client/holos-client.d.ts

@@ -0,0 +1,15 @@
+import { MetaSynergyHost, type MetaSynergyHostOptions } from "../host";
+import type { HostTransport, RemoteHostIdentity } from "../types";
+export interface HolosClientOptions extends MetaSynergyHostOptions {
+    transport?: HostTransport;
+    label?: string;
+}
+export declare class HolosClient {
+    readonly host: MetaSynergyHost;
+    readonly transport?: HostTransport;
+    readonly label?: string;
+    constructor(options?: HolosClientOptions);
+    identity(): RemoteHostIdentity;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/meta-synergy/src/client/holos-client.js

@@ -0,0 +1,35 @@
+import { MetaSynergyHost } from "../host";
+export class HolosClient {
+    host;
+    transport;
+    label;
+    constructor(options = {}) {
+        this.host = new MetaSynergyHost(options);
+        this.transport = options.transport;
+        this.label = options.label;
+    }
+    identity() {
+        if (!this.host.envID) {
+            throw new Error("HolosClient requires envID to build identity");
+        }
+        return {
+            envID: this.host.envID,
+            hostSessionID: this.host.hostSessionID,
+            capabilities: this.host.capabilities,
+            label: this.label,
+        };
+    }
+    async connect() {
+        if (!this.transport) {
+            return;
+        }
+        await this.transport.connect();
+        await this.transport.send(this.host.hello());
+    }
+    async disconnect() {
+        if (!this.transport) {
+            return;
+        }
+        await this.transport.disconnect();
+    }
+}

package/dist/meta-synergy/src/exec/bash-runner.d.ts

@@ -0,0 +1,7 @@
+import type { MetaProtocolBash } from "@ericsanchezok/meta-protocol";
+import { ProcessRegistry } from "./process-registry";
+export declare class BashRunner {
+    private readonly processes;
+    constructor(processes: ProcessRegistry);
+    run(request: MetaProtocolBash.ExecutePayload, envID: string): Promise<MetaProtocolBash.Result>;
+}

package/dist/meta-synergy/src/exec/bash-runner.js

@@ -0,0 +1,9 @@
+export class BashRunner {
+    processes;
+    constructor(processes) {
+        this.processes = processes;
+    }
+    async run(request, envID) {
+        return this.processes.executeBash(request, envID);
+    }
+}

package/dist/meta-synergy/src/exec/process-registry.d.ts

@@ -0,0 +1,11 @@
+import { MetaProtocolBash, MetaProtocolProcess } from "@ericsanchezok/meta-protocol";
+import { MetaSynergyHost } from "../host";
+export declare class ProcessRegistry {
+    #private;
+    constructor(host: MetaSynergyHost, options?: {
+        ttlMs?: number;
+    });
+    executeBash(request: MetaProtocolBash.ExecutePayload, envID: string): Promise<MetaProtocolBash.Result>;
+    execute(request: MetaProtocolProcess.ExecutePayload, envID: string): Promise<MetaProtocolProcess.Result>;
+    reset(): void;
+}