happy-imou-cloud 2.1.49 → 2.1.51

package/dist/runCursor-Bn1PuwJy.cjs

@@ -0,0 +1,506 @@
+'use strict';
+
+var cursor = require('./cursor-Blq1cHdr.cjs');
+var node_crypto = require('node:crypto');
+var persistence = require('./types-CttABk32.cjs');
+var sessionControl = require('./sessionControl-flKnQrx0.cjs');
+var index = require('./index-B_JYgMUS.cjs');
+var bootstrapManagedProviderSession = require('./bootstrapManagedProviderSession-Bln-TwyB.cjs');
+var installFatalProcessHandlers = require('./installFatalProcessHandlers-CyURn5Bp.cjs');
+var RuntimeShell = require('./RuntimeShell-D_Te12wq.cjs');
+require('./AcpBackend-XPiTd6ph.cjs');
+require('cross-spawn');
+require('@agentclientprotocol/sdk');
+require('ps-list');
+require('./resolveCommand-DYMd9PNC.cjs');
+require('node:fs');
+require('node:path');
+require('axios');
+require('chalk');
+require('fs');
+require('node:os');
+require('zod');
+require('node:events');
+require('node:fs/promises');
+require('socket.io-client');
+require('tweetnacl');
+require('fs/promises');
+require('crypto');
+require('path');
+require('node:child_process');
+require('expo-server-sdk');
+require('os');
+require('qrcode-terminal');
+require('node:module');
+require('open');
+require('react');
+require('ink');
+require('child_process');
+require('url');
+require('fastify');
+require('fastify-type-provider-zod');
+require('node:readline');
+require('http');
+require('util');
+require('node:url');
+
+const ACP_PERMISSION_MODES$1 = [
+  "default",
+  "read-only",
+  "safe-yolo",
+  "yolo"
+];
+function isAcpPermissionMode$1(value) {
+  return ACP_PERMISSION_MODES$1.includes(value);
+}
+class ManagedAcpPermissionHandler extends sessionControl.BasePermissionHandler {
+  constructor(session, logPrefix) {
+    super(session);
+    this.logPrefix = logPrefix;
+  }
+  currentPermissionMode = "default";
+  getLogPrefix() {
+    return this.logPrefix;
+  }
+  setPermissionMode(mode) {
+    this.currentPermissionMode = isAcpPermissionMode$1(mode) ? mode : "default";
+    persistence.logger.debug(`${this.getLogPrefix()} Permission mode set to: ${this.currentPermissionMode}`);
+  }
+  async handleToolCall(toolCallId, toolName, input) {
+    if (this.shouldAutoApprove(toolName, toolCallId)) {
+      persistence.logger.debug(`${this.getLogPrefix()} Auto-approving tool ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now(),
+            completedAt: Date.now(),
+            status: "approved",
+            decision: this.currentPermissionMode === "yolo" ? "approved_for_session" : "approved"
+          }
+        }
+      }));
+      return {
+        decision: this.currentPermissionMode === "yolo" ? "approved_for_session" : "approved"
+      };
+    }
+    return this.registerPendingRequest(
+      toolCallId,
+      toolName,
+      input,
+      ` in ${this.currentPermissionMode} mode`
+    );
+  }
+  shouldAutoApprove(toolName, toolCallId) {
+    const normalizedToolName = toolName.toLowerCase();
+    const normalizedToolCallId = toolCallId.toLowerCase();
+    const alwaysAutoApprove = ["reasoning", "think", "save_memory"];
+    if (alwaysAutoApprove.some((name) => normalizedToolName.includes(name)) || normalizedToolCallId.includes("save_memory")) {
+      return true;
+    }
+    switch (this.currentPermissionMode) {
+      case "yolo":
+        return true;
+      case "safe-yolo":
+      case "read-only": {
+        const readTools = [
+          "read",
+          "list",
+          "ls",
+          "view",
+          "cat",
+          "grep",
+          "search",
+          "glob",
+          "find",
+          "inspect",
+          "stat",
+          "tree"
+        ];
+        return readTools.some((name) => normalizedToolName.includes(name));
+      }
+      case "default":
+      default:
+        return false;
+    }
+  }
+}
+
+const ACP_PERMISSION_MODES = ["default", "read-only", "safe-yolo", "yolo"];
+function isAcpPermissionMode(value) {
+  return typeof value === "string" && ACP_PERMISSION_MODES.includes(value);
+}
+function normalizePermissionMode(value, fallback) {
+  return isAcpPermissionMode(value) ? value : fallback;
+}
+function formatRuntimeError(error, providerLabel) {
+  if (error instanceof Error) {
+    return error.message || `${providerLabel} runtime failed`;
+  }
+  if (typeof error === "string") {
+    return error || `${providerLabel} runtime failed`;
+  }
+  try {
+    const serialized = JSON.stringify(error);
+    return serialized && serialized !== "{}" ? serialized : `${providerLabel} runtime failed`;
+  } catch {
+    return `${providerLabel} runtime failed`;
+  }
+}
+async function runManagedAcpProvider(opts) {
+  const provider = opts.provider;
+  const providerLabel = opts.providerLabel;
+  const managedSessionTag = opts.startedBy === "daemon" ? index.readManagedSessionTag() : null;
+  const sessionTag = managedSessionTag ?? index.resolveManagedSessionTag(
+    opts.startedBy === "daemon" ? process.env : {}
+  );
+  const requestedStartingMode = opts.startingMode ?? (opts.startedBy === "daemon" ? "remote" : "local");
+  persistence.connectionState.setBackend(providerLabel);
+  if (opts.startedBy === "daemon" && requestedStartingMode === "local") {
+    throw new Error(`Daemon-spawned ${providerLabel} sessions cannot use local mode.`);
+  }
+  const api = await persistence.ApiClient.create(opts.credentials);
+  let machineId;
+  try {
+    machineId = await sessionControl.ensureManagedProviderMachine({
+      api,
+      missingMachineIdMessage: "[START] No machine ID found in settings."
+    });
+  } catch (error) {
+    if (error instanceof sessionControl.MissingMachineIdError) {
+      console.error(error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
+  let sessionClient;
+  let permissionHandler;
+  let runtimeHandle = null;
+  let unsubscribeRuntimeMessages = null;
+  let accumulatedResponse = "";
+  let currentPermissionMode = "default";
+  let taskStartedSent = false;
+  let turnAbortedSent = false;
+  let turnInFlight = false;
+  let shouldExit = false;
+  let cleanupStarted = false;
+  const abortController = new AbortController();
+  const assistantMessageStream = new persistence.AssistantMessageStream();
+  const messageQueue = new sessionControl.MessageQueue2((mode) => persistence.hashObject(mode));
+  let startupRolePrompt = null;
+  const { metadata, session: initialSession, reconnectionHandle, happyOrgStartupBinding } = await bootstrapManagedProviderSession.bootstrapManagedProviderSession({
+    api,
+    sessionTag,
+    flavor: provider,
+    machineId,
+    startedBy: opts.startedBy,
+    authFallbackLogMessage: `[${providerLabel}] Falling back to offline session stub after authentication failure`,
+    reconcileMetadataOnAttach: managedSessionTag !== null,
+    onSessionSwap: (newSession) => {
+      sessionClient = newSession;
+      permissionHandler.updateSession(newSession);
+      void sessionControl.syncControlledByUserState(newSession, false);
+    }
+  });
+  sessionClient = initialSession;
+  permissionHandler = new ManagedAcpPermissionHandler(sessionClient, `[${providerLabel}]`);
+  startupRolePrompt = happyOrgStartupBinding?.identityPrompt ?? null;
+  const sendAgentMessage = (body) => {
+    sessionClient.sendAgentMessage(provider, body);
+  };
+  const sendTaskStarted = () => {
+    if (taskStartedSent) {
+      return;
+    }
+    sendAgentMessage({
+      type: "task_started",
+      id: node_crypto.randomUUID()
+    });
+    taskStartedSent = true;
+  };
+  const sendTurnAborted = () => {
+    if (turnAbortedSent) {
+      return;
+    }
+    sendAgentMessage({
+      type: "turn_aborted",
+      id: node_crypto.randomUUID()
+    });
+    turnAbortedSent = true;
+  };
+  const commitAssistantStream = (text) => {
+    if (!assistantMessageStream.hasActive() && text.length === 0) {
+      return;
+    }
+    sendAgentMessage({
+      type: "message",
+      message: text,
+      ...assistantMessageStream.commit()
+    });
+  };
+  const abortAssistantStream = () => {
+    if (!assistantMessageStream.hasActive()) {
+      return;
+    }
+    sendAgentMessage({
+      type: "message",
+      message: "",
+      ...assistantMessageStream.abort()
+    });
+  };
+  const handleRuntimeMessage = (msg) => {
+    if (msg.type === "model-output") {
+      const delta = msg.textDelta ?? msg.fullText ?? "";
+      if (!delta) {
+        return;
+      }
+      accumulatedResponse += delta;
+      sendAgentMessage({
+        type: "message",
+        message: delta,
+        ...assistantMessageStream.delta()
+      });
+      return;
+    }
+    if (msg.type === "status") {
+      const detail = msg.detail ? String(msg.detail) : "";
+      persistence.logger.debug(`[${provider}] Status changed: ${msg.status}${detail ? ` - ${detail}` : ""}`);
+      if (msg.status === "running") {
+        turnInFlight = true;
+        sendTaskStarted();
+        sessionClient.keepAlive(true, "remote");
+        return;
+      }
+      if (msg.status === "error") {
+        sendTurnAborted();
+        abortAssistantStream();
+        sendAgentMessage({
+          type: "message",
+          message: detail ? `Error: ${detail}` : `${providerLabel} runtime error`
+        });
+        sessionClient.keepAlive(false, "remote");
+        return;
+      }
+      if (msg.status === "idle" || msg.status === "stopped") {
+        sessionClient.keepAlive(false, "remote");
+      }
+      return;
+    }
+    if (msg.type === "event" && msg.name === "thinking") {
+      const payload = msg.payload && typeof msg.payload === "object" ? msg.payload : null;
+      const text = typeof payload?.text === "string" ? payload.text : "";
+      if (text) {
+        sendAgentMessage({
+          type: "thinking",
+          text,
+          id: node_crypto.randomUUID()
+        });
+      }
+      return;
+    }
+    sessionControl.forwardAgentMessageToProviderSession(msg, {
+      provider,
+      send: (body) => sendAgentMessage(body)
+    });
+  };
+  const ensureRuntimeHandle = async () => {
+    if (runtimeHandle) {
+      return runtimeHandle;
+    }
+    const shell = new RuntimeShell.RuntimeShell();
+    const handle = await shell.launch({
+      provider,
+      cwd: metadata.path,
+      createBackend: (factoryOpts) => opts.createBackend({
+        ...factoryOpts,
+        permissionHandler
+      })
+    });
+    runtimeHandle = handle;
+    unsubscribeRuntimeMessages?.();
+    unsubscribeRuntimeMessages = handle.onMessage(handleRuntimeMessage);
+    return handle;
+  };
+  const disposeRuntimeHandle = async () => {
+    unsubscribeRuntimeMessages?.();
+    unsubscribeRuntimeMessages = null;
+    const handle = runtimeHandle;
+    runtimeHandle = null;
+    if (!handle) {
+      return;
+    }
+    try {
+      await handle.dispose();
+    } catch (error) {
+      persistence.logger.debug(`[${provider}] Error disposing runtime handle`, error);
+    }
+  };
+  const closeAll = async (closeOptions = { archiveOnClose: true }) => {
+    if (cleanupStarted) {
+      return;
+    }
+    cleanupStarted = true;
+    messageQueue.close();
+    abortController.abort();
+    reconnectionHandle?.cancel();
+    await disposeRuntimeHandle();
+    index.stopCaffeinate();
+    await index.closeProviderSession(sessionClient, closeOptions);
+  };
+  sessionControl.registerKillSessionHandler(sessionClient.rpcHandlerManager, async () => {
+    shouldExit = true;
+    messageQueue.close();
+    abortController.abort();
+    try {
+      await runtimeHandle?.cancel();
+    } catch (error) {
+      persistence.logger.debug(`[${provider}] Error cancelling runtime from killSession`, error);
+    }
+  });
+  sessionClient.onUserMessage((message) => {
+    const happyOrgResult = sessionControl.resolveHappyOrgQueuedTurn({
+      metadata: sessionClient.getMetadataSnapshot?.() ?? metadata,
+      message,
+      sessionId: sessionClient.sessionId
+    });
+    if (happyOrgResult.nextMetadata) {
+      sessionClient.updateMetadata(() => happyOrgResult.nextMetadata);
+    }
+    if (happyOrgResult.blocked) {
+      if (happyOrgResult.statusMessage) {
+        sessionClient.sendSessionEvent({ type: "message", message: happyOrgResult.statusMessage });
+      }
+      return;
+    }
+    currentPermissionMode = normalizePermissionMode(message.meta?.permissionMode, currentPermissionMode);
+    const originalUserMessage = message.content.text;
+    const queuedText = message.meta?.appendSystemPrompt ? `${message.meta.appendSystemPrompt}
+
+${originalUserMessage}` : originalUserMessage;
+    messageQueue.push(queuedText, {
+      permissionMode: currentPermissionMode,
+      originalUserMessage,
+      happyOrg: happyOrgResult.queuedTurn
+    });
+  });
+  if (opts.initialPrompt) {
+    messageQueue.push(opts.initialPrompt, {
+      permissionMode: "default",
+      originalUserMessage: opts.initialPrompt,
+      happyOrg: null
+    });
+  }
+  sessionClient.sendSessionEvent({ type: "ready" });
+  await sessionControl.syncControlledByUserState(sessionClient, false);
+  const keepAliveInterval = setInterval(() => {
+    sessionClient.keepAlive(turnInFlight, "remote");
+  }, 2e3);
+  const disposeFatalProcessHandlers = installFatalProcessHandlers.installFatalProcessHandlers({
+    label: provider,
+    cleanup: async ({ event, error }) => {
+      await closeAll({
+        archiveOnClose: true,
+        archiveReason: `Fatal ${event}: ${error.message}`
+      });
+    }
+  });
+  try {
+    while (!shouldExit) {
+      const queued = await messageQueue.waitForMessagesAndGetAsString(abortController.signal);
+      if (!queued) {
+        break;
+      }
+      currentPermissionMode = normalizePermissionMode(queued.mode.permissionMode, currentPermissionMode);
+      permissionHandler.setPermissionMode(currentPermissionMode);
+      accumulatedResponse = "";
+      taskStartedSent = false;
+      turnAbortedSent = false;
+      turnInFlight = true;
+      let turnStatus = "task_complete";
+      try {
+        const handle = await ensureRuntimeHandle();
+        let promptToSend = queued.message;
+        if (queued.mode.happyOrg) {
+          promptToSend = sessionControl.buildHappyOrgTurnPrompt(promptToSend, queued.mode.happyOrg);
+        }
+        if (startupRolePrompt) {
+          promptToSend = `${startupRolePrompt}
+
+${promptToSend}`;
+          startupRolePrompt = null;
+        }
+        await handle.sendPrompt(promptToSend);
+        await sessionControl.waitForResponseCompleteWithAbort(handle.backend, abortController.signal);
+      } catch (error) {
+        const isAbortError = error instanceof Error && error.name === "AbortError";
+        turnStatus = "turn_aborted";
+        sendTurnAborted();
+        abortAssistantStream();
+        if (!isAbortError) {
+          const errorMessage = formatRuntimeError(error, providerLabel);
+          persistence.logger.debug(`[${provider}] Error in managed provider loop`, error);
+          sendAgentMessage({
+            type: "message",
+            message: errorMessage
+          });
+        }
+      } finally {
+        turnInFlight = false;
+        permissionHandler.reset();
+        const finalizedTurn = await sessionControl.finalizeHappyOrgTurnWithBusinessAck({
+          metadata: sessionClient.getMetadataSnapshot?.() ?? metadata,
+          queuedTurn: queued.mode.happyOrg,
+          responseText: accumulatedResponse,
+          turnStatus,
+          submitDispatchAck: async (submission) => {
+            await api.submitOrganizationDispatchBusinessAck(submission);
+          }
+        });
+        if (finalizedTurn.nextMetadata) {
+          sessionClient.updateMetadata(() => finalizedTurn.nextMetadata);
+        }
+        if (finalizedTurn.report) {
+          sendAgentMessage({
+            type: "turn-report",
+            id: node_crypto.randomUUID(),
+            report: finalizedTurn.report
+          });
+        }
+        if (finalizedTurn.terminateMessage) {
+          sessionClient.sendSessionEvent({ type: "message", message: finalizedTurn.terminateMessage });
+        }
+        if ((finalizedTurn.dispatchAck.outcome === "invalid" || finalizedTurn.dispatchAck.outcome === "error") && finalizedTurn.dispatchAck.diagnostic) {
+          sessionClient.sendSessionEvent({ type: "message", message: finalizedTurn.dispatchAck.diagnostic });
+        }
+        commitAssistantStream(finalizedTurn.cleanedText);
+        sendAgentMessage({
+          type: "task_complete",
+          id: node_crypto.randomUUID()
+        });
+        sessionClient.keepAlive(false, "remote");
+        sessionClient.sendSessionEvent({ type: "ready" });
+      }
+    }
+  } finally {
+    disposeFatalProcessHandlers();
+    clearInterval(keepAliveInterval);
+    await closeAll({ archiveOnClose: true });
+  }
+}
+
+async function runCursor(opts) {
+  await runManagedAcpProvider({
+    provider: "cursor",
+    providerLabel: "Cursor",
+    credentials: opts.credentials,
+    startedBy: opts.startedBy,
+    startingMode: opts.startingMode,
+    initialPrompt: opts.initialPrompt,
+    createBackend: (factoryOpts) => cursor.createCursorBackend(factoryOpts).backend
+  });
+}
+
+exports.runCursor = runCursor;