eleveight-codebridge 0.1.2

package/dist/cli.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import chokidar from "chokidar";
+import WebSocket, { WebSocketServer } from "ws";
+const args = process.argv.slice(2);
+function getArg(name, fallback) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return fallback;
+    return args[index + 1] ?? fallback;
+}
+function getFirstPositionalArg() {
+    return args.find((arg) => !arg.startsWith("-"));
+}
+function isWebSocketUrl(value) {
+    return value.startsWith("ws://") || value.startsWith("wss://");
+}
+function isLegacyManagedPath(pathValue) {
+    return /^NCL__?/.test(pathValue);
+}
+function stripNumericSuffixBeforeExtension(name) {
+    return name.replace(/_\d+(\.[^.]+)$/, "$1");
+}
+function normalizeLegacyManagedPath(pathValue) {
+    if (!isLegacyManagedPath(pathValue))
+        return pathValue;
+    const withoutPrefix = pathValue.replace(/^NCL__?/, "");
+    if (!withoutPrefix)
+        return pathValue;
+    const normalized = stripNumericSuffixBeforeExtension(withoutPrefix).replace(/__/g, "/");
+    return normalized || pathValue;
+}
+const positionalArg = getFirstPositionalArg();
+const connectionArg = getArg("--connection") ??
+    (positionalArg && isWebSocketUrl(positionalArg) ? positionalArg : undefined);
+const codeArg = getArg("--code") ??
+    getArg("--room") ??
+    (positionalArg && !isWebSocketUrl(positionalArg) ? positionalArg : undefined);
+const relayArg = getArg("--relay");
+const noRelayArg = args.includes("--no-relay");
+const supportedExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".css"]);
+let relay = relayArg ?? "ws://localhost:8787";
+let code = codeArg;
+if (connectionArg) {
+    try {
+        const url = new URL(connectionArg);
+        relay = connectionArg;
+        code = codeArg ?? url.searchParams.get("code") ?? url.searchParams.get("room") ?? undefined;
+    }
+    catch {
+        console.error("Invalid --connection URL");
+        process.exit(1);
+    }
+}
+if (!code) {
+    console.error("Missing code. Use <code>, --code <id>, or --connection ws://host:port?code=<id>");
+    process.exit(1);
+}
+const codeValue = code;
+const rootDir = path.resolve(getArg("--dir", `./code-bridge-files/${codeValue}`));
+const rootPrefix = `${rootDir}${path.sep}`;
+const suppressedPaths = new Set();
+const suppressedPathTimers = new Map();
+const relayClients = new Map();
+const relayRoomFiles = new Map();
+function relaySend(ws, message) {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(message));
+    }
+}
+function relayError(ws, roomId, message) {
+    relaySend(ws, { v: 1, type: "error", roomId, message });
+}
+function relayAck(ws, roomId, message) {
+    relaySend(ws, { v: 1, type: "ack", roomId, message });
+}
+function relayBroadcast(roomId, payload, except) {
+    for (const [client, meta] of relayClients.entries()) {
+        if (client === except)
+            continue;
+        if (meta.roomId !== roomId)
+            continue;
+        relaySend(client, payload);
+    }
+}
+function relaySnapshotToMessage(roomId) {
+    const files = relayRoomFiles.get(roomId);
+    if (!files || files.size === 0)
+        return null;
+    return {
+        v: 1,
+        type: "full_sync",
+        roomId,
+        files: Array.from(files.entries()).map(([path, content]) => ({ path, content })),
+    };
+}
+function handleRelayMessage(ws, message) {
+    const meta = relayClients.get(ws);
+    if (!meta)
+        return;
+    if (message.type === "join") {
+        meta.roomId = message.roomId;
+        meta.actor = message.actor;
+        relayAck(ws, message.roomId, `Joined room as ${message.actor}`);
+        const snapshot = relaySnapshotToMessage(message.roomId);
+        if (snapshot)
+            relaySend(ws, snapshot);
+        return;
+    }
+    if (!meta.roomId || !meta.actor) {
+        relayError(ws, message.roomId, "Send a join message first");
+        return;
+    }
+    if (message.roomId !== meta.roomId) {
+        relayError(ws, message.roomId, "roomId mismatch for connected client");
+        return;
+    }
+    switch (message.type) {
+        case "full_sync": {
+            const next = new Map();
+            for (const file of message.files)
+                next.set(file.path, file.content);
+            relayRoomFiles.set(message.roomId, next);
+            relayBroadcast(message.roomId, message, ws);
+            relayAck(ws, message.roomId, `Broadcast full sync (${message.files.length} files)`);
+            return;
+        }
+        case "upsert_file": {
+            const files = relayRoomFiles.get(message.roomId) ?? new Map();
+            files.set(message.path, message.content);
+            relayRoomFiles.set(message.roomId, files);
+            relayBroadcast(message.roomId, message, ws);
+            relayAck(ws, message.roomId, `Upserted ${message.path}`);
+            return;
+        }
+        case "delete_file": {
+            const files = relayRoomFiles.get(message.roomId);
+            if (files)
+                files.delete(message.path);
+            relayBroadcast(message.roomId, message, ws);
+            relayAck(ws, message.roomId, `Deleted ${message.path}`);
+            return;
+        }
+        case "ping": {
+            relaySend(ws, message);
+            return;
+        }
+    }
+}
+function isLocalRelayUrl(value) {
+    try {
+        const url = new URL(value);
+        return (url.protocol === "ws:" &&
+            (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1"));
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureEmbeddedRelayIfNeeded() {
+    if (noRelayArg)
+        return;
+    if (!isLocalRelayUrl(relay))
+        return;
+    const relayUrl = new URL(relay);
+    const relayPort = Number(relayUrl.port || "80");
+    await new Promise((resolve) => {
+        const wss = new WebSocketServer({ port: relayPort });
+        let settled = false;
+        const done = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve();
+        };
+        wss.on("connection", (ws) => {
+            relayClients.set(ws, {});
+            ws.on("message", (raw) => {
+                try {
+                    const parsed = JSON.parse(raw.toString());
+                    handleRelayMessage(ws, parsed);
+                }
+                catch {
+                    const meta = relayClients.get(ws);
+                    if (meta?.roomId)
+                        relayError(ws, meta.roomId, "Invalid JSON payload");
+                }
+            });
+            ws.on("close", () => {
+                relayClients.delete(ws);
+            });
+        });
+        wss.on("listening", () => {
+            console.log(`[code-bridge] embedded relay listening on ws://localhost:${relayPort}`);
+            done();
+        });
+        wss.on("error", (error) => {
+            const code = error.code;
+            if (code === "EADDRINUSE") {
+                done();
+                return;
+            }
+            console.error(`[code-bridge] embedded relay failed: ${error.message}`);
+            done();
+        });
+    });
+}
+function toRoomPath(absolutePath) {
+    return path.relative(rootDir, absolutePath).split(path.sep).join("/");
+}
+function toAbsolutePath(roomPath) {
+    const normalized = normalizeLegacyManagedPath(roomPath).replace(/^\/+/, "");
+    const absolutePath = path.resolve(rootDir, normalized);
+    if (!(absolutePath === rootDir || absolutePath.startsWith(rootPrefix))) {
+        throw new Error(`Invalid path outside root: ${roomPath}`);
+    }
+    return absolutePath;
+}
+function markSuppressed(absolutePath) {
+    const existingTimer = suppressedPathTimers.get(absolutePath);
+    if (existingTimer) {
+        clearTimeout(existingTimer);
+    }
+    suppressedPaths.add(absolutePath);
+    const timer = setTimeout(() => {
+        suppressedPaths.delete(absolutePath);
+        suppressedPathTimers.delete(absolutePath);
+    }, 1500);
+    suppressedPathTimers.set(absolutePath, timer);
+}
+function isSupportedFile(absolutePath) {
+    return supportedExtensions.has(path.extname(absolutePath));
+}
+async function listFilesRecursively(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            return listFilesRecursively(absolutePath);
+        return [absolutePath];
+    }));
+    return files.flat();
+}
+async function loadInitialFiles() {
+    await fs.mkdir(rootDir, { recursive: true });
+    const all = await listFilesRecursively(rootDir);
+    const files = [];
+    for (const absolutePath of all) {
+        if (!isSupportedFile(absolutePath))
+            continue;
+        const roomPath = toRoomPath(absolutePath);
+        if (isLegacyManagedPath(roomPath))
+            continue;
+        const content = await fs.readFile(absolutePath, "utf8");
+        files.push({ path: roomPath, content });
+    }
+    return files;
+}
+await ensureEmbeddedRelayIfNeeded();
+const socket = new WebSocket(relay);
+function send(message) {
+    if (socket.readyState !== WebSocket.OPEN)
+        return;
+    socket.send(JSON.stringify(message));
+}
+async function sendUpsert(absolutePath) {
+    if (!isSupportedFile(absolutePath))
+        return;
+    const roomPath = toRoomPath(absolutePath);
+    if (isLegacyManagedPath(roomPath))
+        return;
+    const content = await fs.readFile(absolutePath, "utf8");
+    send({
+        v: 1,
+        type: "upsert_file",
+        roomId: codeValue,
+        path: roomPath,
+        content,
+    });
+}
+async function applyUpsert(pathFromRelay, content) {
+    const absolutePath = toAbsolutePath(pathFromRelay);
+    if (!isSupportedFile(absolutePath))
+        return;
+    try {
+        const current = await fs.readFile(absolutePath, "utf8");
+        if (current === content)
+            return;
+    }
+    catch { }
+    markSuppressed(absolutePath);
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, content, "utf8");
+    console.log(`[relay:apply] upsert ${pathFromRelay}`);
+}
+async function applyDelete(pathFromRelay) {
+    const absolutePath = toAbsolutePath(pathFromRelay);
+    if (!isSupportedFile(absolutePath))
+        return;
+    markSuppressed(absolutePath);
+    await fs.rm(absolutePath, { force: true });
+    console.log(`[relay:apply] delete ${pathFromRelay}`);
+}
+socket.on("open", async () => {
+    send({ v: 1, type: "join", roomId: codeValue, actor: "watcher" });
+    const files = await loadInitialFiles();
+    send({ v: 1, type: "full_sync", roomId: codeValue, files });
+    console.log(`[code-bridge] watcher connected (${files.length} files synced) code=${codeValue}`);
+});
+socket.on("message", async (raw) => {
+    try {
+        const message = JSON.parse(raw.toString());
+        if (message.type === "ack") {
+            console.log(`[relay] ${message.message}`);
+            return;
+        }
+        if (message.type === "error") {
+            console.error(`[relay:error] ${message.message}`);
+            return;
+        }
+        if (message.type === "full_sync") {
+            for (const file of message.files) {
+                await applyUpsert(file.path, file.content);
+            }
+            return;
+        }
+        if (message.type === "upsert_file") {
+            await applyUpsert(message.path, message.content);
+            return;
+        }
+        if (message.type === "delete_file") {
+            await applyDelete(message.path);
+        }
+    }
+    catch {
+        console.error("[code-bridge] invalid relay message");
+    }
+});
+socket.on("close", () => {
+    console.log("[code-bridge] relay connection closed");
+    process.exit(0);
+});
+socket.on("error", (error) => {
+    console.error(`[code-bridge] relay connection failed: ${error.message}`);
+    process.exit(1);
+});
+const watcher = chokidar.watch(rootDir, { ignoreInitial: true });
+watcher.on("add", async (absolutePath) => {
+    const normalizedPath = path.resolve(absolutePath);
+    if (suppressedPaths.has(normalizedPath)) {
+        return;
+    }
+    await sendUpsert(normalizedPath);
+    console.log(`[watch:add] ${toRoomPath(normalizedPath)}`);
+});
+watcher.on("change", async (absolutePath) => {
+    const normalizedPath = path.resolve(absolutePath);
+    if (suppressedPaths.has(normalizedPath)) {
+        return;
+    }
+    await sendUpsert(normalizedPath);
+    console.log(`[watch:change] ${toRoomPath(normalizedPath)}`);
+});
+watcher.on("unlink", (absolutePath) => {
+    const normalizedPath = path.resolve(absolutePath);
+    if (suppressedPaths.has(normalizedPath)) {
+        return;
+    }
+    if (!isSupportedFile(normalizedPath))
+        return;
+    const roomPath = toRoomPath(normalizedPath);
+    if (isLegacyManagedPath(roomPath))
+        return;
+    send({
+        v: 1,
+        type: "delete_file",
+        roomId: codeValue,
+        path: roomPath,
+    });
+    console.log(`[watch:delete] ${roomPath}`);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "eleveight-codebridge",
+  "version": "0.1.2",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "eleveight-codebridge": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "start": "node dist/cli.js",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}