happy-imou-cloud 2.1.49 → 2.1.51

package/dist/bootstrapManagedProviderSession-D2Z6YU3n.mjs

@@ -0,0 +1,145 @@
+import { d as createSessionMetadata, e as publishSessionRegistration } from './index-CX-F_fuk.mjs';
+import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './types-B5vtxa38.mjs';
+import { EventEmitter } from 'node:events';
+
+function createOfflineSessionStub(sessionTag) {
+  const emitter = new EventEmitter();
+  let metadata = null;
+  let agentState = null;
+  const stub = {
+    sessionId: `offline-${sessionTag}`,
+    sendCodexMessage: () => {
+    },
+    sendAgentMessage: () => {
+    },
+    sendClaudeSessionMessage: () => {
+    },
+    keepAlive: () => {
+    },
+    sendSessionEvent: () => {
+    },
+    sendSessionDeath: () => {
+    },
+    updateLifecycleState: () => {
+    },
+    requestControlTransfer: async () => {
+    },
+    flush: async () => {
+    },
+    close: async () => {
+    },
+    updateMetadata: (handler) => {
+      metadata = handler(metadata || {});
+      emitter.emit("metadata-updated", metadata);
+    },
+    updateAgentState: (handler) => {
+      agentState = handler(agentState || {});
+      emitter.emit("agent-state-updated", agentState);
+    },
+    getMetadataSnapshot: () => metadata,
+    getAgentStateSnapshot: () => agentState,
+    waitForMetadataUpdate: async () => metadata,
+    onUserMessage: () => {
+    },
+    onSessionMessage: () => {
+    },
+    configureProtocolV3Sync: () => {
+    },
+    rpcHandlerManager: {
+      registerHandler: () => {
+      }
+    },
+    on: emitter.on.bind(emitter),
+    once: emitter.once.bind(emitter),
+    off: emitter.off.bind(emitter),
+    emit: emitter.emit.bind(emitter)
+  };
+  return stub;
+}
+
+function setupOfflineReconnection(opts) {
+  const { api, sessionTag, metadata, state, response, onSessionSwap } = opts;
+  let session;
+  let reconnectionHandle = null;
+  if (!response) {
+    session = createOfflineSessionStub(sessionTag);
+    reconnectionHandle = startOfflineReconnection({
+      serverUrl: configuration.serverUrl,
+      onReconnected: async () => {
+        const resp = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+        if (!resp) throw new Error("Server unavailable");
+        const realSession = api.sessionSyncClient(resp);
+        onSessionSwap(realSession);
+        return realSession;
+      },
+      onNotify: (msg) => {
+        console.log(msg);
+      }
+    });
+    return { session, reconnectionHandle, isOffline: true };
+  } else {
+    session = api.sessionSyncClient(response);
+    return { session, reconnectionHandle: null, isOffline: false };
+  }
+}
+
+async function bootstrapManagedProviderSession(opts) {
+  const { state, metadata, happyOrgStartupBinding } = createSessionMetadata({
+    flavor: opts.flavor,
+    machineId: opts.machineId,
+    startedBy: opts.startedBy,
+    managedSessionTag: opts.startedBy === "daemon" && (opts.flavor === "codex" || opts.flavor === "cursor") ? opts.sessionTag : void 0
+  });
+  const reconcileAttachedSessionMetadata = (session2) => {
+    if (!opts.reconcileMetadataOnAttach) {
+      return;
+    }
+    try {
+      session2.updateMetadata(() => metadata);
+    } catch (error) {
+      logger.debug(`[managed-session] Failed to reconcile metadata for ${opts.flavor} session`, error);
+    }
+  };
+  let response = null;
+  try {
+    response = await opts.api.getOrCreateSession({
+      tag: opts.sessionTag,
+      metadata,
+      state,
+      stableDataKeyPath: ["managed-session-tag", opts.sessionTag]
+    });
+  } catch (error) {
+    if (!isAuthenticationRequiredError(error)) {
+      throw error;
+    }
+    logger.debug(opts.authFallbackLogMessage);
+  }
+  const { session, reconnectionHandle } = setupOfflineReconnection({
+    api: opts.api,
+    sessionTag: opts.sessionTag,
+    metadata,
+    state,
+    response,
+    onSessionSwap: (newSession) => {
+      opts.onSessionSwap?.(newSession, metadata);
+      reconcileAttachedSessionMetadata(newSession);
+      void publishSessionRegistration(newSession.sessionId, metadata);
+    }
+  });
+  if (response) {
+    reconcileAttachedSessionMetadata(session);
+  }
+  if (response) {
+    await publishSessionRegistration(response.id, metadata);
+  }
+  return {
+    state,
+    metadata,
+    happyOrgStartupBinding,
+    response,
+    session,
+    reconnectionHandle
+  };
+}
+
+export { bootstrapManagedProviderSession as b };