happy-imou-cloud 2.0.10 → 2.0.11

package/scripts/release-smoke.mjs

@@ -165,6 +165,8 @@ function main() {
   runToolStep('typecheck', tsc, ['--noEmit']);
   runToolStep('unit runtime suite', vitest, [
     'run',
+    '--testTimeout',
+    '20000',
     'src/agent/acp/AcpBackend.test.ts',
     'src/agent/acp/AcpBackend.startup.test.ts',
     'src/agent/acp/AcpBackend.waitForResponseComplete.test.ts',
@@ -172,12 +174,27 @@ function main() {
     'src/agent/acp/acpSpawn.test.ts',
     'src/agent/acp/createAcpFilteredStdoutReadable.multiline.test.ts',
     'src/agent/acp/killProcessTree.test.ts',
-    'src/runtime/executeProvider.test.ts',
-    'src/runtime/command.test.ts',
-    'src/runtime/launch.test.ts',
-    'src/runtime/RuntimeShell.test.ts',
-    'src/runtime/createDefaultRuntimeShell.test.ts',
-    'src/security/signedTransport.test.ts',
+  'src/runtime/executeProvider.test.ts',
+  'src/runtime/ensureManagedProviderMachine.test.ts',
+  'src/runtime/bootstrapManagedProviderSession.test.ts',
+  'src/runtime/command.test.ts',
+  'src/runtime/launch.test.ts',
+  'src/runtime/launchWithFactoryResult.test.ts',
+    'src/runtime/providerMessageBridge.test.ts',
+    'src/runtime/runModeLoop.test.ts',
+    'src/runtime/createKeepAliveController.test.ts',
+    'src/runtime/sessionControl.test.ts',
+    'src/runtime/closeProviderSession.test.ts',
+    'src/runtime/waitForResponseCompleteWithAbort.test.ts',
+    'src/utils/ConversationHistory.test.ts',
+    'src/runtime/RuntimeShell.test.ts',
+    'src/runtime/createDefaultRuntimeShell.test.ts',
+    'src/claude/loop.test.ts',
+    'src/claude/claudeAcpRemoteLauncher.test.ts',
+    'src/claude/utils/acpPermissionHandler.test.ts',
+    'src/codex/__tests__/runCodex.lifecycle.test.ts',
+    'src/codex/__tests__/selectionHandler.test.ts',
+    'src/security/signedTransport.test.ts',
     'src/agent/initializeAgents.test.ts',
     'src/agent/factories/factories.test.ts',
     'src/packageContract.test.ts',

package/dist/names-CicSgRNg.mjs

@@ -1,625 +0,0 @@
-import os from 'node:os';
-import { resolve } from 'node:path';
-import { c as configuration, p as packageJson, s as startOfflineReconnection, l as logger } from './api-BjxmW-0W.mjs';
-import { d as projectPath } from './index-CzvgPwr1.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;
-  isResetting = false;
-  constructor(session) {
-    this.session = session;
-    this.setupRpcHandler();
-  }
-  /**
-   * Update the session reference (used after offline reconnection swaps sessions).
-   * This is critical for avoiding stale session references after onSessionSwap.
-   */
-  updateSession(newSession) {
-    logger.debug(`${this.getLogPrefix()} Session reference updated`);
-    this.session = newSession;
-    this.setupRpcHandler();
-  }
-  /**
-   * Setup RPC handler for permission responses.
-   */
-  setupRpcHandler() {
-    this.session.rpcHandlerManager.registerHandler(
-      "permission",
-      async (response) => {
-        const pending = this.pendingRequests.get(response.id);
-        if (!pending) {
-          logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
-          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) => {
-          const request = currentState.requests?.[response.id];
-          if (!request) return currentState;
-          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
-          let res = {
-            ...currentState,
-            requests: remainingRequests,
-            completedRequests: {
-              ...currentState.completedRequests,
-              [response.id]: {
-                ...request,
-                completedAt: Date.now(),
-                status: response.approved ? "approved" : "denied",
-                decision: result.decision
-              }
-            }
-          };
-          return res;
-        });
-        logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
-      }
-    );
-  }
-  /**
-   * Add a pending request to the agent state.
-   */
-  addPendingRequestToState(toolCallId, toolName, input) {
-    this.session.updateAgentState((currentState) => ({
-      ...currentState,
-      requests: {
-        ...currentState.requests,
-        [toolCallId]: {
-          tool: toolName,
-          arguments: input,
-          createdAt: Date.now()
-        }
-      }
-    }));
-  }
-  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.
-   */
-  reset() {
-    if (this.isResetting) {
-      logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
-      return;
-    }
-    this.isResetting = true;
-    try {
-      const pendingSnapshot = Array.from(this.pendingRequests.entries());
-      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);
-        }
-      }
-      this.session.updateAgentState((currentState) => {
-        const pendingRequests = currentState.requests || {};
-        const completedRequests = { ...currentState.completedRequests };
-        for (const [id, request] of Object.entries(pendingRequests)) {
-          completedRequests[id] = {
-            ...request,
-            completedAt: Date.now(),
-            status: "canceled",
-            reason: "Session reset"
-          };
-        }
-        return {
-          ...currentState,
-          requests: {},
-          completedRequests
-        };
-      });
-      logger.debug(`${this.getLogPrefix()} Permission handler reset`);
-    } finally {
-      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 {
-  accumulator = "";
-  inTitleCapture = false;
-  titleBuffer = "";
-  contentBuffer = "";
-  hasTitle = false;
-  currentCallId = null;
-  toolCallStarted = false;
-  currentTitle = null;
-  onMessage = null;
-  constructor(onMessage) {
-    this.onMessage = onMessage || null;
-    this.reset();
-  }
-  /**
-   * Set the message callback for sending messages directly.
-   */
-  setMessageCallback(callback) {
-    this.onMessage = callback;
-  }
-  /**
-   * Process a reasoning section break - indicates a new reasoning section is starting.
-   */
-  handleSectionBreak() {
-    this.finishCurrentToolCall("canceled");
-    this.resetState();
-    logger.debug(`${this.getLogPrefix()} Section break - reset state`);
-  }
-  /**
-   * Process a reasoning delta/chunk and accumulate content.
-   */
-  processInput(input) {
-    this.accumulator += input;
-    if (!this.inTitleCapture && !this.hasTitle && !this.contentBuffer) {
-      if (this.accumulator.startsWith("**")) {
-        this.inTitleCapture = true;
-        this.titleBuffer = this.accumulator.substring(2);
-        logger.debug(`${this.getLogPrefix()} Started title capture`);
-      } else if (this.accumulator.length > 0) {
-        this.contentBuffer = this.accumulator;
-      }
-    } else if (this.inTitleCapture) {
-      this.titleBuffer = this.accumulator.substring(2);
-      const titleEndIndex = this.titleBuffer.indexOf("**");
-      if (titleEndIndex !== -1) {
-        const title = this.titleBuffer.substring(0, titleEndIndex);
-        const afterTitle = this.titleBuffer.substring(titleEndIndex + 2);
-        this.hasTitle = true;
-        this.inTitleCapture = false;
-        this.currentTitle = title;
-        this.contentBuffer = afterTitle;
-        this.currentCallId = randomUUID();
-        logger.debug(`${this.getLogPrefix()} Title captured: "${title}"`);
-        this.sendToolCallStart(title);
-      }
-    } else if (this.hasTitle) {
-      const titleStartIndex = this.accumulator.indexOf("**");
-      if (titleStartIndex !== -1) {
-        this.contentBuffer = this.accumulator.substring(
-          titleStartIndex + 2 + this.currentTitle.length + 2
-        );
-      }
-    } else {
-      this.contentBuffer = this.accumulator;
-    }
-  }
-  /**
-   * Send the tool call start message.
-   */
-  sendToolCallStart(title) {
-    if (!this.currentCallId || this.toolCallStarted) {
-      return;
-    }
-    const toolCall = {
-      type: "tool-call",
-      name: this.getToolName(),
-      callId: this.currentCallId,
-      input: {
-        title
-      },
-      id: randomUUID()
-    };
-    logger.debug(`${this.getLogPrefix()} Sending tool call start for: "${title}"`);
-    this.onMessage?.(toolCall);
-    this.toolCallStarted = true;
-  }
-  /**
-   * Complete the reasoning section.
-   * Returns true if reasoning was completed, false if there was nothing to complete.
-   */
-  completeReasoning(fullText) {
-    const text = fullText ?? this.accumulator;
-    if (!text.trim() && !this.toolCallStarted) {
-      logger.debug(`${this.getLogPrefix()} Complete called but no content accumulated, skipping`);
-      return false;
-    }
-    let title;
-    let content = text;
-    if (text.startsWith("**")) {
-      const titleEndIndex = text.indexOf("**", 2);
-      if (titleEndIndex !== -1) {
-        title = text.substring(2, titleEndIndex);
-        content = text.substring(titleEndIndex + 2).trim();
-      }
-    }
-    logger.debug(`${this.getLogPrefix()} Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
-    if (title && !this.toolCallStarted) {
-      this.currentCallId = this.currentCallId || randomUUID();
-      this.sendToolCallStart(title);
-    }
-    if (this.toolCallStarted && this.currentCallId) {
-      const toolResult = {
-        type: "tool-call-result",
-        callId: this.currentCallId,
-        output: {
-          content,
-          status: "completed"
-        },
-        id: randomUUID()
-      };
-      logger.debug(`${this.getLogPrefix()} Sending tool call result`);
-      this.onMessage?.(toolResult);
-    } else if (content.trim()) {
-      const reasoningMessage = {
-        type: "reasoning",
-        message: content,
-        id: randomUUID()
-      };
-      logger.debug(`${this.getLogPrefix()} Sending reasoning message`);
-      this.onMessage?.(reasoningMessage);
-    }
-    this.resetState();
-    return true;
-  }
-  /**
-   * Abort the current reasoning section.
-   */
-  abort() {
-    logger.debug(`${this.getLogPrefix()} Abort called`);
-    this.finishCurrentToolCall("canceled");
-    this.resetState();
-  }
-  /**
-   * Reset the processor state.
-   */
-  reset() {
-    this.finishCurrentToolCall("canceled");
-    this.resetState();
-  }
-  /**
-   * Finish current tool call if one is in progress.
-   */
-  finishCurrentToolCall(status) {
-    if (this.toolCallStarted && this.currentCallId) {
-      const toolResult = {
-        type: "tool-call-result",
-        callId: this.currentCallId,
-        output: {
-          content: this.contentBuffer || "",
-          status
-        },
-        id: randomUUID()
-      };
-      logger.debug(`${this.getLogPrefix()} Sending tool call result with status: ${status}`);
-      this.onMessage?.(toolResult);
-    }
-  }
-  /**
-   * Reset internal state.
-   */
-  resetState() {
-    this.accumulator = "";
-    this.inTitleCapture = false;
-    this.titleBuffer = "";
-    this.contentBuffer = "";
-    this.hasTitle = false;
-    this.currentCallId = null;
-    this.toolCallStarted = false;
-    this.currentTitle = null;
-  }
-  /**
-   * Get the current call ID for tool result matching.
-   */
-  getCurrentCallId() {
-    return this.currentCallId;
-  }
-  /**
-   * Check if a tool call has been started.
-   */
-  hasStartedToolCall() {
-    return this.toolCallStarted;
-  }
-}
-
-function inferToolResultError(result) {
-  if (!result || typeof result !== "object") {
-    return false;
-  }
-  const record = result;
-  if (record.isError === true || record.is_error === true) {
-    return true;
-  }
-  if (typeof record.error === "string" && record.error.trim().length > 0) {
-    return true;
-  }
-  if (record.success === false) {
-    return true;
-  }
-  const status = typeof record.status === "string" ? record.status.toLowerCase() : "";
-  return status === "failed" || status === "cancelled" || status === "error" || status === "denied" || status === "aborted";
-}
-
-function buildToolHappierMetaV2(input) {
-  return {
-    ...input,
-    v: 2
-  };
-}
-function attachToolHappierMetaV2(value, meta) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return value;
-  }
-  return {
-    ...value,
-    _happier: buildToolHappierMetaV2(meta)
-  };
-}
-
-const KNOWN_CANONICAL_TOOL_NAMES_V2 = [
-  "Bash",
-  "Read",
-  "Write",
-  "Edit",
-  "MultiEdit",
-  "Delete",
-  "Patch",
-  "Diff",
-  "Glob",
-  "Grep",
-  "LS",
-  "CodeSearch",
-  "WebFetch",
-  "WebSearch",
-  "TodoWrite",
-  "TodoRead",
-  "Task",
-  "Reasoning",
-  "EnterPlanMode",
-  "ExitPlanMode",
-  "AskUserQuestion",
-  "AcpHistoryImport",
-  "WorkspaceIndexingPermission",
-  "SubAgentRun",
-  "AgentTeamCreate",
-  "AgentTeamDelete",
-  "AgentTeamSendMessage"
-];
-const CANONICAL_TOOL_NAME_LOOKUP = new Map(
-  KNOWN_CANONICAL_TOOL_NAMES_V2.map((name) => [name.toLowerCase(), name])
-);
-const RAW_TO_CANONICAL_TOOL_NAME_LOOKUP = {
-  bash: "Bash",
-  shell: "Bash",
-  execute: "Bash",
-  codexbash: "Bash",
-  geminibash: "Bash",
-  codexpatch: "Patch",
-  geminipatch: "Patch"
-};
-function resolveCanonicalToolNameV2(rawToolName) {
-  const normalized = typeof rawToolName === "string" ? rawToolName.trim() : "";
-  if (!normalized) {
-    return "Bash";
-  }
-  if (normalized.startsWith("mcp__")) {
-    return normalized;
-  }
-  const lower = normalized.toLowerCase();
-  const known = CANONICAL_TOOL_NAME_LOOKUP.get(lower);
-  if (known) {
-    return known;
-  }
-  const mapped = RAW_TO_CANONICAL_TOOL_NAME_LOOKUP[lower];
-  if (mapped) {
-    return mapped;
-  }
-  return normalized;
-}
-
-export { BasePermissionHandler as B, INTERACTION_SUPERSEDED_ERROR as I, BaseReasoningProcessor as a, attachToolHappierMetaV2 as b, createSessionMetadata as c, INTERACTION_TIMED_OUT_ERROR as d, getPendingInteractionTimeoutMs as g, inferToolResultError as i, resolveCanonicalToolNameV2 as r, setupOfflineReconnection as s };