@wangyaoshen/remux 0.3.8-dev.29e114b

package/src/team.ts

@@ -0,0 +1,123 @@
+/**
+ * E17: Team Mode Foundations — user identity, RBAC, workspace/project models.
+ * Personal Mode (current): single implicit workspace, no user auth.
+ * Team Mode: multi-user with roles and permissions.
+ */
+
+import { getDb } from "./store.js";
+
+// E17-001: User Identity
+export interface UserIdentity {
+  userId: string;
+  displayName: string;
+  email: string;
+  avatarUrl?: string;
+  role: "owner" | "admin" | "member" | "viewer";
+}
+
+// E17-003: RBAC
+export type Permission = "read" | "write" | "admin" | "approve";
+
+const ROLE_PERMISSIONS: Record<string, Permission[]> = {
+  owner: ["read", "write", "admin", "approve"],
+  admin: ["read", "write", "admin", "approve"],
+  member: ["read", "write", "approve"],
+  viewer: ["read"],
+};
+
+export function hasPermission(role: string, permission: Permission): boolean {
+  return ROLE_PERMISSIONS[role]?.includes(permission) ?? false;
+}
+
+// E17-004: Workspace model
+export interface Workspace {
+  id: string;
+  name: string;
+  ownerId: string;
+  createdAt: string;
+}
+
+// E17-005: Project model
+export interface Project {
+  id: string;
+  workspaceId: string;
+  name: string;
+  description: string;
+  createdAt: string;
+}
+
+// E17-006: Audit Log
+export interface AuditEntry {
+  id: number;
+  userId: string;
+  action: string;
+  target: string;
+  timestamp: string;
+  details: string;
+}
+
+export function initTeamTables(): void {
+  const db = getDb();
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS users (
+      user_id TEXT PRIMARY KEY,
+      display_name TEXT NOT NULL,
+      email TEXT UNIQUE NOT NULL,
+      avatar_url TEXT,
+      role TEXT NOT NULL DEFAULT 'member',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      owner_id TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      action TEXT NOT NULL,
+      target TEXT NOT NULL,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+      details TEXT DEFAULT ''
+    );
+
+    CREATE TABLE IF NOT EXISTS workspace_members (
+      workspace_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'member',
+      joined_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (workspace_id, user_id)
+    );
+  `);
+}
+
+export function logAudit(
+  userId: string,
+  action: string,
+  target: string,
+  details?: string,
+): void {
+  const db = getDb();
+  db.prepare(
+    "INSERT INTO audit_log (user_id, action, target, details) VALUES (?, ?, ?, ?)",
+  ).run(userId, action, target, details || "");
+}
+
+export function getAuditLog(limit = 100): AuditEntry[] {
+  const db = getDb();
+  return db
+    .prepare("SELECT * FROM audit_log ORDER BY id DESC LIMIT ?")
+    .all(limit) as AuditEntry[];
+}

package/src/tunnel.ts

@@ -0,0 +1,126 @@
+/**
+ * Cloudflare Tunnel support for Remux.
+ * Detects cloudflared, spawns a quick tunnel, parses the URL.
+ * Adapted from cloudflare/cloudflared quick-tunnel pattern.
+ */
+
+import { spawn, execFile, type ChildProcess } from "child_process";
+
+// ── CLI arg parsing ─────────────────────────────────────────────
+
+export type TunnelMode = "enable" | "disable" | "auto";
+
+/**
+ * Parse tunnel-related CLI flags from argv.
+ */
+export function parseTunnelArgs(argv: string[]): { tunnelMode: TunnelMode } {
+  if (argv.includes("--no-tunnel")) return { tunnelMode: "disable" };
+  if (argv.includes("--tunnel")) return { tunnelMode: "enable" };
+  return { tunnelMode: "auto" };
+}
+
+// ── cloudflared detection ───────────────────────────────────────
+
+/**
+ * Check if cloudflared is available on PATH.
+ */
+export function isCloudflaredAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    execFile("cloudflared", ["--version"], (err) => {
+      resolve(!err);
+    });
+  });
+}
+
+// ── Tunnel lifecycle ────────────────────────────────────────────
+
+const TUNNEL_URL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+
+/**
+ * Start a cloudflared quick tunnel pointing at the given local URL.
+ */
+export function startTunnel(
+  port: number,
+  options: { signal?: AbortSignal } = {},
+): Promise<{ url: string; process: ChildProcess }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      "cloudflared",
+      ["tunnel", "--url", `http://localhost:${port}`],
+      { stdio: ["ignore", "pipe", "pipe"] },
+    );
+
+    let resolved = false;
+    let output = "";
+    const TIMEOUT_MS = 30_000;
+
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        child.kill("SIGTERM");
+        reject(new Error("cloudflared tunnel URL not detected within 30s"));
+      }
+    }, TIMEOUT_MS);
+
+    function handleData(data: Buffer) {
+      output += data.toString();
+      const match = output.match(TUNNEL_URL_RE);
+      if (match && !resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        // Stop accumulating data after URL is found
+        child.stderr!.removeListener("data", handleData);
+        child.stdout!.removeListener("data", handleData);
+        resolve({ url: match[0], process: child });
+      }
+    }
+
+    // cloudflared logs connection info to stderr
+    child.stderr!.on("data", handleData);
+    child.stdout!.on("data", handleData);
+
+    child.on("error", (err) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+
+    child.on("close", (code) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        reject(
+          new Error(
+            `cloudflared exited with code ${code} before URL was detected`,
+          ),
+        );
+      }
+    });
+
+    if (options.signal) {
+      options.signal.addEventListener(
+        "abort",
+        () => {
+          child.kill("SIGTERM");
+        },
+        { once: true },
+      );
+    }
+  });
+}
+
+/**
+ * Build the full tunnel access URL, appending auth token if present.
+ */
+export function buildTunnelAccessUrl(
+  tunnelUrl: string,
+  token: string | null,
+  password: string | null,
+): string {
+  // If password auth, the user logs in via the password page (no token in URL)
+  if (password && !token) return tunnelUrl;
+  if (token) return `${tunnelUrl}?token=${token}`;
+  return tunnelUrl;
+}

