happy-imou-cloud 1.1.7 → 2.0.0

package/dist/{types-BSTmyv9d.cjs → api-D7OK-mML.cjs}

@@ -5,7 +5,7 @@ var chalk = require('chalk');
 var fs$1 = require('fs');
 var fs = require('node:fs');
 var os = require('node:os');
-var node_path = require('node:path');
+var path = require('node:path');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
@@ -15,11 +15,11 @@ var child_process = require('child_process');
 var util = require('util');
 var fs$2 = require('fs/promises');
 var crypto = require('crypto');
-var path = require('path');
+var path$1 = require('path');
 var expoServerSdk = require('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";
@@ -64,22 +64,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",
@@ -217,7 +218,7 @@ class Configuration {
         const expandedPath = process.env.HAPPY_CLOUD_HOME_DIR.replace(/^~/, os.homedir());
         this.happyCloudHomeDir = expandedPath;
       } else {
-        this.happyCloudHomeDir = node_path.join(os.homedir(), ".happy-cloud");
+        this.happyCloudHomeDir = path.join(os.homedir(), ".happy-cloud");
       }
       this.happyHomeDir = this.happyCloudHomeDir;
     } else {
@@ -225,15 +226,15 @@ class Configuration {
         const expandedPath = process.env.HAPPY_HOME_DIR.replace(/^~/, os.homedir());
         this.happyHomeDir = expandedPath;
       } else {
-        this.happyHomeDir = node_path.join(os.homedir(), ".happy");
+        this.happyHomeDir = path.join(os.homedir(), ".happy");
       }
       this.happyCloudHomeDir = this.happyHomeDir;
     }
-    this.logsDir = node_path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "logs");
-    this.settingsFile = node_path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "settings.json");
-    this.privateKeyFile = node_path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "access.key");
-    this.daemonStateFile = node_path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "daemon.state.json");
-    this.daemonLockFile = node_path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "daemon.state.json.lock");
+    this.logsDir = path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "logs");
+    this.settingsFile = path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "settings.json");
+    this.privateKeyFile = path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "access.key");
+    this.daemonStateFile = path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "daemon.state.json");
+    this.daemonLockFile = path.join(this.isHappyCloudMode ? this.happyCloudHomeDir : this.happyHomeDir, "daemon.state.json.lock");
     this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
     this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.HAPPY_DISABLE_CAFFEINATE?.toLowerCase() || "");
     this.currentCliVersion = packageJson.version;
