@ericsanchezok/meta-protocol 1.1.6 → 1.1.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@ericsanchezok/meta-protocol",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "type": "module",
   "license": "MIT",
   "types": "./src/index.ts",

package/src/bash.ts

@@ -37,12 +37,15 @@ export namespace MetaProtocolBash {
   export const ExecuteRequest = MetaProtocolEnvelope.RequestBase.extend({
     tool: z.literal("bash"),
     action: z.literal("execute"),
+    sessionID: MetaProtocolEnv.SessionID,
     payload: ExecutePayload,
   })
   export type ExecuteRequest = z.infer<typeof ExecuteRequest>
 
-  export const ExecuteResult = MetaProtocolEnvelope.ResultBase.extend({
+  export const ExecuteResult = MetaProtocolEnvelope.TypedResultBase.extend({
     ok: z.literal(true),
+    tool: z.literal("bash"),
+    action: z.literal("execute"),
     result: Result,
   })
   export type ExecuteResult = z.infer<typeof ExecuteResult>

package/src/bridge.ts

@@ -0,0 +1,4 @@
+export namespace MetaProtocolBridge {
+  export const RequestEvent = "meta.execution.request"
+  export const ResponseEvent = "meta.execution.response"
+}

package/src/client.ts

@@ -1,13 +1,29 @@
 import type { MetaProtocolBash } from "./bash"
 import type { MetaProtocolEnv } from "./env"
 import type { MetaProtocolProcess } from "./process"
+import type { MetaProtocolSession } from "./session"
 
 export namespace MetaProtocolClient {
+  export interface RemoteExecutionOptions {
+    sessionID?: MetaProtocolEnv.SessionID
+    targetAgentID?: string
+  }
+
   export interface ExecutionClient {
-    executeBash(envID: MetaProtocolEnv.EnvID, input: MetaProtocolBash.ExecutePayload): Promise<MetaProtocolBash.Result>
+    executeBash(
+      envID: MetaProtocolEnv.EnvID,
+      input: MetaProtocolBash.ExecutePayload,
+      options?: RemoteExecutionOptions,
+    ): Promise<MetaProtocolBash.Result>
     executeProcess(
       envID: MetaProtocolEnv.EnvID,
       input: MetaProtocolProcess.ExecutePayload,
+      options?: RemoteExecutionOptions,
     ): Promise<MetaProtocolProcess.Result>
+    executeSession(
+      envID: MetaProtocolEnv.EnvID,
+      input: MetaProtocolSession.ExecutePayload,
+      options?: RemoteExecutionOptions,
+    ): Promise<MetaProtocolSession.Result>
   }
 }

package/src/env.ts

@@ -4,6 +4,9 @@ export namespace MetaProtocolEnv {
   export const EnvID = z.string().min(1).describe("Execution environment ID")
   export type EnvID = z.infer<typeof EnvID>
 
+  export const SessionID = z.string().min(1).describe("Remote collaboration session identifier")
+  export type SessionID = z.infer<typeof SessionID>
+
   export const ProcessID = z.string().min(1).describe("Opaque process identifier")
   export type ProcessID = z.infer<typeof ProcessID>
 

package/src/envelope.ts

@@ -3,7 +3,7 @@ import { MetaProtocolEnv } from "./env"
 import { MetaProtocolError } from "./error"
 
 export namespace MetaProtocolEnvelope {
-  export const Tool = z.enum(["bash", "process"])
+  export const Tool = z.enum(["bash", "process", "session"])
   export type Tool = z.infer<typeof Tool>
 
   export const RequestBase = z.object({
@@ -22,8 +22,16 @@ export namespace MetaProtocolEnvelope {
   })
   export type ResultBase = z.infer<typeof ResultBase>
 
+  export const TypedResultBase = ResultBase.extend({
+    tool: Tool,
+    action: z.string().min(1),
+  })
+  export type TypedResultBase = z.infer<typeof TypedResultBase>
+
   export const ErrorResult = ResultBase.extend({
     ok: z.literal(false),
+    tool: Tool.optional(),
+    action: z.string().min(1).optional(),
     error: MetaProtocolError.Shape,
   })
   export type ErrorResult = z.infer<typeof ErrorResult>

package/src/error.ts

@@ -15,6 +15,11 @@ export namespace MetaProtocolError {
     "host_internal_error",
     "stale_process_handle",
     "stdin_unavailable",
+    "session_required",
+    "session_invalid",
+    "session_busy",
+    "session_refused",
+    "session_caller_mismatch",
   ])
   export type Code = z.infer<typeof Code>
 

package/src/index.ts

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

package/src/process.ts

@@ -94,12 +94,15 @@ export namespace MetaProtocolProcess {
   export const ExecuteRequest = MetaProtocolEnvelope.RequestBase.extend({
     tool: z.literal("process"),
     action: Action,
+    sessionID: MetaProtocolEnv.SessionID,
     payload: ExecutePayload,
   })
   export type ExecuteRequest = z.infer<typeof ExecuteRequest>
 
-  export const ExecuteResult = MetaProtocolEnvelope.ResultBase.extend({
+  export const ExecuteResult = MetaProtocolEnvelope.TypedResultBase.extend({
     ok: z.literal(true),
+    tool: z.literal("process"),
+    action: Action,
     result: Result,
   })
   export type ExecuteResult = z.infer<typeof ExecuteResult>

package/src/session.ts

@@ -0,0 +1,62 @@
+import z from "zod"
+import { MetaProtocolEnvelope } from "./envelope"
+import { MetaProtocolEnv } from "./env"
+
+export namespace MetaProtocolSession {
+  export const Action = z.enum(["open", "close", "heartbeat"])
+  export type Action = z.infer<typeof Action>
+
+  export const Status = z.enum(["opened", "closed", "alive", "refused", "busy"])
+  export type Status = z.infer<typeof Status>
+
+  export const ExecutePayload = z.discriminatedUnion("action", [
+    z.object({
+      action: z.literal("open"),
+      label: z.string().optional(),
+    }),
+    z.object({
+      action: z.literal("close"),
+      sessionID: MetaProtocolEnv.SessionID,
+    }),
+    z.object({
+      action: z.literal("heartbeat"),
+      sessionID: MetaProtocolEnv.SessionID,
+    }),
+  ])
+  export type ExecutePayload = z.infer<typeof ExecutePayload>
+
+  export const ResultMetadata = z.object({
+    action: Action,
+    status: Status,
+    sessionID: MetaProtocolEnv.SessionID.optional(),
+    remoteAgentID: z.string().optional(),
+    remoteOwnerUserID: z.number().optional(),
+    label: z.string().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("session"),
+    action: Action,
+    payload: ExecutePayload,
+  })
+  export type ExecuteRequest = z.infer<typeof ExecuteRequest>
+
+  export const ExecuteResult = MetaProtocolEnvelope.TypedResultBase.extend({
+    ok: z.literal(true),
+    tool: z.literal("session"),
+    action: Action,
+    result: Result,
+  })
+  export type ExecuteResult = z.infer<typeof ExecuteResult>
+}