@linkshell/gateway 0.3.9 → 0.4.0

package/src/sessions.ts

@@ -1,59 +1,54 @@
 import type WebSocket from "ws";
 import type { Envelope } from "@linkshell/protocol";
 
-export type DeviceState = "active" | "host_disconnected" | "terminated";
+export type SessionState = "active" | "host_disconnected" | "terminated";
 
 export interface ConnectedDevice {
   socket: WebSocket;
   role: "host" | "client";
   deviceId: string;
-  token?: string;
-  authorizationId?: string;
   connectedAt: number;
 }
 
-export interface HostDevice {
+export interface Session {
   id: string;
-  hostDeviceId: string;
-  state: DeviceState;
+  state: SessionState;
   host: ConnectedDevice | undefined;
   clients: Map<string, ConnectedDevice>;
   controllerId: string | undefined;
   lastActivity: number;
   createdAt: number;
-  outputBuffers: Map<string, Envelope[]>;
-  lastStatusByTerminal: Map<string, Envelope>;
+  outputBuffers: Map<string, Envelope[]>; // keyed by terminalId
+  lastStatusByTerminal: Map<string, Envelope>; // last terminal.status per terminal
   hostDisconnectedAt: number | undefined;
+  // Metadata from host's session.connect
+  provider: string | undefined;
   machineId: string | undefined;
   hostname: string | undefined;
   platform: string | undefined;
   cwd: string | undefined;
-  capabilities: string[];
+  projectName: string | undefined;
+  // Auth: user who owns this session (set on AUTH_REQUIRED gateways)
   userId: string | undefined;
 }
 
 const OUTPUT_BUFFER_CAPACITY = 200;
-const OUTPUT_BUFFER_MAX_PAYLOAD_BYTES = Number(
-  process.env.OUTPUT_BUFFER_MAX_PAYLOAD_BYTES ?? 64 * 1024,
-);
-const HOST_RECONNECT_WINDOW = 60_000;
+const HOST_RECONNECT_WINDOW = 60_000; // 60s
 const CLEANUP_INTERVAL = 30_000;
 
-export class DeviceManager {
-  private devices = new Map<string, HostDevice>();
+export class SessionManager {
+  private sessions = new Map<string, Session>();
   private cleanupTimer: ReturnType<typeof setInterval>;
-  private droppedClients = 0;
 
   constructor() {
     this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL);
   }
 
-  getOrCreate(hostDeviceId: string): HostDevice {
-    let device = this.devices.get(hostDeviceId);
-    if (!device) {
-      device = {
-        id: hostDeviceId,
-        hostDeviceId,
+  getOrCreate(sessionId: string): Session {
+    let session = this.sessions.get(sessionId);
+    if (!session) {
+      session = {
+        id: sessionId,
         state: "active",
         host: undefined,
         clients: new Map(),
@@ -63,155 +58,122 @@ export class DeviceManager {
         outputBuffers: new Map(),
         lastStatusByTerminal: new Map(),
         hostDisconnectedAt: undefined,
+        provider: undefined,
         machineId: undefined,
         hostname: undefined,
         platform: undefined,
         cwd: undefined,
-        capabilities: [],
+        projectName: undefined,
         userId: undefined,
       };
-      this.devices.set(hostDeviceId, device);
+      this.sessions.set(sessionId, session);
     }
-    return device;
+    return session;
   }
 
-  get(hostDeviceId: string): HostDevice | undefined {
-    return this.devices.get(hostDeviceId);
+  get(sessionId: string): Session | undefined {
+    return this.sessions.get(sessionId);
   }
 
-  setHost(hostDeviceId: string, socketDevice: ConnectedDevice): void {
-    const device = this.getOrCreate(hostDeviceId);
-    device.host = socketDevice;
-    device.state = "active";
-    device.hostDisconnectedAt = undefined;
-    device.lastActivity = Date.now();
+  setHost(sessionId: string, device: ConnectedDevice): void {
+    const session = this.getOrCreate(sessionId);
+    session.host = device;
+    session.state = "active";
+    session.hostDisconnectedAt = undefined;
+    session.lastActivity = Date.now();
   }
 
-  addClient(hostDeviceId: string, socketDevice: ConnectedDevice): void {
-    const device = this.getOrCreate(hostDeviceId);
-    device.clients.set(socketDevice.deviceId, socketDevice);
-    if (!device.controllerId) {
-      device.controllerId = socketDevice.deviceId;
+  addClient(sessionId: string, device: ConnectedDevice): void {
+    const session = this.getOrCreate(sessionId);
+    session.clients.set(device.deviceId, device);
+    if (!session.controllerId) {
+      session.controllerId = device.deviceId;
     }
-    device.lastActivity = Date.now();
+    session.lastActivity = Date.now();
   }
 
   removeHost(
-    hostDeviceId: string,
+    sessionId: string,
   ): { clients: Map<string, ConnectedDevice> } | undefined {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return undefined;
-    device.host = undefined;
-    device.state = "host_disconnected";
-    device.hostDisconnectedAt = Date.now();
-    return { clients: device.clients };
+    const session = this.sessions.get(sessionId);
+    if (!session) return undefined;
+    session.host = undefined;
+    session.state = "host_disconnected";
+    session.hostDisconnectedAt = Date.now();
+    return { clients: session.clients };
   }
 
-  removeClient(hostDeviceId: string, deviceId: string): void {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return;
-    if (device.clients.delete(deviceId)) this.droppedClients++;
-    if (device.controllerId === deviceId) {
-      const next = device.clients.keys().next();
-      device.controllerId = next.done ? undefined : next.value;
+  removeClient(sessionId: string, deviceId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.clients.delete(deviceId);
+    if (session.controllerId === deviceId) {
+      // Transfer control to next client or clear
+      const next = session.clients.keys().next();
+      session.controllerId = next.done ? undefined : next.value;
     }
-    this.maybeDelete(hostDeviceId);
+    this.maybeDelete(sessionId);
   }
 
-  disconnectAuthorization(hostDeviceId: string, authorizationId: string): number {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return 0;
-    let closed = 0;
-    for (const [deviceId, client] of device.clients) {
-      if (client.authorizationId !== authorizationId) continue;
-      try {
-        client.socket.close(4001, "authorization revoked");
-      } catch {}
-      device.clients.delete(deviceId);
-      closed++;
+  /** Force-delete a session: disconnect host + all clients, remove from map. */
+  forceDelete(sessionId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    if (session.host) {
+      try { session.host.socket.close(1000, "session deleted"); } catch {}
     }
-    this.droppedClients += closed;
-    if (device.controllerId && !device.clients.has(device.controllerId)) {
-      const next = device.clients.keys().next();
-      device.controllerId = next.done ? undefined : next.value;
+    for (const [, client] of session.clients) {
+      try { client.socket.close(1000, "session deleted"); } catch {}
     }
-    this.maybeDelete(hostDeviceId);
-    return closed;
-  }
-
-  forceDelete(hostDeviceId: string): boolean {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return false;
-    if (device.host) {
-      try {
-        device.host.socket.close(1000, "device deleted");
-      } catch {}
-    }
-    for (const [, client] of device.clients) {
-      try {
-        client.socket.close(1000, "device deleted");
-      } catch {}
-    }
-    this.devices.delete(hostDeviceId);
+    this.sessions.delete(sessionId);
     return true;
   }
 
-  bufferOutput(hostDeviceId: string, envelope: Envelope): void {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return;
-    const payload = envelope.payload as { data?: unknown } | undefined;
-    if (
-      typeof payload?.data === "string" &&
-      Buffer.byteLength(payload.data, "utf8") > OUTPUT_BUFFER_MAX_PAYLOAD_BYTES
-    ) {
-      device.lastActivity = Date.now();
-      return;
-    }
-    const terminalId = envelope.terminalId ?? "default";
-    let buffer = device.outputBuffers.get(terminalId);
-    if (!buffer) {
-      buffer = [];
-      device.outputBuffers.set(terminalId, buffer);
+  bufferOutput(sessionId: string, envelope: Envelope): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const tid = (envelope as any).terminalId ?? "default";
+    let buf = session.outputBuffers.get(tid);
+    if (!buf) {
+      buf = [];
+      session.outputBuffers.set(tid, buf);
     }
-    buffer.push(envelope);
-    if (buffer.length > OUTPUT_BUFFER_CAPACITY) {
-      buffer.shift();
+    buf.push(envelope);
+    if (buf.length > OUTPUT_BUFFER_CAPACITY) {
+      buf.shift();
     }
-    device.lastActivity = Date.now();
+    session.lastActivity = Date.now();
   }
 
-  cacheStatus(hostDeviceId: string, envelope: Envelope): void {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return;
-    const terminalId = envelope.terminalId ?? "default";
-    device.lastStatusByTerminal.set(terminalId, envelope);
-    device.lastActivity = Date.now();
+  cacheStatus(sessionId: string, envelope: Envelope): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const tid = (envelope as any).terminalId ?? "default";
+    session.lastStatusByTerminal.set(tid, envelope);
+    session.lastActivity = Date.now();
   }
 
-  getStatusReplay(hostDeviceId: string): Envelope[] {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return [];
-    return [...device.lastStatusByTerminal.values()];
+  getStatusReplay(sessionId: string): Envelope[] {
+    const session = this.sessions.get(sessionId);
+    if (!session) return [];
+    return [...session.lastStatusByTerminal.values()];
   }
 
   getReplayFrom(
-    hostDeviceId: string,
+    sessionId: string,
     afterSeqByTerminal: Record<string, number>,
     fallbackAfterSeq = -1,
   ): Envelope[] {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return [];
+    const session = this.sessions.get(sessionId);
+    if (!session) return [];
     const result: Envelope[] = [];
-    for (const [terminalId, buffer] of device.outputBuffers) {
+    for (const [terminalId, buf] of session.outputBuffers) {
       const afterSeq = afterSeqByTerminal[terminalId] ?? fallbackAfterSeq;
-      for (const envelope of buffer) {
-        if (envelope.seq !== undefined && envelope.seq > afterSeq) {
-          result.push(envelope);
-        }
+      for (const e of buf) {
+        if (e.seq !== undefined && e.seq > afterSeq) result.push(e);
       }
     }
     return result.sort((a, b) => {
-      if (a.seq !== undefined && b.seq !== undefined && a.seq !== b.seq) return a.seq - b.seq;
       const at = Date.parse(a.timestamp);
       const bt = Date.parse(b.timestamp);
       if (!Number.isNaN(at) && !Number.isNaN(bt) && at !== bt) return at - bt;
@@ -219,126 +181,101 @@ export class DeviceManager {
     });
   }
 
-  claimControl(hostDeviceId: string, deviceId: string): boolean {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return false;
-    device.controllerId = deviceId;
+  claimControl(sessionId: string, deviceId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    // Always allow takeover – last claimer wins
+    session.controllerId = deviceId;
     return true;
   }
 
-  releaseControl(hostDeviceId: string, deviceId: string): boolean {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return false;
-    if (device.controllerId !== deviceId) return false;
-    device.controllerId = undefined;
+  releaseControl(sessionId: string, deviceId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    if (session.controllerId !== deviceId) return false;
+    session.controllerId = undefined;
     return true;
   }
 
-  terminate(hostDeviceId: string): void {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return;
-    device.state = "terminated";
+  terminate(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.state = "terminated";
   }
 
-  listActive(): HostDevice[] {
-    return [...this.devices.values()].filter((device) => device.state !== "terminated");
+  listActive(): Session[] {
+    return [...this.sessions.values()].filter((s) => s.state !== "terminated");
   }
 
-  getSummary(hostDeviceId: string) {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return undefined;
+  getSummary(sessionId: string) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return undefined;
     return {
-      id: device.hostDeviceId,
-      hostDeviceId: device.hostDeviceId,
-      state: device.state,
-      online:
-        !!device.host &&
-        device.host.socket.readyState === device.host.socket.OPEN,
+      id: session.id,
+      state: session.state,
       hasHost:
-        !!device.host &&
-        device.host.socket.readyState === device.host.socket.OPEN,
-      clientCount: device.clients.size,
-      controllerId: device.controllerId ?? null,
-      lastActivity: device.lastActivity,
-      createdAt: device.createdAt,
-      bufferSize: [...device.outputBuffers.values()].reduce((sum, buf) => sum + buf.length, 0),
-      machineId: device.machineId ?? null,
-      hostname: device.hostname ?? null,
-      platform: device.platform ?? null,
-      cwd: device.cwd ?? null,
-      capabilities: device.capabilities,
-      userId: device.userId ?? null,
-    };
-  }
-
-  getStats() {
-    let clientCount = 0;
-    let bufferedTerminalFrames = 0;
-    let hostAbsentDevices = 0;
-    let terminalCount = 0;
-    for (const device of this.devices.values()) {
-      clientCount += device.clients.size;
-      terminalCount += device.outputBuffers.size;
-      bufferedTerminalFrames += [...device.outputBuffers.values()].reduce((sum, buf) => sum + buf.length, 0);
-      if (!device.host || device.host.socket.readyState !== device.host.socket.OPEN) hostAbsentDevices++;
-    }
-    return {
-      devices: this.devices.size,
-      activeDevices: this.listActive().length,
-      clients: clientCount,
-      droppedClients: this.droppedClients,
-      hostAbsentDevices,
-      terminalsWithReplay: terminalCount,
-      bufferedTerminalFrames,
-      bufferedAgentFrames: 0,
+        !!session.host &&
+        session.host.socket.readyState === session.host.socket.OPEN,
+      clientCount: session.clients.size,
+      controllerId: session.controllerId ?? null,
+      lastActivity: session.lastActivity,
+      createdAt: session.createdAt,
+      bufferSize: [...session.outputBuffers.values()].reduce((sum, buf) => sum + buf.length, 0),
+      provider: session.provider ?? null,
+      machineId: session.machineId ?? null,
+      hostname: session.hostname ?? null,
+      platform: session.platform ?? null,
+      cwd: session.cwd ?? null,
+      projectName: session.projectName ?? null,
+      userId: session.userId ?? null,
     };
   }
 
   setMetadata(
-    hostDeviceId: string,
-    _provider?: string,
+    sessionId: string,
+    provider?: string,
     machineId?: string,
     hostname?: string,
     platform?: string,
     cwd?: string,
-    _projectName?: string,
-    capabilities?: string[],
+    projectName?: string,
   ): void {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return;
-    if (machineId) device.machineId = machineId;
-    if (hostname) device.hostname = hostname;
-    if (platform) device.platform = platform;
-    if (cwd) device.cwd = cwd;
-    if (capabilities) device.capabilities = capabilities;
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    if (provider) session.provider = provider;
+    if (machineId) session.machineId = machineId;
+    if (hostname) session.hostname = hostname;
+    if (platform) session.platform = platform;
+    if (cwd) session.cwd = cwd;
+    if (projectName) session.projectName = projectName;
   }
 
-  private maybeDelete(hostDeviceId: string): void {
-    const device = this.devices.get(hostDeviceId);
-    if (!device) return;
-    if (!device.host && device.clients.size === 0) {
-      this.devices.delete(hostDeviceId);
+  private maybeDelete(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    if (!session.host && session.clients.size === 0) {
+      this.sessions.delete(sessionId);
     }
   }
 
   private cleanup(): void {
     const now = Date.now();
-    for (const [hostDeviceId, device] of this.devices) {
+    for (const [id, session] of this.sessions) {
+      // Remove sessions where host disconnected and window expired
       if (
-        device.state === "host_disconnected" &&
-        device.hostDisconnectedAt &&
-        now - device.hostDisconnectedAt > HOST_RECONNECT_WINDOW
+        session.state === "host_disconnected" &&
+        session.hostDisconnectedAt &&
+        now - session.hostDisconnectedAt > HOST_RECONNECT_WINDOW
       ) {
-        device.state = "terminated";
-        device.outputBuffers.clear();
-        device.lastStatusByTerminal.clear();
+        session.state = "terminated";
       }
+      // Clean up terminated sessions with no connections
       if (
-        device.state === "terminated" &&
-        !device.host &&
-        device.clients.size === 0
+        session.state === "terminated" &&
+        !session.host &&
+        session.clients.size === 0
       ) {
-        this.devices.delete(hostDeviceId);
+        this.sessions.delete(id);
       }
     }
   }

package/src/state-store.ts

@@ -1,35 +1,28 @@
-export interface StoredAuthorizationRecord {
-  authorizationId: string;
+export interface StoredTokenRecord {
   token: string;
-  hostDeviceId: string;
-  clientDeviceId?: string;
-  clientName?: string;
+  sessionIds: string[];
   createdAt: number;
   lastUsedAt: number;
 }
 
 export interface StoredPairingRecord {
-  hostDeviceId: string;
+  sessionId: string;
   pairingCode: string;
   expiresAt: number;
   claimed: boolean;
 }
 
 export interface GatewayStateStore {
-  loadAuthorizations(): Promise<StoredAuthorizationRecord[]>;
-  saveAuthorization(record: StoredAuthorizationRecord): Promise<void>;
-  deleteAuthorization(authorizationId: string): Promise<void>;
+  loadTokens(): Promise<StoredTokenRecord[]>;
+  saveToken(record: StoredTokenRecord): Promise<void>;
+  deleteToken(token: string): Promise<void>;
   loadPairings(): Promise<StoredPairingRecord[]>;
   savePairing(record: StoredPairingRecord): Promise<void>;
   deletePairing(pairingCode: string): Promise<void>;
 }
 
-const AUTHORIZATION_TABLE =
-  process.env.SUPABASE_GATEWAY_AUTHORIZATION_TABLE ??
-  "linkshell_gateway_device_authorizations";
-const PAIRING_TABLE =
-  process.env.SUPABASE_GATEWAY_PAIRING_TABLE ??
-  "linkshell_gateway_pairing_challenges";
+const TOKEN_TABLE = process.env.SUPABASE_GATEWAY_TOKEN_TABLE ?? "linkshell_gateway_tokens";
+const PAIRING_TABLE = process.env.SUPABASE_GATEWAY_PAIRING_TABLE ?? "linkshell_gateway_pairings";
 const STORE_TIMEOUT_MS = Number(process.env.SUPABASE_STATE_TIMEOUT_MS ?? 3_000);
 
 function msToIso(ms: number): string {
@@ -42,10 +35,6 @@ function isoToMs(value: unknown): number {
   return Number.isNaN(parsed) ? Date.now() : parsed;
 }
 
-function maybeString(value: unknown): string | undefined {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
 export function createSupabaseStateStore(): GatewayStateStore | undefined {
   const url = process.env.SUPABASE_URL?.replace(/\/+$/, "");
   const key = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.SUPABASE_ANON_KEY;
@@ -75,54 +64,49 @@ export function createSupabaseStateStore(): GatewayStateStore | undefined {
   }
 
   return {
-    async loadAuthorizations() {
+    async loadTokens() {
       const rows = await request<Array<Record<string, unknown>>>(
-        `${AUTHORIZATION_TABLE}?select=authorization_id,token,host_device_id,client_device_id,client_name,created_at,last_used_at`,
+        `${TOKEN_TABLE}?select=token,session_ids,created_at,last_used_at`,
       );
       return rows.map((row) => ({
-        authorizationId: String(row.authorization_id ?? ""),
         token: String(row.token ?? ""),
-        hostDeviceId: String(row.host_device_id ?? ""),
-        clientDeviceId: maybeString(row.client_device_id),
-        clientName: maybeString(row.client_name),
+        sessionIds: Array.isArray(row.session_ids)
+          ? row.session_ids.map(String)
+          : [],
         createdAt: isoToMs(row.created_at),
         lastUsedAt: isoToMs(row.last_used_at),
-      })).filter((record) => record.authorizationId && record.token && record.hostDeviceId);
+      })).filter((record) => record.token);
     },
-    async saveAuthorization(record) {
+    async saveToken(record) {
       await request(
-        `${AUTHORIZATION_TABLE}?on_conflict=authorization_id`,
+        `${TOKEN_TABLE}?on_conflict=token`,
         {
           method: "POST",
           headers: { Prefer: "resolution=merge-duplicates" },
           body: JSON.stringify({
-            authorization_id: record.authorizationId,
             token: record.token,
-            host_device_id: record.hostDeviceId,
-            client_device_id: record.clientDeviceId ?? null,
-            client_name: record.clientName ?? null,
+            session_ids: record.sessionIds,
             created_at: msToIso(record.createdAt),
             last_used_at: msToIso(record.lastUsedAt),
           }),
         },
       );
     },
-    async deleteAuthorization(authorizationId) {
-      await request(
-        `${AUTHORIZATION_TABLE}?authorization_id=eq.${encodeURIComponent(authorizationId)}`,
-        { method: "DELETE" },
-      );
+    async deleteToken(token) {
+      await request(`${TOKEN_TABLE}?token=eq.${encodeURIComponent(token)}`, {
+        method: "DELETE",
+      });
     },
     async loadPairings() {
       const rows = await request<Array<Record<string, unknown>>>(
-        `${PAIRING_TABLE}?select=pairing_code,host_device_id,expires_at,claimed`,
+        `${PAIRING_TABLE}?select=pairing_code,session_id,expires_at,claimed`,
       );
       return rows.map((row) => ({
         pairingCode: String(row.pairing_code ?? ""),
-        hostDeviceId: String(row.host_device_id ?? ""),
+        sessionId: String(row.session_id ?? ""),
         expiresAt: isoToMs(row.expires_at),
         claimed: row.claimed === true,
-      })).filter((record) => record.pairingCode && record.hostDeviceId);
+      })).filter((record) => record.pairingCode && record.sessionId);
     },
     async savePairing(record) {
       await request(
@@ -132,7 +116,7 @@ export function createSupabaseStateStore(): GatewayStateStore | undefined {
           headers: { Prefer: "resolution=merge-duplicates" },
           body: JSON.stringify({
             pairing_code: record.pairingCode,
-            host_device_id: record.hostDeviceId,
+            session_id: record.sessionId,
             expires_at: msToIso(record.expiresAt),
             claimed: record.claimed,
           }),