happy-imou-cloud 1.1.7 → 2.0.1

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

@@ -1,11 +1,123 @@
 '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-B8v4tczT.cjs');
+var index = require('./index-BOqJ9hwi.cjs');
+var node_events = require('node:events');
+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) {
+  const emitter = new node_events.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: () => {
+    },
+    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: 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";
+const INTERACTION_TIMED_OUT_ERROR = "Interaction timed out waiting for user response";
+const DEFAULT_INTERACTION_TIMEOUT_MS = 2 * 60 * 1e3;
+function getPendingInteractionTimeoutMs() {
+  const raw = Number(process.env.HAPPY_INTERACTION_TIMEOUT_MS);
+  if (Number.isFinite(raw) && raw > 0) {
+    return raw;
+  }
+  return DEFAULT_INTERACTION_TIMEOUT_MS;
+}
 class BasePermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();
   session;
@@ -36,6 +148,7 @@ class BasePermissionHandler {
           return;
         }
         this.pendingRequests.delete(response.id);
+        this.clearPendingRequestTimeout(pending);
         const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
         pending.resolve(result);
         this.session.updateAgentState((currentState) => {
@@ -77,6 +190,62 @@ class BasePermissionHandler {
       }
     }));
   }
+  registerPendingRequest(toolCallId, toolName, input, logSuffix = "") {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        toolName,
+        input
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handlePendingRequestTimeout(toolCallId, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(toolCallId, pending);
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      api.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})${logSuffix}`);
+    });
+  }
+  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) {
+      this.clearPendingRequestTimeout(pending);
+      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.
@@ -92,6 +261,7 @@ class BasePermissionHandler {
       this.pendingRequests.clear();
       for (const [id, pending] of pendingSnapshot) {
         try {
+          this.clearPendingRequestTimeout(pending);
           pending.reject(new Error("Session reset"));
         } catch (err) {
           api.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
@@ -119,6 +289,50 @@ class BasePermissionHandler {
       this.isResetting = false;
     }
   }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handlePendingRequestTimeout(toolCallId, pending) {
+    const active = this.pendingRequests.get(toolCallId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(toolCallId);
+    this.clearPendingRequestTimeout(active);
+    active.resolve({ decision: "abort" });
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[toolCallId] || {
+        tool: active.toolName,
+        arguments: active.input,
+        createdAt: Date.now(),
+        requestKind: "permission"
+      };
+      const { [toolCallId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            decision: "abort",
+            requestKind: request.requestKind || "permission"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    api.logger.debug(`${this.getLogPrefix()} Permission request timed out for ${active.toolName} (${toolCallId})`);
+  }
 }
 
 class BaseReasoningProcessor {
@@ -315,93 +529,10 @@ 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.INTERACTION_TIMED_OUT_ERROR = INTERACTION_TIMED_OUT_ERROR;
 exports.createSessionMetadata = createSessionMetadata;
+exports.getPendingInteractionTimeoutMs = getPendingInteractionTimeoutMs;
 exports.setupOfflineReconnection = setupOfflineReconnection;

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

@@ -1,9 +1,121 @@
-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-B5Ui8Fw0.mjs';
+import { p as projectPath } from './index-BByhFIIq.mjs';
+import { EventEmitter } from 'node:events';
+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) {
+  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: () => {
+    },
+    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 };
+  }
+}
+
+const INTERACTION_SUPERSEDED_ERROR = "Interaction superseded by new user message";
+const INTERACTION_TIMED_OUT_ERROR = "Interaction timed out waiting for user response";
+const DEFAULT_INTERACTION_TIMEOUT_MS = 2 * 60 * 1e3;
+function getPendingInteractionTimeoutMs() {
+  const raw = Number(process.env.HAPPY_INTERACTION_TIMEOUT_MS);
+  if (Number.isFinite(raw) && raw > 0) {
+    return raw;
+  }
+  return DEFAULT_INTERACTION_TIMEOUT_MS;
+}
 class BasePermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();
   session;
@@ -34,6 +146,7 @@ class BasePermissionHandler {
           return;
         }
         this.pendingRequests.delete(response.id);
+        this.clearPendingRequestTimeout(pending);
         const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
         pending.resolve(result);
         this.session.updateAgentState((currentState) => {
@@ -75,6 +188,62 @@ class BasePermissionHandler {
       }
     }));
   }
+  registerPendingRequest(toolCallId, toolName, input, logSuffix = "") {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        toolName,
+        input
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handlePendingRequestTimeout(toolCallId, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(toolCallId, pending);
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})${logSuffix}`);
+    });
+  }
+  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) {
+      this.clearPendingRequestTimeout(pending);
+      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.
@@ -90,6 +259,7 @@ class BasePermissionHandler {
       this.pendingRequests.clear();
       for (const [id, pending] of pendingSnapshot) {
         try {
+          this.clearPendingRequestTimeout(pending);
           pending.reject(new Error("Session reset"));
         } catch (err) {
           logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
@@ -117,6 +287,50 @@ class BasePermissionHandler {
       this.isResetting = false;
     }
   }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handlePendingRequestTimeout(toolCallId, pending) {
+    const active = this.pendingRequests.get(toolCallId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(toolCallId);
+    this.clearPendingRequestTimeout(active);
+    active.resolve({ decision: "abort" });
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[toolCallId] || {
+        tool: active.toolName,
+        arguments: active.input,
+        createdAt: Date.now(),
+        requestKind: "permission"
+      };
+      const { [toolCallId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            decision: "abort",
+            requestKind: request.requestKind || "permission"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    logger.debug(`${this.getLogPrefix()} Permission request timed out for ${active.toolName} (${toolCallId})`);
+  }
 }
 
 class BaseReasoningProcessor {
@@ -313,90 +527,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, INTERACTION_TIMED_OUT_ERROR as b, createSessionMetadata as c, getPendingInteractionTimeoutMs as g, setupOfflineReconnection as s };