@zhigang1992/happy-cli 0.12.1

package/dist/prompt-DXkgjktW.cjs

@@ -0,0 +1,203 @@
+'use strict';
+
+var types = require('./types-BsjUgWOx.cjs');
+var axios = require('axios');
+var socket_ioClient = require('socket.io-client');
+require('chalk');
+require('fs');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('node:fs/promises');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('node:events');
+require('child_process');
+require('util');
+require('fs/promises');
+require('crypto');
+require('path');
+require('url');
+require('os');
+require('expo-server-sdk');
+
+const DEFAULT_TIMEOUT_MINUTES = 20;
+async function promptSession(credentials, sessionId, promptText, timeoutMinutes = DEFAULT_TIMEOUT_MINUTES) {
+  try {
+    const serverUrl = types.configuration.serverUrl;
+    const response = await axios.get(`${serverUrl}/v2/sessions/active`, {
+      headers: {
+        "Authorization": `Bearer ${credentials.token}`
+      }
+    });
+    const session = response.data.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      console.error(`Session ${sessionId} not found or not active.`);
+      process.exit(1);
+    }
+    let agentState = {};
+    if (session.agentState) {
+      try {
+        const key2 = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+        const decrypted = types.decrypt(
+          key2,
+          credentials.encryption.type,
+          types.decodeBase64(session.agentState)
+        );
+        if (decrypted) {
+          agentState = decrypted;
+        }
+      } catch (error) {
+        types.logger.debug(`Failed to decrypt agent state for session ${sessionId}:`, error);
+      }
+    }
+    if (agentState.thinking) {
+      console.error("Claude is already working on a task. Please wait for it to finish.");
+      process.exit(1);
+    }
+    const wsUrl = serverUrl.replace(/^http/, "ws");
+    const socket = socket_ioClient.io(wsUrl, {
+      path: "/v1/updates",
+      auth: {
+        token: credentials.token,
+        clientType: "session-scoped",
+        sessionId
+      },
+      transports: ["websocket", "polling"]
+    });
+    let isThinking = false;
+    let hasStartedThinking = false;
+    let completed = false;
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Connection timeout"));
+      }, 1e4);
+      socket.on("connect", () => {
+        clearTimeout(timeout);
+        types.logger.debug(`Connected to WebSocket for session ${sessionId}`);
+        resolve();
+      });
+      socket.on("connect_error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+    socket.on("update", (data) => {
+      types.logger.debugLargeJson("[prompt] Received update:", data);
+      if (data.body.t === "new-message") {
+        try {
+          const key2 = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+          const content = types.decrypt(
+            key2,
+            credentials.encryption.type,
+            types.decodeBase64(data.body.message.content.c)
+          );
+          if (!content) {
+            types.logger.debug("Failed to decrypt message content");
+            return;
+          }
+          if (content.role === "agent" && content.content?.type === "output") {
+            const output = content.content.data;
+            if (output.type === "user" && output.message?.content) {
+              console.log("[User]:", output.message.content);
+            } else if (output.type === "assistant" && output.message?.content) {
+              if (Array.isArray(output.message.content)) {
+                for (const block of output.message.content) {
+                  if (block.type === "text") {
+                    console.log(block.text);
+                  } else if (block.type === "tool_use") {
+                    console.log(`
+[Tool: ${block.name}]`);
+                  }
+                }
+              }
+            }
+          }
+        } catch (error) {
+          types.logger.debug("Failed to decrypt or process message:", error);
+        }
+      } else if (data.body.t === "update-session" && data.body.agentState) {
+        try {
+          if (data.body.agentState.value) {
+            const key2 = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+            const updatedState = types.decrypt(
+              key2,
+              credentials.encryption.type,
+              types.decodeBase64(data.body.agentState.value)
+            );
+            if (updatedState) {
+              types.logger.debug(`[prompt] Agent state updated: thinking=${updatedState.thinking}`);
+            }
+          }
+        } catch (error) {
+          types.logger.debug("Failed to decrypt agent state:", error);
+        }
+      }
+    });
+    socket.on("ephemeral", (data) => {
+      if (data.type === "activity" && data.id === sessionId) {
+        types.logger.debug(`[prompt] Activity update: thinking=${data.thinking}, active=${data.active}`);
+        if (data.thinking && !hasStartedThinking) {
+          hasStartedThinking = true;
+          console.log("[Claude is thinking...]");
+        }
+        isThinking = data.thinking;
+        if (hasStartedThinking && !data.thinking) {
+          completed = true;
+        }
+      }
+    });
+    const messageContent = {
+      role: "user",
+      content: {
+        type: "text",
+        text: promptText
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    const key = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+    const encryptedMessage = types.encodeBase64(types.encrypt(
+      key,
+      credentials.encryption.type,
+      messageContent
+    ));
+    types.logger.debug("[prompt] Sending message to session...");
+    socket.emit("message", {
+      sid: sessionId,
+      message: encryptedMessage
+    });
+    console.log(`[Sent prompt to session ${sessionId}]`);
+    const checkInterval = setInterval(() => {
+      if (completed) {
+        clearInterval(checkInterval);
+        socket.close();
+        console.log("\n[Claude has finished]");
+        process.exit(0);
+      }
+    }, 500);
+    const timeoutMs = timeoutMinutes * 60 * 1e3;
+    setTimeout(() => {
+      clearInterval(checkInterval);
+      socket.close();
+      console.error(`
+Timeout waiting for Claude to complete (${timeoutMinutes} minutes).`);
+      process.exit(1);
+    }, timeoutMs);
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (error.response?.status === 401) {
+        console.error("Authentication failed. Please run `happy auth` to authenticate.");
+      } else {
+        console.error(`Failed to send prompt: ${error.response?.data?.message || error.message}`);
+      }
+    } else {
+      console.error(`Failed to send prompt: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+exports.promptSession = promptSession;

package/dist/prompt-Dz7G8yGx.mjs

@@ -0,0 +1,201 @@
+import { c as configuration, b as decrypt, d as decodeBase64, l as logger, g as encodeBase64, h as encrypt } from './types-CGco5Y-r.mjs';
+import axios from 'axios';
+import { io } from 'socket.io-client';
+import 'chalk';
+import 'fs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'node:fs/promises';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'node:events';
+import 'child_process';
+import 'util';
+import 'fs/promises';
+import 'crypto';
+import 'path';
+import 'url';
+import 'os';
+import 'expo-server-sdk';
+
+const DEFAULT_TIMEOUT_MINUTES = 20;
+async function promptSession(credentials, sessionId, promptText, timeoutMinutes = DEFAULT_TIMEOUT_MINUTES) {
+  try {
+    const serverUrl = configuration.serverUrl;
+    const response = await axios.get(`${serverUrl}/v2/sessions/active`, {
+      headers: {
+        "Authorization": `Bearer ${credentials.token}`
+      }
+    });
+    const session = response.data.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      console.error(`Session ${sessionId} not found or not active.`);
+      process.exit(1);
+    }
+    let agentState = {};
+    if (session.agentState) {
+      try {
+        const key2 = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+        const decrypted = decrypt(
+          key2,
+          credentials.encryption.type,
+          decodeBase64(session.agentState)
+        );
+        if (decrypted) {
+          agentState = decrypted;
+        }
+      } catch (error) {
+        logger.debug(`Failed to decrypt agent state for session ${sessionId}:`, error);
+      }
+    }
+    if (agentState.thinking) {
+      console.error("Claude is already working on a task. Please wait for it to finish.");
+      process.exit(1);
+    }
+    const wsUrl = serverUrl.replace(/^http/, "ws");
+    const socket = io(wsUrl, {
+      path: "/v1/updates",
+      auth: {
+        token: credentials.token,
+        clientType: "session-scoped",
+        sessionId
+      },
+      transports: ["websocket", "polling"]
+    });
+    let isThinking = false;
+    let hasStartedThinking = false;
+    let completed = false;
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Connection timeout"));
+      }, 1e4);
+      socket.on("connect", () => {
+        clearTimeout(timeout);
+        logger.debug(`Connected to WebSocket for session ${sessionId}`);
+        resolve();
+      });
+      socket.on("connect_error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+    socket.on("update", (data) => {
+      logger.debugLargeJson("[prompt] Received update:", data);
+      if (data.body.t === "new-message") {
+        try {
+          const key2 = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+          const content = decrypt(
+            key2,
+            credentials.encryption.type,
+            decodeBase64(data.body.message.content.c)
+          );
+          if (!content) {
+            logger.debug("Failed to decrypt message content");
+            return;
+          }
+          if (content.role === "agent" && content.content?.type === "output") {
+            const output = content.content.data;
+            if (output.type === "user" && output.message?.content) {
+              console.log("[User]:", output.message.content);
+            } else if (output.type === "assistant" && output.message?.content) {
+              if (Array.isArray(output.message.content)) {
+                for (const block of output.message.content) {
+                  if (block.type === "text") {
+                    console.log(block.text);
+                  } else if (block.type === "tool_use") {
+                    console.log(`
+[Tool: ${block.name}]`);
+                  }
+                }
+              }
+            }
+          }
+        } catch (error) {
+          logger.debug("Failed to decrypt or process message:", error);
+        }
+      } else if (data.body.t === "update-session" && data.body.agentState) {
+        try {
+          if (data.body.agentState.value) {
+            const key2 = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+            const updatedState = decrypt(
+              key2,
+              credentials.encryption.type,
+              decodeBase64(data.body.agentState.value)
+            );
+            if (updatedState) {
+              logger.debug(`[prompt] Agent state updated: thinking=${updatedState.thinking}`);
+            }
+          }
+        } catch (error) {
+          logger.debug("Failed to decrypt agent state:", error);
+        }
+      }
+    });
+    socket.on("ephemeral", (data) => {
+      if (data.type === "activity" && data.id === sessionId) {
+        logger.debug(`[prompt] Activity update: thinking=${data.thinking}, active=${data.active}`);
+        if (data.thinking && !hasStartedThinking) {
+          hasStartedThinking = true;
+          console.log("[Claude is thinking...]");
+        }
+        isThinking = data.thinking;
+        if (hasStartedThinking && !data.thinking) {
+          completed = true;
+        }
+      }
+    });
+    const messageContent = {
+      role: "user",
+      content: {
+        type: "text",
+        text: promptText
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    const key = credentials.encryption.type === "legacy" ? credentials.encryption.secret : credentials.encryption.machineKey;
+    const encryptedMessage = encodeBase64(encrypt(
+      key,
+      credentials.encryption.type,
+      messageContent
+    ));
+    logger.debug("[prompt] Sending message to session...");
+    socket.emit("message", {
+      sid: sessionId,
+      message: encryptedMessage
+    });
+    console.log(`[Sent prompt to session ${sessionId}]`);
+    const checkInterval = setInterval(() => {
+      if (completed) {
+        clearInterval(checkInterval);
+        socket.close();
+        console.log("\n[Claude has finished]");
+        process.exit(0);
+      }
+    }, 500);
+    const timeoutMs = timeoutMinutes * 60 * 1e3;
+    setTimeout(() => {
+      clearInterval(checkInterval);
+      socket.close();
+      console.error(`
+Timeout waiting for Claude to complete (${timeoutMinutes} minutes).`);
+      process.exit(1);
+    }, timeoutMs);
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (error.response?.status === 401) {
+        console.error("Authentication failed. Please run `happy auth` to authenticate.");
+      } else {
+        console.error(`Failed to send prompt: ${error.response?.data?.message || error.message}`);
+      }
+    } else {
+      console.error(`Failed to send prompt: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+export { promptSession };