happy-imou-cloud 2.1.4 → 2.1.6

package/dist/{index-D72RMo5Z.mjs → index-B5e-MA1d.mjs}

@@ -1,9 +1,9 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, q as decodeBase64, r as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-l8X03rs-.mjs';
-import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-CyFjFOlN.mjs';
+import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, p as decodeBase64, q as HAPPY_CLOUD_DAEMON_PORT, r as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-DF9A136-.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-BsWBBi7E.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
-import os, { homedir } from 'os';
+import os$1, { homedir } from 'os';
 import * as tmp from 'tmp';
 import { randomUUID, randomBytes } from 'node:crypto';
 import tweetnacl from 'tweetnacl';
@@ -11,7 +11,7 @@ import axios from 'axios';
 import qrcode from 'qrcode-terminal';
 import { writeFile, unlink, readdir, readFile, mkdir } from 'node:fs/promises';
 import { createRequire } from 'node:module';
-import os$1, { tmpdir, homedir as homedir$1 } from 'node:os';
+import os, { tmpdir, homedir as homedir$1 } from 'node:os';
 import path, { join, resolve as resolve$1, isAbsolute, delimiter, normalize, dirname as dirname$1 } from 'node:path';
 import open from 'open';
 import React, { useState } from 'react';
@@ -2499,6 +2499,128 @@ async function runDaemonHealthCheck({
   await writeHeartbeat();
 }
 
+async function closeProviderSession(session, opts = {}) {
+  let firstError;
+  const captureError = (error) => {
+    if (firstError === void 0) {
+      firstError = error;
+    }
+  };
+  if (opts.archiveOnClose || opts.archiveReason) {
+    try {
+      session.updateMetadata((currentMetadata) => {
+        const { archiveReason: _existingArchiveReason, ...metadataWithoutArchiveReason } = currentMetadata;
+        return {
+          ...metadataWithoutArchiveReason,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: opts.archivedBy ?? "cli",
+          ...opts.archiveReason ? { archiveReason: opts.archiveReason } : {}
+        };
+      });
+    } catch (error) {
+      captureError(error);
+    }
+  }
+  try {
+    session.sendSessionDeath();
+  } catch (error) {
+    captureError(error);
+  }
+  try {
+    await session.flush();
+  } catch (error) {
+    captureError(error);
+  }
+  try {
+    await session.close();
+  } catch (error) {
+    captureError(error);
+  }
+  if (firstError !== void 0) {
+    throw firstError;
+  }
+}
+
+function createSessionMetadata(opts) {
+  const state = {
+    controlledByUser: false
+  };
+  const metadataPath = opts.path ?? process.cwd();
+  const metadataHostPid = opts.hostPid === void 0 ? process.pid : opts.hostPid;
+  const metadata = {
+    path: metadataPath,
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId: opts.machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.happyCloudHomeDir,
+    happyLibDir: projectPath(),
+    happyToolsDir: resolve$1(projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    startedBy: opts.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: opts.flavor,
+    ...metadataHostPid == null ? {} : { hostPid: metadataHostPid }
+  };
+  return { state, metadata };
+}
+
+async function archiveManagedSessionById(opts) {
+  try {
+    const sessionClient = opts.api.sessionSyncClient({ id: opts.sessionId });
+    await closeProviderSession(sessionClient, {
+      archiveReason: opts.archiveReason,
+      archivedBy: "daemon"
+    });
+  } catch (error) {
+    logger.debug(
+      `[DAEMON RUN] Failed to archive managed session ${opts.sessionId}: ${opts.archiveReason}`,
+      error
+    );
+  }
+}
+async function precreateDaemonManagedSession(opts) {
+  const { state, metadata } = createSessionMetadata({
+    flavor: opts.flavor,
+    machineId: opts.machineId,
+    startedBy: "daemon",
+    path: opts.directory,
+    hostPid: null
+  });
+  try {
+    return await opts.api.getOrCreateSession({
+      tag: opts.sessionTag,
+      metadata,
+      state
+    });
+  } catch (error) {
+    logger.debug(`[DAEMON RUN] Failed to precreate ${opts.flavor} session for tag ${opts.sessionTag}`, error);
+    return null;
+  }
+}
+async function archivePrecreatedManagedSession(opts) {
+  await archiveManagedSessionById({
+    api: opts.api,
+    sessionId: opts.session.id,
+    archiveReason: opts.archiveReason
+  });
+}
+async function archiveDetachedManagedSessionIfNeeded(opts) {
+  const { trackedSession } = opts;
+  if (trackedSession.startedBy !== "daemon" || !trackedSession.happySessionId || trackedSession.happySessionMetadataFromLocalWebhook) {
+    return false;
+  }
+  await archiveManagedSessionById({
+    api: opts.api,
+    sessionId: trackedSession.happySessionId,
+    archiveReason: opts.archiveReason
+  });
+  return true;
+}
+
 const NON_SESSION_PROCESS_TYPES$1 = /* @__PURE__ */ new Set([
   "current",
   "daemon",
@@ -2821,6 +2943,19 @@ async function recoverTrackedSessionsFromLocalRegistry({
   return { recoveredCount, removedStaleCount };
 }
 
+const HAPPY_MANAGED_SESSION_TAG_ENV = "HAPPY_MANAGED_SESSION_TAG";
+function readManagedSessionTag(env = process.env) {
+  const raw = env[HAPPY_MANAGED_SESSION_TAG_ENV];
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function resolveManagedSessionTag(env = process.env) {
+  return readManagedSessionTag(env) ?? randomUUID();
+}
+
 const DEFAULT_SESSION_WEBHOOK_TIMEOUT_MS = 45e3;
 function resolveSessionWebhookTimeoutMs() {
   const parsed = Number.parseInt(process.env.HAPPY_DAEMON_SESSION_WEBHOOK_TIMEOUT || "", 10);
@@ -2830,10 +2965,10 @@ function resolveSessionWebhookTimeoutMs() {
   return DEFAULT_SESSION_WEBHOOK_TIMEOUT_MS;
 }
 const initialMachineMetadata = {
-  host: os.hostname(),
-  platform: os.platform(),
+  host: os$1.hostname(),
+  platform: os$1.platform(),
   happyCliVersion: packageJson.version,
-  homeDir: os.homedir(),
+  homeDir: os$1.homedir(),
   happyHomeDir: configuration.happyCloudHomeDir,
   happyLibDir: projectPath()
 };
@@ -2917,9 +3052,21 @@ async function startDaemon() {
     }
     const { credentials, machineId } = await authAndSetupMachineIfNeeded();
     logger.debug("[DAEMON RUN] Auth and machine setup complete");
+    let api = null;
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const pidToAwaiter = /* @__PURE__ */ new Map();
     const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
+    const removeTrackedSession = (pid, archiveReason) => {
+      const trackedSession = pidToTrackedSession.get(pid);
+      if (trackedSession && api) {
+        void archiveDetachedManagedSessionIfNeeded({
+          api,
+          trackedSession,
+          archiveReason
+        });
+      }
+      pidToTrackedSession.delete(pid);
+    };
     const onHappySessionWebhook = (sessionId, sessionMetadata) => {
       logger.debugLargeJson(`[DAEMON RUN] Session reported`, sessionMetadata);
       const pid = sessionMetadata.hostPid;
@@ -2956,8 +3103,9 @@ async function startDaemon() {
     };
     const spawnSession = async (options) => {
       logger.debugLargeJson("[DAEMON RUN] Spawning session", options);
-      const { directory, sessionId, machineId: machineId2, approvedNewDirectoryCreation = true } = options;
+      const { directory, sessionId, machineId: _requestedMachineId, approvedNewDirectoryCreation = true } = options;
       let directoryCreated = false;
+      let precreatedCodexSession = null;
       try {
         await fs.access(directory);
         logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
@@ -3031,6 +3179,11 @@ async function startDaemon() {
         }
         let extraEnv = { ...profileEnv, ...authEnv };
         logger.debug(`[DAEMON RUN] Final environment variable keys (before expansion) (${Object.keys(extraEnv).length}): ${Object.keys(extraEnv).join(", ")}`);
+        const managedSessionTag = options.agent === "codex" ? randomUUID() : null;
+        if (managedSessionTag) {
+          extraEnv[HAPPY_MANAGED_SESSION_TAG_ENV] = managedSessionTag;
+          logger.debug(`[DAEMON RUN] Reserved managed Codex session tag ${managedSessionTag}`);
+        }
         extraEnv = expandEnvironmentVariables(extraEnv, process.env);
         logger.debug(`[DAEMON RUN] After variable expansion: ${Object.keys(extraEnv).join(", ")}`);
         const potentialAuthVars = ["ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "OPENAI_API_KEY", "CODEX_HOME", "AZURE_OPENAI_API_KEY", "TOGETHER_API_KEY"];
@@ -3069,6 +3222,18 @@ async function startDaemon() {
           const fullCommand = `node --no-warnings --no-deprecation ${cliPath} ${buildDaemonSpawnArgs(agent).join(" ")}`;
           const windowName = `happy-${Date.now()}-${agent}`;
           const tmuxEnv = buildDaemonChildEnv(process.env, extraEnv);
+          if (managedSessionTag && api) {
+            precreatedCodexSession = await precreateDaemonManagedSession({
+              api,
+              sessionTag: managedSessionTag,
+              machineId,
+              directory,
+              flavor: "codex"
+            });
+            if (precreatedCodexSession) {
+              logger.debug(`[DAEMON RUN] Precreated Codex session ${precreatedCodexSession.id} before tmux spawn`);
+            }
+          }
           const tmuxResult = await tmux.spawnInTmux([fullCommand], {
             sessionName: tmuxSessionName,
             windowName,
@@ -3081,6 +3246,7 @@ async function startDaemon() {
             }
             const trackedSession = {
               startedBy: "daemon",
+              happySessionId: precreatedCodexSession?.id,
               pid: tmuxResult.pid,
               // Real PID from tmux -P flag
               tmuxSessionId: tmuxResult.sessionId,
@@ -3088,6 +3254,13 @@ async function startDaemon() {
               message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.` : `Spawned new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.`
             };
             pidToTrackedSession.set(tmuxResult.pid, trackedSession);
+            if (precreatedCodexSession) {
+              logger.debug(`[DAEMON RUN] Returning precreated Codex session ${precreatedCodexSession.id} without waiting for webhook`);
+              return {
+                type: "success",
+                sessionId: precreatedCodexSession.id
+              };
+            }
             logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${tmuxResult.pid} (tmux)`);
             return new Promise((resolve) => {
               const timeout = setTimeout(() => {
@@ -3108,6 +3281,14 @@ async function startDaemon() {
               });
             });
           } else {
+            if (precreatedCodexSession && api) {
+              await archivePrecreatedManagedSession({
+                api,
+                session: precreatedCodexSession,
+                archiveReason: `tmux spawn failed before Codex session ${precreatedCodexSession.id} attached`
+              });
+              precreatedCodexSession = null;
+            }
             logger.debug(`[DAEMON RUN] Failed to spawn in tmux: ${tmuxResult.error}, falling back to regular spawning`);
             useTmux = false;
           }
@@ -3127,6 +3308,18 @@ async function startDaemon() {
               errorMessage: spawnError.errorMessage
             };
           }
+          if (managedSessionTag && api) {
+            precreatedCodexSession = await precreateDaemonManagedSession({
+              api,
+              sessionTag: managedSessionTag,
+              machineId,
+              directory,
+              flavor: "codex"
+            });
+            if (precreatedCodexSession) {
+              logger.debug(`[DAEMON RUN] Precreated Codex session ${precreatedCodexSession.id} before process spawn`);
+            }
+          }
           const happyProcess = spawnHappyCLI(args, {
             cwd: directory,
             detached: true,
@@ -3145,6 +3338,14 @@ async function startDaemon() {
           }
           if (!happyProcess.pid) {
             logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
+            if (precreatedCodexSession && api) {
+              await archivePrecreatedManagedSession({
+                api,
+                session: precreatedCodexSession,
+                archiveReason: `spawn produced no PID for precreated Codex session ${precreatedCodexSession.id}`
+              });
+              precreatedCodexSession = null;
+            }
             const spawnError = createSpawnSessionError(
               SPAWN_SESSION_ERROR_CODES.SPAWN_NO_PID,
               "Failed to spawn Happy process - no PID returned"
@@ -3157,6 +3358,7 @@ async function startDaemon() {
           logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
           const trackedSession = {
             startedBy: "daemon",
+            happySessionId: precreatedCodexSession?.id,
             pid: happyProcess.pid,
             childProcess: happyProcess,
             directoryCreated,
@@ -3175,6 +3377,13 @@ async function startDaemon() {
               onChildExited(happyProcess.pid);
             }
           });
+          if (precreatedCodexSession) {
+            logger.debug(`[DAEMON RUN] Returning precreated Codex session ${precreatedCodexSession.id} without waiting for webhook`);
+            return {
+              type: "success",
+              sessionId: precreatedCodexSession.id
+            };
+          }
           logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
           return new Promise((resolve) => {
             const timeout = setTimeout(() => {
@@ -3202,6 +3411,13 @@ async function startDaemon() {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logger.debug("[DAEMON RUN] Failed to spawn session:", error);
+        if (precreatedCodexSession && api) {
+          await archivePrecreatedManagedSession({
+            api,
+            session: precreatedCodexSession,
+            archiveReason: `spawn failed before precreated Codex session ${precreatedCodexSession.id} attached: ${errorMessage}`
+          });
+        }
         const spawnError = createSpawnSessionError(
           SPAWN_SESSION_ERROR_CODES.SPAWN_FAILED,
           `Failed to spawn session: ${errorMessage}`
@@ -3231,7 +3447,7 @@ async function startDaemon() {
               logger.debug(`[DAEMON RUN] Failed to kill external session PID ${pid}:`, error);
             }
           }
-          pidToTrackedSession.delete(pid);
+          removeTrackedSession(pid, `session ${sessionId} was stopped from daemon control before local attachment completed`);
           logger.debug(`[DAEMON RUN] Removed session ${sessionId} from tracking`);
           return true;
         }
@@ -3253,7 +3469,7 @@ async function startDaemon() {
           errorMessage: spawnError.errorMessage
         });
       }
-      pidToTrackedSession.delete(pid);
+      removeTrackedSession(pid, `process ${pid} exited before the managed session fully attached`);
     };
     const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
       getChildren: getCurrentChildren,
@@ -3291,22 +3507,23 @@ async function startDaemon() {
       httpPort: controlPort,
       startedAt: Date.now()
     };
-    const api = await ApiClient.create(credentials);
+    api = await ApiClient.create(credentials);
+    const activeApi = api;
     let userScopedObserver = null;
     if (credentials.signing) {
       try {
-        userScopedObserver = api.userScopedObserverClient?.() ?? null;
+        userScopedObserver = activeApi.userScopedObserverClient?.() ?? null;
       } catch (error) {
         logger.debug("[DAEMON RUN] Failed to start user-scoped observer, continuing without it", error);
       }
     }
-    const machine = await api.getOrCreateMachine({
+    const machine = await activeApi.getOrCreateMachine({
       machineId,
       metadata: initialMachineMetadata,
       daemonState: initialDaemonState
     });
     logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
-    const apiMachine = api.machineSyncClient(machine);
+    const apiMachine = activeApi.machineSyncClient(machine);
     apiMachine.setRPCHandlers({
       spawnSession,
       stopSession,
@@ -3314,7 +3531,7 @@ async function startDaemon() {
     });
     const runRemoteSessionIndexRecovery = async (label) => {
       const recoveryResult = await recoverTrackedSessionsFromRemoteIndex({
-        api,
+        api: activeApi,
         machineId,
         trackedSessionPids: pidToTrackedSession.keys(),
         trackSession: (pid, trackedSession) => {
@@ -3370,7 +3587,7 @@ async function startDaemon() {
         await runDaemonHealthCheck({
           trackedSessionPids: pidToTrackedSession.keys(),
           removeTrackedSession: (pid) => {
-            pidToTrackedSession.delete(pid);
+            removeTrackedSession(pid, `health check removed stale tracked PID ${pid} before local attachment completed`);
           },
           currentCliVersion: configuration.currentCliVersion,
           onDaemonOutdated: async () => {
@@ -3513,10 +3730,10 @@ async function install$1() {
                 <true/>
                 
                 <key>StandardErrorPath</key>
-                <string>${os.homedir()}/.happy/daemon.err</string>
+                <string>${os$1.homedir()}/.happy/daemon.err</string>
                 
                 <key>StandardOutPath</key>
-                <string>${os.homedir()}/.happy/daemon.log</string>
+                <string>${os$1.homedir()}/.happy/daemon.log</string>
                 
                 <key>WorkingDirectory</key>
                 <string>/tmp</string>
@@ -3649,7 +3866,7 @@ async function handleAuthLogin(args) {
     if (existingCreds && settings?.machineId) {
       console.log(chalk.green("\u2713 Already authenticated"));
       console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
-      console.log(chalk.gray(`  Host: ${os$1.hostname()}`));
+      console.log(chalk.gray(`  Host: ${os.hostname()}`));
       console.log(chalk.gray(`  Use 'hicloud auth login --force' to re-authenticate`));
       return;
     } else if (existingCreds && !settings?.machineId) {
@@ -3728,7 +3945,7 @@ async function handleAuthStatus() {
   if (settings?.machineId) {
     console.log(chalk.green("\u2713 Machine registered"));
     console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
-    console.log(chalk.gray(`  Host: ${os$1.hostname()}`));
+    console.log(chalk.gray(`  Host: ${os.hostname()}`));
   } else {
     console.log(chalk.yellow("\u26A0\uFE0F  Machine not registered"));
     console.log(chalk.gray('  Run "hicloud auth login --force" to fix this'));
@@ -7925,7 +8142,7 @@ function firstExistingPath(candidates) {
 }
 function resolveCodexExecutable() {
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path.join(os$1.homedir(), "AppData", "Roaming");
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
     const npmGlobalBin = path.join(appData, "npm");
     const resolved = firstExistingPath([
       path.join(npmGlobalBin, "codex.cmd"),
@@ -8365,6 +8582,7 @@ class Query {
   }
   pendingControlResponses = /* @__PURE__ */ new Map();
   cancelControllers = /* @__PURE__ */ new Map();
+  controlTasks = /* @__PURE__ */ new Set();
   sdkMessages;
   inputStream = new Stream();
   canCallTool;
@@ -8413,7 +8631,12 @@ class Query {
               }
               continue;
             } else if (message.type === "control_request") {
-              await this.handleControlRequest(message);
+              const controlTask = this.handleControlRequest(message).catch((error) => {
+                logger.debug("[ClaudeSDK] Failed to handle control request:", error);
+              }).finally(() => {
+                this.controlTasks.delete(controlTask);
+              });
+              this.controlTasks.add(controlTask);
               continue;
             } else if (message.type === "control_cancel_request") {
               this.handleControlCancelRequest(message);
@@ -8429,8 +8652,11 @@ class Query {
     } catch (error) {
       this.inputStream.error(error);
     } finally {
-      this.inputStream.done();
       this.cleanupControllers();
+      if (this.controlTasks.size > 0) {
+        await Promise.allSettled(Array.from(this.controlTasks));
+      }
+      this.inputStream.done();
       rl.close();
     }
   }
@@ -8495,7 +8721,7 @@ class Query {
           response
         }
       };
-      this.childStdin.write(JSON.stringify(controlResponse) + "\n");
+      this.writeControlResponse(controlResponse);
     } catch (error) {
       const controlErrorResponse = {
         type: "control_response",
@@ -8505,11 +8731,21 @@ class Query {
           error: error instanceof Error ? error.message : String(error)
         }
       };
-      this.childStdin.write(JSON.stringify(controlErrorResponse) + "\n");
+      this.writeControlResponse(controlErrorResponse);
     } finally {
       this.cancelControllers.delete(request.request_id);
     }
   }
+  writeControlResponse(response) {
+    if (!this.childStdin || this.childStdin.destroyed || !this.childStdin.writable) {
+      return;
+    }
+    try {
+      this.childStdin.write(JSON.stringify(response) + "\n");
+    } catch (error) {
+      logger.debug("[ClaudeSDK] Failed to write control response:", error);
+    }
+  }
   /**
    * Handle control cancel requests
    * Replicates the exact logic from the SDK's handleControlCancelRequest method
@@ -9494,11 +9730,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await import('./runClaude-BRhQLKjh.mjs');
+    const { runClaude } = await import('./runClaude-MF34EsCp.mjs');
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-DUs_jBE-.mjs');
+    const { runCodex } = await import('./runCodex-B31D_imZ.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -9507,7 +9743,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-pmvBZ6qU.mjs');
+    const { runGemini } = await import('./runGemini-BJ7PxLyl.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -9583,7 +9819,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-BVCkEMtp.mjs');
+      const { renderRuntimeProviders } = await import('./command-hO52qTzQ.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -9761,8 +9997,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-CyFjFOlN.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-l8X03rs-.mjs').then(function (n) { return n.v; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-BsWBBi7E.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-DF9A136-.mjs').then(function (n) { return n.v; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -10178,4 +10414,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { AbortError as A, ExitCodeError as E, Future as F, GEMINI_MODEL_ENV as G, PushableAsyncIterable as P, RuntimeShell as R, createGeminiBackend as a, stopCaffeinate as b, createDefaultRuntimeShell as c, createCodexBackend as d, projectPath as e, formatDisplayMessage as f, getInitialGeminiModel as g, resolveCanonicalToolNameV2 as h, initialMachineMetadata as i, getProjectPath as j, claudeLocal as k, trimIdent as l, createClaudeBackend as m, claudeCheckSession as n, mapToClaudeMode as o, publishSessionRegistration as p, query as q, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, getEnvironmentInfo as u, validateCodexAcpSpawn as v, startCaffeinate as w };
+export { AbortError as A, startCaffeinate as B, ExitCodeError as E, Future as F, GEMINI_MODEL_ENV as G, PushableAsyncIterable as P, RuntimeShell as R, createSessionMetadata as a, closeProviderSession as b, createDefaultRuntimeShell as c, createGeminiBackend as d, stopCaffeinate as e, formatDisplayMessage as f, getInitialGeminiModel as g, createCodexBackend as h, readManagedSessionTag as i, resolveManagedSessionTag as j, initialMachineMetadata as k, resolveCanonicalToolNameV2 as l, getProjectPath as m, claudeLocal as n, trimIdent as o, publishSessionRegistration as p, createClaudeBackend as q, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, claudeCheckSession as u, validateCodexAcpSpawn as v, projectPath as w, mapToClaudeMode as x, query as y, getEnvironmentInfo as z };