rwsdk 0.1.8-test.20250702232536 → 0.1.9

package/dist/runtime/lib/realtime/client.js

@@ -1,6 +1,5 @@
 import { initClient } from "../../client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
-import { IS_DEV } from "../../constants";
 import { MESSAGE_TYPE } from "./shared";
 const DEFAULT_KEY = "default";
 export const initRealtimeClient = ({ key = DEFAULT_KEY, } = {}) => {
@@ -12,12 +11,13 @@ export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) =
     let isConnected = false;
     const clientId = crypto.randomUUID();
     const clientUrl = new URL(window.location.href);
+    const isHttps = clientUrl.protocol === "https:";
     clientUrl.protocol = "";
     clientUrl.host = "";
     const setupWebSocket = () => {
         if (ws)
             return;
-        const protocol = IS_DEV ? "ws" : "wss";
+        const protocol = isHttps ? "wss" : "ws";
         ws = new WebSocket(`${protocol}://${window.location.host}/__realtime?` +
             `key=${encodeURIComponent(key)}&` +
             `url=${encodeURIComponent(clientUrl.toString())}&` +

package/dist/scripts/debug-sync.mjs

@@ -4,15 +4,24 @@ import { $ } from "execa";
 import fs from "node:fs/promises";
 import { existsSync } from "node:fs";
 import chokidar from "chokidar";
+import { lock } from "proper-lockfile";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageManagerInfo = (targetDir) => {
+    const pnpmResult = {
+        name: "pnpm",
+        lockFile: "pnpm-lock.yaml",
+        command: "add",
+    };
     if (existsSync(path.join(targetDir, "yarn.lock"))) {
         return { name: "yarn", lockFile: "yarn.lock", command: "add" };
     }
     if (existsSync(path.join(targetDir, "pnpm-lock.yaml"))) {
-        return { name: "pnpm", lockFile: "pnpm-lock.yaml", command: "add" };
+        return pnpmResult;
     }
-    return { name: "npm", lockFile: "package-lock.json", command: "install" };
+    if (existsSync(path.join(targetDir, "package-lock.json"))) {
+        return { name: "npm", lockFile: "package-lock.json", command: "install" };
+    }
+    return pnpmResult;
 };
 const performFullSync = async (sdkDir, targetDir) => {
     console.log("📦 Packing SDK...");
@@ -34,11 +43,18 @@ const performFullSync = async (sdkDir, targetDir) => {
         .readFile(lockfilePath, "utf-8")
         .catch(() => null);
     try {
-        let installCommand = `${pm.name} ${pm.command} ${tarballPath}`;
+        const cmd = pm.name;
+        const args = [pm.command];
         if (pm.name === "yarn") {
-            installCommand = `yarn add file:${tarballPath}`;
+            args.push(`file:${tarballPath}`);
+        }
+        else {
+            args.push(tarballPath);
         }
-        await $ `${installCommand}`;
+        await $(cmd, args, {
+            cwd: targetDir,
+            stdio: "inherit",
+        });
     }
     finally {
         if (originalPackageJson) {
@@ -96,50 +112,77 @@ export const debugSync = async (opts) => {
         console.error("❌ Please provide a target directory as an argument.");
         process.exit(1);
     }
-    // Initial sync
+    // If not in watch mode, just do a one-time sync and exit.
+    if (!watch) {
+        await performSync(sdkDir, targetDir);
+        return;
+    }
+    // --- Watch Mode Logic ---
+    const lockfilePath = path.join(targetDir, "node_modules", ".rwsync.lock");
+    let release;
+    // Ensure the directory for the lockfile exists
+    await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
+    // "Touch" the file to ensure it exists before locking
+    await fs.appendFile(lockfilePath, "").catch(() => { });
+    try {
+        release = await lock(lockfilePath, { retries: 0 });
+    }
+    catch (e) {
+        if (e.code === "ELOCKED") {
+            console.error(`❌ Another rwsync process is already watching ${targetDir}.`);
+            console.error(`   If this is not correct, please remove the lockfile at ${lockfilePath}`);
+            process.exit(1);
+        }
+        throw e;
+    }
+    // Initial sync for watch mode. We do it *after* acquiring the lock.
     await performSync(sdkDir, targetDir);
-    if (watch) {
-        const sdkPackageJson = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"));
-        const filesToWatch = (sdkPackageJson.files || []).map((p) => path.join(sdkDir, p));
-        filesToWatch.push(path.join(sdkDir, "package.json"));
-        console.log("👀 Watching for changes...");
-        let childProc = null;
-        const runWatchedCommand = () => {
-            if (typeof watch === "string") {
-                console.log(`\n> ${watch}\n`);
-                childProc = $({
-                    stdio: "inherit",
-                    shell: true,
-                    cwd: targetDir,
-                    reject: false,
-                }) `${watch}`;
-            }
-        };
-        const watcher = chokidar.watch(filesToWatch, {
-            ignoreInitial: true,
-            cwd: sdkDir,
-        });
-        watcher.on("all", async () => {
-            console.log("\n Detected change, re-syncing...");
-            if (childProc && !childProc.killed) {
-                console.log("Stopping running process...");
-                childProc.kill();
-                await childProc.catch(() => {
-                    /* ignore kill errors */
-                });
-            }
-            await performSync(sdkDir, targetDir);
-            runWatchedCommand();
-        });
-        const cleanup = () => {
-            if (childProc && !childProc.killed) {
-                childProc.kill();
-            }
-        };
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
+    const filesToWatch = [
+        path.join(sdkDir, "src"),
+        path.join(sdkDir, "types"),
+        path.join(sdkDir, "bin"),
+        path.join(sdkDir, "package.json"),
+    ];
+    console.log("👀 Watching for changes...");
+    let childProc = null;
+    const runWatchedCommand = () => {
+        if (typeof watch === "string") {
+            console.log(`\n> ${watch}\n`);
+            childProc = $({
+                stdio: "inherit",
+                shell: true,
+                cwd: targetDir,
+                reject: false,
+            }) `${watch}`;
+        }
+    };
+    const watcher = chokidar.watch(filesToWatch, {
+        ignoreInitial: true,
+        cwd: sdkDir,
+    });
+    watcher.on("all", async () => {
+        console.log("\nDetected change, re-syncing...");
+        if (childProc && !childProc.killed) {
+            console.log("Stopping running process...");
+            childProc.kill();
+            await childProc.catch(() => {
+                /* ignore kill errors */
+            });
+        }
+        await performSync(sdkDir, targetDir);
         runWatchedCommand();
-    }
+    });
+    const cleanup = async () => {
+        console.log("\nCleaning up...");
+        if (childProc && !childProc.killed) {
+            childProc.kill();
+        }
+        await release();
+        process.exit();
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    runWatchedCommand();
 };
 if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
     const args = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.1.8-test.20250702232536",
+  "version": "0.1.9",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -135,6 +135,7 @@
     "magic-string": "^0.30.17",
     "miniflare": "^4.20250405.0",
     "picocolors": "^1.1.1",
+    "proper-lockfile": "^4.1.2",
     "puppeteer-core": "^22.8.1",
     "react": "19.2.0-canary-39cad7af-20250411",
     "react-dom": "19.2.0-canary-39cad7af-20250411",
@@ -155,6 +156,7 @@
     "@types/debug": "^4.1.12",
     "@types/lodash": "^4.17.16",
     "@types/node": "^22.14.0",
+    "@types/proper-lockfile": "^4.1.4",
     "semver": "^7.7.1",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",