package/src/types.d.ts

@@ -0,0 +1,50 @@
+declare module "qrcode-terminal" {
+  export function generate(
+    text: string,
+    options?: { small?: boolean },
+    callback?: (code: string) => void,
+  ): void;
+}
+
+declare module "web-push" {
+  export interface PushSubscription {
+    endpoint: string;
+    keys: {
+      p256dh: string;
+      auth: string;
+    };
+  }
+
+  export interface RequestOptions {
+    TTL?: number;
+    headers?: Record<string, string>;
+    vapidDetails?: {
+      subject: string;
+      publicKey: string;
+      privateKey: string;
+    };
+  }
+
+  export interface SendResult {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+  }
+
+  export interface VapidKeys {
+    publicKey: string;
+    privateKey: string;
+  }
+
+  export function generateVAPIDKeys(): VapidKeys;
+  export function setVapidDetails(
+    subject: string,
+    publicKey: string,
+    privateKey: string,
+  ): void;
+  export function sendNotification(
+    subscription: PushSubscription,
+    payload?: string | Buffer | null,
+    options?: RequestOptions,
+  ): Promise<SendResult>;
+}

package/src/vt-tracker.ts

@@ -0,0 +1,188 @@
+/**
+ * Server-side ghostty-vt (WASM) -- tsm-style VT tracking.
+ * Loads the ghostty-vt WASM binary and provides a factory for VT terminals.
+ */
+
+import fs from "fs";
+
+// ── WASM state (module-level singletons) ────────────────────────
+
+let wasmExports: any = null;
+let wasmMemory: WebAssembly.Memory | null = null;
+
+// ── VT Terminal type ─────────────────────────────────────────────
+
+export interface VtTerminal {
+  handle: number;
+  consume(data: string | Buffer): void;
+  resize(cols: number, rows: number): void;
+  isAltScreen(): boolean;
+  /** Build a VT escape sequence snapshot from viewport cells (tsm Snapshot equivalent). */
+  snapshot(): string | null;
+  /** Extract plain text from viewport (for Inspect view). */
+  textSnapshot(): { text: string; cols: number; rows: number };
+  dispose(): void;
+}
+
+// ── Init ─────────────────────────────────────────────────────────
+
+/**
+ * Load the ghostty-vt WASM binary from disk.
+ */
+export async function initGhosttyVt(wasmPath: string): Promise<void> {
+  const wasmBytes = fs.readFileSync(wasmPath);
+  const result = await WebAssembly.instantiate(wasmBytes, {
+    env: { log: () => {} },
+  });
+  wasmExports = result.instance.exports;
+  wasmMemory = wasmExports.memory;
+  console.log("[ghostty-vt] WASM loaded for server-side VT tracking");
+}
+
+// ── Factory ──────────────────────────────────────────────────────
+
+/**
+ * Create a new VT terminal instance with the given dimensions.
+ * Returns null if WASM is not loaded.
+ */
+export function createVtTerminal(
+  cols: number,
+  rows: number,
+): VtTerminal | null {
+  if (!wasmExports) return null;
+  const handle = wasmExports.ghostty_terminal_new(cols, rows);
+  if (!handle) return null;
+
+  return {
+    handle,
+
+    consume(data: string | Buffer) {
+      if (!this.handle) return; // disposed
+      const bytes = typeof data === "string" ? Buffer.from(data) : data;
+      const ptr = wasmExports.ghostty_wasm_alloc_u8_array(bytes.length);
+      new Uint8Array(wasmMemory!.buffer).set(bytes, ptr);
+      wasmExports.ghostty_terminal_write(handle, ptr, bytes.length);
+      wasmExports.ghostty_wasm_free_u8_array(ptr, bytes.length);
+    },
+
+    resize(cols: number, rows: number) {
+      if (!this.handle) return; // disposed
+      wasmExports.ghostty_terminal_resize(handle, cols, rows);
+    },
+
+    isAltScreen(): boolean {
+      if (!this.handle) return false; // disposed
+      return !!wasmExports.ghostty_terminal_is_alternate_screen(handle);
+    },
+
+    snapshot(): string | null {
+      if (!this.handle) return null; // disposed
+      wasmExports.ghostty_render_state_update(handle);
+      const cols = wasmExports.ghostty_render_state_get_cols(handle);
+      const rows = wasmExports.ghostty_render_state_get_rows(handle);
+      const cellSize = 16;
+      const bufSize = cols * rows * cellSize;
+      const bufPtr = wasmExports.ghostty_wasm_alloc_u8_array(bufSize);
+      const count = wasmExports.ghostty_render_state_get_viewport(
+        handle,
+        bufPtr,
+        bufSize,
+      );
+
+      const view = new DataView(wasmMemory!.buffer);
+      let out = "\x1b[H\x1b[2J"; // clear + home
+      let lastFg: number | null = null;
+      let lastBg: number | null = null;
+      let lastFlags = 0;
+
+      for (let row = 0; row < rows; row++) {
+        if (row > 0) out += "\r\n";
+        for (let col = 0; col < cols; col++) {
+          const off = bufPtr + (row * cols + col) * cellSize;
+          const cp = view.getUint32(off, true);
+          const fg_r = view.getUint8(off + 4);
+          const fg_g = view.getUint8(off + 5);
+          const fg_b = view.getUint8(off + 6);
+          const bg_r = view.getUint8(off + 7);
+          const bg_g = view.getUint8(off + 8);
+          const bg_b = view.getUint8(off + 9);
+          const flags = view.getUint8(off + 10);
+          const width = view.getUint8(off + 11);
+
+          if (width === 0) continue; // continuation cell (wide char)
+
+          // SGR: only emit changes
+          const fgKey = (fg_r << 16) | (fg_g << 8) | fg_b;
+          const bgKey = (bg_r << 16) | (bg_g << 8) | bg_b;
+          let sgr = "";
+          if (flags !== lastFlags) {
+            sgr += "\x1b[0m"; // reset, then re-apply
+            if (flags & 1) sgr += "\x1b[1m"; // bold
+            if (flags & 2) sgr += "\x1b[3m"; // italic
+            if (flags & 4) sgr += "\x1b[4m"; // underline
+            if (flags & 128) sgr += "\x1b[2m"; // faint
+            lastFg = null;
+            lastBg = null; // force re-emit colors after reset
+            lastFlags = flags;
+          }
+          if (fgKey !== lastFg && fgKey !== 0) {
+            sgr += `\x1b[38;2;${fg_r};${fg_g};${fg_b}m`;
+            lastFg = fgKey;
+          }
+          if (bgKey !== lastBg && bgKey !== 0) {
+            sgr += `\x1b[48;2;${bg_r};${bg_g};${bg_b}m`;
+            lastBg = bgKey;
+          }
+          out += sgr;
+          out += cp > 0 ? String.fromCodePoint(cp) : " ";
+        }
+      }
+
+      // Restore cursor position
+      const cx = wasmExports.ghostty_render_state_get_cursor_x(handle);
+      const cy = wasmExports.ghostty_render_state_get_cursor_y(handle);
+      out += `\x1b[0m\x1b[${cy + 1};${cx + 1}H`;
+
+      wasmExports.ghostty_wasm_free_u8_array(bufPtr, bufSize);
+      return out;
+    },
+
+    textSnapshot(): { text: string; cols: number; rows: number } {
+      if (!this.handle) return { text: "", cols: 0, rows: 0 }; // disposed
+      wasmExports.ghostty_render_state_update(handle);
+      const cols = wasmExports.ghostty_render_state_get_cols(handle);
+      const rows = wasmExports.ghostty_render_state_get_rows(handle);
+      const cellSize = 16;
+      const bufSize = cols * rows * cellSize;
+      const bufPtr = wasmExports.ghostty_wasm_alloc_u8_array(bufSize);
+      wasmExports.ghostty_render_state_get_viewport(handle, bufPtr, bufSize);
+
+      const view = new DataView(wasmMemory!.buffer);
+      const lines: string[] = [];
+
+      for (let row = 0; row < rows; row++) {
+        let line = "";
+        for (let col = 0; col < cols; col++) {
+          const off = bufPtr + (row * cols + col) * cellSize;
+          const cp = view.getUint32(off, true);
+          const width = view.getUint8(off + 11);
+          if (width === 0) continue; // continuation cell (wide char)
+          line += cp > 0 ? String.fromCodePoint(cp) : " ";
+        }
+        lines.push(line.trimEnd());
+      }
+
+      wasmExports.ghostty_wasm_free_u8_array(bufPtr, bufSize);
+
+      // Trim trailing empty lines
+      while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+      return { text: lines.join("\n"), cols, rows };
+    },
+
+    dispose() {
+      if (this.handle === 0) return; // already disposed
+      wasmExports.ghostty_terminal_free(handle);
+      this.handle = 0;
+    },
+  };
+}

