@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/start.ps1

@@ -0,0 +1,83 @@
+#!/usr/bin/env pwsh
+# Start remux.
+#
+# Usage:
+#   .\start.ps1                           Dev mode (hot reload, no tunnel)
+#   .\start.ps1 --prod                    Production (build + run with tunnel)
+#   .\start.ps1 --prod --password mypass  Production with custom password
+#   .\start.ps1 --dev --tunnel            Dev mode with tunnel enabled
+
+$ErrorActionPreference = "Stop"
+Set-Location $PSScriptRoot
+
+# Parse our flags, pass the rest through to the CLI.
+$isProd = $false
+$passthrough = @()
+
+for ($i = 0; $i -lt $args.Count; $i++) {
+    if ($args[$i] -eq "--prod") {
+        $isProd = $true
+    } elseif ($args[$i] -eq "--dev") {
+        # explicit dev mode (default anyway)
+    } else {
+        $passthrough += $args[$i]
+    }
+}
+
+if ($isProd) {
+    # Production mode: always rebuild to ensure dist/ is current.
+    Write-Host "Building remux..." -ForegroundColor Yellow
+    npm run build
+    # Use a stable token so the URL doesn't change on restart.
+    if (-not $env:REMUX_TOKEN) {
+        $tokenFile = Join-Path (Join-Path $env:USERPROFILE ".remux") "token"
+        if (Test-Path $tokenFile) {
+            $env:REMUX_TOKEN = (Get-Content $tokenFile -Raw).Trim()
+        } else {
+            $env:REMUX_TOKEN = -join ((48..57) + (65..90) + (97..122) | Get-Random -Count 24 | ForEach-Object { [char]$_ })
+            New-Item -ItemType Directory -Path (Split-Path $tokenFile) -Force | Out-Null
+            Set-Content $tokenFile $env:REMUX_TOKEN
+        }
+        Write-Host "  Stable token saved to $tokenFile" -ForegroundColor DarkGray
+    }
+    Write-Host "Starting remux (production)..." -ForegroundColor Cyan
+    node dist/backend/cli-zellij.js @passthrough
+    return
+}
+
+# Dev mode: tsx watch (hot reload) + Vite frontend.
+# Default: no tunnel, no password. Override with explicit flags.
+$devArgs = @("--no-require-password")
+
+# Only add --no-tunnel if user didn't explicitly pass --tunnel.
+$hasTunnel = $passthrough -contains "--tunnel"
+if (-not $hasTunnel) {
+    $devArgs += "--no-tunnel"
+}
+
+$devArgs += $passthrough
+
+Write-Host ""
+Write-Host "Starting remux dev mode..." -ForegroundColor Cyan
+Write-Host "  Backend:  tsx watch (auto-restart on changes)" -ForegroundColor DarkGray
+Write-Host "  Frontend: Vite HMR on http://localhost:5173" -ForegroundColor DarkGray
+Write-Host ""
+
+# Start Vite in background.
+$viteJob = Start-Process -FilePath "node" -ArgumentList "node_modules/vite/bin/vite.js","--config","vite.config.ts" `
+    -NoNewWindow -PassThru -RedirectStandardOutput "$env:TEMP\remux-vite.log" -RedirectStandardError "$env:TEMP\remux-vite-err.log"
+
+Write-Host "[vite] started (pid=$($viteJob.Id))" -ForegroundColor Green
+Start-Sleep 2
+
+try {
+    Write-Host "[back] starting..." -ForegroundColor Blue
+    $env:VITE_DEV_MODE = "1"
+    npx tsx watch src/backend/cli-zellij.ts @devArgs
+}
+finally {
+    if (-not $viteJob.HasExited) {
+        Stop-Process -Id $viteJob.Id -Force -ErrorAction SilentlyContinue
+        Write-Host "[vite] stopped" -ForegroundColor Green
+    }
+}

package/tests/adapters.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect } from "vitest";
+
+// Test the adapter framework (E10)
+// Since adapters are ES modules in the bundle, test the logic patterns
+
+describe("AdapterRegistry pattern", () => {
+  it("should register and query adapters", () => {
+    // Simulate registry behavior
+    const adapters = new Map();
+
+    const genericShell = {
+      id: "generic-shell",
+      name: "Shell",
+      mode: "passive",
+      capabilities: ["cwd", "last-command"],
+      getCurrentState: () => ({
+        adapterId: "generic-shell",
+        name: "Shell",
+        mode: "passive",
+        capabilities: ["cwd", "last-command"],
+        currentState: "idle",
+      }),
+    };
+
+    adapters.set(genericShell.id, genericShell);
+    expect(adapters.get("generic-shell")).toBeDefined();
+    expect(adapters.get("generic-shell").name).toBe("Shell");
+  });
+
+  it("should emit events to listeners", () => {
+    const listeners = [];
+    const events = [];
+
+    listeners.push((event) => events.push(event));
+
+    // Simulate emit
+    const event = {
+      type: "state_change",
+      seq: 1,
+      timestamp: new Date().toISOString(),
+      data: { state: "running" },
+      adapterId: "claude-code",
+    };
+
+    for (const listener of listeners) {
+      listener(event);
+    }
+
+    expect(events.length).toBe(1);
+    expect(events[0].adapterId).toBe("claude-code");
+    expect(events[0].data.state).toBe("running");
+  });
+
+  it("should handle adapter errors without crashing", () => {
+    const errorAdapter = {
+      id: "broken",
+      mode: "passive",
+      onTerminalData: () => {
+        throw new Error("adapter crash");
+      },
+    };
+
+    // Should not throw
+    expect(() => {
+      try {
+        errorAdapter.onTerminalData("test", "data");
+      } catch {
+        // Registry catches this
+      }
+    }).not.toThrow();
+  });
+});
+
+describe("OSC notification parsing", () => {
+  it("should parse OSC 9 notifications", () => {
+    const data = 'before\x1b]9;Build complete\x07after';
+    const osc9Re = /\x1b\]9;([^\x07\x1b]+)[\x07]/;
+    const match = data.match(osc9Re);
+    expect(match).not.toBeNull();
+    expect(match[1]).toBe("Build complete");
+  });
+
+  it("should parse OSC 777 notifications", () => {
+    const data = '\x1b]777;notify;Build;All tests passed\x07';
+    const osc777Re = /\x1b\]777;notify;([^;]*);([^\x07\x1b]*)[\x07]/;
+    const match = data.match(osc777Re);
+    expect(match).not.toBeNull();
+    expect(match[1]).toBe("Build");
+    expect(match[2]).toBe("All tests passed");
+  });
+
+  it("should handle data without OSC sequences", () => {
+    const data = "normal terminal output";
+    const osc9Re = /\x1b\]9;([^\x07\x1b]+)[\x07]/;
+    expect(data.match(osc9Re)).toBeNull();
+  });
+});
+
+describe("Generic shell adapter patterns", () => {
+  it("should detect OSC 7 working directory", () => {
+    const data = "\x1b]7;file://hostname/Users/test\x07";
+    const osc7Re = /\x1b\]7;file:\/\/[^/]*([^\x07\x1b]+)/;
+    const match = data.match(osc7Re);
+    expect(match).not.toBeNull();
+    expect(decodeURIComponent(match[1])).toBe("/Users/test");
+  });
+
+  it("should detect OSC 133 command boundaries", () => {
+    const promptStart = "\x1b]133;A\x07";
+    const commandStart = "\x1b]133;B\x07";
+    const outputStart = "\x1b]133;C\x07";
+    const commandEnd = "\x1b]133;D;0\x07";
+
+    expect(commandStart.match(/\x1b\]133;B\x07/)).not.toBeNull();
+    expect(commandEnd.match(/\x1b\]133;D;?(\d*)\x07/)).not.toBeNull();
+    expect(commandEnd.match(/\x1b\]133;D;?(\d*)\x07/)[1]).toBe("0");
+  });
+});
+
+describe("Git service patterns", () => {
+  it("should parse worktree porcelain output", () => {
+    const output = `worktree /Users/test/remux
+HEAD abc1234
+branch refs/heads/main
+
+worktree /Users/test/remux/.worktrees/feature
+HEAD def5678
+branch refs/heads/feat/new
+`;
+
+    const worktrees = [];
+    let current = {};
+
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        if (current.path) worktrees.push({ ...current });
+        current = { path: line.replace("worktree ", "") };
+      } else if (line.startsWith("HEAD ")) {
+        current.head = line.replace("HEAD ", "").substring(0, 7);
+      } else if (line.startsWith("branch ")) {
+        current.branch = line.replace("branch refs/heads/", "");
+      }
+    }
+    if (current.path) worktrees.push({ ...current });
+
+    expect(worktrees.length).toBe(2);
+    expect(worktrees[0].branch).toBe("main");
+    expect(worktrees[1].branch).toBe("feat/new");
+    expect(worktrees[1].head).toBe("def5678");
+  });
+});
+
+describe("Team mode patterns", () => {
+  it("should validate RBAC permissions", () => {
+    const ROLE_PERMISSIONS = {
+      owner: ["read", "write", "admin", "approve"],
+      admin: ["read", "write", "admin", "approve"],
+      member: ["read", "write", "approve"],
+      viewer: ["read"],
+    };
+
+    const hasPermission = (role, perm) =>
+      ROLE_PERMISSIONS[role]?.includes(perm) ?? false;
+
+    expect(hasPermission("owner", "admin")).toBe(true);
+    expect(hasPermission("viewer", "write")).toBe(false);
+    expect(hasPermission("member", "read")).toBe(true);
+    expect(hasPermission("member", "admin")).toBe(false);
+    expect(hasPermission("unknown", "read")).toBe(false);
+  });
+});

package/tests/auth.test.js

@@ -0,0 +1,243 @@
+/**
+ * Auth tests for Remux server.
+ * Tests: auto-generated token, password authentication, token validation.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { spawn } from "child_process";
+import http from "http";
+import WebSocket from "ws";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SERVER_JS = path.join(__dirname, "..", "server.js");
+
+function httpGet(port, urlPath) {
+  return new Promise((resolve, reject) => {
+    http
+      .get(`http://localhost:${port}${urlPath}`, (res) => {
+        let body = "";
+        res.on("data", (d) => (body += d));
+        res.on("end", () =>
+          resolve({ status: res.statusCode, body, headers: res.headers }),
+        );
+      })
+      .on("error", reject);
+  });
+}
+
+function httpPost(port, urlPath, data) {
+  return new Promise((resolve, reject) => {
+    const body = new URLSearchParams(data).toString();
+    const req = http.request(
+      {
+        hostname: "localhost",
+        port,
+        path: urlPath,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Content-Length": Buffer.byteLength(body),
+        },
+      },
+      (res) => {
+        let resBody = "";
+        res.on("data", (d) => (resBody += d));
+        res.on("end", () =>
+          resolve({ status: res.statusCode, body: resBody, headers: res.headers }),
+        );
+      },
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function connectWs(port) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://localhost:${port}/ws`);
+    ws.on("open", () => resolve(ws));
+    ws.on("error", reject);
+  });
+}
+
+/** Unwrap envelope if present. */
+function unwrap(parsed) {
+  if (parsed && parsed.v === 1 && typeof parsed.type === "string") {
+    return { type: parsed.type, ...(parsed.payload || {}) };
+  }
+  return parsed;
+}
+
+function waitForMsg(ws, type, timeout = 3000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      ws.removeListener("message", handler);
+      reject(new Error(`timeout waiting for ${type}`));
+    }, timeout);
+    const handler = (raw) => {
+      try {
+        const msg = unwrap(JSON.parse(raw.toString()));
+        if (msg.type === type) {
+          clearTimeout(timer);
+          ws.removeListener("message", handler);
+          resolve(msg);
+        }
+      } catch {}
+    };
+    ws.on("message", handler);
+  });
+}
+
+/** Start a server instance and wait for "Remux running" output.
+ * Returns { proc, port, stdout } where stdout contains all console output.
+ * Explicitly removes REMUX_TOKEN and REMUX_PASSWORD from parent env to avoid leaking. */
+function startServer(env, port) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.REMUX_TOKEN;
+    delete cleanEnv.REMUX_PASSWORD;
+    const proc = spawn("node", [SERVER_JS], {
+      env: { ...cleanEnv, ...env, PORT: String(port) },
+      stdio: "pipe",
+    });
+    const timeout = setTimeout(
+      () => reject(new Error("server start timeout")),
+      10000,
+    );
+    proc.stdout.on("data", (d) => {
+      stdout += d.toString();
+      if (stdout.includes("Remux running")) {
+        clearTimeout(timeout);
+        // Extra delay for WASM init
+        setTimeout(() => resolve({ proc, port, stdout }), 2000);
+      }
+    });
+    proc.stderr.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.on("error", reject);
+  });
+}
+
+// ── Auto-generated token ─────────────────────────────────────────
+
+describe("auto-generated token (no REMUX_TOKEN, no REMUX_PASSWORD)", () => {
+  let server;
+
+  beforeAll(async () => {
+    server = await startServer(
+      { REMUX_INSTANCE_ID: "auth-test-auto-" + Date.now() },
+      19877,
+    );
+  }, 15000);
+
+  afterAll(() => server?.proc?.kill("SIGTERM"));
+
+  it("prints full URL with auto-generated token on startup", () => {
+    expect(server.stdout).toMatch(/http:\/\/localhost:\d+\?token=[a-f0-9]{32}/);
+  });
+
+  it("rejects access without token", async () => {
+    const res = await httpGet(server.port, "/");
+    expect(res.status).toBe(403);
+  });
+
+  it("accepts access with auto-generated token from startup output", async () => {
+    const match = server.stdout.match(/token=([a-f0-9]{32})/);
+    expect(match).not.toBeNull();
+    const token = match[1];
+
+    const res = await httpGet(server.port, `/?token=${token}`);
+    expect(res.status).toBe(200);
+    expect(res.body).toContain("<title>Remux</title>");
+  });
+
+  it("authenticates WebSocket with auto-generated token", async () => {
+    const match = server.stdout.match(/token=([a-f0-9]{32})/);
+    const token = match[1];
+
+    const ws = await connectWs(server.port);
+    ws.send(JSON.stringify({ type: "auth", token }));
+    const msg = await waitForMsg(ws, "auth_ok");
+    expect(msg.type).toBe("auth_ok");
+    ws.close();
+  });
+});
+
+// ── Password authentication ──────────────────────────────────────
+
+describe("password authentication (REMUX_PASSWORD set)", () => {
+  let server;
+  const TEST_PASSWORD = "test-secret-pw-" + Date.now();
+
+  beforeAll(async () => {
+    server = await startServer(
+      {
+        REMUX_PASSWORD: TEST_PASSWORD,
+        REMUX_INSTANCE_ID: "auth-test-pw-" + Date.now(),
+      },
+      19878,
+    );
+  }, 15000);
+
+  afterAll(() => server?.proc?.kill("SIGTERM"));
+
+  it("shows password page when accessing root without token", async () => {
+    const res = await httpGet(server.port, "/");
+    expect(res.status).toBe(200);
+    expect(res.body).toContain("Remux — Login");
+    expect(res.body).toContain('type="password"');
+    expect(res.body).toContain('action="/auth"');
+  });
+
+  it("rejects wrong password and redirects with error", async () => {
+    const res = await httpPost(server.port, "/auth", {
+      password: "wrong-password",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.location).toContain("error=1");
+  });
+
+  it("correct password generates working token and redirects", async () => {
+    const res = await httpPost(server.port, "/auth", {
+      password: TEST_PASSWORD,
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.location).toMatch(/\?token=[a-f0-9]{32}/);
+
+    // Follow the redirect — the token should work
+    const tokenMatch = res.headers.location.match(/token=([a-f0-9]{32})/);
+    const token = tokenMatch[1];
+
+    const pageRes = await httpGet(server.port, `/?token=${token}`);
+    expect(pageRes.status).toBe(200);
+    expect(pageRes.body).toContain("<title>Remux</title>");
+  });
+
+  it("password-generated token works for WebSocket auth", async () => {
+    // First get a token via password
+    const res = await httpPost(server.port, "/auth", {
+      password: TEST_PASSWORD,
+    });
+    const tokenMatch = res.headers.location.match(/token=([a-f0-9]{32})/);
+    const token = tokenMatch[1];
+
+    const ws = await connectWs(server.port);
+    ws.send(JSON.stringify({ type: "auth", token }));
+    const msg = await waitForMsg(ws, "auth_ok");
+    expect(msg.type).toBe("auth_ok");
+    ws.close();
+  });
+
+  it("rejects WebSocket auth with invalid token", async () => {
+    const ws = await connectWs(server.port);
+    ws.send(JSON.stringify({ type: "auth", token: "invalid-token" }));
+    const msg = await waitForMsg(ws, "auth_error");
+    expect(msg.reason).toBe("invalid token");
+    ws.close();
+  });
+});