@linkshell/gateway 0.2.47 → 0.3.0

package/src/relay.ts

@@ -8,7 +8,7 @@ import {
 } from "@linkshell/protocol";
 import type { Envelope, ProtocolMessageType } from "@linkshell/protocol";
 import { ZodError } from "zod";
-import type { SessionManager, ConnectedDevice } from "./sessions.js";
+import type { DeviceManager, ConnectedDevice } from "./sessions.js";
 import {
   handleTunnelResponse,
   handleTunnelWsData,
@@ -20,31 +20,31 @@ export function handleSocketMessage(
   socket: WebSocket,
   raw: string,
   role: "host" | "client",
-  sessionId: string,
+  hostDeviceId: string,
   deviceId: string,
-  sessions: SessionManager,
+  sessions: DeviceManager,
 ): void {
   let envelope: Envelope;
   try {
     envelope = parseEnvelope(raw);
   } catch {
-    sendSessionError(socket, sessionId, "invalid_message", "Failed to parse envelope");
+    sendSessionError(socket, hostDeviceId, "invalid_message", "Failed to parse envelope");
     return;
   }
 
-  if (envelope.sessionId !== sessionId) {
+  if (envelope.hostDeviceId !== hostDeviceId) {
     sendSessionError(
       socket,
-      sessionId,
+      hostDeviceId,
       "invalid_message",
-      "Envelope sessionId does not match connection sessionId",
+      "Envelope hostDeviceId does not match connection hostDeviceId",
     );
     return;
   }
 
-  const session = sessions.get(sessionId);
+  const session = sessions.get(hostDeviceId);
   if (!session) {
-    sendSessionError(socket, sessionId, "session_not_found", "Session not found");
+    sendSessionError(socket, hostDeviceId, "device_not_found", "Device not found");
     return;
   }
 
@@ -65,13 +65,13 @@ export function handleSocketMessage(
     if (error instanceof ZodError) {
       sendSessionError(
         socket,
-        sessionId,
+        hostDeviceId,
         "invalid_message",
         error.errors[0]?.message ?? "Invalid message payload",
       );
       return;
     }
-    sendSessionError(socket, sessionId, "invalid_message", "Failed to handle message");
+    sendSessionError(socket, hostDeviceId, "invalid_message", "Failed to handle message");
   }
 }
 
@@ -81,7 +81,7 @@ function isProtocolMessageType(type: string): type is ProtocolMessageType {
 
 function sendSessionError(
   socket: WebSocket,
-  sessionId: string,
+  hostDeviceId: string,
   code: string,
   message: string,
 ): void {
@@ -89,8 +89,8 @@ function sendSessionError(
   socket.send(
     serializeEnvelope(
       createEnvelope({
-        type: "session.error",
-        sessionId,
+        type: "device.error",
+        hostDeviceId,
         payload: { code, message },
       }),
     ),
@@ -99,22 +99,23 @@ function sendSessionError(
 
 function handleHostMessage(
   envelope: Envelope,
-  session: ReturnType<SessionManager["get"]> & {},
-  sessions: SessionManager,
+  session: ReturnType<DeviceManager["get"]> & {},
+  sessions: DeviceManager,
 ): void {
   switch (envelope.type) {
-    case "session.connect": {
+    case "device.connect": {
       // Extract metadata from host's connect message
-      const p = parseTypedPayload("session.connect", envelope.payload);
-      if (p.provider || p.machineId || p.hostname || p.platform || p.cwd || p.projectName) {
+      const p = parseTypedPayload("device.connect", envelope.payload);
+      if (p.machineId || p.hostname || p.platform || p.cwd || p.capabilities) {
         sessions.setMetadata(
           session.id,
-          p.provider ?? undefined,
+          undefined,
           p.machineId ?? undefined,
           p.hostname ?? undefined,
           p.platform ?? undefined,
           p.cwd ?? undefined,
-          p.projectName ?? undefined,
+          undefined,
+          p.capabilities ?? undefined,
         );
       }
       break;
@@ -129,12 +130,12 @@ function handleHostMessage(
       broadcastToClients(session, envelope);
       break;
     }
-    case "session.heartbeat":
+    case "device.heartbeat":
       break;
     case "permission.decision.result": {
       const p = parseTypedPayload("permission.decision.result", envelope.payload);
       resolveAgentPermissionHttpAck({
-        sessionId: session.id,
+        hostDeviceId: session.id,
         ack: {
           requestId: p.requestId,
           decision: p.decision,
@@ -172,11 +173,7 @@ function handleHostMessage(
     case "screen.status":
     case "screen.offer":
     case "screen.ice":
-    // Agent GUI: host → clients
-    case "agent.capabilities":
-    case "agent.update":
-    case "agent.permission.request":
-    case "agent.snapshot":
+    // Agent Workspace: host → clients
     case "agent.v2.capabilities":
     case "agent.v2.conversation.opened":
     case "agent.v2.conversation.list.result":
@@ -204,17 +201,17 @@ function handleHostMessage(
 function handleClientMessage(
   envelope: Envelope,
   socket: WebSocket,
-  session: ReturnType<SessionManager["get"]> & {},
+  session: ReturnType<DeviceManager["get"]> & {},
   deviceId: string,
-  sessions: SessionManager,
+  sessions: DeviceManager,
 ): void {
   const requireController = (): boolean => {
     if (session.controllerId === deviceId) return true;
     socket.send(
       serializeEnvelope(
         createEnvelope({
-          type: "session.error",
-          sessionId: session.id,
+          type: "device.error",
+          hostDeviceId: session.id,
           payload: {
             code: "control_conflict",
             message: "Not the controller",
@@ -236,13 +233,13 @@ function handleClientMessage(
       sendToHost(session, envelope);
       break;
     }
-    case "session.ack": {
+    case "device.ack": {
       // Forward ACK to host
       sendToHost(session, envelope);
       break;
     }
-    case "session.resume": {
-      const p = parseTypedPayload("session.resume", envelope.payload);
+    case "device.resume": {
+      const p = parseTypedPayload("device.resume", envelope.payload);
       // Replay from gateway buffer first
       const replay = sessions.getReplayFrom(
         session.id,
@@ -255,7 +252,7 @@ function handleClientMessage(
           serializeEnvelope(
             createEnvelope({
               type: "terminal.output",
-              sessionId: session.id,
+              hostDeviceId: session.id,
               terminalId: msg.terminalId,
               seq: msg.seq,
               payload: { ...payload, isReplay: true },
@@ -284,7 +281,7 @@ function handleClientMessage(
       sessions.claimControl(session.id, deviceId);
       const grantMsg = createEnvelope({
         type: "control.grant",
-        sessionId: session.id,
+        hostDeviceId: session.id,
         payload: { deviceId },
       });
       // Broadcast to ALL clients so previous controller updates its state
@@ -296,25 +293,20 @@ function handleClientMessage(
       sessions.releaseControl(session.id, deviceId);
       const releaseMsg = createEnvelope({
         type: "control.release",
-        sessionId: session.id,
+        hostDeviceId: session.id,
         payload: { deviceId },
       });
       broadcastToClients(session, releaseMsg);
       sendToHost(session, releaseMsg);
       break;
     }
-    case "session.heartbeat":
+    case "device.heartbeat":
       break;
     // Screen sharing: client → host
     case "screen.start":
     case "screen.stop":
     case "screen.answer":
     case "screen.ice":
-    case "agent.session.new":
-    case "agent.session.load":
-    case "agent.prompt":
-    case "agent.cancel":
-    case "agent.permission.response":
     case "agent.v2.conversation.open":
     case "agent.v2.prompt":
     case "agent.v2.command.execute":
@@ -334,8 +326,6 @@ function handleClientMessage(
       if (!requireController()) return;
       sendToHost(session, envelope);
       break;
-    case "agent.initialize":
-    case "agent.session.list":
     case "agent.v2.capabilities.request":
     case "agent.v2.conversation.list":
     case "agent.v2.snapshot.request":
@@ -348,7 +338,7 @@ function handleClientMessage(
 }
 
 function broadcastToClients(
-  session: ReturnType<SessionManager["get"]> & {},
+  session: ReturnType<DeviceManager["get"]> & {},
   envelope: Envelope,
 ): void {
   const data = serializeEnvelope(envelope);
@@ -360,7 +350,7 @@ function broadcastToClients(
 }
 
 function sendToHost(
-  session: ReturnType<SessionManager["get"]> & {},
+  session: ReturnType<DeviceManager["get"]> & {},
   envelope: Envelope,
 ): void {
   if (