package/src/workspace-head.ts

@@ -0,0 +1,144 @@
+/**
+ * Workspace head — shared state for multi-device sync.
+ * Tracks which session/tab/view the workspace is focused on.
+ * All connected devices see the same workspace head and can update it.
+ *
+ * Inspired by CRDTs and Figma's multiplayer cursor model.
+ */
+
+import { getDb } from "./store.js";
+
+// ── Types ───────────────────────────────────────────────────────
+
+export interface WorkspaceHead {
+  id: string;
+  sessionName: string;
+  tabId: number;
+  topicId: string | null;
+  view: string; // "live" | "inspect" | "workspace"
+  revision: number;
+  updatedByDevice: string | null;
+  updatedAt: number;
+}
+
+// ── Table initialization ────────────────────────────────────────
+
+/**
+ * Create the workspace_head table if it doesn't exist.
+ * Called from store.ts getDb() during database initialization.
+ */
+export function initWorkspaceHeadTable(): void {
+  const db = getDb();
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workspace_head (
+      id TEXT PRIMARY KEY DEFAULT 'global',
+      session_name TEXT NOT NULL,
+      tab_id INTEGER NOT NULL,
+      topic_id TEXT,
+      view TEXT NOT NULL DEFAULT 'live',
+      revision INTEGER NOT NULL DEFAULT 0,
+      updated_by_device TEXT,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+}
+
+// ── CRUD ────────────────────────────────────────────────────────
+
+/**
+ * Get the current workspace head (global singleton).
+ * Returns null if no head has been set yet.
+ */
+export function getHead(): WorkspaceHead | null {
+  const db = getDb();
+  const row = db
+    .prepare("SELECT * FROM workspace_head WHERE id = 'global'")
+    .get() as any;
+  if (!row) return null;
+  return {
+    id: row.id,
+    sessionName: row.session_name,
+    tabId: row.tab_id,
+    topicId: row.topic_id,
+    view: row.view,
+    revision: row.revision,
+    updatedByDevice: row.updated_by_device,
+    updatedAt: row.updated_at,
+  };
+}
+
+/**
+ * Update the workspace head with partial fields.
+ * Auto-increments revision and sets updatedAt.
+ * Creates the head if it doesn't exist yet.
+ */
+export function updateHead(
+  fields: Partial<Omit<WorkspaceHead, "id" | "revision" | "updatedAt">>,
+  deviceId?: string,
+): WorkspaceHead {
+  const db = getDb();
+  const now = Date.now();
+  const current = getHead();
+
+  if (!current) {
+    // First-time creation
+    const head: WorkspaceHead = {
+      id: "global",
+      sessionName: fields.sessionName || "default",
+      tabId: fields.tabId ?? 0,
+      topicId: fields.topicId ?? null,
+      view: fields.view || "live",
+      revision: 1,
+      updatedByDevice: deviceId || fields.updatedByDevice || null,
+      updatedAt: now,
+    };
+    db.prepare(
+      `INSERT INTO workspace_head (id, session_name, tab_id, topic_id, view, revision, updated_by_device, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      head.id,
+      head.sessionName,
+      head.tabId,
+      head.topicId,
+      head.view,
+      head.revision,
+      head.updatedByDevice,
+      head.updatedAt,
+    );
+    return head;
+  }
+
+  // Update existing head
+  const updated: WorkspaceHead = {
+    id: "global",
+    sessionName: fields.sessionName ?? current.sessionName,
+    tabId: fields.tabId ?? current.tabId,
+    topicId: fields.topicId !== undefined ? fields.topicId : current.topicId,
+    view: fields.view ?? current.view,
+    revision: current.revision + 1,
+    updatedByDevice: deviceId || fields.updatedByDevice || current.updatedByDevice,
+    updatedAt: now,
+  };
+
+  db.prepare(
+    `UPDATE workspace_head SET
+       session_name = ?,
+       tab_id = ?,
+       topic_id = ?,
+       view = ?,
+       revision = ?,
+       updated_by_device = ?,
+       updated_at = ?
+     WHERE id = 'global'`,
+  ).run(
+    updated.sessionName,
+    updated.tabId,
+    updated.topicId,
+    updated.view,
+    updated.revision,
+    updated.updatedByDevice,
+    updated.updatedAt,
+  );
+
+  return updated;
+}