happy-imou-cloud 1.1.7 → 2.0.0

package/dist/{setupOfflineReconnection-ndObLZk0.mjs → BaseReasoningProcessor-BKLRCKTU.mjs}

@@ -1,9 +1,99 @@
-import { l as logger, c as configuration, p as packageJson, s as startOfflineReconnection } from './types-BXyraW9R.mjs';
-import { randomUUID } from 'node:crypto';
 import os from 'node:os';
 import { resolve } from 'node:path';
-import { p as projectPath } from './index-CUmYqKWt.mjs';
+import { c as configuration, p as packageJson, s as startOfflineReconnection, l as logger } from './api-BGXYX0yH.mjs';
+import { p as projectPath } from './index-C7Y0R-MI.mjs';
+import { randomUUID } from 'node:crypto';
+
+function createSessionMetadata(opts) {
+  const state = {
+    controlledByUser: false
+  };
+  const metadata = {
+    path: process.cwd(),
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId: opts.machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.happyCloudHomeDir,
+    happyLibDir: projectPath(),
+    happyToolsDir: resolve(projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: opts.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: opts.flavor
+  };
+  return { state, metadata };
+}
+
+function createOfflineSessionStub(sessionTag) {
+  return {
+    sessionId: `offline-${sessionTag}`,
+    sendCodexMessage: () => {
+    },
+    sendAgentMessage: () => {
+    },
+    sendClaudeSessionMessage: () => {
+    },
+    keepAlive: () => {
+    },
+    sendSessionEvent: () => {
+    },
+    sendSessionDeath: () => {
+    },
+    updateLifecycleState: () => {
+    },
+    requestControlTransfer: async () => {
+    },
+    flush: async () => {
+    },
+    close: async () => {
+    },
+    updateMetadata: () => {
+    },
+    updateAgentState: () => {
+    },
+    getMetadataSnapshot: () => null,
+    getAgentStateSnapshot: () => null,
+    waitForMetadataUpdate: async () => null,
+    onUserMessage: () => {
+    },
+    rpcHandlerManager: {
+      registerHandler: () => {
+      }
+    }
+  };
+}
+
+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 };
+  }
+}
 
+const INTERACTION_SUPERSEDED_ERROR = "Interaction superseded by new user message";
 class BasePermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();
   session;
@@ -75,6 +165,45 @@ class BasePermissionHandler {
       }
     }));
   }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