@@ -285,7 +286,7 @@ function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
 function getSessionLogPath() {
   const timestamp = createTimestampForFilename();
   const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
-  return node_path.join(configuration.logsDir, filename);
+  return path.join(configuration.logsDir, filename);
 }
 class Logger {
   constructor(logFilePath = getSessionLogPath()) {
@@ -427,12 +428,12 @@ async function listDaemonLogFiles(limit = 50) {
       return [];
     }
     const logs = fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
-      const fullPath = node_path.join(logsDir, file);
+      const fullPath = path.join(logsDir, file);
       const stats = fs.statSync(fullPath);
       return { file, path: fullPath, modified: stats.mtime };
     }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
     try {
-      const { readDaemonState } = await Promise.resolve().then(function () { return require('./persistence-BRH9F6RS.cjs'); });
+      const { readDaemonState } = await Promise.resolve().then(function () { return require('./persistence-DHgf1CTG.cjs'); });
       const state = await readDaemonState();
       if (!state) {
         return logs;
@@ -440,7 +441,7 @@ async function listDaemonLogFiles(limit = 50) {
       if (state.daemonLogPath && fs.existsSync(state.daemonLogPath)) {
         const stats = fs.statSync(state.daemonLogPath);
         const persisted = {
-          file: node_path.basename(state.daemonLogPath),
+          file: path.basename(state.daemonLogPath),
           path: state.daemonLogPath,
           modified: stats.mtime
         };
@@ -464,6 +465,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(node_crypto.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 = node_crypto.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 = node_crypto.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.z.object({
   c: z.z.string(),
   // Base64 encoded encrypted content
@@ -595,108 +698,6 @@ const AgentMessageSchema = z.z.object({
 });
 z.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(node_crypto.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 = node_crypto.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 = node_crypto.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));
 }
@@ -853,8 +854,8 @@ class RpcHandlerManager {
 }
 
 function validatePath(targetPath, workingDirectory) {
-  const resolvedTarget = path.resolve(workingDirectory, targetPath);
-  const resolvedWorkingDir = path.resolve(workingDirectory);
+  const resolvedTarget = path$1.resolve(workingDirectory, targetPath);
+  const resolvedWorkingDir = path$1.resolve(workingDirectory);
   const targetNormalized = resolvedTarget.replace(/\\/g, "/");
   const workingDirNormalized = resolvedWorkingDir.replace(/\\/g, "/");
   process.platform === "win32" ? "\\" : "/";
@@ -1008,7 +1009,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       const entries = await fs$2.readdir(data.path, { withFileTypes: true });
       const directoryEntries = await Promise.all(
         entries.map(async (entry) => {
-          const fullPath = path.join(data.path, entry.name);
+          const fullPath = path$1.join(data.path, entry.name);
           let type = "other";
           let size;
           let modified;
@@ -1049,26 +1050,26 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
     if (!validation.valid) {
       return { success: false, error: validation.error };
     }
-    async function buildTree(path$1, name, currentDepth) {
+    async function buildTree(path, name, currentDepth) {
       try {
-        const stats = await fs$2.stat(path$1);
+        const stats = await fs$2.stat(path);
         const node = {
           name,
-          path: path$1,
+          path,
           type: stats.isDirectory() ? "directory" : "file",
           size: stats.size,
           modified: stats.mtime.getTime()
         };
         if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await fs$2.readdir(path$1, { withFileTypes: true });
+          const entries = await fs$2.readdir(path, { withFileTypes: true });
           const children = [];
           await Promise.all(
             entries.map(async (entry) => {
               if (entry.isSymbolicLink()) {
-                logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
+                logger.debug(`Skipping symlink: ${path$1.join(path, entry.name)}`);
                 return;
               }
-              const childPath = path.join(path$1, entry.name);
+              const childPath = path$1.join(path, entry.name);
               const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
               if (childNode) {
                 children.push(childNode);
@@ -1084,7 +1085,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
         }
         return node;
       } catch (error) {
-        logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
+        logger.debug(`Failed to process ${path}:`, error instanceof Error ? error.message : String(error));
         return null;
       }
     }
@@ -1360,6 +1361,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   metadataLock = new AsyncLock();
   encryptionKey;
   encryptionVariant;
+  pendingReliableCodexMessages = [];
   constructor(credentials, session) {
     super();
     this.credentials = credentials;
@@ -1395,6 +1397,7 @@ class ApiSessionClient extends node_events.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));
@@ -1431,10 +1434,12 @@ class ApiSessionClient extends node_events.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`);
@@ -1456,6 +1461,33 @@ class ApiSessionClient extends node_events.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)
@@ -1514,25 +1546,28 @@ class ApiSessionClient extends node_events.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.
@@ -1632,10 +1667,12 @@ class ApiSessionClient extends node_events.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") ;
@@ -1655,11 +1692,13 @@ class ApiSessionClient extends node_events.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") ;
@@ -1686,6 +1725,44 @@ class ApiSessionClient extends node_events.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 {
@@ -2462,60 +2539,10 @@ var api = /*#__PURE__*/Object.freeze({
   ApiClient: ApiClient
 });
 
-const UsageSchema = z.z.object({
-  input_tokens: z.z.number().int().nonnegative(),
-  cache_creation_input_tokens: z.z.number().int().nonnegative().optional(),
-  cache_read_input_tokens: z.z.number().int().nonnegative().optional(),
-  output_tokens: z.z.number().int().nonnegative(),
-  service_tier: z.z.string().optional()
-}).passthrough();
-const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
-  // User message - validates uuid and message.content
-  z.z.object({
-    type: z.z.literal("user"),
-    isSidechain: z.z.boolean().optional(),
-    isMeta: z.z.boolean().optional(),
-    uuid: z.z.string(),
-    // Used in getMessageKey()
-    message: z.z.object({
-      content: z.z.union([z.z.string(), z.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.z.object({
-    uuid: z.z.string(),
-    type: z.z.literal("assistant"),
-    message: z.z.object({
-      usage: UsageSchema.optional(),
-      // Used in apiSession.ts
-      model: z.z.string().optional()
-      // Used for cost calculation
-    }).passthrough().optional()
-  }).passthrough(),
-  // Summary message - validates summary and leafUuid
-  z.z.object({
-    type: z.z.literal("summary"),
-    summary: z.z.string(),
-    // Used in apiSession.ts
-    leafUuid: z.z.string()
-    // Used in getMessageKey()
-  }).passthrough(),
-  // System message - validates uuid
-  z.z.object({
-    type: z.z.literal("system"),
-    uuid: z.z.string()
-    // Used in getMessageKey()
-  }).passthrough()
-]);
-
 exports.ApiClient = ApiClient;
 exports.ApiSessionClient = ApiSessionClient;
 exports.AsyncLock = AsyncLock;
 exports.HAPPY_CLOUD_DAEMON_PORT = HAPPY_CLOUD_DAEMON_PORT;
-exports.RawJSONLinesSchema = RawJSONLinesSchema;
 exports.api = api;
 exports.backoff = backoff;
 exports.buildAuthenticatedHeaders = buildAuthenticatedHeaders;

package/dist/command-CnLtKtP-.mjs

@@ -0,0 +1,51 @@
+import { c as createDefaultRuntimeShell } from './index-C7Y0R-MI.mjs';
+import 'chalk';
+import './api-BGXYX0yH.mjs';
+import 'axios';
+import 'fs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'node:events';
+import 'socket.io-client';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'child_process';
+import 'util';
+import 'fs/promises';
+import 'crypto';
+import 'path';
+import 'expo-server-sdk';
+import './persistence-BA_unuca.mjs';
+import 'node:fs/promises';
+import 'os';
+import 'tmp';
+import 'qrcode-terminal';
+import 'node:module';
+import 'open';
+import 'react';
+import 'ink';
+import 'url';
+import 'node:child_process';
+import 'ps-list';
+import 'cross-spawn';
+import 'fastify';
+import 'fastify-type-provider-zod';
+import 'node:readline';
+import 'http';
+import '@agentclientprotocol/sdk';
+
+function listRuntimeProviders() {
+  const shell = createDefaultRuntimeShell();
+  const providers = ["claude", "codex", "gemini", "cursor"];
+  return providers.map((provider) => ({
+    provider,
+    supported: shell.supports(provider)
+  }));
+}
+function renderRuntimeProviders() {
+  return listRuntimeProviders().map(({ provider, supported }) => `${provider}: ${supported ? "registered" : "missing"}`).join("\n");
+}
+
+export { listRuntimeProviders, renderRuntimeProviders };