antigravity-usage 0.1.0 → 0.2.0

package/dist/index.js

@@ -525,6 +525,17 @@ var OAUTH_CONFIG = {
     "https://www.googleapis.com/auth/userinfo.email"
   ]
 };
+var CLOUDCODE_CONFIG = {
+  baseUrl: "https://cloudcode-pa.googleapis.com",
+  userAgent: "antigravity",
+  metadata: {
+    ideType: "ANTIGRAVITY",
+    platform: "PLATFORM_UNSPECIFIED",
+    pluginType: "GEMINI"
+  },
+  onboardAttempts: 5,
+  onboardDelayMs: 2e3
+};
 function generateState() {
   return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
 }
@@ -585,28 +596,124 @@ async function getUserEmail(accessToken) {
   }
   return void 0;
 }
-async function fetchProjectId(accessToken) {
-  debug("oauth", "Fetching project ID from Cloud Code API");
+function extractProjectId(value) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  if (value && typeof value === "object" && "id" in value) {
+    const id = value.id;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  return void 0;
+}
+function pickOnboardTier(allowedTiers, tierIdFromLoad) {
+  if (!allowedTiers || allowedTiers.length === 0) {
+    return tierIdFromLoad;
+  }
+  const defaultTier = allowedTiers.find((t) => t.isDefault === true && t.id && t.id.length > 0);
+  if (defaultTier?.id) {
+    return defaultTier.id;
+  }
+  const firstTier = allowedTiers.find((t) => t.id && t.id.length > 0);
+  if (firstTier?.id) {
+    return firstTier.id;
+  }
+  if (allowedTiers.length > 0) {
+    return "LEGACY";
+  }
+  return tierIdFromLoad;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function tryOnboardUser(accessToken, tierId) {
+  debug("oauth", `Starting onboard flow with tierId: ${tierId}`);
+  const payload = {
+    tierId,
+    metadata: CLOUDCODE_CONFIG.metadata
+  };
+  for (let attempt = 1; attempt <= CLOUDCODE_CONFIG.onboardAttempts; attempt++) {
+    debug("oauth", `Onboard attempt ${attempt}/${CLOUDCODE_CONFIG.onboardAttempts}`);
+    try {
+      const response = await fetch(`${CLOUDCODE_CONFIG.baseUrl}/v1internal:onboardUser`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+          "User-Agent": CLOUDCODE_CONFIG.userAgent
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        debug("oauth", `Onboard request failed: ${response.status}`);
+        if (response.status === 401 || response.status === 403) {
+          debug("oauth", "Onboarding forbidden or unauthorized, stopping retries");
+          return void 0;
+        }
+      } else {
+        const data = await response.json();
+        debug("oauth", `Onboard response: done=${data.done}`);
+        if (data.done === true) {
+          const projectId = extractProjectId(data.response?.cloudaicompanionProject);
+          if (projectId) {
+            debug("oauth", `Onboarding complete, projectId: ${projectId}`);
+            return projectId;
+          }
+          debug("oauth", "Onboarding done but no projectId in response");
+          return void 0;
+        }
+      }
+    } catch (err) {
+      debug("oauth", `Onboard attempt ${attempt} error:`, err);
+    }
+    if (attempt < CLOUDCODE_CONFIG.onboardAttempts) {
+      debug("oauth", `Waiting ${CLOUDCODE_CONFIG.onboardDelayMs}ms before next attempt`);
+      await sleep(CLOUDCODE_CONFIG.onboardDelayMs);
+    }
+  }
+  debug("oauth", "Onboarding attempts exhausted");
+  return void 0;
+}
+async function resolveProjectId(accessToken) {
+  debug("oauth", "Resolving project ID from Cloud Code API");
   try {
-    const response = await fetch("https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist", {
+    const response = await fetch(`${CLOUDCODE_CONFIG.baseUrl}/v1internal:loadCodeAssist`, {
       method: "POST",
       headers: {
         "Authorization": `Bearer ${accessToken}`,
         "Content-Type": "application/json",
-        "User-Agent": "antigravity/1.11.3 Darwin/arm64"
+        "User-Agent": CLOUDCODE_CONFIG.userAgent
       },
-      body: JSON.stringify({ metadata: { ideType: "ANTIGRAVITY" } })
+      body: JSON.stringify({ metadata: CLOUDCODE_CONFIG.metadata })
     });
-    if (response.ok) {
-      const data = await response.json();
-      debug("oauth", `Got project ID: ${data.cloudaicompanionProject}`);
-      return data.cloudaicompanionProject;
+    if (!response.ok) {
+      debug("oauth", `loadCodeAssist failed: ${response.status}`);
+      return { projectId: void 0, tierId: void 0 };
+    }
+    const data = await response.json();
+    const projectId = extractProjectId(data.cloudaicompanionProject);
+    const tierId = data.paidTier?.id || data.currentTier?.id;
+    if (projectId) {
+      debug("oauth", `Got projectId from loadCodeAssist: ${projectId}`);
+      return { projectId, tierId };
+    }
+    debug("oauth", "No projectId in loadCodeAssist response, initiating onboarding");
+    const onboardTier = pickOnboardTier(data.allowedTiers, tierId);
+    if (!onboardTier) {
+      debug("oauth", "Cannot determine tier for onboarding");
+      return { projectId: void 0, tierId };
     }
-    debug("oauth", `Failed to get project ID: ${response.status}`);
+    const onboardedProjectId = await tryOnboardUser(accessToken, onboardTier);
+    return {
+      projectId: onboardedProjectId,
+      tierId: onboardTier
+    };
   } catch (err) {
-    debug("oauth", "Error fetching project ID", err);
+    debug("oauth", "Error resolving project ID", err);
+    return { projectId: void 0, tierId: void 0 };
   }
-  return void 0;
 }
 async function startOAuthFlow(options = {}) {
   const port = await getAvailablePort(options.port);
@@ -653,9 +760,15 @@ async function startOAuthFlow(options = {}) {
           const email = await getUserEmail(tokenResponse.access_token);
           let projectId;
           try {
-            projectId = await fetchProjectId(tokenResponse.access_token);
+            const projectResult = await resolveProjectId(tokenResponse.access_token);
+            projectId = projectResult.projectId;
+            if (projectId) {
+              debug("oauth", `Project ID resolved: ${projectId}`);
+            } else {
+              debug("oauth", "No project ID obtained (will fetch on demand)");
+            }
           } catch (err) {
-            debug("oauth", "Failed to fetch project ID during login (will fetch on demand)", err);
+            debug("oauth", "Failed to resolve project ID during login (will fetch on demand)", err);
           }
           const tokens = {
             accessToken: tokenResponse.access_token,
@@ -852,9 +965,29 @@ var APIError = class extends Error {
   }
 };
 var TokenRefreshError = class extends Error {
-  constructor(message = "Failed to refresh token. Please login again.") {
+  /** Original error that caused the refresh failure */
+  cause;
+  /** HTTP status code if available */
+  statusCode;
+  /** Whether the error is retryable (network issues) vs permanent (invalid token) */
+  isRetryable;
+  constructor(message = "Failed to refresh token. Please login again.", options) {
     super(message);
     this.name = "TokenRefreshError";
+    this.cause = options?.cause;
+    this.statusCode = options?.statusCode;
+    this.isRetryable = options?.isRetryable ?? true;
+  }
+  /** Get detailed error message including cause */
+  getDetailedMessage() {
+    let msg = this.message;
+    if (this.statusCode) {
+      msg += ` (HTTP ${this.statusCode})`;
+    }
+    if (this.cause) {
+      msg += `: ${this.cause.message}`;
+    }
+    return msg;
   }
 };
 var AntigravityNotRunningError = class extends Error {
@@ -893,7 +1026,11 @@ var TokenManager = class {
       this.tokens = loadAccountTokens(email);
     } else {
       this.accountEmail = getActiveAccountEmail();
-      this.tokens = loadTokens();
+      if (this.accountEmail) {
+        this.tokens = loadAccountTokens(this.accountEmail);
+      } else {
+        this.tokens = loadTokens();
+      }
     }
   }
   /**
@@ -930,6 +1067,19 @@ var TokenManager = class {
   getProjectId() {
     return this.tokens?.projectId;
   }
+  /**
+   * Set and persist project ID
+   */
+  setProjectId(projectId) {
+    if (!this.tokens) return;
+    this.tokens.projectId = projectId;
+    if (this.accountEmail) {
+      saveAccountTokens(this.accountEmail, this.tokens);
+    } else {
+      saveTokens(this.tokens);
+    }
+    debug("token-manager", `Project ID saved: ${projectId}`);
+  }
   /**
    * Check if token is expired or about to expire
    */
@@ -952,33 +1102,65 @@ var TokenManager = class {
     return this.tokens.accessToken;
   }
   /**
-   * Refresh the access token
+   * Refresh the access token with retry logic
+   * Retries on transient network errors, fails immediately on permanent errors (invalid_grant)
    */
   async refreshToken() {
     if (!this.tokens?.refreshToken) {
       throw new NotLoggedInError("No refresh token available. Please login again.");
     }
-    try {
-      debug("token-manager", "Refreshing token...");
-      const response = await refreshAccessToken(this.tokens.refreshToken);
-      this.tokens = {
-        accessToken: response.access_token,
-        refreshToken: response.refresh_token || this.tokens.refreshToken,
-        expiresAt: Date.now() + response.expires_in * 1e3,
-        email: this.tokens.email,
-        projectId: this.tokens.projectId
-      };
-      if (this.accountEmail) {
-        saveAccountTokens(this.accountEmail, this.tokens);
-        updateLastUsed(this.accountEmail);
-      } else {
-        saveTokens(this.tokens);
+    const MAX_RETRIES = 3;
+    const BASE_DELAY_MS = 1e3;
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        debug("token-manager", `Refreshing token (attempt ${attempt}/${MAX_RETRIES})...`);
+        const response = await refreshAccessToken(this.tokens.refreshToken);
+        this.tokens = {
+          accessToken: response.access_token,
+          refreshToken: response.refresh_token || this.tokens.refreshToken,
+          expiresAt: Date.now() + response.expires_in * 1e3,
+          email: this.tokens.email,
+          projectId: this.tokens.projectId
+        };
+        if (this.accountEmail) {
+          saveAccountTokens(this.accountEmail, this.tokens);
+          updateLastUsed(this.accountEmail);
+        } else {
+          saveTokens(this.tokens);
+        }
+        debug("token-manager", "Token refreshed successfully");
+        return;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        const errorMessage = lastError.message.toLowerCase();
+        const isPermanentError = errorMessage.includes("invalid_grant") || errorMessage.includes("400") || errorMessage.includes("401") || errorMessage.includes("invalid_token") || errorMessage.includes("token has been revoked");
+        if (isPermanentError) {
+          debug("token-manager", `Token refresh failed permanently: ${lastError.message}`);
+          throw new TokenRefreshError(
+            `Refresh token invalid or expired. Please login again.`,
+            { cause: lastError, isRetryable: false }
+          );
+        }
+        if (attempt < MAX_RETRIES) {
+          const delayMs = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+          debug("token-manager", `Token refresh attempt ${attempt} failed: ${lastError.message}. Retrying in ${delayMs}ms...`);
+          await this.sleep(delayMs);
+        } else {
+          debug("token-manager", `Token refresh failed after ${MAX_RETRIES} attempts: ${lastError.message}`);
+        }
       }
-      debug("token-manager", "Token refreshed successfully");
-    } catch (err) {
-      debug("token-manager", "Token refresh failed", err);
-      throw new TokenRefreshError();
     }
+    throw new TokenRefreshError(
+      `Failed to refresh token after ${MAX_RETRIES} attempts`,
+      { cause: lastError, isRetryable: true }
+    );
+  }
+  /**
+   * Sleep helper for retry delays
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
   /**
    * Reload tokens from disk
@@ -1208,11 +1390,24 @@ function statusCommand(options = {}) {
 }
 
 // src/google/cloudcode.ts
-var BASE_URL = "https://cloudcode-pa.googleapis.com";
-var USER_AGENT = "antigravity/1.11.3 Darwin/arm64";
+var BASE_URLS = [
+  "https://cloudcode-pa.googleapis.com",
+  "https://daily-cloudcode-pa.sandbox.googleapis.com"
+];
+var BASE_URL = BASE_URLS[0];
+var USER_AGENT = "antigravity";
+var MAX_TRIGGER_ATTEMPTS = 3;
+var STREAM_PATH = "/v1internal:streamGenerateContent?alt=sse";
+var SYSTEM_PROMPT = "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding. You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**";
+var METADATA = {
+  ideType: "ANTIGRAVITY",
+  platform: "PLATFORM_UNSPECIFIED",
+  pluginType: "GEMINI"
+};
 var CloudCodeClient = class {
   constructor(tokenManager) {
     this.tokenManager = tokenManager;
+    this.projectId = tokenManager.getProjectId();
   }
   projectId;
   /**
@@ -1270,14 +1465,85 @@ var CloudCodeClient = class {
    */
   async loadCodeAssist() {
     const response = await this.request("/v1internal:loadCodeAssist", {
-      metadata: { ideType: "ANTIGRAVITY" }
+      metadata: METADATA
     });
     if (response.cloudaicompanionProject) {
-      this.projectId = response.cloudaicompanionProject;
+      if (typeof response.cloudaicompanionProject === "string") {
+        this.projectId = response.cloudaicompanionProject;
+      } else if (response.cloudaicompanionProject.id) {
+        this.projectId = response.cloudaicompanionProject.id;
+      }
       debug("cloudcode", `Project ID: ${this.projectId}`);
     }
     return response;
   }
+  /**
+   * Extract project ID from loadCodeAssist response
+   */
+  extractProjectId(response) {
+    const projectId = response.cloudaicompanionProject || response.project || response.projectId || response.cloudProject;
+    if (projectId && typeof projectId === "string" && projectId.length > 0) {
+      this.projectId = projectId;
+      debug("cloudcode", `Project ID extracted: ${this.projectId}`);
+    } else {
+      debug("cloudcode", "No project ID found in response");
+    }
+  }
+  /**
+   * Resolve project ID with onboarding retry if needed
+   * This is the recommended way to get projectId reliably
+   */
+  async resolveProjectId(maxRetries = 5, retryDelayMs = 2e3) {
+    if (this.projectId) {
+      debug("cloudcode", `Using cached project ID: ${this.projectId}`);
+      return this.projectId;
+    }
+    const loadResponse = await this.loadCodeAssist();
+    if (this.projectId) {
+      return this.projectId;
+    }
+    debug("cloudcode", "Project ID not found, attempting onboarding...");
+    const tiers = loadResponse.allowedTiers || [];
+    let tierId;
+    const defaultTier = tiers.find((t) => t.isDefault);
+    if (defaultTier) {
+      tierId = defaultTier.id;
+    } else if (loadResponse.paidTier?.id) {
+      tierId = loadResponse.paidTier.id;
+    } else if (loadResponse.currentTier?.id) {
+      tierId = loadResponse.currentTier.id;
+    } else if (tiers.length > 0) {
+      tierId = tiers[0].id;
+    }
+    if (!tierId) {
+      debug("cloudcode", "No tier available for onboarding");
+      return void 0;
+    }
+    debug("cloudcode", `Onboarding with tier: ${tierId}`);
+    try {
+      await this.request("/v1internal:onboardUser", {
+        tierId,
+        metadata: {
+          ideType: "ANTIGRAVITY",
+          platform: "PLATFORM_UNSPECIFIED",
+          pluginType: "GEMINI"
+        }
+      });
+    } catch (err) {
+      debug("cloudcode", "Onboarding call failed (may be expected):", err);
+    }
+    for (let i = 0; i < maxRetries; i++) {
+      debug("cloudcode", `Retry ${i + 1}/${maxRetries} for project ID...`);
+      await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      await this.loadCodeAssist();
+      if (this.projectId) {
+        debug("cloudcode", `Project ID resolved after ${i + 1} retries: ${this.projectId}`);
+        return this.projectId;
+      }
+    }
+    debug("cloudcode", "Failed to resolve project ID after all retries");
+    return void 0;
+  }
   /**
    * Fetch available models with quota info
    * Requires project ID from loadCodeAssist
@@ -1286,6 +1552,154 @@ var CloudCodeClient = class {
     const body = this.projectId ? { project: this.projectId } : {};
     return this.request("/v1internal:fetchAvailableModels", body);
   }
+  /**
+   * Generate content using a specific model (Agent Request Format)
+   * Used for wake-up triggers to warm up models
+   * 
+   * Per docs/trigger.md, must use the agent request format with:
+   * - project: Cloud Code project ID
+   * - requestId: unique ID
+   * - model: model ID
+   * - userAgent: "antigravity"
+   * - requestType: "agent"
+   * - request: contains contents, session_id, systemInstruction, generationConfig
+   * 
+   * @param modelId Model ID to use
+   * @param prompt User prompt to send
+   * @param maxOutputTokens Maximum tokens to generate (0 = no limit)
+   * @returns Generated text and optional token usage
+   */
+  async generateContent(modelId, prompt, maxOutputTokens) {
+    debug("cloudcode", `Generating content with model: ${modelId}`);
+    debug("cloudcode", `Current projectId: ${this.projectId}`);
+    debug("cloudcode", "Warming up session with loadCodeAssist...");
+    try {
+      await this.loadCodeAssist();
+      debug("cloudcode", `Session warmed up, projectId: ${this.projectId}`);
+    } catch (err) {
+      debug("cloudcode", "Warmup failed (continuing anyway):", err);
+    }
+    const requestId = crypto.randomUUID();
+    const sessionId = crypto.randomUUID();
+    const systemInstruction = {
+      parts: [{ text: SYSTEM_PROMPT }]
+    };
+    const generationConfig = {
+      temperature: 0
+    };
+    if (maxOutputTokens && maxOutputTokens > 0) {
+      generationConfig.maxOutputTokens = maxOutputTokens;
+    }
+    const body = {
+      requestId,
+      model: modelId,
+      userAgent: "antigravity",
+      requestType: "agent",
+      request: {
+        contents: [{
+          role: "user",
+          parts: [{ text: prompt }]
+        }],
+        session_id: sessionId,
+        systemInstruction,
+        generationConfig
+      }
+    };
+    if (this.projectId) {
+      body.project = this.projectId;
+      debug("cloudcode", `Using project ID: ${this.projectId}`);
+    } else {
+      debug("cloudcode", "Sending request WITHOUT project ID");
+    }
+    debug("cloudcode", `Request body:`, JSON.stringify(body, null, 2));
+    const token = await this.tokenManager.getValidAccessToken();
+    const getBackoffDelay = (attempt) => {
+      const raw = 500 * Math.pow(2, attempt - 2);
+      const jitter = Math.random() * 100;
+      return Math.min(raw + jitter, 4e3);
+    };
+    const sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const parseSSEResponse = (sseText) => {
+      let fullText = "";
+      let tokensUsed;
+      for (const line of sseText.split("\n")) {
+        if (line.startsWith("data: ")) {
+          const jsonStr = line.substring(6);
+          if (jsonStr.trim() === "[DONE]") continue;
+          try {
+            const data = JSON.parse(jsonStr);
+            const candidateText = data.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (candidateText) {
+              fullText += candidateText;
+            }
+            if (data.usageMetadata) {
+              tokensUsed = {
+                prompt: data.usageMetadata.promptTokenCount || 0,
+                completion: data.usageMetadata.candidatesTokenCount || 0,
+                total: data.usageMetadata.totalTokenCount || 0
+              };
+            }
+          } catch {
+          }
+        }
+      }
+      return { text: fullText, tokensUsed };
+    };
+    for (const baseUrl of BASE_URLS) {
+      for (let attempt = 1; attempt <= MAX_TRIGGER_ATTEMPTS; attempt++) {
+        if (attempt > 1) {
+          const delay = getBackoffDelay(attempt);
+          debug("cloudcode", `Retry ${attempt}/${MAX_TRIGGER_ATTEMPTS} in ${Math.round(delay)}ms...`);
+          await sleep2(delay);
+        }
+        const url = `${baseUrl}${STREAM_PATH}`;
+        debug("cloudcode", `Attempt ${attempt}/${MAX_TRIGGER_ATTEMPTS} on ${baseUrl}`);
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${token}`,
+              "User-Agent": USER_AGENT,
+              "Content-Type": "application/json",
+              "Accept-Encoding": "gzip"
+              // CRITICAL: Must match example.ts
+            },
+            body: JSON.stringify(body)
+          });
+          const text = await response.text();
+          debug("cloudcode", `Response ${response.status}`);
+          debug("cloudcode", `Response text: ${text.slice(0, 500)}`);
+          if (response.status === 429 || response.status >= 500) {
+            debug("cloudcode", `${response.status} - retryable`);
+            if (attempt === MAX_TRIGGER_ATTEMPTS) {
+              debug("cloudcode", "Max attempts on this URL, trying next...");
+              break;
+            }
+            continue;
+          }
+          if (response.ok) {
+            debug("cloudcode", "Request succeeded!");
+            const parsed = parseSSEResponse(text);
+            debug("cloudcode", `Generated ${parsed.text.length} chars, tokens: ${parsed.tokensUsed?.total || "unknown"}`);
+            return parsed;
+          }
+          debug("cloudcode", `Non-retryable error: ${response.status}`);
+          throw new Error(`API request failed: ${response.status} - ${text}`);
+        } catch (err) {
+          if (err instanceof Error && !err.message.startsWith("API request failed")) {
+            debug("cloudcode", `Network error: ${err.message}`);
+            if (attempt === MAX_TRIGGER_ATTEMPTS) {
+              debug("cloudcode", "Max attempts on this URL, trying next...");
+              break;
+            }
+            continue;
+          }
+          throw err;
+        }
+      }
+    }
+    throw new Error("All trigger attempts failed across all base URLs");
+  }
 };
 
 // src/google/parser.ts
@@ -1976,6 +2390,13 @@ async function fetchQuotaGoogle() {
   const client = new CloudCodeClient(tokenManager);
   const codeAssistResponse = await client.loadCodeAssist();
   debug("service", "Code assist response received", JSON.stringify(codeAssistResponse));
+  if (codeAssistResponse?.cloudaicompanionProject) {
+    const projectId = extractProjectId(codeAssistResponse.cloudaicompanionProject);
+    if (projectId) {
+      tokenManager.setProjectId(projectId);
+      debug("service", `Project ID saved: ${projectId}`);
+    }
+  }
   let modelsResponse = {};
   try {
     modelsResponse = await client.fetchAvailableModels();
@@ -2707,6 +3128,1037 @@ async function accountsCommand(subcommand, args, options) {
   }
 }
 
+// src/commands/wakeup.ts
+import inquirer from "inquirer";
+import Table4 from "cli-table3";
+
+// src/wakeup/types.ts
+function getDefaultConfig() {
+  return {
+    enabled: false,
+    selectedModels: ["claude-sonnet-4-5", "gemini-3-flash"],
+    selectedAccounts: void 0,
+    customPrompt: void 0,
+    maxOutputTokens: 1,
+    // Minimal tokens to save quota
+    scheduleMode: "interval",
+    intervalHours: 6,
+    dailyTimes: ["09:00"],
+    weeklySchedule: {},
+    cronExpression: void 0,
+    wakeOnReset: false,
+    resetCooldownMinutes: 10
+  };
+}
+
+// src/wakeup/storage.ts
+import { join as join3 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
+var WAKEUP_DIR_NAME = "wakeup";
+var CONFIG_FILE_NAME = "config.json";
+var HISTORY_FILE_NAME = "history.json";
+var MAX_HISTORY_ENTRIES = 100;
+function getWakeupDir() {
+  return join3(getConfigDir(), WAKEUP_DIR_NAME);
+}
+function ensureWakeupDir() {
+  const dir = getWakeupDir();
+  if (!existsSync4(dir)) {
+    mkdirSync4(dir, { recursive: true });
+    debug("wakeup-storage", `Created wakeup directory: ${dir}`);
+  }
+}
+function readJsonFile(filename, defaultValue) {
+  const filepath = join3(getWakeupDir(), filename);
+  try {
+    if (existsSync4(filepath)) {
+      const content = readFileSync4(filepath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch (err) {
+    debug("wakeup-storage", `Error reading ${filename}:`, err);
+  }
+  return defaultValue;
+}
+function writeJsonFile(filename, data) {
+  ensureWakeupDir();
+  const filepath = join3(getWakeupDir(), filename);
+  try {
+    writeFileSync4(filepath, JSON.stringify(data, null, 2), "utf-8");
+    debug("wakeup-storage", `Wrote ${filename}`);
+  } catch (err) {
+    debug("wakeup-storage", `Error writing ${filename}:`, err);
+    throw err;
+  }
+}
+function loadWakeupConfig() {
+  const config = readJsonFile(CONFIG_FILE_NAME, null);
+  if (config) {
+    debug("wakeup-storage", "Loaded wakeup config");
+  }
+  return config;
+}
+function saveWakeupConfig(config) {
+  writeJsonFile(CONFIG_FILE_NAME, config);
+  debug("wakeup-storage", "Saved wakeup config");
+}
+function getOrCreateConfig() {
+  const existing = loadWakeupConfig();
+  if (existing) {
+    if (!existing.selectedModels || existing.selectedModels.length === 0) {
+      existing.selectedModels = ["claude-sonnet-4-5", "gemini-3-flash"];
+      saveWakeupConfig(existing);
+      debug("wakeup-storage", "Migrated config to new default models");
+    }
+    return existing;
+  }
+  const defaultConfig = getDefaultConfig();
+  saveWakeupConfig(defaultConfig);
+  return defaultConfig;
+}
+function loadTriggerHistory() {
+  return readJsonFile(HISTORY_FILE_NAME, []);
+}
+function saveTriggerHistory(history) {
+  writeJsonFile(HISTORY_FILE_NAME, history);
+}
+function addTriggerRecord(record) {
+  const history = loadTriggerHistory();
+  history.unshift(record);
+  if (history.length > MAX_HISTORY_ENTRIES) {
+    history.splice(MAX_HISTORY_ENTRIES);
+  }
+  saveTriggerHistory(history);
+  debug("wakeup-storage", `Added trigger record (total: ${history.length})`);
+}
+function getRecentHistory(limit = 10) {
+  const history = loadTriggerHistory();
+  return history.slice(0, limit);
+}
+function getLastTrigger() {
+  const history = loadTriggerHistory();
+  return history.length > 0 ? history[0] : null;
+}
+
+// src/wakeup/account-resolver.ts
+function resolveAccounts(selectedAccounts) {
+  const accountManager = getAccountManager();
+  if (selectedAccounts !== void 0) {
+    debug("account-resolver", `Explicit account selection: ${selectedAccounts.length} accounts`);
+    const validAccounts = selectedAccounts.filter((email) => {
+      if (!accountManager.hasAccount(email)) {
+        debug("account-resolver", `Account ${email} not found, skipping`);
+        return false;
+      }
+      const status = accountManager.getAccountStatus(email);
+      if (status === "invalid") {
+        debug("account-resolver", `Account ${email} is invalid, skipping`);
+        return false;
+      }
+      return true;
+    });
+    debug("account-resolver", `Resolved ${validAccounts.length} valid accounts from selection`);
+    return validAccounts;
+  }
+  debug("account-resolver", "No explicit selection, using fallback logic");
+  const activeEmail = accountManager.getActiveEmail();
+  if (activeEmail) {
+    const status = accountManager.getAccountStatus(activeEmail);
+    if (status === "valid" || status === "expired") {
+      debug("account-resolver", `Using active account: ${activeEmail}`);
+      return [activeEmail];
+    }
+    debug("account-resolver", `Active account ${activeEmail} is ${status}, trying fallback`);
+  }
+  const allEmails = accountManager.getAccountEmails();
+  for (const email of allEmails) {
+    const status = accountManager.getAccountStatus(email);
+    if (status === "valid" || status === "expired") {
+      debug("account-resolver", `Fallback to first valid account: ${email}`);
+      return [email];
+    }
+  }
+  debug("account-resolver", "No valid accounts found");
+  return [];
+}
+function getAccountResolutionStatus(selectedAccounts) {
+  const resolved = resolveAccounts(selectedAccounts);
+  if (resolved.length === 0) {
+    if (selectedAccounts !== void 0 && selectedAccounts.length > 0) {
+      return "Selected accounts are invalid or not found";
+    }
+    return "No valid accounts available";
+  }
+  if (resolved.length === 1) {
+    return `Using account: ${resolved[0]}`;
+  }
+  return `Using ${resolved.length} accounts: ${resolved.join(", ")}`;
+}
+
+// src/wakeup/schedule-converter.ts
+function configToCronExpression(config) {
+  if (config.cronExpression) {
+    return config.cronExpression;
+  }
+  switch (config.scheduleMode) {
+    case "interval":
+      return intervalToCron(config.intervalHours || 6);
+    case "daily":
+      return dailyToCron(config.dailyTimes || ["09:00"]);
+    case "weekly":
+      return weeklyToCron(config.weeklySchedule || {});
+    case "custom":
+      return "0 */6 * * *";
+    default:
+      throw new Error(`Unknown schedule mode: ${config.scheduleMode}`);
+  }
+}
+function intervalToCron(hours) {
+  if (hours < 1 || hours > 23) {
+    throw new Error("Interval hours must be between 1 and 23");
+  }
+  return `0 */${hours} * * *`;
+}
+function dailyToCron(times) {
+  if (times.length === 0) {
+    throw new Error("Daily mode requires at least one time");
+  }
+  const parsedTimes = times.map(parseTime);
+  const [firstHour, firstMinute] = parsedTimes[0];
+  const hours = parsedTimes.map(([h]) => h);
+  const allSameMinute = parsedTimes.every(([, m]) => m === firstMinute);
+  if (allSameMinute) {
+    return `${firstMinute} ${hours.join(",")} * * *`;
+  }
+  return `${firstMinute} ${firstHour} * * *`;
+}
+function weeklyToCron(schedule) {
+  const days = Object.keys(schedule).map(Number).sort();
+  if (days.length === 0) {
+    throw new Error("Weekly mode requires at least one day");
+  }
+  const firstDay = days[0];
+  const firstDayTimes = schedule[firstDay];
+  if (!firstDayTimes || firstDayTimes.length === 0) {
+    throw new Error(`No times specified for day ${firstDay}`);
+  }
+  const [hour, minute] = parseTime(firstDayTimes[0]);
+  const daysStr = days.join(",");
+  return `${minute} ${hour} * * ${daysStr}`;
+}
+function parseTime(timeStr) {
+  const match = timeStr.match(/^(\d{1,2}):(\d{2})$/);
+  if (!match) {
+    throw new Error(`Invalid time format: ${timeStr}. Expected HH:MM`);
+  }
+  const hour = parseInt(match[1], 10);
+  const minute = parseInt(match[2], 10);
+  if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+    throw new Error(`Invalid time values: ${timeStr}`);
+  }
+  return [hour, minute];
+}
+function getScheduleDescription(config) {
+  if (!config.enabled) {
+    return "Disabled";
+  }
+  if (config.wakeOnReset) {
+    const cooldown = config.resetCooldownMinutes || 10;
+    return `Quota-reset based (${cooldown}min cooldown)`;
+  }
+  switch (config.scheduleMode) {
+    case "interval":
+      const hours = config.intervalHours || 6;
+      return `Every ${hours} hour${hours > 1 ? "s" : ""}`;
+    case "daily":
+      const times = config.dailyTimes || ["09:00"];
+      if (times.length === 1) {
+        return `Daily at ${times[0]}`;
+      }
+      return `Daily at ${times.join(", ")}`;
+    case "weekly":
+      const days = Object.keys(config.weeklySchedule || {}).map(Number);
+      const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+      const dayList = days.map((d) => dayNames[d]).join(", ");
+      return `Weekly on ${dayList}`;
+    case "custom":
+      return `Custom: ${config.cronExpression || "Not set"}`;
+    default:
+      return "Unknown schedule";
+  }
+}
+function getNextRunEstimate(cronExpression) {
+  try {
+    const parts = cronExpression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+      return "Invalid cron";
+    }
+    const [minute, hour, day, month, weekday] = parts;
+    if (hour.startsWith("*/")) {
+      const interval = parseInt(hour.substring(2), 10);
+      return `Every ${interval} hour${interval > 1 ? "s" : ""}`;
+    }
+    if (day === "*" && month === "*" && weekday === "*") {
+      const displayHour = hour.includes(",") ? hour.split(",")[0] : hour;
+      return `Daily at ${displayHour.padStart(2, "0")}:${minute.padStart(2, "0")}`;
+    }
+    if (weekday !== "*") {
+      const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+      const dayNums = weekday.split(",").map(Number);
+      const dayList = dayNums.map((d) => dayNames[d] || d).join(", ");
+      return `${dayList} at ${hour.padStart(2, "0")}:${minute.padStart(2, "0")}`;
+    }
+    return cronExpression;
+  } catch {
+    return cronExpression;
+  }
+}
+
+// src/wakeup/cron-installer.ts
+import { execSync, exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+var CRON_COMMENT_MARKER = "antigravity-usage-wakeup";
+function getBinaryPath() {
+  try {
+    const path = execSync("which antigravity-usage", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (path) {
+      debug("cron-installer", `Found binary at: ${path}`);
+      return path;
+    }
+  } catch {
+    debug("cron-installer", "Could not find antigravity-usage via which");
+  }
+  if (process.argv[1]) {
+    const nodePath = process.execPath;
+    const scriptPath = process.argv[1];
+    debug("cron-installer", `Using node + script: ${nodePath} ${scriptPath}`);
+    return `${nodePath} ${scriptPath}`;
+  }
+  throw new Error("Could not determine binary path for cron job");
+}
+async function loadCrontab() {
+  try {
+    const { stdout } = await execAsync3('crontab -l 2>/dev/null || echo ""');
+    const lines = stdout.split("\n").filter((line) => line.trim());
+    debug("cron-installer", `Loaded ${lines.length} crontab entries`);
+    return lines;
+  } catch {
+    debug("cron-installer", "No existing crontab or error loading");
+    return [];
+  }
+}
+async function saveCrontab(lines) {
+  const content = lines.join("\n") + "\n";
+  try {
+    const { exec: execCallback } = await import("child_process");
+    await new Promise((resolve, reject) => {
+      const proc = execCallback("crontab -", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+      proc.stdin?.write(content);
+      proc.stdin?.end();
+    });
+    debug("cron-installer", "Saved crontab successfully");
+  } catch (err) {
+    debug("cron-installer", "Error saving crontab:", err);
+    throw err;
+  }
+}
+function removeWakeupEntries(lines) {
+  return lines.filter((line) => !line.includes(CRON_COMMENT_MARKER));
+}
+function isCronSupported() {
+  return process.platform === "darwin" || process.platform === "linux";
+}
+async function installCronJob(cronExpression) {
+  if (!isCronSupported()) {
+    return {
+      success: false,
+      error: `Cron is not supported on ${process.platform}. Windows Task Scheduler support coming soon.`,
+      manualInstructions: getWindowsInstructions(cronExpression)
+    };
+  }
+  try {
+    const binaryPath = getBinaryPath();
+    const lines = await loadCrontab();
+    const filteredLines = removeWakeupEntries(lines);
+    const command = `${binaryPath} wakeup trigger --scheduled`;
+    const cronLine = `${cronExpression} ${command} # ${CRON_COMMENT_MARKER}`;
+    filteredLines.push(cronLine);
+    await saveCrontab(filteredLines);
+    debug("cron-installer", `Installed cron job: ${cronLine}`);
+    return {
+      success: true,
+      cronExpression
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    debug("cron-installer", `Failed to install cron job: ${errorMessage}`);
+    const binaryPath = tryGetBinaryPath();
+    return {
+      success: false,
+      error: errorMessage,
+      manualInstructions: getManualInstructions(cronExpression, binaryPath)
+    };
+  }
+}
+async function uninstallCronJob() {
+  if (!isCronSupported()) {
+    debug("cron-installer", "Cron not supported on this platform");
+    return false;
+  }
+  try {
+    const lines = await loadCrontab();
+    const filteredLines = removeWakeupEntries(lines);
+    if (filteredLines.length === lines.length) {
+      debug("cron-installer", "No cron job found to uninstall");
+      return true;
+    }
+    await saveCrontab(filteredLines);
+    debug("cron-installer", "Uninstalled cron job successfully");
+    return true;
+  } catch (err) {
+    debug("cron-installer", "Failed to uninstall cron job:", err);
+    return false;
+  }
+}
+async function getCronStatus() {
+  if (!isCronSupported()) {
+    return { installed: false };
+  }
+  try {
+    const lines = await loadCrontab();
+    const cronLine = lines.find((line) => line.includes(CRON_COMMENT_MARKER));
+    if (!cronLine) {
+      return { installed: false };
+    }
+    const parts = cronLine.trim().split(/\s+/);
+    const cronExpression = parts.slice(0, 5).join(" ");
+    return {
+      installed: true,
+      cronExpression,
+      nextRun: getNextRunDescription(cronExpression)
+    };
+  } catch {
+    return { installed: false };
+  }
+}
+function tryGetBinaryPath() {
+  try {
+    return getBinaryPath();
+  } catch {
+    return "antigravity-usage";
+  }
+}
+function getManualInstructions(cronExpression, binaryPath) {
+  return `
+Failed to automatically install cron job. Please add manually:
+
+1. Open terminal and run: crontab -e
+
+2. Add this line at the end:
+   ${cronExpression} ${binaryPath} wakeup trigger --scheduled # ${CRON_COMMENT_MARKER}
+
+3. Save and exit the editor
+
+To verify, run: crontab -l
+`.trim();
+}
+function getWindowsInstructions(cronExpression) {
+  return `
+Windows Task Scheduler support is not yet available.
+
+To set up manually using Task Scheduler:
+
+1. Open Task Scheduler (taskschd.msc)
+2. Create a new Basic Task
+3. Set trigger: Based on your schedule (${cronExpression})
+4. Set action: Start a program
+   - Program: antigravity-usage
+   - Arguments: wakeup trigger --scheduled
+5. Save the task
+
+Alternatively, use Windows Subsystem for Linux (WSL) with cron.
+`.trim();
+}
+function getNextRunDescription(cronExpression) {
+  try {
+    const parts = cronExpression.split(/\s+/);
+    if (parts.length !== 5) return "Unknown";
+    const [minute, hour] = parts;
+    if (hour.startsWith("*/")) {
+      const hours = parseInt(hour.substring(2), 10);
+      const now2 = /* @__PURE__ */ new Date();
+      const currentHour = now2.getHours();
+      const nextHour = Math.ceil((currentHour + 1) / hours) * hours;
+      const isToday = nextHour < 24;
+      return isToday ? `Today around ${nextHour}:00` : "Tomorrow";
+    }
+    const hourNum = parseInt(hour.split(",")[0], 10);
+    const minuteNum = parseInt(minute, 10);
+    const now = /* @__PURE__ */ new Date();
+    const currentMinutes = now.getHours() * 60 + now.getMinutes();
+    const targetMinutes = hourNum * 60 + minuteNum;
+    if (targetMinutes > currentMinutes) {
+      return `Today at ${hour.padStart(2, "0")}:${minute.padStart(2, "0")}`;
+    }
+    return `Tomorrow at ${hour.padStart(2, "0")}:${minute.padStart(2, "0")}`;
+  } catch {
+    return "Unknown";
+  }
+}
+
+// src/wakeup/trigger-service.ts
+var DEFAULT_PROMPT = "hi";
+var REQUEST_TIMEOUT_MS = 3e4;
+var MAX_CONCURRENT_REQUESTS = 4;
+async function executeTrigger(options) {
+  const {
+    models,
+    accountEmail,
+    triggerType,
+    triggerSource,
+    customPrompt,
+    maxOutputTokens
+  } = options;
+  debug("trigger-service", `Executing trigger for ${models.length} models with account ${accountEmail}`);
+  if (models.length === 0) {
+    debug("trigger-service", "No models to trigger");
+    return { success: true, results: [] };
+  }
+  let tokenManager;
+  try {
+    tokenManager = getTokenManagerForAccount(accountEmail);
+  } catch (err) {
+    debug("trigger-service", `Failed to get token manager for ${accountEmail}:`, err);
+    const results2 = models.map((modelId) => ({
+      modelId,
+      success: false,
+      durationMs: 0,
+      error: `Failed to get credentials for ${accountEmail}`
+    }));
+    recordResults(results2, options);
+    return { success: false, results: results2 };
+  }
+  try {
+    await tokenManager.getValidAccessToken();
+  } catch (err) {
+    let errorMessage = `Authentication failed for ${accountEmail}`;
+    if (err && typeof err === "object" && "getDetailedMessage" in err) {
+      errorMessage = err.getDetailedMessage();
+    } else if (err instanceof Error) {
+      errorMessage = `Token refresh failed: ${err.message}`;
+    }
+    debug("trigger-service", `Failed to refresh token for ${accountEmail}:`, err);
+    const results2 = models.map((modelId) => ({
+      modelId,
+      success: false,
+      durationMs: 0,
+      error: errorMessage
+    }));
+    recordResults(results2, options);
+    return { success: false, results: results2 };
+  }
+  const client = new CloudCodeClient(tokenManager);
+  debug("trigger-service", `Account ${accountEmail} projectId from tokenManager: ${tokenManager.getProjectId()}`);
+  try {
+    const projectId = await client.resolveProjectId();
+    if (projectId) {
+      debug("trigger-service", `Project ID resolved: ${projectId}`);
+      tokenManager.setProjectId(projectId);
+    } else {
+      debug("trigger-service", "WARNING: Could not resolve project ID");
+    }
+  } catch (err) {
+    debug("trigger-service", "Failed to resolve project ID:", err);
+  }
+  const userPrompt = customPrompt || DEFAULT_PROMPT;
+  const results = [];
+  for (let i = 0; i < models.length; i += MAX_CONCURRENT_REQUESTS) {
+    const batch = models.slice(i, i + MAX_CONCURRENT_REQUESTS);
+    debug("trigger-service", `Processing batch ${i / MAX_CONCURRENT_REQUESTS + 1}: ${batch.join(", ")}`);
+    const batchResults = await Promise.all(
+      batch.map((modelId) => triggerSingleModel(client, modelId, userPrompt, maxOutputTokens))
+    );
+    results.push(...batchResults);
+  }
+  recordResults(results, options);
+  const allSuccess = results.every((r) => r.success);
+  const successCount = results.filter((r) => r.success).length;
+  debug("trigger-service", `Trigger complete: ${successCount}/${results.length} succeeded`);
+  return { success: allSuccess, results };
+}
+async function triggerSingleModel(client, modelId, prompt, maxTokens) {
+  const startTime = Date.now();
+  debug("trigger-service", `Triggering model: ${modelId}`);
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Request timed out")), REQUEST_TIMEOUT_MS);
+    });
+    const response = await Promise.race([
+      client.generateContent(modelId, prompt, maxTokens),
+      timeoutPromise
+    ]);
+    const durationMs = Date.now() - startTime;
+    debug("trigger-service", `Model ${modelId} responded in ${durationMs}ms`);
+    return {
+      modelId,
+      success: true,
+      durationMs,
+      response: response.text.substring(0, 500),
+      // Truncate to 500 chars
+      tokensUsed: response.tokensUsed
+    };
+  } catch (err) {
+    const durationMs = Date.now() - startTime;
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    debug("trigger-service", `Model ${modelId} failed after ${durationMs}ms: ${errorMessage}`);
+    return {
+      modelId,
+      success: false,
+      durationMs,
+      error: errorMessage
+    };
+  }
+}
+function recordResults(results, options) {
+  const { triggerType, triggerSource, accountEmail, customPrompt } = options;
+  const prompt = customPrompt || DEFAULT_PROMPT;
+  for (const result of results) {
+    const record = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: result.success,
+      triggerType,
+      triggerSource,
+      models: [result.modelId],
+      accountEmail,
+      durationMs: result.durationMs,
+      prompt,
+      response: result.response,
+      error: result.error,
+      tokensUsed: result.tokensUsed
+    };
+    addTriggerRecord(record);
+  }
+}
+async function testTrigger(modelId, accountEmail, prompt) {
+  const result = await executeTrigger({
+    models: [modelId],
+    accountEmail,
+    triggerType: "manual",
+    triggerSource: "manual",
+    customPrompt: prompt
+  });
+  return result.results[0] || {
+    modelId,
+    success: false,
+    durationMs: 0,
+    error: "No result returned"
+  };
+}
+
+// src/wakeup/reset-detector.ts
+var RESET_TIME_MIN_HOURS = 4.5;
+var RESET_TIME_MAX_HOURS = 5.5;
+var RESET_TIME_MIN_MS = RESET_TIME_MIN_HOURS * 60 * 60 * 1e3;
+var RESET_TIME_MAX_MS = RESET_TIME_MAX_HOURS * 60 * 60 * 1e3;
+var DEFAULT_COOLDOWN_MS = 60 * 60 * 1e3;
+
+// src/commands/wakeup.ts
+async function wakeupCommand(subcommand, args, options) {
+  debug("wakeup", `Subcommand: ${subcommand}, options:`, options);
+  switch (subcommand) {
+    case "config":
+      await configureWakeup();
+      break;
+    case "trigger":
+      await runScheduledTrigger(options.scheduled ?? false);
+      break;
+    case "install":
+      await installSchedule();
+      break;
+    case "uninstall":
+      await uninstallSchedule();
+      break;
+    case "test":
+      await runTestTrigger();
+      break;
+    case "history":
+      await showHistory(options);
+      break;
+    case "status":
+    default:
+      await showStatus();
+      break;
+  }
+}
+async function configureWakeup() {
+  console.log("\n\u{1F527} Auto Wake-up Configuration\n");
+  const config = getOrCreateConfig();
+  const accountManager = getAccountManager();
+  const accounts = accountManager.getAccountEmails();
+  if (accounts.length === 0) {
+    console.log("\u274C No accounts available. Please login first:");
+    console.log("   antigravity-usage login\n");
+    return;
+  }
+  const { enabled } = await inquirer.prompt([{
+    type: "confirm",
+    name: "enabled",
+    message: "Enable auto wake-up?",
+    default: config.enabled
+  }]);
+  if (!enabled) {
+    config.enabled = false;
+    saveWakeupConfig(config);
+    console.log("\n\u2705 Auto wake-up disabled");
+    return;
+  }
+  const { triggerMode } = await inquirer.prompt([{
+    type: "list",
+    name: "triggerMode",
+    message: "Trigger mode:",
+    choices: [
+      { name: "Schedule-based (run at specific times)", value: "schedule" },
+      { name: "Quota-reset-based (trigger when quota resets)", value: "reset" }
+    ],
+    default: config.wakeOnReset ? "reset" : "schedule"
+  }]);
+  config.wakeOnReset = triggerMode === "reset";
+  if (!config.wakeOnReset) {
+    const { scheduleMode } = await inquirer.prompt([{
+      type: "list",
+      name: "scheduleMode",
+      message: "Schedule type:",
+      choices: [
+        { name: "Every N hours", value: "interval" },
+        { name: "Daily at specific times", value: "daily" },
+        { name: "Custom cron expression", value: "custom" }
+      ],
+      default: config.scheduleMode
+    }]);
+    config.scheduleMode = scheduleMode;
+    if (scheduleMode === "interval") {
+      const { intervalHours } = await inquirer.prompt([{
+        type: "number",
+        name: "intervalHours",
+        message: "Trigger every N hours:",
+        default: config.intervalHours || 6,
+        validate: (val) => val >= 1 && val <= 23 ? true : "Must be 1-23"
+      }]);
+      config.intervalHours = intervalHours;
+    } else if (scheduleMode === "daily") {
+      const { dailyTime } = await inquirer.prompt([{
+        type: "input",
+        name: "dailyTime",
+        message: "Time to trigger (HH:MM):",
+        default: config.dailyTimes?.[0] || "09:00",
+        validate: (val) => /^\d{1,2}:\d{2}$/.test(val) ? true : "Use HH:MM format"
+      }]);
+      config.dailyTimes = [dailyTime];
+    } else if (scheduleMode === "custom") {
+      const { cronExpression } = await inquirer.prompt([{
+        type: "input",
+        name: "cronExpression",
+        message: "Cron expression (min hour day month weekday):",
+        default: config.cronExpression || "0 */6 * * *"
+      }]);
+      config.cronExpression = cronExpression;
+    }
+  } else {
+    const { resetCooldown } = await inquirer.prompt([{
+      type: "number",
+      name: "resetCooldown",
+      message: "Cooldown between triggers (minutes):",
+      default: config.resetCooldownMinutes || 10,
+      validate: (val) => val >= 1 ? true : "Must be at least 1 minute"
+    }]);
+    config.resetCooldownMinutes = resetCooldown;
+  }
+  config.selectedModels = ["claude-sonnet-4-5", "gemini-3-flash"];
+  console.log("\n   \u{1F4E6} Models: claude-sonnet-4-5, gemini-3-flash");
+  console.log("      (Triggers both Claude and Gemini families)");
+  if (accounts.length > 1) {
+    const { selectedAccounts } = await inquirer.prompt([{
+      type: "checkbox",
+      name: "selectedAccounts",
+      message: "Select accounts to use:",
+      choices: accounts.map((email) => ({
+        name: email,
+        value: email,
+        checked: !config.selectedAccounts || config.selectedAccounts.includes(email)
+      }))
+    }]);
+    config.selectedAccounts = selectedAccounts.length > 0 ? selectedAccounts : void 0;
+  } else {
+    config.selectedAccounts = void 0;
+  }
+  const { customPrompt } = await inquirer.prompt([{
+    type: "input",
+    name: "customPrompt",
+    message: 'Custom wake-up prompt (leave empty for default "hi"):',
+    default: config.customPrompt || ""
+  }]);
+  config.customPrompt = customPrompt || void 0;
+  const { maxTokens } = await inquirer.prompt([{
+    type: "number",
+    name: "maxTokens",
+    message: "Max output tokens (0 = no limit):",
+    default: config.maxOutputTokens || 0
+  }]);
+  config.maxOutputTokens = maxTokens;
+  config.enabled = true;
+  saveWakeupConfig(config);
+  console.log("\n\u2705 Configuration saved!");
+  console.log(`   Mode: ${getScheduleDescription(config)}`);
+  console.log(`   Models: ${config.selectedModels.join(", ")}`);
+  console.log(`   Accounts: ${config.selectedAccounts?.join(", ") || "Active account"}`);
+  if (!config.wakeOnReset && isCronSupported()) {
+    const { installNow } = await inquirer.prompt([{
+      type: "confirm",
+      name: "installNow",
+      message: "Install to system cron now?",
+      default: true
+    }]);
+    if (installNow) {
+      await installSchedule();
+    } else {
+      console.log("\n\u{1F4CB} To install later, run:");
+      console.log("   antigravity-usage wakeup install");
+    }
+  }
+  console.log("");
+}
+async function runScheduledTrigger(isScheduled) {
+  debug("wakeup", `Running trigger (scheduled: ${isScheduled})`);
+  const config = loadWakeupConfig();
+  if (!config || !config.enabled) {
+    debug("wakeup", "Wakeup not configured or disabled");
+    return;
+  }
+  const accounts = resolveAccounts(config.selectedAccounts);
+  if (accounts.length === 0) {
+    debug("wakeup", "No valid accounts");
+    return;
+  }
+  if (config.selectedModels.length === 0) {
+    debug("wakeup", "No models selected");
+    return;
+  }
+  for (const accountEmail of accounts) {
+    const result = await executeTrigger({
+      models: config.selectedModels,
+      accountEmail,
+      triggerType: "auto",
+      triggerSource: isScheduled ? "scheduled" : "manual",
+      customPrompt: config.customPrompt,
+      maxOutputTokens: config.maxOutputTokens
+    });
+    const successCount = result.results.filter((r) => r.success).length;
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${accountEmail}: ${successCount}/${result.results.length} models triggered`);
+  }
+}
+async function installSchedule() {
+  console.log("\n\u{1F4C5} Installing wake-up schedule to cron...\n");
+  if (!isCronSupported()) {
+    console.log("\u274C Cron is not supported on this platform.");
+    console.log("   Windows Task Scheduler support coming soon.");
+    return;
+  }
+  const config = loadWakeupConfig();
+  if (!config) {
+    console.log("\u274C No wake-up configuration found.");
+    console.log("   Run: antigravity-usage wakeup config");
+    return;
+  }
+  if (!config.enabled) {
+    console.log("\u274C Wake-up is disabled. Enable it first:");
+    console.log("   antigravity-usage wakeup config");
+    return;
+  }
+  if (config.wakeOnReset) {
+    console.log("\u2139\uFE0F  Quota-reset mode does not require cron installation.");
+    console.log("   Triggers happen automatically when you check quota.");
+    return;
+  }
+  try {
+    const cronExpression = configToCronExpression(config);
+    console.log(`   Schedule: ${getScheduleDescription(config)}`);
+    console.log(`   Cron: ${cronExpression}`);
+    console.log("");
+    const result = await installCronJob(cronExpression);
+    if (result.success) {
+      console.log("\u2705 Cron job installed successfully!");
+      console.log(`   Next run: ${getNextRunEstimate(cronExpression)}`);
+      console.log("");
+      console.log("   To check status: antigravity-usage wakeup status");
+      console.log("   To uninstall: antigravity-usage wakeup uninstall");
+    } else {
+      console.log("\u26A0\uFE0F  Automatic installation failed.");
+      if (result.manualInstructions) {
+        console.log("");
+        console.log(result.manualInstructions);
+      }
+    }
+  } catch (err) {
+    console.log(`\u274C Error: ${err instanceof Error ? err.message : err}`);
+  }
+  console.log("");
+}
+async function uninstallSchedule() {
+  console.log("\n\u{1F5D1}\uFE0F  Removing wake-up schedule from cron...\n");
+  const success2 = await uninstallCronJob();
+  if (success2) {
+    console.log("\u2705 Cron job removed successfully!");
+  } else {
+    console.log("\u26A0\uFE0F  Could not remove cron job. It may not be installed.");
+    console.log("   Check your crontab: crontab -l");
+  }
+  console.log("");
+}
+async function runTestTrigger() {
+  console.log("\n\u{1F9EA} Test Trigger\n");
+  const accountManager = getAccountManager();
+  const accounts = accountManager.getAccountEmails();
+  if (accounts.length === 0) {
+    console.log("\u274C No accounts available. Please login first.");
+    return;
+  }
+  let accountEmail = accounts[0];
+  if (accounts.length > 1) {
+    const { selectedAccount } = await inquirer.prompt([{
+      type: "list",
+      name: "selectedAccount",
+      message: "Select account:",
+      choices: accounts
+    }]);
+    accountEmail = selectedAccount;
+  }
+  const config = loadWakeupConfig();
+  const { modelId } = await inquirer.prompt([{
+    type: "input",
+    name: "modelId",
+    message: "Model ID to test:",
+    default: config?.selectedModels[0] || "claude-sonnet-4-5"
+  }]);
+  const { prompt } = await inquirer.prompt([{
+    type: "input",
+    name: "prompt",
+    message: "Test prompt:",
+    default: "hi"
+  }]);
+  console.log("\n\u23F3 Triggering...");
+  try {
+    const result = await testTrigger(modelId, accountEmail, prompt);
+    if (result.success) {
+      console.log(`
+\u2705 Success! (${result.durationMs}ms)`);
+      if (result.response) {
+        console.log(`
+\u{1F4DD} Response:
+${result.response.substring(0, 200)}...`);
+      }
+      if (result.tokensUsed) {
+        console.log(`
+\u{1F4CA} Tokens: ${result.tokensUsed.total} (prompt: ${result.tokensUsed.prompt}, completion: ${result.tokensUsed.completion})`);
+      }
+    } else {
+      console.log(`
+\u274C Failed: ${result.error}`);
+    }
+  } catch (err) {
+    console.log(`
+\u274C Error: ${err instanceof Error ? err.message : err}`);
+  }
+  console.log("");
+  process.exit(0);
+}
+async function showHistory(options) {
+  const limit = parseInt(options.limit || "10", 10);
+  const history = getRecentHistory(limit);
+  if (history.length === 0) {
+    console.log("\n\u{1F4DC} No trigger history yet.\n");
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(history, null, 2));
+    return;
+  }
+  console.log(`
+\u{1F4DC} Trigger History (last ${Math.min(limit, history.length)} records)
+`);
+  const table = new Table4({
+    head: ["Time", "Source", "Model", "Account", "Duration", "Status"],
+    style: { head: ["cyan"] }
+  });
+  for (const record of history) {
+    const time = new Date(record.timestamp).toLocaleString();
+    const status = record.success ? "\u2705" : `\u274C ${record.error?.substring(0, 20) || ""}`;
+    table.push([
+      time,
+      record.triggerSource,
+      record.models[0] || "-",
+      record.accountEmail.split("@")[0],
+      `${record.durationMs}ms`,
+      status
+    ]);
+  }
+  console.log(table.toString());
+  console.log("");
+}
+async function showStatus() {
+  console.log("\n\u{1F4CA} Auto Wake-up Status\n");
+  const config = loadWakeupConfig();
+  if (!config) {
+    console.log("   Status: Not configured");
+    console.log("");
+    console.log("   To configure: antigravity-usage wakeup config");
+    console.log("");
+    return;
+  }
+  console.log(`   Enabled: ${config.enabled ? "\u2705 Yes" : "\u274C No"}`);
+  console.log(`   Mode: ${getScheduleDescription(config)}`);
+  if (config.selectedModels.length > 0) {
+    console.log(`   Models: ${config.selectedModels.join(", ")}`);
+  } else {
+    console.log("   Models: None selected");
+  }
+  console.log(`   Accounts: ${getAccountResolutionStatus(config.selectedAccounts)}`);
+  if (!config.wakeOnReset && config.enabled) {
+    const cronStatus = await getCronStatus();
+    if (cronStatus.installed) {
+      console.log(`   Cron: \u2705 Installed (${cronStatus.cronExpression})`);
+      if (cronStatus.nextRun) {
+        console.log(`   Next run: ${cronStatus.nextRun}`);
+      }
+    } else {
+      console.log("   Cron: \u274C Not installed");
+      console.log("         Run: antigravity-usage wakeup install");
+    }
+  }
+  const lastTrigger = getLastTrigger();
+  if (lastTrigger) {
+    const ago = getTimeAgo(new Date(lastTrigger.timestamp));
+    const status = lastTrigger.success ? "\u2705 success" : `\u274C ${lastTrigger.error?.substring(0, 30) || "failed"}`;
+    console.log(`   Last trigger: ${ago} (${status})`);
+  } else {
+    console.log("   Last trigger: Never");
+  }
+  console.log("");
+}
+function getTimeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return "Just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)} minutes ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)} hours ago`;
+  return `${Math.floor(seconds / 86400)} days ago`;
+}
+
 // src/index.ts
 var program = new Command();
 program.name("antigravity-usage").description("CLI tool to check Antigravity model quota via Google Cloud Code API").version(version).option("--debug", "Enable debug mode").hook("preAction", (thisCommand) => {
@@ -2728,5 +4180,14 @@ accountsCmd.command("current").description("Show current active account").action
 accountsCmd.command("refresh [email]").description("Refresh account tokens").option("--all", "Refresh all accounts").action((email, options) => accountsCommand("refresh", email ? [email] : [], options));
 accountsCmd.action(() => accountsCommand("list", [], {}));
 program.command("doctor").description("Run diagnostics and show configuration").action(doctorCommand);
+var wakeupCmd = program.command("wakeup").description("Auto wake-up and warm up AI models");
+wakeupCmd.command("config").description("Configure auto wake-up schedule").action(() => wakeupCommand("config", [], {}));
+wakeupCmd.command("trigger").description("Execute one trigger cycle (called by cron)").option("--scheduled", "Mark as scheduled trigger").action((options) => wakeupCommand("trigger", [], options));
+wakeupCmd.command("install").description("Install wake-up schedule to system cron").action(() => wakeupCommand("install", [], {}));
+wakeupCmd.command("uninstall").description("Remove wake-up schedule from system cron").action(() => wakeupCommand("uninstall", [], {}));
+wakeupCmd.command("test").description("Test trigger manually").action(() => wakeupCommand("test", [], {}));
+wakeupCmd.command("history").description("View trigger history").option("--limit <n>", "Number of records to show", "10").option("--json", "Output as JSON").action((options) => wakeupCommand("history", [], options));
+wakeupCmd.command("status").description("Show wake-up status and configuration").action(() => wakeupCommand("status", [], {}));
+wakeupCmd.action(() => wakeupCommand("status", [], {}));
 program.parse();
 //# sourceMappingURL=index.js.map