@zhigang1992/happy-cli 0.12.3 → 0.12.4

package/dist/{types-CllU28mx.cjs → types-Q-euvEmG.cjs}

@@ -41,7 +41,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "@zhigang1992/happy-cli";
-var version = "0.12.2";
+var version = "0.12.4";
 var description = "Mobile and Web client for Claude Code and Codex";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";
@@ -332,6 +332,31 @@ 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 = node_crypto.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 encrypt(key, variant, data) {
   if (variant === "legacy") {
     return encryptLegacy(data, key);
@@ -873,12 +898,27 @@ z.z.object({
     agentStateVersion: z.z.number()
   })
 });
+const TextContentSchema = z.z.object({
+  type: z.z.literal("text"),
+  text: z.z.string()
+});
+const ImageRefContentSchema = z.z.object({
+  type: z.z.literal("image_ref"),
+  blobId: z.z.string(),
+  mimeType: z.z.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]),
+  width: z.z.number().optional(),
+  height: z.z.number().optional()
+});
+const ContentBlockSchema = z.z.union([TextContentSchema, ImageRefContentSchema]);
+const UserMessageContentSchema = z.z.union([
+  TextContentSchema,
+  // Legacy: single text content
+  z.z.array(ContentBlockSchema)
+  // New: array of content blocks
+]);
 const UserMessageSchema = z.z.object({
   role: z.z.literal("user"),
-  content: z.z.object({
-    type: z.z.literal("text"),
-    text: z.z.string()
-  }),
+  content: UserMessageContentSchema,
   localKey: z.z.string().optional(),
   // Mobile messages include this
   meta: MessageMetaSchema.optional()
@@ -990,12 +1030,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)
@@ -1073,7 +1130,7 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-CllU28mx.cjs', document.baseURI).href))));
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-Q-euvEmG.cjs', document.baseURI).href))));
 function projectPath() {
   const path$1 = path.resolve(__dirname$1, "..");
   return path$1;
@@ -1171,10 +1228,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 {
@@ -1704,6 +1764,64 @@ class ApiSessionClient extends node_events.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);
+      if (this.encryptionVariant !== "dataKey") {
+        logger.debug("[API] Cannot decrypt blob: session uses legacy encryption");
+        return null;
+      }
+      const decryptedData = decryptBlobWithDataKey(encryptedData, this.encryptionKey);
+      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.4",
   "description": "Mobile and Web client for Claude Code and Codex",
   "author": "Kirill Dubovitskiy",
   "license": "MIT",