chainlesschain 0.163.8 → 0.164.0

package/src/lib/process-execution-broker/windows-sandbox.cs

@@ -89,7 +89,10 @@ namespace ChainlessChain.WindowsSandbox
         private const UInt32 WAIT_TIMEOUT = 0x00000102;
         private const UInt32 HANDLE_FLAG_INHERIT = 0x00000001;
         private const Int32 ERROR_INSUFFICIENT_BUFFER = 122;
+        private const Int32 ERROR_OPLOCK_NOT_GRANTED = 300;
         private const Int32 ERROR_IO_PENDING = 997;
+        private const Int32 LAUNCH_PATH_OPLOCK_MAX_ATTEMPTS = 22;
+        private const Int32 LAUNCH_PATH_OPLOCK_RETRY_BASE_DELAY_MS = 50;
         private const Int32 HRESULT_FROM_WIN32_ERROR_ALREADY_EXISTS =
             unchecked((Int32)0x800700B7);
         private const Int32 SecurityImpersonation = 2;
@@ -122,8 +125,10 @@ namespace ChainlessChain.WindowsSandbox
         private const UInt16 IMAGE_FILE_MACHINE_ARM64 = 0xaa64;
         private const UInt32 GENERIC_READ = 0x80000000;
         private const UInt32 GENERIC_WRITE = 0x40000000;
+        private const UInt32 FILE_READ_ATTRIBUTES = 0x00000080;
         private const UInt32 FILE_SHARE_READ = 0x00000001;
         private const UInt32 FILE_SHARE_WRITE = 0x00000002;
+        private const UInt32 FILE_SHARE_DELETE = 0x00000004;
         private const UInt32 OPEN_EXISTING = 3;
         private const UInt32 FILE_ATTRIBUTE_DIRECTORY = 0x00000010;
         private const UInt32 FILE_ATTRIBUTE_NORMAL = 0x00000080;
@@ -2305,6 +2310,42 @@ namespace ChainlessChain.WindowsSandbox
 
         private static LaunchPathLock AcquireLaunchPathLock(
             LaunchPathLockSpec spec)
