@linkshell/gateway 0.2.47 → 0.3.0

package/src/sessions.ts

@@ -1,54 +1,55 @@
 import type WebSocket from "ws";
 import type { Envelope } from "@linkshell/protocol";
 
-export type SessionState = "active" | "host_disconnected" | "terminated";
+export type DeviceState = "active" | "host_disconnected" | "terminated";
 
 export interface ConnectedDevice {
   socket: WebSocket;
   role: "host" | "client";
   deviceId: string;
+  token?: string;
+  authorizationId?: string;
   connectedAt: number;
 }
 
-export interface Session {
+export interface HostDevice {
   id: string;
-  state: SessionState;
+  hostDeviceId: string;
+  state: DeviceState;
   host: ConnectedDevice | undefined;
   clients: Map<string, ConnectedDevice>;
   controllerId: string | undefined;
   lastActivity: number;
   createdAt: number;
-  outputBuffers: Map<string, Envelope[]>; // keyed by terminalId
-  lastStatusByTerminal: Map<string, Envelope>; // last terminal.status per terminal
+  outputBuffers: Map<string, Envelope[]>;
+  lastStatusByTerminal: Map<string, Envelope>;
   hostDisconnectedAt: number | undefined;
-  // Metadata from host's session.connect
-  provider: string | undefined;
   machineId: string | undefined;
   hostname: string | undefined;
   platform: string | undefined;
   cwd: string | undefined;
-  projectName: string | undefined;
-  // Auth: user who owns this session (set on AUTH_REQUIRED gateways)
+  capabilities: string[];
   userId: string | undefined;
 }
 
 const OUTPUT_BUFFER_CAPACITY = 200;
-const HOST_RECONNECT_WINDOW = 60_000; // 60s
+const HOST_RECONNECT_WINDOW = 60_000;
 const CLEANUP_INTERVAL = 30_000;
 
-export class SessionManager {
-  private sessions = new Map<string, Session>();
+export class DeviceManager {
+  private devices = new Map<string, HostDevice>();
   private cleanupTimer: ReturnType<typeof setInterval>;
 
   constructor() {
     this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL);
   }
 
-  getOrCreate(sessionId: string): Session {
-    let session = this.sessions.get(sessionId);
-    if (!session) {
-      session = {
-        id: sessionId,
+  getOrCreate(hostDeviceId: string): HostDevice {
+    let device = this.devices.get(hostDeviceId);
+    if (!device) {
+      device = {
+        id: hostDeviceId,
+        hostDeviceId,
         state: "active",
         host: undefined,
         clients: new Map(),
@@ -58,119 +59,142 @@ export class SessionManager {
         outputBuffers: new Map(),
         lastStatusByTerminal: new Map(),
         hostDisconnectedAt: undefined,
-        provider: undefined,
         machineId: undefined,
         hostname: undefined,
         platform: undefined,
         cwd: undefined,
-        projectName: undefined,
+        capabilities: [],
         userId: undefined,
       };
-      this.sessions.set(sessionId, session);
+      this.devices.set(hostDeviceId, device);
     }
-    return session;
+    return device;
   }
 
-  get(sessionId: string): Session | undefined {
-    return this.sessions.get(sessionId);
+  get(hostDeviceId: string): HostDevice | undefined {
+    return this.devices.get(hostDeviceId);
   }
 
-  setHost(sessionId: string, device: ConnectedDevice): void {
-    const session = this.getOrCreate(sessionId);
-    session.host = device;
-    session.state = "active";
-    session.hostDisconnectedAt = undefined;
-    session.lastActivity = Date.now();
+  setHost(hostDeviceId: string, socketDevice: ConnectedDevice): void {
+    const device = this.getOrCreate(hostDeviceId);
+    device.host = socketDevice;
+    device.state = "active";
+    device.hostDisconnectedAt = undefined;
+    device.lastActivity = Date.now();
   }
 
-  addClient(sessionId: string, device: ConnectedDevice): void {
-    const session = this.getOrCreate(sessionId);
-    session.clients.set(device.deviceId, device);
-    if (!session.controllerId) {
-      session.controllerId = device.deviceId;
+  addClient(hostDeviceId: string, socketDevice: ConnectedDevice): void {
+    const device = this.getOrCreate(hostDeviceId);
+    device.clients.set(socketDevice.deviceId, socketDevice);
+    if (!device.controllerId) {
+      device.controllerId = socketDevice.deviceId;
     }
-    session.lastActivity = Date.now();
+    device.lastActivity = Date.now();
   }
 
   removeHost(
-    sessionId: string,
+    hostDeviceId: string,
   ): { clients: Map<string, ConnectedDevice> } | undefined {
-    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 };
+    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 };
   }
 
-  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;
+  removeClient(hostDeviceId: string, deviceId: string): void {
+    const device = this.devices.get(hostDeviceId);
+    if (!device) return;
+    device.clients.delete(deviceId);
+    if (device.controllerId === deviceId) {
+      const next = device.clients.keys().next();
+      device.controllerId = next.done ? undefined : next.value;
     }
-    this.maybeDelete(sessionId);
+    this.maybeDelete(hostDeviceId);
   }
 
-  /** 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 {}
+  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++;
     }
-    for (const [, client] of session.clients) {
-      try { client.socket.close(1000, "session deleted"); } catch {}
+    if (device.controllerId && !device.clients.has(device.controllerId)) {
+      const next = device.clients.keys().next();
+      device.controllerId = next.done ? undefined : next.value;
     }
-    this.sessions.delete(sessionId);
+    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);
     return true;
   }
 
-  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);
+  bufferOutput(hostDeviceId: string, envelope: Envelope): void {
+    const device = this.devices.get(hostDeviceId);
+    if (!device) return;
+    const terminalId = envelope.terminalId ?? "default";
+    let buffer = device.outputBuffers.get(terminalId);
+    if (!buffer) {
+      buffer = [];
+      device.outputBuffers.set(terminalId, buffer);
     }
-    buf.push(envelope);
-    if (buf.length > OUTPUT_BUFFER_CAPACITY) {
-      buf.shift();
+    buffer.push(envelope);
+    if (buffer.length > OUTPUT_BUFFER_CAPACITY) {
+      buffer.shift();
     }
-    session.lastActivity = Date.now();
+    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();
+  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();
   }
 
-  getStatusReplay(sessionId: string): Envelope[] {
-    const session = this.sessions.get(sessionId);
-    if (!session) return [];
-    return [...session.lastStatusByTerminal.values()];
+  getStatusReplay(hostDeviceId: string): Envelope[] {
+    const device = this.devices.get(hostDeviceId);
+    if (!device) return [];
+    return [...device.lastStatusByTerminal.values()];
   }
 
   getReplayFrom(
-    sessionId: string,
+    hostDeviceId: string,
     afterSeqByTerminal: Record<string, number>,
     fallbackAfterSeq = -1,
   ): Envelope[] {
-    const session = this.sessions.get(sessionId);
-    if (!session) return [];
+    const device = this.devices.get(hostDeviceId);
+    if (!device) return [];
     const result: Envelope[] = [];
-    for (const [terminalId, buf] of session.outputBuffers) {
+    for (const [terminalId, buffer] of device.outputBuffers) {
       const afterSeq = afterSeqByTerminal[terminalId] ?? fallbackAfterSeq;
-      for (const e of buf) {
-        if (e.seq !== undefined && e.seq > afterSeq) result.push(e);
+      for (const envelope of buffer) {
+        if (envelope.seq !== undefined && envelope.seq > afterSeq) {
+          result.push(envelope);
+        }
       }
     }
     return result.sort((a, b) => {
@@ -181,101 +205,101 @@ export class SessionManager {
     });
   }
 
-  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;
+  claimControl(hostDeviceId: string, deviceId: string): boolean {
+    const device = this.devices.get(hostDeviceId);
+    if (!device) return false;
+    device.controllerId = deviceId;
     return true;
   }
 
-  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;
+  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;
     return true;
   }
 
-  terminate(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    session.state = "terminated";
+  terminate(hostDeviceId: string): void {
+    const device = this.devices.get(hostDeviceId);
+    if (!device) return;
+    device.state = "terminated";
   }
 
-  listActive(): Session[] {
-    return [...this.sessions.values()].filter((s) => s.state !== "terminated");
+  listActive(): HostDevice[] {
+    return [...this.devices.values()].filter((device) => device.state !== "terminated");
   }
 
-  getSummary(sessionId: string) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return undefined;
+  getSummary(hostDeviceId: string) {
+    const device = this.devices.get(hostDeviceId);
+    if (!device) return undefined;
     return {
-      id: session.id,
-      state: session.state,
+      id: device.hostDeviceId,
+      hostDeviceId: device.hostDeviceId,
+      state: device.state,
+      online:
+        !!device.host &&
+        device.host.socket.readyState === device.host.socket.OPEN,
       hasHost:
-        !!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,
+        !!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,
     };
   }
 
   setMetadata(
-    sessionId: string,
-    provider?: string,
+    hostDeviceId: string,
+    _provider?: string,
     machineId?: string,
     hostname?: string,
     platform?: string,
     cwd?: string,
-    projectName?: string,
+    _projectName?: string,
+    capabilities?: string[],
   ): void {
-    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;
+    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;
   }
 
-  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 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 cleanup(): void {
     const now = Date.now();
-    for (const [id, session] of this.sessions) {
-      // Remove sessions where host disconnected and window expired
+    for (const [hostDeviceId, device] of this.devices) {
       if (
-        session.state === "host_disconnected" &&
-        session.hostDisconnectedAt &&
-        now - session.hostDisconnectedAt > HOST_RECONNECT_WINDOW
+        device.state === "host_disconnected" &&
+        device.hostDisconnectedAt &&
+        now - device.hostDisconnectedAt > HOST_RECONNECT_WINDOW
       ) {
-        session.state = "terminated";
+        device.state = "terminated";
       }
-      // Clean up terminated sessions with no connections
       if (
-        session.state === "terminated" &&
-        !session.host &&
-        session.clients.size === 0
+        device.state === "terminated" &&
+        !device.host &&
+        device.clients.size === 0
       ) {
-        this.sessions.delete(id);
+        this.devices.delete(hostDeviceId);
       }
     }
   }

package/src/state-store.ts

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