@ricsam/r5d-worker 0.0.47 → 0.0.49

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "type": "commonjs"
 }

package/dist/cjs/port-forward-client.cjs

@@ -0,0 +1,148 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var port_forward_client_exports = {};
+__export(port_forward_client_exports, {
+  openWorkerPortForwardRelay: () => openWorkerPortForwardRelay
+});
+module.exports = __toCommonJS(port_forward_client_exports);
+var import_node_net = __toESM(require("node:net"), 1);
+var import_ws = __toESM(require("ws"), 1);
+const RELAY_FRAME_BYTES = 64 * 1024;
+const RELAY_PAUSE_BYTES = 1024 * 1024;
+const RELAY_RESUME_BYTES = 256 * 1024;
+function relayUrl(baseUrl, label, forwardId, relayConnectionId) {
+  const url = new URL("/worker/port-forward/ws", baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("label", label);
+  url.searchParams.set("forward", forwardId);
+  url.searchParams.set("connection", relayConnectionId);
+  return url.toString();
+}
+function rawDataBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (Array.isArray(data)) return Buffer.concat(data);
+  return Buffer.from(data);
+}
+function openWorkerPortForwardRelay(options) {
+  const socket = import_node_net.default.createConnection({ host: "127.0.0.1", port: options.workerPort, allowHalfOpen: true });
+  socket.pause();
+  socket.setNoDelay(true);
+  const relay = new import_ws.default(relayUrl(options.baseUrl, options.label, options.forwardId, options.relayConnectionId), {
+    headers: { Authorization: `Bearer ${options.token}` },
+    perMessageDeflate: false
+  });
+  let relayReady = false;
+  let targetReady = false;
+  const pendingChunks = [];
+  let pendingBytes = 0;
+  let closing = false;
+  let resumeTimer;
+  const maybeResume = () => {
+    if (relayReady && targetReady && !resumeTimer) socket.resume();
+  };
+  const cleanup = () => {
+    if (closing) return;
+    closing = true;
+    if (resumeTimer) clearInterval(resumeTimer);
+    socket.destroy();
+    if (relay.readyState === import_ws.default.OPEN || relay.readyState === import_ws.default.CONNECTING) relay.close();
+  };
+  const sendError = (message) => {
+    if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "error", error: message }));
+    cleanup();
+  };
+  const waitForRelayDrain = () => {
+    if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
+    socket.pause();
+    resumeTimer = setInterval(() => {
+      if (relay.readyState !== import_ws.default.OPEN) return cleanup();
+      if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
+      clearInterval(resumeTimer);
+      resumeTimer = void 0;
+      maybeResume();
+    }, 10);
+  };
+  const sendChunk = (chunk) => {
+    for (let offset = 0; offset < chunk.byteLength; offset += RELAY_FRAME_BYTES) {
+      relay.send(chunk.subarray(offset, Math.min(chunk.byteLength, offset + RELAY_FRAME_BYTES)), { binary: true });
+    }
+    waitForRelayDrain();
+  };
+  socket.once("connect", () => {
+    targetReady = true;
+    maybeResume();
+  });
+  socket.on("data", (chunk) => {
+    if (!relayReady || relay.readyState !== import_ws.default.OPEN) {
+      pendingBytes += chunk.byteLength;
+      if (pendingBytes > RELAY_PAUSE_BYTES) return cleanup();
+      pendingChunks.push(Buffer.from(chunk));
+      socket.pause();
+      return;
+    }
+    sendChunk(chunk);
+  });
+  socket.on("end", () => {
+    if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "end" }));
+  });
+  socket.on("error", (error) => sendError(`Could not connect to 127.0.0.1:${options.workerPort}: ${error.message}`));
+  socket.on("close", cleanup);
+  relay.on("message", (data, isBinary) => {
+    if (!isBinary) {
+      let control;
+      try {
+        control = JSON.parse(rawDataBuffer(data).toString("utf8"));
+      } catch {
+        return cleanup();
+      }
+      if (control.type === "ready") {
+        relayReady = true;
+        for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
+        pendingBytes = 0;
+        maybeResume();
+      } else if (control.type === "end") {
+        socket.end();
+      } else if (control.type === "error") {
+        socket.destroy(new Error(control.error || "Port-forward relay failed."));
+      }
+      return;
+    }
+    if (!socket.write(rawDataBuffer(data))) {
+      relay.pause();
+      socket.once("drain", () => relay.resume());
+    }
+  });
+  relay.once("error", cleanup);
+  relay.once("close", cleanup);
+  socket.pause();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openWorkerPortForwardRelay
+});

package/dist/cjs/workspace-sync.cjs

