happy-imou-cloud 2.1.49 → 2.1.51

package/dist/runCursor-M6dQ6bGF.mjs

@@ -0,0 +1,504 @@
+import { c as createCursorBackend } from './cursor-CwPNSy_A.mjs';
+import { randomUUID } from 'node:crypto';
+import { l as logger, b as connectionState, A as ApiClient, h as hashObject, d as AssistantMessageStream } from './types-B5vtxa38.mjs';
+import { B as BasePermissionHandler, e as ensureManagedProviderMachine, M as MissingMachineIdError, b as MessageQueue2, r as registerKillSessionHandler, c as resolveHappyOrgQueuedTurn, s as syncControlledByUserState, d as buildHappyOrgTurnPrompt, w as waitForResponseCompleteWithAbort, f as finalizeHappyOrgTurnWithBusinessAck, h as forwardAgentMessageToProviderSession } from './sessionControl-1bT_7OI6.mjs';
+import { r as readManagedSessionTag, a as resolveManagedSessionTag, s as stopCaffeinate, b as closeProviderSession } from './index-CX-F_fuk.mjs';
+import { b as bootstrapManagedProviderSession } from './bootstrapManagedProviderSession-D2Z6YU3n.mjs';
+import { i as installFatalProcessHandlers } from './installFatalProcessHandlers-0vaw9MAz.mjs';
+import { R as RuntimeShell } from './RuntimeShell-BDt42io_.mjs';
+import './AcpBackend-CqO3D07V.mjs';
+import 'cross-spawn';
+import '@agentclientprotocol/sdk';
+import 'ps-list';
+import './resolveCommand-B3BGyBE2.mjs';
+import 'node:fs';
+import 'node:path';
+import 'axios';
+import 'chalk';
+import 'fs';
+import 'node:os';
+import 'zod';
+import 'node:events';
+import 'node:fs/promises';
+import 'socket.io-client';
+import 'tweetnacl';
+import 'fs/promises';
+import 'crypto';
+import 'path';
+import 'node:child_process';
+import 'expo-server-sdk';
+import 'os';
+import 'qrcode-terminal';
+import 'node:module';
+import 'open';
+import 'react';
+import 'ink';
+import 'child_process';
+import 'url';
+import 'fastify';
+import 'fastify-type-provider-zod';
+import 'node:readline';
+import 'http';
+import 'util';
+import '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 BasePermissionHandler {
+  constructor(session, logPrefix) {
+    super(session);
+    this.logPrefix = logPrefix;
+  }
+  currentPermissionMode = "default";
+  getLogPrefix() {
+    return this.logPrefix;
+  }
+  setPermissionMode(mode) {
+    this.currentPermissionMode = isAcpPermissionMode$1(mode) ? mode : "default";
+    logger.debug(`${this.getLogPrefix()} Permission mode set to: ${this.currentPermissionMode}`);
+  }
+  async handleToolCall(toolCallId, toolName, input) {
+    if (this.shouldAutoApprove(toolName, toolCallId)) {
+      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" ? readManagedSessionTag() : null;
+  const sessionTag = managedSessionTag ?? resolveManagedSessionTag(
+    opts.startedBy === "daemon" ? process.env : {}
+  );
+  const requestedStartingMode = opts.startingMode ?? (opts.startedBy === "daemon" ? "remote" : "local");
+  connectionState.setBackend(providerLabel);
+  if (opts.startedBy === "daemon" && requestedStartingMode === "local") {
+    throw new Error(`Daemon-spawned ${providerLabel} sessions cannot use local mode.`);
+  }
+  const api = await ApiClient.create(opts.credentials);
+  let machineId;
+  try {
+    machineId = await ensureManagedProviderMachine({
+      api,
+      missingMachineIdMessage: "[START] No machine ID found in settings."
+    });
+  } catch (error) {
+    if (error instanceof 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 AssistantMessageStream();
+  const messageQueue = new MessageQueue2((mode) => hashObject(mode));
+  let startupRolePrompt = null;
+  const { metadata, session: initialSession, reconnectionHandle, happyOrgStartupBinding } = await 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 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: randomUUID()
+    });
+    taskStartedSent = true;
+  };
+  const sendTurnAborted = () => {
+    if (turnAbortedSent) {
+      return;
+    }
+    sendAgentMessage({
+      type: "turn_aborted",
+      id: 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) : "";
+      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: randomUUID()
+        });
+      }
+      return;
+    }
+    forwardAgentMessageToProviderSession(msg, {
+      provider,
+      send: (body) => sendAgentMessage(body)
+    });
+  };
+  const ensureRuntimeHandle = async () => {
+    if (runtimeHandle) {
+      return runtimeHandle;
+    }
+    const shell = new 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) {
+      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();
+    stopCaffeinate();
+    await closeProviderSession(sessionClient, closeOptions);
+  };
+  registerKillSessionHandler(sessionClient.rpcHandlerManager, async () => {
+    shouldExit = true;
+    messageQueue.close();
+    abortController.abort();
+    try {
+      await runtimeHandle?.cancel();
+    } catch (error) {
+      logger.debug(`[${provider}] Error cancelling runtime from killSession`, error);
+    }
+  });
+  sessionClient.onUserMessage((message) => {
+    const happyOrgResult = 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 syncControlledByUserState(sessionClient, false);
+  const keepAliveInterval = setInterval(() => {
+    sessionClient.keepAlive(turnInFlight, "remote");
+  }, 2e3);
+  const disposeFatalProcessHandlers = 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 = buildHappyOrgTurnPrompt(promptToSend, queued.mode.happyOrg);
+        }
+        if (startupRolePrompt) {
+          promptToSend = `${startupRolePrompt}
+
+${promptToSend}`;
+          startupRolePrompt = null;
+        }
+        await handle.sendPrompt(promptToSend);
+        await 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);
+          logger.debug(`[${provider}] Error in managed provider loop`, error);
+          sendAgentMessage({
+            type: "message",
+            message: errorMessage
+          });
+        }
+      } finally {
+        turnInFlight = false;
+        permissionHandler.reset();
+        const finalizedTurn = await 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: 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: 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) => createCursorBackend(factoryOpts).backend
+  });
+}
+
+export { runCursor };