@indigoai-us/hq-cloud 6.18.104 → 6.18.106

package/dist/bin/sync-runner-watch-loop.js

@@ -49,7 +49,8 @@ import { DEFAULT_REALTIME_AUTHORIZATION_TIMEOUT_MS } from "../sync/realtime-roll
 import { RealtimeTelemetrySpan, writeRealtimeTelemetryToStderr, } from "../sync/realtime-telemetry.js";
 import { InlineSyncWorkerAdapter, } from "../sync/sync-work.js";
 import { buildRoutePullArgv, buildScopedPushArgv, buildScopedDrainPullArgv, buildTargetedPullArgv, isWatchRouteSelected, routeChangeToTarget, routeKey, scopePathForRoute, } from "./sync-runner-watch-routes.js";
-import { resolveSkipCompanies } from "./sync-runner-planning.js";
+import { buildFanoutPlan, resolveSkipCompanies } from "./sync-runner-planning.js";
+import { LegacySyncWakeBridge } from "./legacy-sync-wake.js";
 import { buildPassRequestArgv } from "./sync-pass-request.js";
 const FULL_RECONCILE_EVERY_TICKS = 10;
 const warnedUnresolvedReceiverCompanies = new Set();
@@ -3149,6 +3150,77 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         }
     };
     let nextCoordinatorCausality = 0;
+    const locallyLegacyTarget = (target) => {
+        const route = target.personalMode ? { kind: "personal" } : { kind: "company", slug: target.slug };
+        return !stopped && isWatchRouteSelected(route, watchRouteSelection) &&
+            (target.personalMode || !resolveSkipCompanies().has(target.slug)) &&
+            !fs.existsSync(path.join(getStateDir(), "sync-core", "engines", target.uid, ".hq", "sync-core", "owned", `${target.uid}.json`));
+    };
+    const wakeToken = deps.getAccessToken ?? runtime.defaultGetAccessToken;
+    const wakeClaims = deps.getIdTokenClaims ?? runtime.defaultGetIdTokenClaims;
+    const normalizedWakeClaims = (raw) => {
+        if (!raw || typeof raw !== "object" || !("sub" in raw) || typeof raw.sub !== "string" || !raw.sub)
+            return null;
+        return {
+            sub: raw.sub,
+            email: "email" in raw && typeof raw.email === "string" ? raw.email : undefined,
+            "custom:entityType": "custom:entityType" in raw && typeof raw["custom:entityType"] === "string" ? raw["custom:entityType"] : undefined,
+            "custom:entityUid": "custom:entityUid" in raw && typeof raw["custom:entityUid"] === "string" ? raw["custom:entityUid"] : undefined,
+        };
+    };
+    const identityOf = (raw) => {
+        const claims = normalizedWakeClaims(raw);
+        return claims ? JSON.stringify([claims.sub, claims["custom:entityUid"] ?? null]) : null;
+    };
+    const resolveLegacyWakeTarget = deps.resolveLegacyWakeTarget ?? (async (expected) => {
+        await wakeToken();
+        const claims = normalizedWakeClaims(wakeClaims());
+        const identity = identityOf(claims);
+        if (!identity)
+            return null;
+        const client = new VaultClient({ apiUrl: runtime.apiUrl, authToken: wakeToken, region: runtime.region });
+        const memberships = expected.personalMode ? [] : (await client.listMyMemberships())
+            .filter((member) => member.status === "active" && member.companyUid === expected.uid);
+        if (!expected.personalMode && memberships.length === 0)
+            return null;
+        const result = await buildFanoutPlan({
+            memberships, companies: !expected.personalMode, personal: expected.personalMode === true,
+            skipPersonal: watchRouteSelection.skipPersonal, client, claims,
+            resolveSkipPersonal: (flag) => flag || watchRouteSelection.skipPersonal,
+            skipCompanies: resolveSkipCompanies(),
+        });
+        await wakeToken();
+        if (identityOf(wakeClaims()) !== identity || result.status !== "plan")
+            return null;
+        return result.plan.find((target) => target.uid === expected.uid && target.slug === expected.slug &&
+            (target.personalMode === true) === (expected.personalMode === true)) ?? null;
+    });
+    const currentLegacyTarget = async (target) => {
+        if (!locallyLegacyTarget(target))
+            return null;
+        try {
+            const current = await resolveLegacyWakeTarget(target);
+            return current && current.uid === target.uid && current.slug === target.slug &&
+                (current.personalMode === true) === (target.personalMode === true) && locallyLegacyTarget(current) ? current : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const legacyWakeBridge = eventPush && drainRunsPull && resolveEventSync(process.env.HQ_SYNC_EVENT_SYNC) && runtime.subscribeTargets
+        ? new LegacySyncWakeBridge({
+            statePath: path.join(getStateDir(), "work-mesh", "sync-wake.json"),
+            canPull: async (target) => (await currentLegacyTarget(target)) !== null,
+            pull: async (target) => {
+                const route = target.personalMode ? { kind: "personal" } : { kind: "company", slug: target.uid };
+                const outcome = await runGuarded(buildRoutePullArgv(route, passArgv), async () => {
+                    if (!await currentLegacyTarget(target))
+                        throw new Error("legacy wake no longer authorized");
+                }, "slow", "chore", false, undefined, false, undefined, false, undefined, "sync-wake");
+                return passExitCode(outcome) === 0;
+            },
+        }) : null;
+    const detachWakeTargets = runtime.subscribeTargets?.((targets, complete) => legacyWakeBridge?.setTargets(targets, complete));
     const realtimeWork = (source, direction, paths, lane, sizeClass = "unknown") => ({
         class: "realtime",
         source,
@@ -5334,6 +5406,7 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         // the guarded queue, but every surface must still be constructed once.
         const firstActivation = !eventPushSurfacesActivated;
         eventPushSurfacesActivated = true;
+        legacyWakeBridge?.start();
         const clock = deps.clock ?? systemClock;
         // Quiet-period debounce + max-wait ceiling (HQ_SYNC_EVENT_DEBOUNCE_MS /
         // HQ_SYNC_EVENT_MAX_WAIT_MS): rapid-fire editor bursts collapse into one
@@ -6106,6 +6179,8 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         if (stopped)
             return shutdownPromise ?? Promise.resolve();
         stopped = true;
+        legacyWakeBridge?.stop();
+        detachWakeTargets?.();
         clearInterval(watcherPushStagesTimer);
         if (durableWatcherPersistTimer !== undefined)
             clearTimeout(durableWatcherPersistTimer);