@linkshell/gateway 0.2.48 → 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,
@@ -22,7 +22,7 @@ export function handleSocketMessage(
   role: "host" | "client",
   hostDeviceId: string,
   deviceId: string,
-  sessions: SessionManager,
+  sessions: DeviceManager,
 ): void {
   let envelope: Envelope;
   try {
@@ -99,14 +99,13 @@ function sendSessionError(
 
 function handleHostMessage(
   envelope: Envelope,
-  session: ReturnType<SessionManager["get"]> & {},
-  sessions: SessionManager,
+  session: ReturnType<DeviceManager["get"]> & {},
+  sessions: DeviceManager,
 ): void {
   switch (envelope.type) {
-    case "device.connect":
-    case "session.connect": {
+    case "device.connect": {
       // Extract metadata from host's connect message
-      const p = parseTypedPayload("session.connect", envelope.payload);
+      const p = parseTypedPayload("device.connect", envelope.payload);
       if (p.machineId || p.hostname || p.platform || p.cwd || p.capabilities) {
         sessions.setMetadata(
           session.id,
@@ -132,12 +131,11 @@ function handleHostMessage(
       break;
     }
     case "device.heartbeat":
-    case "session.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,
@@ -175,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":
@@ -207,9 +201,9 @@ 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;
@@ -239,15 +233,13 @@ function handleClientMessage(
       sendToHost(session, envelope);
       break;
     }
-    case "device.ack":
-    case "session.ack": {
+    case "device.ack": {
       // Forward ACK to host
       sendToHost(session, envelope);
       break;
     }
-    case "device.resume":
-    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,
@@ -309,18 +301,12 @@ function handleClientMessage(
       break;
     }
     case "device.heartbeat":
-    case "session.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":
@@ -340,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":
@@ -354,7 +338,7 @@ function handleClientMessage(
 }
 
 function broadcastToClients(
-  session: ReturnType<SessionManager["get"]> & {},
+  session: ReturnType<DeviceManager["get"]> & {},
   envelope: Envelope,
 ): void {
   const data = serializeEnvelope(envelope);
@@ -366,7 +350,7 @@ function broadcastToClients(
 }
 
 function sendToHost(
-  session: ReturnType<SessionManager["get"]> & {},
+  session: ReturnType<DeviceManager["get"]> & {},
   envelope: Envelope,
 ): void {
   if (

package/src/sessions.ts

@@ -2,7 +2,6 @@ import type WebSocket from "ws";
 import type { Envelope } from "@linkshell/protocol";
 
 export type DeviceState = "active" | "host_disconnected" | "terminated";
-export type SessionState = DeviceState;
 
 export interface ConnectedDevice {
   socket: WebSocket;
@@ -33,8 +32,6 @@ export interface HostDevice {
   userId: string | undefined;
 }
 
-export type Session = HostDevice;
-
 const OUTPUT_BUFFER_CAPACITY = 200;
 const HOST_RECONNECT_WINDOW = 60_000;
 const CLEANUP_INTERVAL = 30_000;
@@ -311,5 +308,3 @@ export class DeviceManager {
     clearInterval(this.cleanupTimer);
   }
 }
-
-export class SessionManager extends DeviceManager {}

package/src/tokens.ts

@@ -149,7 +149,7 @@ export class AuthorizationManager {
     return this.tokens.get(token)?.authorizations.get(hostDeviceId)?.authorizationId;
   }
 
-  getTokenForSession(hostDeviceId: string): string | undefined {
+  getTokenForHostDevice(hostDeviceId: string): string | undefined {
     return this.hostDeviceToTokens.get(hostDeviceId)?.values().next().value;
   }
 

package/src/tunnel.ts

@@ -5,7 +5,7 @@ import {
   createEnvelope,
   serializeEnvelope,
 } from "@linkshell/protocol";
-import type { SessionManager } from "./sessions.js";
+import type { DeviceManager } from "./sessions.js";
 import type { TokenManager } from "./tokens.js";
 import { AUTH_REQUIRED } from "./auth-middleware.js";
 
@@ -66,7 +66,7 @@ function extractToken(req: IncomingMessage, url: URL): string | null {
 }
 
 /** Parse lsh_tunnel cookie: "hostDeviceId:port:token" */
-export function parseTunnelCookie(req: IncomingMessage): { hostDeviceId: string; sessionId: string; port: number; token: string } | null {
+export function parseTunnelCookie(req: IncomingMessage): { hostDeviceId: string; port: number; token: string } | null {
   const cookie = req.headers.cookie;
   if (!cookie) return null;
   const match = cookie.match(/lsh_tunnel=([^;]+)/);
@@ -77,7 +77,7 @@ export function parseTunnelCookie(req: IncomingMessage): { hostDeviceId: string;
   const port = Number(parts[1]);
   const token = parts.slice(2).join(":"); // token may contain colons
   if (!hostDeviceId || isNaN(port) || port < 1 || port > 65535 || !token) return null;
-  return { hostDeviceId, sessionId: hostDeviceId, port, token };
+  return { hostDeviceId, port, token };
 }
 
 function errorResponse(res: ServerResponse, status: number, message: string): void {
@@ -89,22 +89,20 @@ function errorResponse(res: ServerResponse, status: number, message: string): vo
   res.end(message);
 }
 
-export function parseTunnelPath(pathname: string): { hostDeviceId: string; sessionId: string; port: number; path: string } | null {
+export function parseTunnelPath(pathname: string): { hostDeviceId: string; port: number; path: string } | null {
   const match = pathname.match(/^\/tunnel\/([^/]+)\/(\d+)(\/.*)?$/);
   if (!match) return null;
   const port = Number(match[2]);
   if (port < 1 || port > 65535) return null;
   return {
     hostDeviceId: match[1]!,
-    sessionId: match[1]!,
     port,
     path: match[3] || "/",
   };
 }
 
 type ParsedTunnelTarget = {
-  hostDeviceId?: string;
-  sessionId?: string;
+  hostDeviceId: string;
   port: number;
   path: string;
 };
@@ -112,18 +110,13 @@ type ParsedTunnelTarget = {
 export async function handleTunnelRequest(
   req: IncomingMessage,
   res: ServerResponse,
-  sessions: SessionManager,
+  sessions: DeviceManager,
   tokens: TokenManager,
   parsed: ParsedTunnelTarget,
   url: URL,
   preAuthToken?: string,
 ): Promise<void> {
-  const hostDeviceId = parsed.hostDeviceId ?? parsed.sessionId;
-  const { port, path } = parsed;
-  if (!hostDeviceId) {
-    errorResponse(res, 400, "Missing host device id");
-    return;
-  }
+  const { hostDeviceId, port, path } = parsed;
 
   // Auth: device token OR Supabase JWT (userId owns session)
   const token = preAuthToken || extractToken(req, url);
@@ -342,15 +335,10 @@ export async function handleTunnelWsUpgrade(
   ws: WebSocket,
   parsed: ParsedTunnelTarget,
   url: URL,
-  sessions: SessionManager,
+  sessions: DeviceManager,
   tokens: TokenManager,
 ): Promise<void> {
-  const hostDeviceId = parsed.hostDeviceId ?? parsed.sessionId;
-  const { port, path } = parsed;
-  if (!hostDeviceId) {
-    ws.close(1008, "Missing host device id");
-    return;
-  }
+  const { hostDeviceId, port, path } = parsed;
 
   // Auth: device token OR Supabase JWT (userId owns session)
   const token = url.searchParams.get("token");