rovloom 0.5.0 → 0.6.1

package/dist/src/{chunk-4etdq0cp.js → chunk-ftpy8xx3.js}

@@ -12,11 +12,13 @@ import {
   fields2,
   id2,
   uint2,
+  sha2,
   boundedJson2,
   parseJson2,
   hash2,
   validateTarget2,
   validateProvider2,
+  validateContractSource2,
   contractRef2,
   validatePolicies2,
   assertBinding2,
@@ -27,10 +29,10 @@ import {
   Router2
 } from "./chunk-y4hksha9.js";
 import {
-  LuvusAdapterError2,
   pinTerminalExecution
-} from "./chunk-57ayxqnb.js";
+} from "./chunk-8fy8w7ds.js";
 import {
+  compileBundle2,
   createNativeValidator2
 } from "./chunk-mqyq5jh6.js";
 import {
@@ -47,15 +49,17 @@ import {
   createConnector2,
   createDeviceLifecycle2,
   createDeviceLifecycleAdapter2
-} from "./chunk-zjzrcc59.js";
+} from "./chunk-59h200cr.js";
 import {
-  createLuvusRequestPreflight,
-  luvusValidation
-} from "./chunk-zj48jvfe.js";
+  LUVUS_OPERATION_METHODS2,
+  luvusOperationDescriptor2,
+  luvusOperationValidation2,
+  validateLuvusOperationParams2
+} from "./chunk-efty77sb.js";
 import {
   configuredSnapshotDirectory,
   Store2
-} from "./chunk-nyn75b8v.js";
+} from "./chunk-av31bx1e.js";
 import {
   createProviderResultAccess2,
   LUVUS_ENDPOINT_TRANSPORT,
@@ -72,13 +76,13 @@ import {
   parseRpcFrame,
   LuvusRpcAdapter2,
   readLuvusPeer2
-} from "./chunk-0xgpxdgc.js";
+} from "./chunk-bbdtsg4b.js";
 import {
   CONNECTOR_MAX_DEADLINE_MS2,
   ConnectorAttemptBook2,
   createConnectorAdmissionBackend2,
   connectorAdmissionAdapter
-} from "./chunk-d4ejrtjq.js";
+} from "./chunk-6n6b1xpy.js";
 import {
   OwnedProcessShutdownError,
   observeLuvusProcess,
@@ -90,18 +94,22 @@ import {
   NativeInstanceContext,
   discoverLuvusInstallation,
   MANAGED_LUVUS_REVISION2,
+  MANAGED_LUVUS_CLASSIFICATION2,
   registerLocalOwnerLuvus,
   assertLocalOwnerLuvus,
   observedLuvusContract,
-  startManagedLuvus2,
-  assertLuvusOperationsContract,
-  createLuvusOperationsAuthority,
-  checkedRemoteLuvusConfig,
-  createPinnedRemoteLuvus
-} from "./chunk-5s2emvww.js";
+  startManagedLuvus2
+} from "./chunk-j6svdqr8.js";
+import {
+  createLuvusRequestPreflight,
+  luvusValidation
+} from "./chunk-xtvgm6kf.js";
 import {
   LuvusDispatchClaims2
-} from "./chunk-gbsbwssz.js";
+} from "./chunk-sf4ztxba.js";
+import {
+  LuvusAdapterError2
+} from "./chunk-pksaqt9a.js";
 import {
   agentSearchPath
 } from "./chunk-3nnahj0j.js";
