happy-imou-cloud 1.1.7 → 2.0.0

package/dist/{types-BXyraW9R.mjs → api-BGXYX0yH.mjs}

@@ -17,7 +17,7 @@ import { resolve, join as join$1 } from 'path';
 import { Expo } from 'expo-server-sdk';
 
 var name = "happy-imou-cloud";
-var version = "1.1.7";
+var version = "2.0.0";
 var description = "hicloud - Imou 企业定制版。关键是 happy！移动端远程 AI 编程工具，支持 Claude Code、Codex 和 Gemini CLI";
 var author = "long.zhu";
 var license = "MIT";
@@ -62,22 +62,23 @@ var scripts = {
 	typecheck: "tsc --noEmit",
 	build: "shx rm -rf dist && npx tsc --noEmit && pkgroll",
 	"// ==== Testing ====": "",
-	test: "$npm_execpath run build && vitest run",
-	"test:integration": "$npm_execpath run build && vitest run --config vitest.integration.config.ts",
+	test: "yarn build && vitest run",
+	"test:integration": "yarn build && vitest run --config vitest.integration.config.ts",
 	"test:integration:watch": "vitest run --config vitest.integration.config.ts --watch",
-	"test:coverage": "$npm_execpath run build && vitest run --coverage && node scripts/generate-coverage-report.js",
+	"test:coverage": "yarn build && vitest run --coverage && node scripts/generate-coverage-report.js",
 	"// ==== Benchmarks ====": "",
-	bench: "$npm_execpath run build && vitest bench src/daemon/integration/benchmarks/",
-	"bench:auth": "$npm_execpath run build && vitest bench src/daemon/integration/benchmarks/auth.bench.ts",
+	bench: "yarn build && vitest bench src/daemon/integration/benchmarks/",
+	"bench:auth": "yarn build && vitest bench src/daemon/integration/benchmarks/auth.bench.ts",
 	"bench:report": "node scripts/generate-benchmark-report.js",
 	"// ==== Start & Dev ====": "",
-	start: "$npm_execpath run build && node ./bin/happy-cloud.mjs",
+	start: "yarn build && node ./bin/happy-cloud.mjs",
 	dev: "tsx src/index.ts",
-	"dev:local-server": "$npm_execpath run build && tsx --env-file .env.dev-local-server src/index.ts",
-	"dev:integration-test-env": "$npm_execpath run build && tsx --env-file .env.integration-test src/index.ts",
+	"dev:local-server": "yarn build && tsx --env-file .env.dev-local-server src/index.ts",
+	"dev:integration-test-env": "yarn build && tsx --env-file .env.integration-test src/index.ts",
 	"// ==== Release ====": "",
 	prepublishOnly: "npm run build",
-	release: "$npm_execpath install && release-it",
+	release: "yarn install && release-it",
+	"release:smoke": "node ./scripts/release-smoke.mjs",
 	"// ==== Dev/Stable Variant Management ====": "",
 	stable: "node scripts/env-wrapper.cjs stable",
 	"dev:variant": "node scripts/env-wrapper.cjs dev",
@@ -430,7 +431,7 @@ async function listDaemonLogFiles(limit = 50) {
       return { file, path: fullPath, modified: stats.mtime };
     }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
     try {
-      const { readDaemonState } = await import('./persistence-BGsuPqaO.mjs');
+      const { readDaemonState } = await import('./persistence-BA_unuca.mjs');
       const state = await readDaemonState();
       if (!state) {
         return logs;
@@ -462,6 +463,108 @@ async function getLatestDaemonLog() {
   return latest || null;
 }
 
+function encodeBase64(buffer, variant = "base64") {
+  if (variant === "base64url") {
+    return encodeBase64Url(buffer);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64, variant = "base64") {
+  if (variant === "base64url") {
+    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
+    return new Uint8Array(Buffer.from(base64Standard, "base64"));
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function getRandomBytes(size) {
+  return new Uint8Array(randomBytes(size));
+}
+function libsodiumEncryptForPublicKey(data, recipientPublicKey) {
+  const ephemeralKeyPair = tweetnacl.box.keyPair();
+  const nonce = getRandomBytes(tweetnacl.box.nonceLength);
+  const encrypted = tweetnacl.box(data, nonce, recipientPublicKey, ephemeralKeyPair.secretKey);
+  const result = new Uint8Array(ephemeralKeyPair.publicKey.length + nonce.length + encrypted.length);
+  result.set(ephemeralKeyPair.publicKey, 0);
+  result.set(nonce, ephemeralKeyPair.publicKey.length);
+  result.set(encrypted, ephemeralKeyPair.publicKey.length + nonce.length);
+  return result;
+}
+function encryptLegacy(data, secret) {
+  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
+  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
+  const result = new Uint8Array(nonce.length + encrypted.length);
+  result.set(nonce);
+  result.set(encrypted, nonce.length);
+  return result;
+}
+function decryptLegacy(data, secret) {
+  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
+  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
+  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
+  if (!decrypted) {
+    return null;
+  }
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
+function encryptWithDataKey(data, dataKey) {
+  const nonce = getRandomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", dataKey, nonce);
+  const plaintext = new TextEncoder().encode(JSON.stringify(data));
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext),
+    cipher.final()
+  ]);
+  const authTag = cipher.getAuthTag();
+  const bundle = new Uint8Array(12 + encrypted.length + 16 + 1);
+  bundle.set([0], 0);
+  bundle.set(nonce, 1);
+  bundle.set(new Uint8Array(encrypted), 13);
+  bundle.set(new Uint8Array(authTag), 13 + encrypted.length);
+  return bundle;
+}
+function decryptWithDataKey(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 JSON.parse(new TextDecoder().decode(decrypted));
+  } catch (error) {
+    return null;
+  }
+}
+function encrypt(key, variant, data) {
+  if (variant === "legacy") {
+    return encryptLegacy(data, key);
+  } else {
+    return encryptWithDataKey(data, key);
+  }
+}
+function decrypt(key, variant, data) {
+  if (variant === "legacy") {
+    return decryptLegacy(data, key);
+  } else {
+    return decryptWithDataKey(data, key);
+  }
+}
+
 const SessionMessageContentSchema = z.object({
   c: z.string(),
   // Base64 encoded encrypted content
@@ -593,108 +696,6 @@ const AgentMessageSchema = z.object({
 });
 z.union([UserMessageSchema, AgentMessageSchema]);
 
-function encodeBase64(buffer, variant = "base64") {
-  if (variant === "base64url") {
-    return encodeBase64Url(buffer);
-  }
-  return Buffer.from(buffer).toString("base64");
-}
-function encodeBase64Url(buffer) {
-  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-}
-function decodeBase64(base64, variant = "base64") {
-  if (variant === "base64url") {
-    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
-    return new Uint8Array(Buffer.from(base64Standard, "base64"));
-  }
-  return new Uint8Array(Buffer.from(base64, "base64"));
-}
-function getRandomBytes(size) {
-  return new Uint8Array(randomBytes(size));
-}
-function libsodiumEncryptForPublicKey(data, recipientPublicKey) {
-  const ephemeralKeyPair = tweetnacl.box.keyPair();
-  const nonce = getRandomBytes(tweetnacl.box.nonceLength);
-  const encrypted = tweetnacl.box(data, nonce, recipientPublicKey, ephemeralKeyPair.secretKey);
-  const result = new Uint8Array(ephemeralKeyPair.publicKey.length + nonce.length + encrypted.length);
-  result.set(ephemeralKeyPair.publicKey, 0);
-  result.set(nonce, ephemeralKeyPair.publicKey.length);
-  result.set(encrypted, ephemeralKeyPair.publicKey.length + nonce.length);
-  return result;
-}
-function encryptLegacy(data, secret) {
-  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
-  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
-  const result = new Uint8Array(nonce.length + encrypted.length);
-  result.set(nonce);
-  result.set(encrypted, nonce.length);
-  return result;
-}
-function decryptLegacy(data, secret) {
-  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
-  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
-  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
-  if (!decrypted) {
-    return null;
-  }
-  return JSON.parse(new TextDecoder().decode(decrypted));
-}
-function encryptWithDataKey(data, dataKey) {
-  const nonce = getRandomBytes(12);
-  const cipher = createCipheriv("aes-256-gcm", dataKey, nonce);
-  const plaintext = new TextEncoder().encode(JSON.stringify(data));
-  const encrypted = Buffer.concat([
-    cipher.update(plaintext),
-    cipher.final()
-  ]);
-  const authTag = cipher.getAuthTag();
-  const bundle = new Uint8Array(12 + encrypted.length + 16 + 1);
-  bundle.set([0], 0);
-  bundle.set(nonce, 1);
-  bundle.set(new Uint8Array(encrypted), 13);
-  bundle.set(new Uint8Array(authTag), 13 + encrypted.length);
-  return bundle;
-}
-function decryptWithDataKey(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 JSON.parse(new TextDecoder().decode(decrypted));
-  } catch (error) {
-    return null;
-  }
-}
-function encrypt(key, variant, data) {
-  if (variant === "legacy") {
-    return encryptLegacy(data, key);
-  } else {
-    return encryptWithDataKey(data, key);
-  }
-}
-function decrypt(key, variant, data) {
-  if (variant === "legacy") {
-    return decryptLegacy(data, key);
-  } else {
-    return decryptWithDataKey(data, key);
-  }
-}
-
 async function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1358,6 +1359,7 @@ class ApiSessionClient extends EventEmitter {
   metadataLock = new AsyncLock();
   encryptionKey;
   encryptionVariant;
+  pendingReliableCodexMessages = [];
   constructor(credentials, session) {
     super();
     this.credentials = credentials;
@@ -1393,6 +1395,7 @@ class ApiSessionClient extends EventEmitter {
     this.socket.on("connect", () => {
       logger.debug("Socket connected successfully");
       this.rpcHandlerManager.onSocketConnect(this.socket);
+      this.flushReliableCodexMessages();
     });
     this.socket.on("rpc-request", async (data, callback) => {
       callback(await this.rpcHandlerManager.handleRequest(data));
@@ -1429,10 +1432,12 @@ class ApiSessionClient extends EventEmitter {
           if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
             this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.metadata.value));
             this.metadataVersion = data.body.metadata.version;
+            this.emit("metadata-updated", this.metadata);
           }
           if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
             this.agentState = data.body.agentState.value ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.agentState.value)) : null;
             this.agentStateVersion = data.body.agentState.version;
+            this.emit("agent-state-updated", this.agentState);
           }
         } else if (data.body.t === "update-machine") {
           logger.debug(`[SOCKET] WARNING: Session client received unexpected machine update - ignoring`);
@@ -1454,6 +1459,33 @@ class ApiSessionClient extends EventEmitter {
       callback(this.pendingMessages.shift());
     }
   }
+  getMetadataSnapshot() {
+    return this.metadata;
+  }
+  getAgentStateSnapshot() {
+    return this.agentState;
+  }
+  async waitForMetadataUpdate(signal) {
+    if (signal?.aborted) {
+      throw createAbortError();
+    }
+    return await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        cleanup();
+        reject(createAbortError());
+      };
+      const onMetadataUpdate = (metadata) => {
+        cleanup();
+        resolve(metadata);
+      };
+      const cleanup = () => {
+        signal?.removeEventListener("abort", onAbort);
+        this.off("metadata-updated", onMetadataUpdate);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.on("metadata-updated", onMetadataUpdate);
+    });
+  }
   /**
    * Send message to session
    * @param body - Message body (can be MessageContent or raw content for agent messages)
@@ -1512,25 +1544,28 @@ class ApiSessionClient extends EventEmitter {
     }
   }
   sendCodexMessage(body) {
-    let content = {
+    const content = {
       role: "agent",
       content: {
         type: "codex",
         data: body
-        // This wraps the entire Claude message
       },
       meta: {
         sentFrom: "cli"
       }
     };
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const eventType = typeof body?.type === "string" ? body.type : "unknown";
     if (!this.socket.connected) {
-      logger.debug("[API] Socket not connected, cannot send message. Message will be lost:", { type: body.type });
+      if (this.shouldBufferReliableCodexMessage(body)) {
+        logger.debug("[API] Socket not connected, buffering reliable Codex message:", { type: eventType });
+        this.pendingReliableCodexMessages.push({ encrypted, type: eventType });
+      } else {
+        logger.debug("[API] Socket not connected, dropping non-critical Codex message:", { type: eventType });
+      }
+      return;
     }
-    this.socket.emit("message", {
-      sid: this.sessionId,
-      message: encrypted
-    });
+    this.emitEncryptedSessionMessage(encrypted);
   }
   /**
    * Send a generic agent message to the session using ACP (Agent Communication Protocol) format.
@@ -1630,10 +1665,12 @@ class ApiSessionClient extends EventEmitter {
         if (answer.result === "success") {
           this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata));
           this.metadataVersion = answer.version;
+          this.emit("metadata-updated", this.metadata);
         } else if (answer.result === "version-mismatch") {
           if (answer.version > this.metadataVersion) {
             this.metadataVersion = answer.version;
             this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata));
+            this.emit("metadata-updated", this.metadata);
           }
           throw new Error("Metadata version mismatch");
         } else if (answer.result === "error") ;
@@ -1653,11 +1690,13 @@ class ApiSessionClient extends EventEmitter {
         if (answer.result === "success") {
           this.agentState = answer.agentState ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.agentState)) : null;
           this.agentStateVersion = answer.version;
+          this.emit("agent-state-updated", this.agentState);
           logger.debug("Agent state updated", this.agentState);
         } else if (answer.result === "version-mismatch") {
           if (answer.version > this.agentStateVersion) {
             this.agentStateVersion = answer.version;
             this.agentState = answer.agentState ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.agentState)) : null;
+            this.emit("agent-state-updated", this.agentState);
           }
           throw new Error("Agent state version mismatch");
         } else if (answer.result === "error") ;
@@ -1684,6 +1723,44 @@ class ApiSessionClient extends EventEmitter {
     logger.debug("[API] socket.close() called");
     this.socket.close();
   }
+  emitEncryptedSessionMessage(encrypted) {
+    this.socket.emit("message", {
+      sid: this.sessionId,
+      message: encrypted
+    });
+  }
+  flushReliableCodexMessages() {
+    if (!this.socket.connected || this.pendingReliableCodexMessages.length === 0) {
+      return;
+    }
+    const buffered = this.pendingReliableCodexMessages.splice(0, this.pendingReliableCodexMessages.length);
+    logger.debug("[API] Flushing buffered Codex messages after reconnect", {
+      count: buffered.length,
+      types: buffered.map((message) => message.type)
+    });
+    for (const message of buffered) {
+      this.emitEncryptedSessionMessage(message.encrypted);
+    }
+  }
+  shouldBufferReliableCodexMessage(body) {
+    switch (body?.type) {
+      case "message":
+      case "tool-call":
+      case "tool-call-result":
+      case "permission-request":
+      case "task_started":
+      case "task_complete":
+      case "turn_aborted":
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+function createAbortError() {
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
 }
 
 class ApiMachineClient {
@@ -2460,53 +2537,4 @@ var api = /*#__PURE__*/Object.freeze({
   ApiClient: ApiClient
 });
 
-const UsageSchema = z.object({
-  input_tokens: z.number().int().nonnegative(),
-  cache_creation_input_tokens: z.number().int().nonnegative().optional(),
-  cache_read_input_tokens: z.number().int().nonnegative().optional(),
-  output_tokens: z.number().int().nonnegative(),
-  service_tier: z.string().optional()
-}).passthrough();
-const RawJSONLinesSchema = z.discriminatedUnion("type", [
-  // User message - validates uuid and message.content
-  z.object({
-    type: z.literal("user"),
-    isSidechain: z.boolean().optional(),
-    isMeta: z.boolean().optional(),
-    uuid: z.string(),
-    // Used in getMessageKey()
-    message: z.object({
-      content: z.union([z.string(), z.any()])
-      // Used in sessionScanner.ts
-    }).passthrough()
-  }).passthrough(),
-  // Assistant message - only validates uuid and type
-  // message object is optional to handle synthetic error messages (isApiErrorMessage: true)
-  // which may have different structure than normal assistant messages
-  z.object({
-    uuid: z.string(),
-    type: z.literal("assistant"),
-    message: z.object({
-      usage: UsageSchema.optional(),
-      // Used in apiSession.ts
-      model: z.string().optional()
-      // Used for cost calculation
-    }).passthrough().optional()
-  }).passthrough(),
-  // Summary message - validates summary and leafUuid
-  z.object({
-    type: z.literal("summary"),
-    summary: z.string(),
-    // Used in apiSession.ts
-    leafUuid: z.string()
-    // Used in getMessageKey()
-  }).passthrough(),
-  // System message - validates uuid
-  z.object({
-    type: z.literal("system"),
-    uuid: z.string()
-    // Used in getMessageKey()
-  }).passthrough()
-]);
-
-export { ApiClient as A, HAPPY_CLOUD_DAEMON_PORT as H, RawJSONLinesSchema as R, ApiSessionClient as a, connectionState as b, configuration as c, delay as d, encodeBase64 as e, backoff as f, AsyncLock as g, buildAuthenticatedHeaders as h, encodeBase64Url as i, buildClientHeaders as j, decodeBase64 as k, logger as l, getLatestDaemonLog as m, api as n, packageJson as p, startOfflineReconnection as s };
+export { ApiClient as A, HAPPY_CLOUD_DAEMON_PORT as H, ApiSessionClient as a, connectionState as b, configuration as c, backoff as d, encodeBase64 as e, delay as f, AsyncLock as g, buildAuthenticatedHeaders as h, encodeBase64Url as i, buildClientHeaders as j, decodeBase64 as k, logger as l, getLatestDaemonLog as m, api as n, packageJson as p, startOfflineReconnection as s };