+  }
+  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
+    }
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      pending.resolve({ decision: "abort" });
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind === "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "denied",
+          reason,
+          decision: "abort",
+          requestKind: request.requestKind || "permission"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    logger.debug(`${this.getLogPrefix()} Superseded ${pendingSnapshot.length} pending permission request(s)`);
+    return pendingSnapshot.length;
+  }
   /**
    * Reset state for new sessions.
    * This method is idempotent - safe to call multiple times.
@@ -313,90 +442,4 @@ class BaseReasoningProcessor {
   }
 }
 
-function createSessionMetadata(opts) {
-  const state = {
-    controlledByUser: false
-  };
-  const metadata = {
-    path: process.cwd(),
-    host: os.hostname(),
-    version: packageJson.version,
-    os: os.platform(),
-    machineId: opts.machineId,
-    homeDir: os.homedir(),
-    happyHomeDir: configuration.happyCloudHomeDir,
-    happyLibDir: projectPath(),
-    happyToolsDir: resolve(projectPath(), "tools", "unpacked"),
-    startedFromDaemon: opts.startedBy === "daemon",
-    hostPid: process.pid,
-    startedBy: opts.startedBy || "terminal",
-    lifecycleState: "running",
-    lifecycleStateSince: Date.now(),
-    flavor: opts.flavor
-  };
-  return { state, metadata };
-}
-
-function createOfflineSessionStub(sessionTag) {
-  return {
-    sessionId: `offline-${sessionTag}`,
-    sendCodexMessage: () => {
-    },
-    sendAgentMessage: () => {
-    },
-    sendClaudeSessionMessage: () => {
-    },
-    keepAlive: () => {
-    },
-    sendSessionEvent: () => {
-    },
-    sendSessionDeath: () => {
-    },
-    updateLifecycleState: () => {
-    },
-    requestControlTransfer: async () => {
-    },
-    flush: async () => {
-    },
-    close: async () => {
-    },
-    updateMetadata: () => {
-    },
-    updateAgentState: () => {
-    },
-    onUserMessage: () => {
-    },
-    rpcHandlerManager: {
-      registerHandler: () => {
-      }
-    }
-  };
-}
-
-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 };
-  }
-}
-
-export { BasePermissionHandler as B, BaseReasoningProcessor as a, createSessionMetadata as c, setupOfflineReconnection as s };
+export { BasePermissionHandler as B, INTERACTION_SUPERSEDED_ERROR as I, BaseReasoningProcessor as a, createSessionMetadata as c, setupOfflineReconnection as s };

package/dist/{setupOfflineReconnection-obypStdD.cjs → BaseReasoningProcessor-BRCQXCZY.cjs}

@@ -1,11 +1,101 @@
 'use strict';
 
-var api = require('./types-BSTmyv9d.cjs');
-var node_crypto = require('node:crypto');
 var os = require('node:os');
-var node_path = require('node:path');
-var index = require('./index-DVI4b0mv.cjs');
+var path = require('node:path');
+var api = require('./api-D7OK-mML.cjs');
+var index = require('./index-B_wlQBy2.cjs');
+var node_crypto = require('node:crypto');
+
+function createSessionMetadata(opts) {
+  const state = {
+    controlledByUser: false
+  };
+  const metadata = {
+    path: process.cwd(),
+    host: os.hostname(),
+    version: api.packageJson.version,
+    os: os.platform(),
+    machineId: opts.machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: api.configuration.happyCloudHomeDir,
+    happyLibDir: index.projectPath(),
+    happyToolsDir: path.resolve(index.projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: opts.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: opts.flavor
+  };
+  return { state, metadata };
+}
 
+function createOfflineSessionStub(sessionTag) {
+  return {
+    sessionId: `offline-${sessionTag}`,
+    sendCodexMessage: () => {
+    },
+    sendAgentMessage: () => {
+    },
+    sendClaudeSessionMessage: () => {
+    },
+    keepAlive: () => {
+    },
+    sendSessionEvent: () => {
+    },
+    sendSessionDeath: () => {
+    },
+    updateLifecycleState: () => {
+    },
+    requestControlTransfer: async () => {
+    },
+    flush: async () => {
+    },
+    close: async () => {
+    },
+    updateMetadata: () => {
+    },
+    updateAgentState: () => {
+    },
+    getMetadataSnapshot: () => null,
+    getAgentStateSnapshot: () => null,
+    waitForMetadataUpdate: async () => null,
+    onUserMessage: () => {
+    },
+    rpcHandlerManager: {
+      registerHandler: () => {
+      }
+    }
+  };
+}
+
+function setupOfflineReconnection(opts) {
+  const { api: api$1, sessionTag, metadata, state, response, onSessionSwap } = opts;
+  let session;
+  let reconnectionHandle = null;
+  if (!response) {
+    session = createOfflineSessionStub(sessionTag);
+    reconnectionHandle = api.startOfflineReconnection({
+      serverUrl: api.configuration.serverUrl,
+      onReconnected: async () => {
+        const resp = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+        if (!resp) throw new Error("Server unavailable");
+        const realSession = api$1.sessionSyncClient(resp);
+        onSessionSwap(realSession);
+        return realSession;
+      },
+      onNotify: (msg) => {
+        console.log(msg);
+      }
+    });
+    return { session, reconnectionHandle, isOffline: true };
+  } else {
+    session = api$1.sessionSyncClient(response);
+    return { session, reconnectionHandle: null, isOffline: false };
+  }
+}
+
+const INTERACTION_SUPERSEDED_ERROR = "Interaction superseded by new user message";
 class BasePermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();
   session;
@@ -77,6 +167,45 @@ class BasePermissionHandler {
       }
     }));
   }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
+  }
+  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
+    }
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      pending.resolve({ decision: "abort" });
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind === "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "denied",
+          reason,
+          decision: "abort",
+          requestKind: request.requestKind || "permission"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    api.logger.debug(`${this.getLogPrefix()} Superseded ${pendingSnapshot.length} pending permission request(s)`);
+    return pendingSnapshot.length;
+  }
   /**
    * Reset state for new sessions.
    * This method is idempotent - safe to call multiple times.
@@ -315,93 +444,8 @@ class BaseReasoningProcessor {
   }
 }
 
-function createSessionMetadata(opts) {
-  const state = {
-    controlledByUser: false
-  };
-  const metadata = {
-    path: process.cwd(),
-    host: os.hostname(),
-    version: api.packageJson.version,
-    os: os.platform(),
-    machineId: opts.machineId,
-    homeDir: os.homedir(),
-    happyHomeDir: api.configuration.happyCloudHomeDir,
-    happyLibDir: index.projectPath(),
-    happyToolsDir: node_path.resolve(index.projectPath(), "tools", "unpacked"),
-    startedFromDaemon: opts.startedBy === "daemon",
-    hostPid: process.pid,
-    startedBy: opts.startedBy || "terminal",
-    lifecycleState: "running",
-    lifecycleStateSince: Date.now(),
-    flavor: opts.flavor
-  };
-  return { state, metadata };
-}
-
-function createOfflineSessionStub(sessionTag) {
-  return {
-    sessionId: `offline-${sessionTag}`,
-    sendCodexMessage: () => {
-    },
-    sendAgentMessage: () => {
-    },
-    sendClaudeSessionMessage: () => {
-    },
-    keepAlive: () => {
-    },
-    sendSessionEvent: () => {
-    },
-    sendSessionDeath: () => {
-    },
-    updateLifecycleState: () => {
-    },
-    requestControlTransfer: async () => {
-    },
-    flush: async () => {
-    },
-    close: async () => {
-    },
-    updateMetadata: () => {
-    },
-    updateAgentState: () => {
-    },
-    onUserMessage: () => {
-    },
-    rpcHandlerManager: {
-      registerHandler: () => {
-      }
-    }
-  };
-}
-
-function setupOfflineReconnection(opts) {
-  const { api: api$1, sessionTag, metadata, state, response, onSessionSwap } = opts;
-  let session;
-  let reconnectionHandle = null;
-  if (!response) {
-    session = createOfflineSessionStub(sessionTag);
-    reconnectionHandle = api.startOfflineReconnection({
-      serverUrl: api.configuration.serverUrl,
-      onReconnected: async () => {
-        const resp = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
-        if (!resp) throw new Error("Server unavailable");
-        const realSession = api$1.sessionSyncClient(resp);
-        onSessionSwap(realSession);
-        return realSession;
-      },
-      onNotify: (msg) => {
-        console.log(msg);
-      }
-    });
-    return { session, reconnectionHandle, isOffline: true };
-  } else {
-    session = api$1.sessionSyncClient(response);
-    return { session, reconnectionHandle: null, isOffline: false };
-  }
-}
-
 exports.BasePermissionHandler = BasePermissionHandler;
 exports.BaseReasoningProcessor = BaseReasoningProcessor;
+exports.INTERACTION_SUPERSEDED_ERROR = INTERACTION_SUPERSEDED_ERROR;
 exports.createSessionMetadata = createSessionMetadata;
 exports.setupOfflineReconnection = setupOfflineReconnection;