+        {
+            for (
+                int attempt = 1;
+                attempt <= LAUNCH_PATH_OPLOCK_MAX_ATTEMPTS;
+                attempt++)
+            {
+                try
+                {
+                    return AcquireLaunchPathLockOnce(spec);
+                }
+                catch (Win32Exception error)
+                {
+                    if (
+                        error.NativeErrorCode != ERROR_OPLOCK_NOT_GRANTED ||
+                        attempt == LAUNCH_PATH_OPLOCK_MAX_ATTEMPTS)
+                    {
+                        throw;
+                    }
+                    // Filter oplocks are exclusive. Another strict helper or
+                    // a short-lived host scanner can hold the same runtime;
+                    // add at most 4.75s of backoff for that explicit denial.
+                    // AcquireLaunchPathLockOnce closes every failed attempt
+                    // before this delay, and all identity checks run again.
+                    int retryDelay = Math.Min(
+                        250,
+                        LAUNCH_PATH_OPLOCK_RETRY_BASE_DELAY_MS *
+                            attempt);
+                    Thread.Sleep(retryDelay);
+                }
+            }
+            throw new InvalidOperationException(
+                "Launch path Filter oplock retry contract failed");
+        }
+
+        private static LaunchPathLock AcquireLaunchPathLockOnce(
+            LaunchPathLockSpec spec)
         {
             UInt64 expectedDevice;
             UInt64 expectedFileId;
@@ -2345,8 +2386,8 @@ namespace ChainlessChain.WindowsSandbox
             {
                 lockingHandle = CreateFile(
                     expectedPath,
-                    0,
-                    FILE_SHARE_READ,
+                    FILE_READ_ATTRIBUTES,
+                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                     ref attributes,
                     OPEN_EXISTING,
                     FILE_FLAG_OVERLAPPED,
@@ -2373,12 +2414,17 @@ namespace ChainlessChain.WindowsSandbox
                     0,
                     out returned,
                     overlapped);
-                int oplockError = Marshal.GetLastWin32Error();
+                int oplockError = completed
+                    ? 0
+                    : Marshal.GetLastWin32Error();
                 if (completed || oplockError != ERROR_IO_PENDING)
                 {
                     throw new Win32Exception(
                         oplockError,
-                        "FSCTL_REQUEST_FILTER_OPLOCK was not granted");
+                        "FSCTL_REQUEST_FILTER_OPLOCK was not granted " +
+                        "(win32=" +
+                        oplockError.ToString(CultureInfo.InvariantCulture) +
+                        ", role=" + spec.role + ")");
                 }
                 oplockPending = true;
 

package/src/lib/public-ide-capability-manifest.js

@@ -37,6 +37,7 @@ const BRIDGE_TOOL_FEATURES = [
   ["getCallHierarchy", "semantic_call_hierarchy"],
   ["getSymbolInfo", "semantic_symbols"],
   ["getProjectModel", "project_model"],
+  ["getContextCenter", "context_center"],
 ];
 
 const VSCODE_COMMANDS = [
@@ -58,6 +59,7 @@ const VSCODE_COMMANDS = [
   "chainlesschain.chrome.connector",
   "chainlesschain.artifacts.show",
   "chainlesschain.policy.show",
+  "chainlesschain.context.show",
   "chainlesschain.workspace.scanAutoExec",
   "chainlesschain.remote.doctor",
   "chainlesschain.lens.explain",
@@ -106,6 +108,7 @@ const JETBRAINS_ACTIONS = [
   "chainlesschain.usage.Show",
   "chainlesschain.artifacts.Browse",
   "chainlesschain.policy.Viewer",
+  "chainlesschain.context.Center",
   "chainlesschain.plugins.Manage",
   "chainlesschain.worktree.Tasks",
   "chainlesschain.chrome.Connector",

package/src/lib/remote-approval-bridge.js

@@ -29,6 +29,11 @@ import {
   defaultApprovalAuthorityStatePath,
 } from "./approval-authority-store.js";
 import { OperationApprovalRegistry } from "./operation-fingerprint.js";
+import {
+  DurableRemoteMembershipAuthority,
+  REMOTE_MEMBERSHIP_AUTHORITY_UNAVAILABLE_CODE,
+  REMOTE_MEMBERSHIP_AUTHORITY_VERSION,
+} from "./remote-membership-authority.js";
 import {
   buildDirectPairingUri,
   pickLanAddress,
@@ -50,6 +55,8 @@ export class RemoteApprovalBridge {
     now = Date.now,
     approvalStore = undefined,
     approvalStateFile = null,
+    membershipAuthority = undefined,
+    membershipStateFile = null,
     onSecurityError = null,
   } = {}) {
     if (!wsUrl) throw new Error("wsUrl is required");
@@ -71,6 +78,13 @@ export class RemoteApprovalBridge {
     this._securityErrors = [];
     this._onSecurityError =
       typeof onSecurityError === "function" ? onSecurityError : null;
+    this._membershipAuthority =
+      membershipAuthority === undefined
+        ? () =>
+            new DurableRemoteMembershipAuthority(
+              membershipStateFile ? { filePath: membershipStateFile } : {},
+            )
+        : membershipAuthority;
     const durableStore =
       approvalStore === undefined
         ? new ApprovalAuthorityStore({
@@ -100,6 +114,23 @@ export class RemoteApprovalBridge {
     this._approvalStore = durableStore;
   }
 
+  _requireMembershipAuthority() {
+    if (typeof this._membershipAuthority === "function") {
+      this._membershipAuthority = this._membershipAuthority();
+    }
+    if (
+      !this._membershipAuthority ||
+      typeof this._membershipAuthority.withActiveMembership !== "function"
+    ) {
+      const error = new Error(
+        "Durable Remote membership authority is unavailable; remote approval is denied",
+      );
+      error.code = REMOTE_MEMBERSHIP_AUTHORITY_UNAVAILABLE_CODE;
+      throw error;
+    }
+    return this._membershipAuthority;
+  }
+
   _recordSecurityError({ action, requestId = null, reason, errorCode = null }) {
     const entry = {
       timestamp: this._now(),
@@ -139,7 +170,17 @@ export class RemoteApprovalBridge {
       sessionId: this.agentSessionId,
       name: this.name,
       scopes: this.scopes,
+      requireDurableMembershipAuthority: true,
     });
+    if (
+      created.session?.membershipAuthority !==
+        REMOTE_MEMBERSHIP_AUTHORITY_VERSION ||
+      typeof created.session?.sessionEpoch !== "string"
+    ) {
+      throw new Error(
+        "Remote Session server did not establish durable membership authority",
+      );
+    }
     this.remoteSessionId = created.session.sessionId;
     this.pairing = created.pairing;
     return this;
@@ -181,6 +222,28 @@ export class RemoteApprovalBridge {
     const requestId = message.event.requestId || message.event.approvalId;
     const pending = requestId ? this._pending.get(requestId) : null;
     if (!pending) return;
+    if (message.agentSessionId !== this.agentSessionId) {
+      this._recordSecurityError({
+        action: "approval.resolve",
+        requestId,
+        reason: "membership-agent-session-mismatch",
+      });
+      return;
+    }
+    if (
+      message.membershipAuthority !== REMOTE_MEMBERSHIP_AUTHORITY_VERSION ||
+      typeof message.from !== "string" ||
+      !message.from ||
+      typeof message.sessionEpoch !== "string" ||
+      typeof message.membershipEpoch !== "string"
+    ) {
+      this._recordSecurityError({
+        action: "approval.resolve",
+        requestId,
+        reason: "membership-binding-required",
+      });
+      return;
+    }
     // The device must echo the complete durable capability tuple. Missing,
     // mismatched, stale, duplicate, or expired resolutions never settle an
     // approval; only the store's successful CAS can return approved=true.
@@ -202,23 +265,66 @@ export class RemoteApprovalBridge {
     }
     const decision =
       rawAnswer === true || rawAnswer === "true" || rawAnswer === "yes";
-    const authority = {
-      origin: ORIGIN.REMOTE,
-      authenticated: true,
-      scopes: ["approve"],
-      principalId: message.from || "paired-device",
-      sessionId: this.agentSessionId,
-    };
-    const verdict = this._registry.resolve(pending.fingerprint, {
-      requestId,
-      fingerprint: message.event.fingerprint,
-      binding: message.event.binding,
-      sessionId: this.agentSessionId,
-      decision,
-      authority,
-      expectedRevision: message.event.revision,
-      now: this._now(),
-    });
+    let fenced;
+    try {
+      // The membership lock encloses the approval-store CAS. Therefore a
+      // revoke either commits first and suppresses this CAS, or waits behind an
+      // approval that has already linearized. No server-forwarded `from`
+      // string can authorize a side effect on its own.
+      fenced = this._requireMembershipAuthority().withActiveMembership(
+        {
+          sessionId: this.remoteSessionId,
+          principalId: message.from,
+          sessionEpoch: message.sessionEpoch,
+          membershipEpoch: message.membershipEpoch,
+        },
+        "approve",
+        (membership) => {
+          const authority = {
+            origin: ORIGIN.REMOTE,
+            authenticated: true,
+            scopes: ["approve"],
+            principalId: membership.principalId,
+            sessionId: this.agentSessionId,
+            remoteSessionId: membership.sessionId,
+            sessionEpoch: membership.sessionEpoch,
+            membershipEpoch: membership.membershipEpoch,
+          };
+          return this._registry.resolve(pending.fingerprint, {
+            requestId,
+            fingerprint: message.event.fingerprint,
+            binding: message.event.binding,
+            sessionId: this.agentSessionId,
+            decision,
+            authority,
+            expectedRevision: message.event.revision,
+            now: this._now(),
+          });
+        },
+      );
+    } catch (error) {
+      const verdict = {
+        reason: "membership-state-unavailable",
+        errorCode: error?.code || REMOTE_MEMBERSHIP_AUTHORITY_UNAVAILABLE_CODE,
+      };
+      this._recordSecurityError({
+        action: "approval.resolve",
+        requestId,
+        reason: verdict.reason,
+        errorCode: verdict.errorCode,
+      });
+      this._settleDeniedForStateFailure(requestId, pending, verdict);
+      return;
+    }
+    if (!fenced.ok) {
+      this._recordSecurityError({
+        action: "approval.resolve",
+        requestId,
+        reason: fenced.reason,
+      });
+      return;
+    }
+    const verdict = fenced.value;
     if (!verdict.ok) {
       this._recordSecurityError({
         action: "approval.resolve",