@@ -2030,10 +2038,7 @@ function createManagementSessionAuthority2(source, options = {}) {
           if (lease.revoked && !lease.expiry_only || at < lease.session.expires_at || input.issued_at !== lease.upstream.issued_at || input.expires_at !== lease.upstream.expires_at) {
             throw new GatewayError2("unauthenticated");
           }
-          const session = Object.freeze({
-            ...lease.upstream,
-            expires_at: Math.min(lease.upstream.expires_at, at + 300000)
-          });
+          const session = lease.upstream;
           try {
             base(session, lease.policy);
           } catch {
@@ -2054,7 +2059,7 @@ function createManagementSessionAuthority2(source, options = {}) {
             caller,
             management_session_ref: sessionRef,
             issued_at: input.issued_at,
-            expires_at: Math.min(input.expires_at, at + 300000)
+            expires_at: input.expires_at
           });
           const current = base(session);
           if (leases.has(name) || leases.size >= capacity) {
@@ -2129,6 +2134,53 @@ function createManagementSessionAuthority2(source, options = {}) {
     close
   });
 }
+// src/runtime/luvus-operations-authority.ts
+import { isDeepStrictEqual } from "util";
+function assertLuvusOperationsContract(contract) {
+  const source = contract.wire.source;
+  const capabilities = object2(object2(contract.capabilities).result);
+  if (contract.wire.support_status !== "validated" || source.provider_kind !== "luvus" || source.protocol_family !== "uhp" || source.schema_origin !== "installed_cli" || source.schema_command !== "luvus uhp schema" || !/^1\.\d+$/u.test(source.native_protocol_version ?? "") || source.support_basis !== "live_catalog" || source.adapter_revision !== MANAGED_LUVUS_REVISION2 || source.classification_revision !== MANAGED_LUVUS_CLASSIFICATION2 || typeof source.runtime_generation !== "string" || !source.runtime_generation.length || source.runtime_generation !== capabilities.server_generation || contract.compiled.identity.binary_sha256 !== source.binary_sha256 || contract.compiled.identity.schema_sha256 !== source.schema_sha256 || contract.compiled.identity.revision !== source.adapter_revision || !Array.isArray(capabilities.method_contracts)) {
+    throw new LuvusAdapterError2("luvus_operations_source_mismatch");
+  }
+}
+function createLuvusOperationsAuthority(contract, current, rawAllowed) {
+  assertLuvusOperationsContract(contract);
+  const methods = object2(object2(contract.capabilities).result).method_contracts;
+  return (attempt, native) => {
+    const proven = current(attempt.binding);
+    const descriptor = luvusOperationDescriptor2(attempt.method);
+    if (proven.authenticated !== true || proven.source_verified !== true || !descriptor || attempt.native_request.method !== attempt.method || attempt.mode !== luvusOperationValidation2(attempt.method) || !isDeepStrictEqual(proven.binding, native)) {
+      throw new LuvusAdapterError2("luvus_operation_unreviewed");
+    }
+    const live = methods.filter((row) => row.method === attempt.method);
+    if (live.length !== 1 || !isDeepStrictEqual({
+      method: live[0].method,
+      access: live[0].access,
+      scope: live[0].scope,
+      idempotent: live[0].idempotent
+    }, descriptor.native)) {
+      throw new LuvusAdapterError2("luvus_operations_contract_mismatch");
+    }
+    validateLuvusOperationParams2(attempt.method, attempt.native_request.params);
+    const raw = attempt.mode === "raw-contract";
+    const allowed = raw && rawAllowed(attempt) === true;
+    return {
+      owner: allowed,
+      raw_requested: raw,
+      ...allowed ? {
+        raw_grant: {
+          id: attempt.binding.call_id,
+          source_verified: true,
+          principal_id: attempt.principal_id,
+          binding: native,
+          methods: [attempt.method],
+          expires_at: attempt.binding.registration.deadline
+        }
+      } : {}
+    };
+  };
+}
+
 // src/runtime/luvus-operations-provider.ts
 function createLuvusOperationsProvider2(owner, peerPolicyRevision) {
   assertLocalOwnerLuvus(owner);
@@ -2178,7 +2230,7 @@ function createLuvusOperationsProvider2(owner, peerPolicyRevision) {
 }
 // src/runtime/native-attach.ts
 import { randomUUID } from "crypto";
-import { isDeepStrictEqual } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 class AttachedLuvus extends NativeInstanceContext {
   #observation;
   #closed = false;
@@ -2257,7 +2309,7 @@ async function attachExistingLuvus2(config, options = {}) {
         bytes,
         beforeWrite() {
           observation.assertLive();
-          if (!isDeepStrictEqual(readLuvusPeer2(socket, endpoint), observation.identity())) {
+          if (!isDeepStrictEqual2(readLuvusPeer2(socket, endpoint), observation.identity())) {
             throw new LuvusAdapterError2("attached_peer_mismatch");
           }
         }
@@ -2282,7 +2334,7 @@ async function attachExistingLuvus2(config, options = {}) {
 }
 // src/runtime/production-luvus.ts
 import { join as join2 } from "path";
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 
 // src/runtime/luvus-user-source.ts
 import { spawn } from "child_process";
@@ -2461,6 +2513,239 @@ async function startUserLuvus(input) {
   });
 }
 
+// src/runtime/remote-luvus.ts
+function checkedRemoteLuvusConfig(reference, input) {
+  const config = object2(JSON.parse(boundedJson2(input)));
+  fields2(config, ["kind", "authentication", "binding", "target", "contract", "peer_policy_revision"], ["raw_grant"]);
+  validateProvider2(config.binding);
+  validateTarget2(config.target);
+  id2(config.peer_policy_revision);
+  const pin = object2(config.contract);
+  fields2(pin, [
+    "binary_version",
+    "binary_sha256",
+    "schema_sha256",
+    "adapter_revision",
+    "classification_revision",
+    "schema_bundle"
+  ]);
+  sha2(pin.binary_sha256);
+  sha2(pin.schema_sha256);
+  if (config.kind !== "luvus" || config.authentication !== "remote_connector" || config.binding.kind !== "luvus" || config.target.profile !== "session" || config.binding.machine_id !== config.target.machine_id || config.binding.provider_id !== config.target.provider_id || config.binding.config_ref !== reference || typeof pin.binary_version !== "string" || !pin.binary_version.length || pin.binary_version.length > 128 || pin.adapter_revision !== MANAGED_LUVUS_REVISION2 || pin.classification_revision !== MANAGED_LUVUS_CLASSIFICATION2 || typeof pin.schema_bundle !== "string" || hash2(pin.schema_bundle) !== pin.schema_sha256) {
+    throw new LuvusAdapterError2("remote_luvus_pin_invalid");
+  }
+  if (config.raw_grant !== undefined) {
+    const grant = object2(config.raw_grant);
+    fields2(grant, ["principal_id", "methods"]);
+    id2(grant.principal_id);
+    if (!Array.isArray(grant.methods) || grant.methods.length > LUVUS_OPERATION_METHODS2.length || new Set(grant.methods).size !== grant.methods.length || grant.methods.some((method) => !LUVUS_OPERATION_METHODS2.includes(method))) {
+      throw new LuvusAdapterError2("remote_luvus_raw_grant_invalid");
+    }
+    Object.freeze(grant.methods);
+    Object.freeze(grant);
+  }
+  Object.freeze(config.binding);
+  Object.freeze(config.target);
+  Object.freeze(pin);
+  return Object.freeze(config);
+}
+async function createPinnedRemoteLuvus(config) {
+  const pin = config.contract;
+  const compiled = await compileBundle2(Buffer.from(pin.schema_bundle), {
+    identity: { binary_sha256: pin.binary_sha256, schema_sha256: pin.schema_sha256, revision: pin.adapter_revision }
+  });
+  if (!compiled.ok) {
+    throw new LuvusAdapterError2(compiled.error.code);
+  }
+  const contractHandle = compiled.value;
+  const target = config.target;
+  if (target.profile !== "session") {
+    throw new LuvusAdapterError2("remote_luvus_pin_invalid");
+  }
+  const validator = createNativeValidator2(contractHandle);
+  let closed = false;
+  let active;
+  function assertEpoch(epoch) {
+    if (closed || epoch.closed || active !== epoch) {
+      throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+    }
+    const checked = epoch.assertCurrent();
+    if (checked !== undefined) {
+      Promise.resolve(checked).catch(() => {});
+      throw new LuvusAdapterError2("synchronous_remote_source_required");
+    }
+    if (closed || epoch.closed || active !== epoch) {
+      throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+    }
+  }
+  function closeEpoch(epoch) {
+    epoch.closed = true;
+    epoch.record = undefined;
+    epoch.provider = undefined;
+    if (active === epoch) {
+      active = undefined;
+    }
+  }
+  function nativeBinding(epoch, policies) {
+    assertEpoch(epoch);
+    const record = epoch.record;
+    if (!record) {
+      throw new LuvusAdapterError2("remote_luvus_snapshot_required");
+    }
+    id2(policies.caller_policy_revision);
+    id2(policies.local_policy_revision);
+    const target = config.target;
+    if (target.profile !== "session") {
+      throw new LuvusAdapterError2("remote_luvus_pin_invalid");
+    }
+    const binding = Object.freeze({
+      kind: "luvus",
+      provider_id: target.provider_id,
+      binding_revision: config.binding.binding_revision,
+      contract_source_ref: contractRef2(record.wire.source),
+      target: Object.freeze({ machine_id: target.machine_id, profile: "session", session: target.session }),
+      server_generation: record.wire.source.runtime_generation,
+      connection_epoch: epoch.connection.connection_epoch,
+      recovery_generation: epoch.connection.recovery_generation,
+      capability_revision: record.capability_revision,
+      caller_policy_revision: policies.caller_policy_revision,
+      local_policy_revision: policies.local_policy_revision,
+      classification_revision: pin.classification_revision,
+      contract: contractHandle.identity
+    });
+    assertEpoch(epoch);
+    return Object.freeze({ binding, authenticated: true, source_verified: true });
+  }
+  function ready() {
+    try {
+      if (!active?.record) {
+        return false;
+      }
+      assertEpoch(active);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  const provider = Object.freeze({
+    remote_luvus: true,
+    binding: config.binding,
+    target: config.target,
+    peer_policy_revision: config.peer_policy_revision,
+    preflightRequest: createLuvusRequestPreflight(contractHandle),
+    ready,
+    open(connection, assertCurrent) {
+      if (closed || active || !connection.authenticated || !connection.active || connection.machine_id !== config.target.machine_id || !connection.negotiated.capabilities.includes("provider_snapshot")) {
+        throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+      }
+      const epoch = { connection: structuredClone(connection), assertCurrent, closed: false };
+      active = epoch;
+      try {
+        assertEpoch(epoch);
+      } catch (error) {
+        closeEpoch(epoch);
+        throw error;
+      }
+      return Object.freeze({
+        accept(input) {
+          assertEpoch(epoch);
+          const copied = parseNativeJson2(boundedJson2(input));
+          if (!copied.ok) {
+            throw new LuvusAdapterError2(copied.error.code);
+          }
+          const snapshot = copied.value;
+          fields2(object2(snapshot), ["binding", "target", "source", "capabilities", "capability_revision"]);
+          validateProvider2(snapshot.binding);
+          validateTarget2(snapshot.target);
+          validateContractSource2(snapshot.source);
+          sha2(snapshot.capability_revision);
+          if (boundedJson2(snapshot.binding) !== boundedJson2(config.binding) || boundedJson2(snapshot.target) !== boundedJson2(config.target)) {
+            throw new LuvusAdapterError2("remote_luvus_binding_mismatch");
+          }
+          const source = snapshot.source;
+          if (source.binary_sha256 !== pin.binary_sha256 || source.schema_sha256 !== pin.schema_sha256 || source.adapter_revision !== pin.adapter_revision || source.classification_revision !== pin.classification_revision || typeof source.runtime_generation !== "string" || !source.runtime_generation.length) {
+            throw new LuvusAdapterError2("remote_luvus_contract_mismatch");
+          }
+          const capabilities = object2(snapshot.capabilities);
+          const value = object2(capabilities.result);
+          if (hash2(boundedJson2(value)) !== snapshot.capability_revision) {
+            throw new LuvusAdapterError2("remote_luvus_capability_mismatch");
+          }
+          const shape = validator.checkCapabilitiesShape(capabilities, {
+            target: { machine_id: target.machine_id, profile: "session", session: target.session },
+            server_generation: source.runtime_generation
+          });
+          if (!shape.ok) {
+            throw new LuvusAdapterError2(shape.error.code);
+          }
+          const record = Object.freeze({
+            wire: Object.freeze({ source: Object.freeze(source), support_status: "validated" }),
+            compiled: contractHandle,
+            capabilities,
+            capability_revision: snapshot.capability_revision
+          });
+          assertLuvusOperationsContract(record);
+          const fingerprint = hash2(boundedJson2(snapshot));
+          if (epoch.fingerprint !== undefined) {
+            if (epoch.fingerprint !== fingerprint) {
+              throw new LuvusAdapterError2("remote_luvus_snapshot_changed");
+            }
+            assertEpoch(epoch);
+            return epoch.provider;
+          }
+          function sourceFor(binding) {
+            assertEpoch(epoch);
+            assertBinding2(binding, binding);
+            if (binding.machine_id !== epoch.connection.machine_id || binding.recovery_generation !== epoch.connection.recovery_generation || binding.connection_epoch !== epoch.connection.connection_epoch || binding.provider_kind !== "luvus" || binding.binding_revision !== config.binding.binding_revision || boundedJson2(binding.target) !== boundedJson2(config.target) || binding.contract_ref !== contractRef2(record.wire.source)) {
+              throw new LuvusAdapterError2("remote_luvus_binding_mismatch");
+            }
+            return nativeBinding(epoch, binding.registration);
+          }
+          const live = Object.freeze({
+            binding: config.binding,
+            target: config.target,
+            peer_policy_revision: config.peer_policy_revision,
+            contract: record,
+            source: sourceFor,
+            catalogSource(current, policies) {
+              if (boundedJson2(current) !== boundedJson2(epoch.connection)) {
+                throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+              }
+              return nativeBinding(epoch, policies);
+            },
+            authority: createLuvusOperationsAuthority(record, sourceFor, (attempt) => config.raw_grant?.principal_id === attempt.principal_id && config.raw_grant.methods.includes(attempt.method)),
+            ready() {
+              try {
+                assertEpoch(epoch);
+                return !!epoch.record;
+              } catch {
+                return false;
+              }
+            }
+          });
+          assertEpoch(epoch);
+          epoch.record = record;
+          epoch.fingerprint = fingerprint;
+          epoch.provider = live;
+          return live;
+        },
+        close() {
+          closeEpoch(epoch);
+        }
+      });
+    }
+  });
+  return Object.freeze({
+    provider,
+    close() {
+      closed = true;
+      if (active) {
+        closeEpoch(active);
+      }
+    }
+  });
+}
+
 // src/runtime/production-luvus.ts
 function references(input, mode) {
   try {
@@ -2807,8 +3092,8 @@ function createLuvusProductionSources2() {
               routes,
               book,
               source: {
-                provider: (target) => isDeepStrictEqual2(target, fixed.target) ? provider.binding : undefined,
-                localProvider: (target) => isDeepStrictEqual2(target, fixed.target) ? provider.binding : undefined,
+                provider: (target) => isDeepStrictEqual3(target, fixed.target) ? provider.binding : undefined,
+                localProvider: (target) => isDeepStrictEqual3(target, fixed.target) ? provider.binding : undefined,
                 contract: (ref) => ref === reference ? provider.contract : undefined,
                 nativeSource: (call, attempt) => {
                   const row = admitted.backend?.attempt(call, attempt);
@@ -2870,6 +3155,6 @@ function createLuvusProductionSources2() {
     }
   });
 }
-export { createTrustedRequestScope2, composeGatewaySessions2, composeConnectorSessions2, createGatewayRuntime2, createProviderGatewayRuntime2, openGatewayState2, createLuvusConnectorSessions2, createConnectorRuntime2, ConnectorHostStartupError2, createProviderConnectorRuntime2, createManagementSessionAuthority2, createLuvusOperationsProvider2, attachExistingLuvus2, LuvusProductionStartupError2, createLuvusProductionSources2 };
+export { createTrustedRequestScope2, composeGatewaySessions2, composeConnectorSessions2, createGatewayRuntime2, createProviderGatewayRuntime2, openGatewayState2, createLuvusConnectorSessions2, createConnectorRuntime2, ConnectorHostStartupError2, createProviderConnectorRuntime2, createManagementSessionAuthority2, createLuvusOperationsProvider2, attachExistingLuvus2, checkedRemoteLuvusConfig, createPinnedRemoteLuvus, LuvusProductionStartupError2, createLuvusProductionSources2 };
 
-//# debugId=785921E4C40CA8AB64756E2164756E21
+//# debugId=A165CD691DA8923B64756E2164756E21

package/dist/src/{chunk-zdxww7ms.js → chunk-h3xyq7zk.js}

@@ -2,7 +2,7 @@
 import {
   currentProcessIdentity,
   ownerIsDead
-} from "./chunk-0pewfj89.js";
+} from "./chunk-qp8tgms2.js";
 import {
   syncParentDirectory
 } from "./chunk-0y5542k8.js";

package/dist/src/{chunk-ttsrctxg.js → chunk-hxmq28pg.js}

@@ -11,27 +11,29 @@ import {
   MessageWindow2
 } from "./chunk-g7pnjzkk.js";
 import {
-  LuvusAdapterError2,
-  ConnectorCapacityError,
   assertTerminalExecutionAllowed
-} from "./chunk-57ayxqnb.js";
+} from "./chunk-8fy8w7ds.js";
 import {
   HerdrLocalError,
   readHerdrPeer
-} from "./chunk-q5pgbwb3.js";
+} from "./chunk-e7jgpxkf.js";
 import {
   checkHerdrSignal,
   herdrDeadline,
   withHerdrSocket,
   exchangeHerdr,
   HerdrInstallation2
-} from "./chunk-863tk45b.js";
+} from "./chunk-41fny9qm.js";
 import {
   createHerdrReadonlyAdapter2
 } from "./chunk-zb641qa3.js";
 import {
   LuvusDispatchClaims2
-} from "./chunk-gbsbwssz.js";
+} from "./chunk-sf4ztxba.js";
+import {
+  LuvusAdapterError2,
+  ConnectorCapacityError
+} from "./chunk-pksaqt9a.js";
 
 // src/connector/herdr/wire.ts
 function identityOf(binding) {
@@ -273,4 +275,4 @@ function createHerdrRuntime2(installation, backend, claims, terminalExecution) {
 
 export { createHerdrWireAdapter, createHerdrRuntime2 };
 
-//# debugId=828EF1FDC5E8AF4B64756E2164756E21
+//# debugId=0A9E0EF4232D9B8364756E2164756E21

package/dist/src/{chunk-r0nfthsf.js → chunk-j59ac0xs.js}

@@ -1,8 +1,8 @@
 // @bun
 // src/mcp/version.ts
 var MCP_REVISION2 = "2025-11-25";
-var PRODUCT_VERSION2 = "0.5.0";
+var PRODUCT_VERSION2 = "0.6.1";
 
 export { MCP_REVISION2, PRODUCT_VERSION2 };
 
-//# debugId=1479A7639E360A6A64756E2164756E21
+//# debugId=D4F5A83CF09C923064756E2164756E21