@zhigang1992/happy-cli 0.12.3 → 0.12.5

package/dist/{types-D4_aCy-H.mjs → types-BmcSXhbq.mjs}

@@ -20,7 +20,7 @@ import { fileURLToPath } from 'url';
 import { Expo } from 'expo-server-sdk';
 
 var name = "@zhigang1992/happy-cli";
-var version = "0.12.2";
+var version = "0.12.5";
 var description = "Mobile and Web client for Claude Code and Codex";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";
@@ -311,6 +311,43 @@ function decryptWithDataKey(bundle, dataKey) {
     return null;
   }
 }
+function decryptBlobWithDataKey(bundle, dataKey) {
+  if (bundle.length < 1) {
+    return null;
+  }
+  if (bundle[0] !== 0) {
+    return null;
+  }
+  if (bundle.length < 12 + 16 + 1) {
+    return null;
+  }
+  const nonce = bundle.slice(1, 13);
+  const authTag = bundle.slice(bundle.length - 16);
+  const ciphertext = bundle.slice(13, bundle.length - 16);
+  try {
+    const decipher = createDecipheriv("aes-256-gcm", dataKey, nonce);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return new Uint8Array(decrypted);
+  } catch (error) {
+    return null;
+  }
+}
+function decryptBlobWithSecretBox(bundle, secret) {
+  if (bundle.length < 1 + tweetnacl.secretbox.nonceLength) {
+    return null;
+  }
+  if (bundle[0] !== 0) {
+    return null;
+  }
+  const nonce = bundle.slice(1, 1 + tweetnacl.secretbox.nonceLength);
+  const ciphertext = bundle.slice(1 + tweetnacl.secretbox.nonceLength);
+  const decrypted = tweetnacl.secretbox.open(ciphertext, nonce, secret);
+  return decrypted || null;
+}
 function encrypt(key, variant, data) {
   if (variant === "legacy") {
     return encryptLegacy(data, key);
@@ -325,6 +362,13 @@ function decrypt(key, variant, data) {
     return decryptWithDataKey(data, key);
   }
 }
+function decryptBlob(key, variant, bundle) {
+  if (variant === "legacy") {
+    return decryptBlobWithSecretBox(bundle, key);
+  } else {
+    return decryptBlobWithDataKey(bundle, key);
+  }
+}
 function authChallenge(secret) {
   const keypair = tweetnacl.sign.keyPair.fromSeed(secret);
   const challenge = getRandomBytes(32);
@@ -852,12 +896,27 @@ z$1.object({
     agentStateVersion: z$1.number()
   })
 });
+const TextContentSchema = z$1.object({
+  type: z$1.literal("text"),
+  text: z$1.string()
+});
+const ImageRefContentSchema = z$1.object({
+  type: z$1.literal("image_ref"),
+  blobId: z$1.string(),
+  mimeType: z$1.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]),
+  width: z$1.number().optional(),
+  height: z$1.number().optional()
+});
+const ContentBlockSchema = z$1.union([TextContentSchema, ImageRefContentSchema]);
+const UserMessageContentSchema = z$1.union([
+  TextContentSchema,
+  // Legacy: single text content
+  z$1.array(ContentBlockSchema)
+  // New: array of content blocks
+]);
 const UserMessageSchema = z$1.object({
   role: z$1.literal("user"),
-  content: z$1.object({
-    type: z$1.literal("text"),
-    text: z$1.string()
-  }),
+  content: UserMessageContentSchema,
   localKey: z$1.string().optional(),
   // Mobile messages include this
   meta: MessageMetaSchema.optional()
@@ -969,12 +1028,29 @@ class RpcHandlerManager {
   encryptionVariant;
   logger;
   socket = null;
+  sessionContext = null;
   constructor(config) {
     this.scopePrefix = config.scopePrefix;
     this.encryptionKey = config.encryptionKey;
     this.encryptionVariant = config.encryptionVariant;
     this.logger = config.logger || ((msg, data) => logger.debug(msg, data));
   }
+  /**
+   * Set the session context (path and environment)
+   * This should be called after direnv environment is loaded
+   * @param context - The session context with path and environment
+   */
+  setSessionContext(context) {
+    this.sessionContext = context;
+    this.logger("[RPC] Session context set", { path: context.path, envVarCount: Object.keys(context.env).length });
+  }
+  /**
+   * Get the current session context
+   * @returns The session context or null if not set
+   */
+  getSessionContext() {
+    return this.sessionContext;
+  }
   /**
    * Register an RPC handler for a specific method
    * @param method - The method name (without prefix)
@@ -1150,10 +1226,13 @@ function registerCommonHandlers(rpcHandlerManager) {
   rpcHandlerManager.registerHandler("bash", async (data) => {
     logger.debug("Shell command request:", data.command);
     try {
+      const sessionContext = rpcHandlerManager.getSessionContext();
       const options = {
         cwd: data.cwd,
-        timeout: data.timeout || 3e4
+        timeout: data.timeout || 3e4,
         // Default 30 seconds timeout
+        // Use session environment if available, otherwise inherit process.env
+        env: sessionContext?.env ?? process.env
       };
       const { stdout, stderr } = await execAsync(data.command, options);
       return {
@@ -1683,6 +1762,60 @@ class ApiSessionClient extends EventEmitter {
     logger.debug("[API] socket.close() called");
     this.socket.close();
   }
+  /**
+   * Download and decrypt a blob from the server
+   * @param blobId - The blob ID to download
+   * @returns The decrypted binary data and metadata, or null if download/decryption fails
+   */
+  async downloadBlob(blobId) {
+    try {
+      const response = await axios.get(
+        `${configuration.serverUrl}/v1/sessions/${this.sessionId}/blobs/${blobId}`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`
+          },
+          responseType: "arraybuffer"
+        }
+      );
+      const encryptedData = new Uint8Array(response.data);
+      const mimeType = response.headers["x-blob-mimetype"];
+      const originalSize = parseInt(response.headers["x-blob-size"], 10);
+      const decryptedData = decryptBlob(this.encryptionKey, this.encryptionVariant, encryptedData);
+      if (!decryptedData) {
+        logger.debug("[API] Failed to decrypt blob");
+        return null;
+      }
+      return {
+        data: decryptedData,
+        mimeType,
+        size: originalSize
+      };
+    } catch (error) {
+      logger.debug("[API] Failed to download blob:", error);
+      return null;
+    }
+  }
+  /**
+   * Convert an image_ref content block to a Claude API image content block
+   * Downloads, decrypts, and base64 encodes the image
+   * @param imageRef - The image reference content block
+   * @returns Claude API image content block, or null if conversion fails
+   */
+  async resolveImageRef(imageRef) {
+    const blob = await this.downloadBlob(imageRef.blobId);
+    if (!blob) {
+      return null;
+    }
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: blob.mimeType,
+        data: Buffer.from(blob.data).toString("base64")
+      }
+    };
+  }
 }
 
 class ApiMachineClient {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhigang1992/happy-cli",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "description": "Mobile and Web client for Claude Code and Codex",
   "author": "Kirill Dubovitskiy",
   "license": "MIT",