happy-imou-cloud 2.1.49 → 2.1.51

package/dist/{ProviderSelectionHandler-BJJc7qOR.cjs → ProviderSelectionHandler-C7GE5QjX.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var persistence = require('./api-D7nAeZi7.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-CfCya6si.cjs');
+var persistence = require('./types-CttABk32.cjs');
+var sessionControl = require('./sessionControl-flKnQrx0.cjs');
 
 async function runModeLoop(opts) {
   let currentMode = opts.startingMode;
@@ -75,7 +75,7 @@ class ProviderSelectionHandler {
       };
       pending.timeoutHandle = setTimeout(() => {
         this.handleSelectionTimeout(request.id, pending);
-      }, registerKillSessionHandler.getPendingInteractionTimeoutMs());
+      }, sessionControl.getPendingInteractionTimeoutMs());
       this.pendingRequests.set(request.id, pending);
       this.session.updateAgentState((currentState) => ({
         ...currentState,
@@ -111,7 +111,7 @@ class ProviderSelectionHandler {
   hasPendingRequests() {
     return this.pendingRequests.size > 0;
   }
-  supersedePendingRequests(reason = registerKillSessionHandler.INTERACTION_SUPERSEDED_ERROR) {
+  supersedePendingRequests(reason = sessionControl.INTERACTION_SUPERSEDED_ERROR) {
     const pendingSnapshot = Array.from(this.pendingRequests.entries());
     if (pendingSnapshot.length === 0) {
       return 0;
@@ -223,7 +223,7 @@ class ProviderSelectionHandler {
     }
     this.pendingRequests.delete(requestId);
     this.clearPendingRequestTimeout(active);
-    active.reject(new Error(registerKillSessionHandler.INTERACTION_TIMED_OUT_ERROR));
+    active.reject(new Error(sessionControl.INTERACTION_TIMED_OUT_ERROR));
     this.session.updateAgentState((currentState) => {
       const request = currentState.requests?.[requestId] || {
         tool: "AskUserQuestion",
@@ -246,7 +246,7 @@ class ProviderSelectionHandler {
             ...request,
             completedAt: Date.now(),
             status: "canceled",
-            reason: registerKillSessionHandler.INTERACTION_TIMED_OUT_ERROR,
+            reason: sessionControl.INTERACTION_TIMED_OUT_ERROR,
             requestKind: "selection"
           }
         }

package/dist/{ProviderSelectionHandler-DIYidT13.mjs → ProviderSelectionHandler-uQ8jzdzr.mjs}

@@ -1,5 +1,5 @@
-import { l as logger } from './api-DnqaNvyV.mjs';
-import { g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, a as INTERACTION_TIMED_OUT_ERROR } from './registerKillSessionHandler-DLDg2EES.mjs';
+import { l as logger } from './types-B5vtxa38.mjs';
+import { g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, a as INTERACTION_TIMED_OUT_ERROR } from './sessionControl-1bT_7OI6.mjs';
 
 async function runModeLoop(opts) {
   let currentMode = opts.startingMode;

package/dist/RuntimeShell-BDt42io_.mjs

@@ -0,0 +1,252 @@
+import 'cross-spawn';
+import '@agentclientprotocol/sdk';
+import 'node:crypto';
+import './types-B5vtxa38.mjs';
+import './index-CX-F_fuk.mjs';
+import 'ps-list';
+import 'fs';
+import 'path';
+import 'os';
+import 'child_process';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'node:child_process';
+import 'node:readline';
+
+class AgentRegistry {
+  factories = /* @__PURE__ */ new Map();
+  /**
+   * Register a factory function for an agent type.
+   * 
+   * @param id - The agent identifier
+   * @param factory - Factory function to create the backend
+   */
+  register(id, factory) {
+    this.factories.set(id, factory);
+  }
+  /**
+   * Check if an agent type is registered.
+   * 
+   * @param id - The agent identifier to check
+   * @returns true if the agent is registered
+   */
+  has(id) {
+    return this.factories.has(id);
+  }
+  /**
+   * Get the list of registered agent identifiers.
+   * 
+   * @returns Array of registered agent IDs
+   */
+  list() {
+    return Array.from(this.factories.keys());
+  }
+  /**
+   * Create an agent backend instance.
+   * 
+   * @param id - The agent identifier
+   * @param opts - Options for creating the backend
+   * @returns The created agent backend
+   * @throws Error if the agent type is not registered
+   */
+  create(id, opts) {
+    const factory = this.factories.get(id);
+    if (!factory) {
+      const available = this.list().join(", ") || "none";
+      throw new Error(`Unknown agent: ${id}. Available agents: ${available}`);
+    }
+    return factory(opts);
+  }
+}
+const agentRegistry = new AgentRegistry();
+
+const PREFERRED_MESSAGE_FIELDS = ["stderr", "error", "message", "detail", "stdout", "text", "reason"];
+function safeSerializeDisplayValue(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    const serialized = JSON.stringify(value, (_key, currentValue) => {
+      if (typeof currentValue === "bigint") {
+        return currentValue.toString();
+      }
+      if (currentValue instanceof Error) {
+        return {
+          name: currentValue.name,
+          message: currentValue.message,
+          stack: currentValue.stack
+        };
+      }
+      if (typeof currentValue === "object" && currentValue !== null) {
+        if (seen.has(currentValue)) {
+          return "[Circular]";
+        }
+        seen.add(currentValue);
+      }
+      return currentValue;
+    });
+    return serialized ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatDisplayMessage(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.message || String(value);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const record = value;
+    for (const field of PREFERRED_MESSAGE_FIELDS) {
+      if (!(field in record)) {
+        continue;
+      }
+      const formattedField = formatDisplayMessage(record[field], seen).trim();
+      if (formattedField.length > 0) {
+        return formattedField;
+      }
+    }
+    return safeSerializeDisplayValue(value);
+  }
+  return String(value);
+}
+function truncateDisplayMessage(value, maxLength) {
+  const formatted = formatDisplayMessage(value);
+  if (formatted.length <= maxLength) {
+    return formatted;
+  }
+  return `${formatted.substring(0, maxLength)}...`;
+}
+
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasOnlyAllowedKeys(record, allowedKeys) {
+  return Object.keys(record).every((key) => allowedKeys.includes(key));
+}
+function isTerminalReferenceItem(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const hasTerminalId = typeof value.terminalId === "string" && value.terminalId.length > 0 || typeof value.terminal_id === "string" && value.terminal_id.length > 0;
+  return hasTerminalId && value.type === "terminal" && hasOnlyAllowedKeys(value, ["terminalId", "terminal_id", "type", "id"]);
+}
+function isTerminalReferenceOnlyPayload(value) {
+  if (Array.isArray(value)) {
+    return value.length > 0 && value.every((entry) => isTerminalReferenceOnlyPayload(entry));
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (isTerminalReferenceItem(value)) {
+    return true;
+  }
+  const items = Array.isArray(value.items) ? value.items : null;
+  if (items && items.length > 0 && items.every((entry) => isTerminalReferenceOnlyPayload(entry)) && hasOnlyAllowedKeys(value, ["items", "type"])) {
+    return true;
+  }
+  const content = "content" in value ? value.content : void 0;
+  if (content !== void 0 && isTerminalReferenceOnlyPayload(content) && hasOnlyAllowedKeys(value, ["content", "type"])) {
+    return true;
+  }
+  return false;
+}
+
+class InMemoryRuntimeEventBuffer {
+  events = [];
+  maxEvents;
+  constructor(maxEvents = 64) {
+    this.maxEvents = Math.max(1, maxEvents);
+  }
+  push(event) {
+    this.events.push(event);
+    while (this.events.length > this.maxEvents) {
+      this.events.shift();
+    }
+  }
+  drain() {
+    return this.events.splice(0, this.events.length);
+  }
+}
+class RuntimeShell {
+  registry;
+  constructor(registry = agentRegistry) {
+    this.registry = registry;
+  }
+  supports(provider) {
+    return this.registry.has(provider);
+  }
+  async launch(opts) {
+    if (!opts.createBackend && !this.registry.has(opts.provider)) {
+      throw new Error(`Runtime provider "${opts.provider}" is not registered`);
+    }
+    const backendFactory = opts.createBackend ?? ((factoryOpts) => this.registry.create(opts.provider, factoryOpts));
+    const backend = backendFactory({
+      cwd: opts.cwd,
+      env: opts.env
+    });
+    const handlers = /* @__PURE__ */ new Set();
+    const eventBuffer = new InMemoryRuntimeEventBuffer();
+    const fanout = (message) => {
+      if (handlers.size === 0) {
+        eventBuffer.push(message);
+      }
+      for (const handler of handlers) {
+        handler(message);
+      }
+    };
+    backend.onMessage(fanout);
+    const started = await backend.startSession(opts.initialPrompt);
+    return {
+      provider: opts.provider,
+      backend,
+      sessionId: started.sessionId,
+      sendPrompt: async (prompt) => {
+        await backend.sendPrompt(started.sessionId, prompt);
+      },
+      cancel: async () => {
+        await backend.cancel(started.sessionId);
+      },
+      respondToPermission: async (requestId, approved) => {
+        if (!backend.respondToPermission) {
+          throw new Error(`Runtime provider "${opts.provider}" does not support permission responses`);
+        }
+        await backend.respondToPermission(requestId, approved);
+      },
+      waitForResponseComplete: async (timeoutMs) => {
+        if (!backend.waitForResponseComplete) {
+          return;
+        }
+        await backend.waitForResponseComplete(timeoutMs);
+      },
+      dispose: async () => {
+        await backend.dispose();
+      },
+      onMessage: (handler) => {
+        for (const buffered of eventBuffer.drain()) {
+          handler(buffered);
+        }
+        handlers.add(handler);
+        return () => {
+          handlers.delete(handler);
+        };
+      }
+    };
+  }
+}
+
+export { RuntimeShell as R, agentRegistry as a, formatDisplayMessage as f, isTerminalReferenceOnlyPayload as i, truncateDisplayMessage as t };

package/dist/RuntimeShell-D_Te12wq.cjs

@@ -0,0 +1,258 @@
+'use strict';
+
+require('cross-spawn');
+require('@agentclientprotocol/sdk');
+require('node:crypto');
+require('./types-CttABk32.cjs');
+require('./index-B_JYgMUS.cjs');
+require('ps-list');
+require('fs');
+require('path');
+require('os');
+require('child_process');
+require('node:fs');
+require('node:path');
+require('node:os');
+require('node:child_process');
+require('node:readline');
+
+class AgentRegistry {
+  factories = /* @__PURE__ */ new Map();
+  /**
+   * Register a factory function for an agent type.
+   * 
+   * @param id - The agent identifier
+   * @param factory - Factory function to create the backend
+   */
+  register(id, factory) {
+    this.factories.set(id, factory);
+  }
+  /**
+   * Check if an agent type is registered.
+   * 
+   * @param id - The agent identifier to check
+   * @returns true if the agent is registered
+   */
+  has(id) {
+    return this.factories.has(id);
+  }
+  /**
+   * Get the list of registered agent identifiers.
+   * 
+   * @returns Array of registered agent IDs
+   */
+  list() {
+    return Array.from(this.factories.keys());
+  }
+  /**
+   * Create an agent backend instance.
+   * 
+   * @param id - The agent identifier
+   * @param opts - Options for creating the backend
+   * @returns The created agent backend
+   * @throws Error if the agent type is not registered
+   */
+  create(id, opts) {
+    const factory = this.factories.get(id);
+    if (!factory) {
+      const available = this.list().join(", ") || "none";
+      throw new Error(`Unknown agent: ${id}. Available agents: ${available}`);
+    }
+    return factory(opts);
+  }
+}
+const agentRegistry = new AgentRegistry();
+
+const PREFERRED_MESSAGE_FIELDS = ["stderr", "error", "message", "detail", "stdout", "text", "reason"];
+function safeSerializeDisplayValue(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    const serialized = JSON.stringify(value, (_key, currentValue) => {
+      if (typeof currentValue === "bigint") {
+        return currentValue.toString();
+      }
+      if (currentValue instanceof Error) {
+        return {
+          name: currentValue.name,
+          message: currentValue.message,
+          stack: currentValue.stack
+        };
+      }
+      if (typeof currentValue === "object" && currentValue !== null) {
+        if (seen.has(currentValue)) {
+          return "[Circular]";
+        }
+        seen.add(currentValue);
+      }
+      return currentValue;
+    });
+    return serialized ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatDisplayMessage(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.message || String(value);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const record = value;
+    for (const field of PREFERRED_MESSAGE_FIELDS) {
+      if (!(field in record)) {
+        continue;
+      }
+      const formattedField = formatDisplayMessage(record[field], seen).trim();
+      if (formattedField.length > 0) {
+        return formattedField;
+      }
+    }
+    return safeSerializeDisplayValue(value);
+  }
+  return String(value);
+}
+function truncateDisplayMessage(value, maxLength) {
+  const formatted = formatDisplayMessage(value);
+  if (formatted.length <= maxLength) {
+    return formatted;
+  }
+  return `${formatted.substring(0, maxLength)}...`;
+}
+
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasOnlyAllowedKeys(record, allowedKeys) {
+  return Object.keys(record).every((key) => allowedKeys.includes(key));
+}
+function isTerminalReferenceItem(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const hasTerminalId = typeof value.terminalId === "string" && value.terminalId.length > 0 || typeof value.terminal_id === "string" && value.terminal_id.length > 0;
+  return hasTerminalId && value.type === "terminal" && hasOnlyAllowedKeys(value, ["terminalId", "terminal_id", "type", "id"]);
+}
+function isTerminalReferenceOnlyPayload(value) {
+  if (Array.isArray(value)) {
+    return value.length > 0 && value.every((entry) => isTerminalReferenceOnlyPayload(entry));
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (isTerminalReferenceItem(value)) {
+    return true;
+  }
+  const items = Array.isArray(value.items) ? value.items : null;
+  if (items && items.length > 0 && items.every((entry) => isTerminalReferenceOnlyPayload(entry)) && hasOnlyAllowedKeys(value, ["items", "type"])) {
+    return true;
+  }
+  const content = "content" in value ? value.content : void 0;
+  if (content !== void 0 && isTerminalReferenceOnlyPayload(content) && hasOnlyAllowedKeys(value, ["content", "type"])) {
+    return true;
+  }
+  return false;
+}
+
+class InMemoryRuntimeEventBuffer {
+  events = [];
+  maxEvents;
+  constructor(maxEvents = 64) {
+    this.maxEvents = Math.max(1, maxEvents);
+  }
+  push(event) {
+    this.events.push(event);
+    while (this.events.length > this.maxEvents) {
+      this.events.shift();
+    }
+  }
+  drain() {
+    return this.events.splice(0, this.events.length);
+  }
+}
+class RuntimeShell {
+  registry;
+  constructor(registry = agentRegistry) {
+    this.registry = registry;
+  }
+  supports(provider) {
+    return this.registry.has(provider);
+  }
+  async launch(opts) {
+    if (!opts.createBackend && !this.registry.has(opts.provider)) {
+      throw new Error(`Runtime provider "${opts.provider}" is not registered`);
+    }
+    const backendFactory = opts.createBackend ?? ((factoryOpts) => this.registry.create(opts.provider, factoryOpts));
+    const backend = backendFactory({
+      cwd: opts.cwd,
+      env: opts.env
+    });
+    const handlers = /* @__PURE__ */ new Set();
+    const eventBuffer = new InMemoryRuntimeEventBuffer();
+    const fanout = (message) => {
+      if (handlers.size === 0) {
+        eventBuffer.push(message);
+      }
+      for (const handler of handlers) {
+        handler(message);
+      }
+    };
+    backend.onMessage(fanout);
+    const started = await backend.startSession(opts.initialPrompt);
+    return {
+      provider: opts.provider,
+      backend,
+      sessionId: started.sessionId,
+      sendPrompt: async (prompt) => {
+        await backend.sendPrompt(started.sessionId, prompt);
+      },
+      cancel: async () => {
+        await backend.cancel(started.sessionId);
+      },
+      respondToPermission: async (requestId, approved) => {
+        if (!backend.respondToPermission) {
+          throw new Error(`Runtime provider "${opts.provider}" does not support permission responses`);
+        }
+        await backend.respondToPermission(requestId, approved);
+      },
+      waitForResponseComplete: async (timeoutMs) => {
+        if (!backend.waitForResponseComplete) {
+          return;
+        }
+        await backend.waitForResponseComplete(timeoutMs);
+      },
+      dispose: async () => {
+        await backend.dispose();
+      },
+      onMessage: (handler) => {
+        for (const buffered of eventBuffer.drain()) {
+          handler(buffered);
+        }
+        handlers.add(handler);
+        return () => {
+          handlers.delete(handler);
+        };
+      }
+    };
+  }
+}
+
+exports.RuntimeShell = RuntimeShell;
+exports.agentRegistry = agentRegistry;
+exports.formatDisplayMessage = formatDisplayMessage;
+exports.isTerminalReferenceOnlyPayload = isTerminalReferenceOnlyPayload;
+exports.truncateDisplayMessage = truncateDisplayMessage;

package/dist/bootstrapManagedProviderSession-Bln-TwyB.cjs

@@ -0,0 +1,147 @@
+'use strict';
+
+var index = require('./index-B_JYgMUS.cjs');
+var persistence = require('./types-CttABk32.cjs');
+var node_events = require('node:events');
+
+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: () => {
+    },
+    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 = persistence.startOfflineReconnection({
+      serverUrl: persistence.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 } = index.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) {
+      persistence.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 (!persistence.isAuthenticationRequiredError(error)) {
+      throw error;
+    }
+    persistence.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 index.publishSessionRegistration(newSession.sessionId, metadata);
+    }
+  });
+  if (response) {
+    reconcileAttachedSessionMetadata(session);
+  }
+  if (response) {
+    await index.publishSessionRegistration(response.id, metadata);
+  }
+  return {
+    state,
+    metadata,
+    happyOrgStartupBinding,
+    response,
+    session,
+    reconnectionHandle
+  };
+}
+
+exports.bootstrapManagedProviderSession = bootstrapManagedProviderSession;