@linkshell/gateway 0.5.2 → 0.6.0

package/src/state-store.ts

@@ -1,140 +0,0 @@
-export interface StoredTokenRecord {
-  token: string;
-  sessionIds: string[];
-  createdAt: number;
-  lastUsedAt: number;
-}
-
-export interface StoredPairingRecord {
-  sessionId: string;
-  pairingCode: string;
-  expiresAt: number;
-  claimed: boolean;
-}
-
-export interface GatewayStateStore {
-  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 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 {
-  return new Date(ms).toISOString();
-}
-
-function isoToMs(value: unknown): number {
-  if (typeof value !== "string") return Date.now();
-  const parsed = Date.parse(value);
-  return Number.isNaN(parsed) ? Date.now() : parsed;
-}
-
-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;
-  if (!url || !key) return undefined;
-
-  const headers = {
-    apikey: key,
-    Authorization: `Bearer ${key}`,
-    "Content-Type": "application/json",
-  };
-
-  async function request<T>(path: string, init?: RequestInit): Promise<T> {
-    const res = await fetch(`${url}/rest/v1/${path}`, {
-      ...init,
-      signal: init?.signal ?? AbortSignal.timeout(STORE_TIMEOUT_MS),
-      headers: {
-        ...headers,
-        ...(init?.headers ?? {}),
-      },
-    });
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      throw new Error(`Supabase state store ${res.status}: ${body || res.statusText}`);
-    }
-    if (res.status === 204) return undefined as T;
-    // Writes (POST upsert / DELETE) can return 2xx with an EMPTY body depending
-    // on PostgREST's Prefer handling — calling res.json() on that throws
-    // "Unexpected end of JSON input". Read as text and only parse when non-empty
-    // so writes resolve to undefined cleanly; reads (SELECT) always return a
-    // JSON array ("[]" at minimum), so they still parse.
-    const text = await res.text();
-    if (!text.trim()) return undefined as T;
-    return JSON.parse(text) as T;
-  }
-
-  return {
-    async loadTokens() {
-      const rows = await request<Array<Record<string, unknown>>>(
-        `${TOKEN_TABLE}?select=token,session_ids,created_at,last_used_at`,
-      );
-      return rows.map((row) => ({
-        token: String(row.token ?? ""),
-        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.token);
-    },
-    async saveToken(record) {
-      await request(
-        `${TOKEN_TABLE}?on_conflict=token`,
-        {
-          method: "POST",
-          headers: { Prefer: "return=minimal,resolution=merge-duplicates" },
-          body: JSON.stringify({
-            token: record.token,
-            session_ids: record.sessionIds,
-            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 loadPairings() {
-      const rows = await request<Array<Record<string, unknown>>>(
-        `${PAIRING_TABLE}?select=pairing_code,session_id,expires_at,claimed`,
-      );
-      return rows.map((row) => ({
-        pairingCode: String(row.pairing_code ?? ""),
-        sessionId: String(row.session_id ?? ""),
-        expiresAt: isoToMs(row.expires_at),
-        claimed: row.claimed === true,
-      })).filter((record) => record.pairingCode && record.sessionId);
-    },
-    async savePairing(record) {
-      await request(
-        `${PAIRING_TABLE}?on_conflict=pairing_code`,
-        {
-          method: "POST",
-          headers: { Prefer: "return=minimal,resolution=merge-duplicates" },
-          body: JSON.stringify({
-            pairing_code: record.pairingCode,
-            session_id: record.sessionId,
-            expires_at: msToIso(record.expiresAt),
-            claimed: record.claimed,
-          }),
-        },
-      );
-    },
-    async deletePairing(pairingCode) {
-      await request(
-        `${PAIRING_TABLE}?pairing_code=eq.${encodeURIComponent(pairingCode)}`,
-        { method: "DELETE" },
-      );
-    },
-  };
-}

package/src/static-web.ts

@@ -1,133 +0,0 @@
-import { existsSync } from "node:fs";
-import { stat, readFile } from "node:fs/promises";
-import { resolve, join, extname, normalize } from "node:path";
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-// Serves the built web-dashboard SPA from the gateway, so a single deployment
-// (and single origin) hosts both the API/WebSocket and the UI. The web is
-// optional: if WEB_DIST doesn't exist (e.g. local dev using the Vite dev
-// server), the gateway runs API-only and this is a no-op.
-
-const WEB_DIST = process.env.WEB_DIST ?? resolve(process.cwd(), "web");
-const hasWeb = existsSync(join(WEB_DIST, "index.html"));
-
-const CONTENT_TYPES: Record<string, string> = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".ico": "image/x-icon",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".map": "application/json; charset=utf-8",
-  ".txt": "text/plain; charset=utf-8",
-};
-
-export function webEnabled(): boolean {
-  return hasWeb;
-}
-
-export function webDistPath(): string {
-  return WEB_DIST;
-}
-
-async function resolveWebFile(pathname: string, allowSpaFallback: boolean): Promise<string | null> {
-  // Path-traversal guard: normalize, then confine to WEB_DIST.
-  const candidate = resolve(WEB_DIST, "." + normalize(pathname));
-  const inRoot = candidate === WEB_DIST || candidate.startsWith(WEB_DIST + "/");
-
-  let filePath: string | null = null;
-  if (inRoot && pathname !== "/") {
-    try {
-      const s = await stat(candidate);
-      if (s.isFile()) filePath = candidate;
-    } catch {
-      // not a real file
-    }
-  }
-
-  // SPA fallback: serve index.html for "/" and for any path without a file
-  // extension (a client-side route). Missing assets (with an extension) 404.
-  if (!filePath) {
-    if (allowSpaFallback && (pathname === "/" || extname(pathname) === "")) {
-      filePath = join(WEB_DIST, "index.html");
-    } else {
-      return null; // let the caller 404/proxy the missing asset
-    }
-  }
-
-  return filePath;
-}
-
-async function serveWebFile(req: IncomingMessage, res: ServerResponse, filePath: string): Promise<boolean> {
-  try {
-    const ext = extname(filePath).toLowerCase();
-    const type = CONTENT_TYPES[ext] ?? "application/octet-stream";
-    res.setHeader("Content-Type", type);
-    // Hashed assets (Vite emits content-hashed filenames) can cache hard;
-    // index.html must never be cached so deploys take effect immediately.
-    if (filePath.endsWith("index.html")) {
-      res.setHeader("Cache-Control", "no-cache");
-      // lsh_tunnel is an HttpOnly helper cookie for preview subresources. Older
-      // builds used Path=/, so stale values are still sent to the LinkShell app
-      // shell and even /ws handshakes. Clear it whenever the real app document
-      // is served; /tunnel/... responses will set a fresh value when preview is
-      // actually opened.
-      res.setHeader("Set-Cookie", "lsh_tunnel=; Path=/; Max-Age=0; HttpOnly; SameSite=Lax");
-    } else {
-      res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
-    }
-    if (req.method === "HEAD") {
-      res.writeHead(200);
-      res.end();
-      return true;
-    }
-    const body = await readFile(filePath);
-    res.writeHead(200);
-    res.end(body);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Try to serve a concrete web asset without the SPA fallback. This lets the
- * gateway protect its own built assets before tunnel cookie fallback handles a
- * previewed app's absolute assets such as "/assets/app.css".
- */
-export async function serveWebAsset(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
-  if (!hasWeb) return false;
-  if (req.method !== "GET" && req.method !== "HEAD") return false;
-
-  const url = new URL(req.url ?? "/", "http://localhost");
-  const pathname = decodeURIComponent(url.pathname);
-  const filePath = await resolveWebFile(pathname, false);
-  if (!filePath) return false;
-  return serveWebFile(req, res, filePath);
-}
-
-/**
- * Try to serve a GET/HEAD request from the web dist. Returns true if handled.
- * Place AFTER all API routes so it never shadows them. Unmatched non-asset
- * paths fall back to index.html (SPA client-side routing).
- */
-export async function serveWeb(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
-  if (!hasWeb) return false;
-  if (req.method !== "GET" && req.method !== "HEAD") return false;
-
-  const url = new URL(req.url ?? "/", "http://localhost");
-  const pathname = decodeURIComponent(url.pathname);
-  const filePath = await resolveWebFile(pathname, true);
-  if (!filePath) return false;
-
-  return serveWebFile(req, res, filePath);
-}

package/src/tokens.ts

@@ -1,159 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type { GatewayStateStore } from "./state-store.js";
-
-const CLEANUP_INTERVAL = 5 * 60_000;
-const SESSION_TTL = 7 * 24 * 60 * 60_000; // 7 days — prune stale bindings
-
-interface TokenRecord {
-  token: string;
-  sessionIds: Set<string>;
-  createdAt: number;
-  lastUsedAt: number;
-}
-
-export class TokenManager {
-  private tokens = new Map<string, TokenRecord>();
-  private sessionToToken = new Map<string, string>();
-  private cleanupTimer: ReturnType<typeof setInterval>;
-
-  constructor(private readonly store?: GatewayStateStore) {
-    this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL);
-  }
-
-  async hydrate(): Promise<void> {
-    if (!this.store) return;
-    try {
-      const records = await this.store.loadTokens();
-      const now = Date.now();
-      for (const record of records) {
-        if (now - record.lastUsedAt > SESSION_TTL) {
-          void this.store.deleteToken(record.token).catch(() => {});
-          continue;
-        }
-        this.tokens.set(record.token, {
-          token: record.token,
-          sessionIds: new Set(record.sessionIds),
-          createdAt: record.createdAt,
-          lastUsedAt: record.lastUsedAt,
-        });
-        for (const sessionId of record.sessionIds) {
-          this.sessionToToken.set(sessionId, record.token);
-        }
-      }
-    } catch (err) {
-      process.stderr.write(`[gateway] token store hydrate failed, using memory only: ${err}\n`);
-    }
-  }
-
-  register(deviceToken?: string): string {
-    if (deviceToken && this.tokens.has(deviceToken)) {
-      const record = this.tokens.get(deviceToken)!;
-      record.lastUsedAt = Date.now();
-      this.persist(record);
-      return deviceToken;
-    }
-    const token = deviceToken || randomUUID();
-    this.tokens.set(token, {
-      token,
-      sessionIds: new Set(),
-      createdAt: Date.now(),
-      lastUsedAt: Date.now(),
-    });
-    this.persist(this.tokens.get(token)!);
-    return token;
-  }
-
-  bind(token: string, sessionId: string): boolean {
-    const record = this.tokens.get(token);
-    if (!record) return false;
-    record.sessionIds.add(sessionId);
-    record.lastUsedAt = Date.now();
-    this.sessionToToken.set(sessionId, token);
-    this.persist(record);
-    return true;
-  }
-
-  validate(token: string): boolean {
-    const record = this.tokens.get(token);
-    if (!record) return false;
-    record.lastUsedAt = Date.now();
-    this.persist(record);
-    return true;
-  }
-
-  owns(token: string, sessionId: string): boolean {
-    const record = this.tokens.get(token);
-    if (!record) return false;
-    record.lastUsedAt = Date.now();
-    this.persist(record);
-    return record.sessionIds.has(sessionId);
-  }
-
-  async ownsFresh(token: string, sessionId: string): Promise<boolean> {
-    if (this.owns(token, sessionId)) return true;
-    if (!this.store) return false;
-    try {
-      const records = await this.store.loadTokens();
-      const now = Date.now();
-      for (const record of records) {
-        if (now - record.lastUsedAt > SESSION_TTL) continue;
-        if (record.token !== token) continue;
-        const next = {
-          token: record.token,
-          sessionIds: new Set(record.sessionIds),
-          createdAt: record.createdAt,
-          lastUsedAt: Date.now(),
-        };
-        this.tokens.set(record.token, next);
-        for (const sid of record.sessionIds) {
-          this.sessionToToken.set(sid, record.token);
-        }
-        this.persist(next);
-        return next.sessionIds.has(sessionId);
-      }
-    } catch (err) {
-      process.stderr.write(`[gateway] token store refresh failed: ${err}\n`);
-    }
-    return false;
-  }
-
-  getSessionIds(token: string): Set<string> {
-    const record = this.tokens.get(token);
-    if (!record) return new Set();
-    record.lastUsedAt = Date.now();
-    this.persist(record);
-    return record.sessionIds;
-  }
-
-  getTokenForSession(sessionId: string): string | undefined {
-    return this.sessionToToken.get(sessionId);
-  }
-
-  private cleanup(): void {
-    const now = Date.now();
-    for (const [token, record] of this.tokens) {
-      if (now - record.lastUsedAt > SESSION_TTL) {
-        for (const sid of record.sessionIds) {
-          this.sessionToToken.delete(sid);
-        }
-        this.tokens.delete(token);
-        void this.store?.deleteToken(token).catch(() => {});
-      }
-    }
-  }
-
-  private persist(record: TokenRecord): void {
-    void this.store?.saveToken({
-      token: record.token,
-      sessionIds: [...record.sessionIds],
-      createdAt: record.createdAt,
-      lastUsedAt: record.lastUsedAt,
-    }).catch((err) => {
-      process.stderr.write(`[gateway] token store save failed: ${err}\n`);
-    });
-  }
-
-  destroy(): void {
-    clearInterval(this.cleanupTimer);
-  }
-}