@ricsam/r5d-worker 0.0.47 → 0.0.49

package/dist/mjs/package.json

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

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

@@ -0,0 +1,114 @@
+import net from "node:net";
+import WebSocket, {} from "ws";
+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 = net.createConnection({ host: "127.0.0.1", port: options.workerPort, allowHalfOpen: true });
+  socket.pause();
+  socket.setNoDelay(true);
+  const relay = new WebSocket(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 === WebSocket.OPEN || relay.readyState === WebSocket.CONNECTING) relay.close();
+  };
+  const sendError = (message) => {
+    if (relay.readyState === WebSocket.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 !== WebSocket.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 !== WebSocket.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 === WebSocket.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();
+}
+export {
+  openWorkerPortForwardRelay
+};

package/dist/mjs/workspace-sync.mjs

@@ -84,12 +84,16 @@ function workspaceProjectBranchRelativePath(projectId, branchName) {
 function workspacePlansRelativePath(projectId, branchName) {
   return path.posix.join("plans", projectId, encodeWorkspaceBranch(branchName));
 }
+const WORKSPACE_NATIVE_PLANS_RELATIVE_PATH = "workspace-plans";
 function visibleProjectBranchPath(projectsRoot, manifest, branchName) {
   return managedBranchPath(projectsRoot, manifest.checkoutPathSegments, branchName);
 }
 function localPlansBranchPath(plansRoot, projectId, branchName) {
   return path.join(plansRoot, projectId, branchName);
 }
+function localWorkspacePlansPath(plansRoot) {
+  return path.join(plansRoot, "workspace");
+}
 function assertInside(root, candidate, label) {
   const resolvedRoot = path.resolve(root);
   const resolvedCandidate = path.resolve(candidate);
@@ -667,12 +671,43 @@ function mirrorShadowPlansToLocal(input, manifest, branchName) {
     listFilesRecursively(targetRoot, planFilter)
   );
 }
+function mirrorLocalWorkspacePlansToShadow(input) {
+  if (input.trigger.canonicalCheckoutOnly) return;
+  const sourceRoot = localWorkspacePlansPath(input.plansRoot);
+  if (!fs.existsSync(sourceRoot)) return;
+  const targetRoot = path.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 = path.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 (fs.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;
@@ -708,6 +743,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);
@@ -1291,6 +1327,7 @@ class WorkspaceSyncSingleFlight {
 export {
   MAX_WORKSPACE_SYNC_DIFF_BYTES,
   WORKSPACE_BRANCH,
+  WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
   WORKSPACE_PERIODIC_SCAN_INTERVAL_MS,
   WorkspaceSyncSingleFlight,
   assertCanonicalCheckoutIndexMatchesWorktree,

package/dist/types/main.d.ts

@@ -1,5 +1,14 @@
 #!/usr/bin/env bun
 import { type WorkspaceProjectManifestEntry } from "./workspace-sync";
+export type WorkerSessionTarget = {
+    type: "project";
+    projectId: string;
+    branchName: string;
+} | {
+    type: "workspace";
+    ownerUserId: string;
+    rootProfile: "visible_projects" | "canonical_sync";
+};
 type WorkerReadFileResult = {
     type: "read";
     kind: "text";
@@ -60,22 +69,17 @@ export declare function isArtifactEnvPath(filePath: string): boolean;
 export declare function syncSessionArtifacts(input: {
     baseUrl: string;
     token: string;
-    projectId: string;
-    branchName: string;
     sessionId: string;
     artifactRoot: string;
 }): Promise<string>;
 export declare function prepareArtifactEnvForShell(input: {
     baseUrl: string;
     token: string;
-    projectId: string;
-    branchName: string;
     sessionId?: string;
     artifactRoot: string;
 }): Promise<Record<string, string>>;
 export declare function preparePlanEnvForShell(input: {
-    projectId: string;
-    branchName: string;
+    target: WorkerSessionTarget;
     planRoot: string;
     activePlanId?: string;
 }): Record<string, string>;
@@ -136,6 +140,21 @@ export declare function ensureVisibleGitCheckout(input: {
     allowRequiredRemoteMigration?: boolean;
     clearPersistentAuth?: boolean;
 }): string;
+type ResolvedWorkerSessionTarget = {
+    target: WorkerSessionTarget;
+    rootPath: string;
+    manifest?: WorkerProjectManifestEntry;
+};
+export declare function describeWorkerSessionTarget(target: WorkerSessionTarget): string;
+export declare function resolveWorkerSessionTarget(input: {
+    target: WorkerSessionTarget;
+    baseUrl: string;
+    token: string;
+    projectsRoot: string;
+    syncRoot: string;
+    workspaceShadowRoot: string;
+    manifestByProjectId: Map<string, WorkerProjectManifestEntry>;
+}): ResolvedWorkerSessionTarget;
 type VisibleCheckoutTarget = {
     projectId: string;
     branchName: string;
@@ -146,6 +165,17 @@ export declare function workspaceSyncCheckoutTargets(input: {
     includeAllManifestCheckouts: boolean;
     canonicalCheckoutOnly?: VisibleCheckoutTarget;
 }): VisibleCheckoutTarget[];
+export declare function prepareBuiltInToolPathsForTarget(input: {
+    target: WorkerSessionTarget;
+    filePath: string;
+    baseUrl: string;
+    token: string;
+    sessionId?: string;
+    activePlanId?: string;
+    artifactRoot: string;
+    planRoot: string;
+    access: "read" | "write";
+}): Promise<WorkerBuiltInToolPaths | undefined>;
 export declare function readWorkerTextFile(branchPath: string, filePath: string, offset?: number, limit?: number, builtInPaths?: WorkerBuiltInToolPaths): WorkerReadFileResult;
 export declare function writeWorkerTextFile(branchPath: string, filePath: string, content: string, builtInPaths?: WorkerBuiltInToolPaths): WorkerWriteFileResult;
 export declare function editWorkerTextFile(branchPath: string, filePath: string, edits: Array<{
@@ -167,6 +197,15 @@ export declare function findWorkerFiles(branchPath: string, input: {
 }, builtInPaths?: WorkerBuiltInToolPaths): WorkerFindResult;
 export declare function listWorkerDirectory(branchPath: string, inputPath?: string, inputLimit?: number, builtInPaths?: WorkerBuiltInToolPaths): WorkerLsResult;
 export declare function readWorkerImageFile(branchPath: string, filePath: string, builtInPaths?: WorkerBuiltInToolPaths): WorkerViewFileBytesResult;
+export declare function prepareShellEnvForTarget(input: {
+    target: WorkerSessionTarget;
+    baseUrl: string;
+    token: string;
+    sessionId?: string;
+    activePlanId?: string;
+    artifactRoot: string;
+    planRoot: string;
+}): Promise<Record<string, string>>;
 export declare function resolveHostShell(command?: string, platform?: NodeJS.Platform): {
     file: string;
     args: string[];

package/dist/types/port-forward-client.d.ts

@@ -0,0 +1,8 @@
+export declare function openWorkerPortForwardRelay(options: {
+    baseUrl: string;
+    token: string;
+    label: string;
+    forwardId: string;
+    relayConnectionId: string;
+    workerPort: number;
+}): void;

package/dist/types/workspace-sync.d.ts

@@ -78,6 +78,7 @@ export declare function encodeWorkspaceBranch(branchName: string): string;
 export declare function workspaceProjectsForSync(projects: readonly WorkspaceProjectManifestEntry[], trigger: WorkspaceSyncTrigger): WorkspaceProjectManifestEntry[];
 export declare function workspaceProjectBranchRelativePath(projectId: string, branchName: string): string;
 export declare function workspacePlansRelativePath(projectId: string, branchName: string): string;
+export declare const WORKSPACE_NATIVE_PLANS_RELATIVE_PATH = "workspace-plans";
 export declare function visibleProjectBranchPath(projectsRoot: string, manifest: WorkspaceProjectManifestEntry, branchName: string): string;
 type GitlinkEntry = {
     filePath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",