@@ -30,6 +30,7 @@ var workspace_sync_exports = {};
 __export(workspace_sync_exports, {
   MAX_WORKSPACE_SYNC_DIFF_BYTES: () => MAX_WORKSPACE_SYNC_DIFF_BYTES,
   WORKSPACE_BRANCH: () => WORKSPACE_BRANCH,
+  WORKSPACE_NATIVE_PLANS_RELATIVE_PATH: () => WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
   WORKSPACE_PERIODIC_SCAN_INTERVAL_MS: () => WORKSPACE_PERIODIC_SCAN_INTERVAL_MS,
   WorkspaceSyncSingleFlight: () => WorkspaceSyncSingleFlight,
   assertCanonicalCheckoutIndexMatchesWorktree: () => assertCanonicalCheckoutIndexMatchesWorktree,
@@ -130,12 +131,16 @@ function workspaceProjectBranchRelativePath(projectId, branchName) {
 function workspacePlansRelativePath(projectId, branchName) {
   return import_node_path.default.posix.join("plans", projectId, encodeWorkspaceBranch(branchName));
 }
+const WORKSPACE_NATIVE_PLANS_RELATIVE_PATH = "workspace-plans";
 function visibleProjectBranchPath(projectsRoot, manifest, branchName) {
   return (0, import_managed_paths.managedBranchPath)(projectsRoot, manifest.checkoutPathSegments, branchName);
 }
 function localPlansBranchPath(plansRoot, projectId, branchName) {
   return import_node_path.default.join(plansRoot, projectId, branchName);
 }
+function localWorkspacePlansPath(plansRoot) {
+  return import_node_path.default.join(plansRoot, "workspace");
+}
 function assertInside(root, candidate, label) {
   const resolvedRoot = import_node_path.default.resolve(root);
   const resolvedCandidate = import_node_path.default.resolve(candidate);
@@ -713,12 +718,43 @@ function mirrorShadowPlansToLocal(input, manifest, branchName) {
     listFilesRecursively(targetRoot, planFilter)
   );
 }
+function mirrorLocalWorkspacePlansToShadow(input) {
+  if (input.trigger.canonicalCheckoutOnly) return;
+  const sourceRoot = localWorkspacePlansPath(input.plansRoot);
+  if (!import_node_fs.default.existsSync(sourceRoot)) return;
+  const targetRoot = import_node_path.default.join(input.shadowRoot, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH);
+  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
+  mirrorFileSet(sourceRoot, targetRoot, listFilesRecursively(sourceRoot, planFilter), listFilesRecursively(targetRoot, planFilter));
+}
+function mirrorShadowWorkspacePlansToLocal(input) {
+  if (input.trigger.canonicalCheckoutOnly) return;
+  const sourceRoot = import_node_path.default.join(input.shadowRoot, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH);
+  const targetRoot = localWorkspacePlansPath(input.plansRoot);
+  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
+  mirrorFileSet(
+    sourceRoot,
+    targetRoot,
+    listShadowTrackedFiles(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH).filter(planFilter),
+    listFilesRecursively(targetRoot, planFilter)
+  );
+}
+function reconcileWorkspaceNativePlans(input) {
+  if (input.trigger.canonicalCheckoutOnly) return;
+  if (import_node_fs.default.existsSync(localWorkspacePlansPath(input.plansRoot))) {
+    mirrorLocalWorkspacePlansToShadow(input);
+    return;
+  }
+  if (listShadowTrackedFiles(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH).length > 0 || restoreShadowRootFromRemote(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH)) {
+    mirrorShadowWorkspacePlansToLocal(input);
+  }
+}
 function mergeGitlinkProjection(target, source) {
   target.entries.push(...source.entries);
   target.opaqueRoots.push(...source.opaqueRoots);
 }
 function mirrorVisibleWorkspaceToShadow(input, excludedCheckouts = /* @__PURE__ */ new Set()) {
   const projection = { entries: [], opaqueRoots: [] };
+  reconcileWorkspaceNativePlans(input);
   for (const manifest of [...input.projects].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
     for (const branchName of [...new Set(manifest.branches)].sort()) {
       if (excludedCheckouts.has(`${manifest.projectId}\0${branchName}`)) continue;
@@ -754,6 +790,7 @@ function reconcileNewVisibleCheckouts(input) {
   return projection;
 }
 function mirrorShadowWorkspaceToVisible(input, opaqueWorkspaceRoots = []) {
+  mirrorShadowWorkspacePlansToLocal(input);
   for (const manifest of [...input.projects].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
     for (const branchName of [...new Set(manifest.branches)].sort()) {
       const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
@@ -1338,6 +1375,7 @@ class WorkspaceSyncSingleFlight {
 0 && (module.exports = {
   MAX_WORKSPACE_SYNC_DIFF_BYTES,
   WORKSPACE_BRANCH,
+  WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
   WORKSPACE_PERIODIC_SCAN_INTERVAL_MS,
   WorkspaceSyncSingleFlight,
   assertCanonicalCheckoutIndexMatchesWorktree,