very-happy-cli 0.2.159 → 0.2.160

package/dist/connect-C2CiOUFs.cjs

@@ -0,0 +1,684 @@
+'use strict';
+
+var chalk = require('chalk');
+var os = require('os');
+var path = require('path');
+var persistence = require('./persistence-yKTH3-5X.cjs');
+var api = require('./api-CgundNNX.cjs');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var http = require('http');
+var crypto = require('crypto');
+var browser = require('./browser-Y6Bl8L_O.cjs');
+var child_process = require('child_process');
+var util = require('util');
+require('node:fs/promises');
+require('node:fs');
+require('zod');
+require('./authRelay-BdYkC1Po.cjs');
+require('node:crypto');
+require('tweetnacl');
+require('./logger-CS0mw3fa.cjs');
+require('node:util');
+require('node:path');
+require('node:os');
+require('./package-BwMrPwqH.cjs');
+require('axios');
+require('node:events');
+require('socket.io-client');
+require('./attachmentLimits-CzVrqgLR.cjs');
+require('./index-DA7yINuk.cjs');
+require('@paralleldrive/cuid2');
+require('./limits-C-a7gr04.cjs');
+require('./time-DCuTyook.cjs');
+require('./lidState-BeDfxxEX.cjs');
+require('./registerCommonHandlers-DskirN-_.cjs');
+require('fs/promises');
+require('cross-spawn');
+require('./projectPath-ChLhdOyt.cjs');
+require('url');
+require('./sync-DccIKZ5_.cjs');
+require('./backgroundTaskActivity-CBvUdj39.cjs');
+require('./controlClient-Bcwv3D21.cjs');
+require('./contentLogMetadata-ZSFk_NjQ.cjs');
+require('open');
+
+const CLIENT_ID$2 = "app_EMoamEEZ73f0CkXaXp7hrann";
+const AUTH_BASE_URL = "https://auth.openai.com";
+const DEFAULT_PORT$2 = 1455;
+function generatePKCE$2() {
+  const verifier = crypto.randomBytes(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return { verifier, challenge };
+}
+function generateState$2() {
+  return crypto.randomBytes(16).toString("hex");
+}
+function parseJWT(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("Invalid JWT format");
+  }
+  const payload = Buffer.from(parts[1], "base64url").toString();
+  return JSON.parse(payload);
+}
+async function findAvailablePort$2() {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+  });
+}
+async function isPortAvailable$2(port) {
+  return new Promise((resolve) => {
+    const testServer = http.createServer();
+    testServer.once("error", () => {
+      testServer.close();
+      resolve(false);
+    });
+    testServer.listen(port, "127.0.0.1", () => {
+      testServer.close(() => resolve(true));
+    });
+  });
+}
+async function exchangeCodeForTokens$2(code, verifier, port) {
+  const response = await fetch(`${AUTH_BASE_URL}/oauth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID$2,
+      code,
+      code_verifier: verifier,
+      redirect_uri: `http://localhost:${port}/auth/callback`
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${error}`);
+  }
+  const data = await response.json();
+  const idTokenPayload = parseJWT(data.id_token);
+  let accountId = idTokenPayload.chatgpt_account_id;
+  if (!accountId) {
+    const authClaim = idTokenPayload["https://api.openai.com/auth"];
+    if (authClaim && typeof authClaim === "object") {
+      accountId = authClaim.chatgpt_account_id || authClaim.account_id;
+    }
+  }
+  return {
+    id_token: data.id_token,
+    access_token: data.access_token || data.id_token,
+    refresh_token: data.refresh_token,
+    account_id: accountId
+  };
+}
+async function startCallbackServer$2(state, verifier, port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/auth/callback") {
+        const code = url.searchParams.get("code");
+        const receivedState = url.searchParams.get("state");
+        if (receivedState !== state) {
+          res.writeHead(400);
+          res.end("Invalid state parameter");
+          server.close();
+          reject(new Error("Invalid state parameter"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("No authorization code received");
+          server.close();
+          reject(new Error("No authorization code received"));
+          return;
+        }
+        try {
+          const tokens = await exchangeCodeForTokens$2(code, verifier, port);
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+                        <html>
+                        <body style="font-family: sans-serif; padding: 20px;">
+                            <h2>\u2705 Authentication Successful!</h2>
+                            <p>You can close this window and return to your terminal.</p>
+                            <script>setTimeout(() => window.close(), 3000);<\/script>
+                        </body>
+                        </html>
+                    `);
+          server.close();
+          resolve(tokens);
+        } catch (error) {
+          res.writeHead(500);
+          res.end("Token exchange failed");
+          server.close();
+          reject(error);
+        }
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function authenticateCodex() {
+  const { verifier, challenge } = generatePKCE$2();
+  const state = generateState$2();
+  let port = DEFAULT_PORT$2;
+  const portAvailable = await isPortAvailable$2(port);
+  if (!portAvailable) {
+    port = await findAvailablePort$2();
+  }
+  const serverPromise = startCallbackServer$2(state, verifier, port);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const redirect_uri = `http://localhost:${port}/auth/callback`;
+  const params = [
+    ["response_type", "code"],
+    ["client_id", CLIENT_ID$2],
+    ["redirect_uri", redirect_uri],
+    ["scope", "openid profile email offline_access"],
+    ["code_challenge", challenge],
+    ["code_challenge_method", "S256"],
+    ["id_token_add_organizations", "true"],
+    ["codex_cli_simplified_flow", "true"],
+    ["state", state]
+  ];
+  const queryString = params.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+  const authUrl = `${AUTH_BASE_URL}/oauth/authorize?${queryString}`;
+  console.log("\u{1F4CB} Opening browser for authentication...");
+  console.log(`If browser doesn't open, visit:
+${authUrl}
+`);
+  await browser.openBrowser(authUrl);
+  const tokens = await serverPromise;
+  console.log("\u{1F389} Authentication successful!");
+  return tokens;
+}
+
+const CLIENT_ID$1 = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const CLAUDE_AI_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL$1 = "https://console.anthropic.com/v1/oauth/token";
+const DEFAULT_PORT$1 = 54545;
+const SCOPE = "user:inference";
+function generatePKCE$1() {
+  const verifier = crypto.randomBytes(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return { verifier, challenge };
+}
+function generateState$1() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+async function findAvailablePort$1() {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+  });
+}
+async function isPortAvailable$1(port) {
+  return new Promise((resolve) => {
+    const testServer = http.createServer();
+    testServer.once("error", () => {
+      testServer.close();
+      resolve(false);
+    });
+    testServer.listen(port, "127.0.0.1", () => {
+      testServer.close(() => resolve(true));
+    });
+  });
+}
+async function exchangeCodeForTokens$1(code, verifier, port, state) {
+  const tokenResponse = await fetch(TOKEN_URL$1, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: `http://localhost:${port}/callback`,
+      client_id: CLIENT_ID$1,
+      code_verifier: verifier,
+      state
+    })
+  });
+  if (!tokenResponse.ok) {
+    throw new Error(`Token exchange failed: ${tokenResponse.statusText}`);
+  }
+  const tokenData = await tokenResponse.json();
+  return {
+    raw: tokenData,
+    token: tokenData.access_token,
+    expires: Date.now() + tokenData.expires_in * 1e3
+  };
+}
+async function startCallbackServer$1(state, verifier, port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const receivedState = url.searchParams.get("state");
+        if (receivedState !== state) {
+          res.writeHead(400);
+          res.end("Invalid state parameter");
+          server.close();
+          reject(new Error("Invalid state parameter"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("No authorization code received");
+          server.close();
+          reject(new Error("No authorization code received"));
+          return;
+        }
+        try {
+          const tokens = await exchangeCodeForTokens$1(code, verifier, port, state);
+          res.writeHead(302, {
+            "Location": "https://console.anthropic.com/oauth/code/success?app=claude-code"
+          });
+          res.end();
+          server.close();
+          resolve(tokens);
+        } catch (error) {
+          res.writeHead(500);
+          res.end("Token exchange failed");
+          server.close();
+          reject(error);
+        }
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function authenticateClaude() {
+  console.log("\u{1F680} Starting Anthropic Claude authentication...");
+  const { verifier, challenge } = generatePKCE$1();
+  const state = generateState$1();
+  let port = DEFAULT_PORT$1;
+  const portAvailable = await isPortAvailable$1(port);
+  if (!portAvailable) {
+    console.log(`Port ${port} is in use, finding an available port...`);
+    port = await findAvailablePort$1();
+  }
+  console.log(`\u{1F4E1} Using callback port: ${port}`);
+  const serverPromise = startCallbackServer$1(state, verifier, port);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const redirect_uri = `http://localhost:${port}/callback`;
+  const params = new URLSearchParams({
+    code: "true",
+    // This tells Claude.ai to show the code AND redirect
+    client_id: CLIENT_ID$1,
+    response_type: "code",
+    redirect_uri,
+    scope: SCOPE,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state
+  });
+  const authUrl = `${CLAUDE_AI_AUTHORIZE_URL}?${params}`;
+  console.log("\u{1F4CB} Opening browser for authentication...");
+  console.log("If browser doesn't open, visit this URL:");
+  console.log();
+  console.log(`${authUrl}`);
+  console.log();
+  await browser.openBrowser(authUrl);
+  try {
+    const tokens = await serverPromise;
+    console.log("\u{1F389} Authentication successful!");
+    console.log("\u2705 OAuth tokens received");
+    return tokens;
+  } catch (error) {
+    console.error("\n\u274C Failed to authenticate with Anthropic");
+    throw error;
+  }
+}
+
+const execAsync = util.promisify(child_process.exec);
+const CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
+const CLIENT_SECRET = "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";
+const AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const TOKEN_URL = "https://oauth2.googleapis.com/token";
+const DEFAULT_PORT = 54545;
+const SCOPES = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile"
+].join(" ");
+function generatePKCE() {
+  const verifier = crypto.randomBytes(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return { verifier, challenge };
+}
+function generateState() {
+  return crypto.randomBytes(32).toString("hex");
+}
+async function findAvailablePort() {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+  });
+}
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const testServer = http.createServer();
+    testServer.once("error", () => {
+      testServer.close();
+      resolve(false);
+    });
+    testServer.listen(port, "127.0.0.1", () => {
+      testServer.close(() => resolve(true));
+    });
+  });
+}
+async function exchangeCodeForTokens(code, verifier, port) {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      code,
+      code_verifier: verifier,
+      redirect_uri: `http://localhost:${port}/oauth2callback`
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${error}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function startCallbackServer(state, verifier, port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/oauth2callback") {
+        const code = url.searchParams.get("code");
+        const receivedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(302, {
+            "Location": "https://developers.google.com/gemini-code-assist/auth_failure_gemini"
+          });
+          res.end();
+          server.close();
+          reject(new Error(`Authentication error: ${error}`));
+          return;
+        }
+        if (receivedState !== state) {
+          res.writeHead(400);
+          res.end("State mismatch. Possible CSRF attack");
+          server.close();
+          reject(new Error("Invalid state parameter"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("No authorization code received");
+          server.close();
+          reject(new Error("No authorization code received"));
+          return;
+        }
+        try {
+          const tokens = await exchangeCodeForTokens(code, verifier, port);
+          res.writeHead(302, {
+            "Location": "https://developers.google.com/gemini-code-assist/auth_success_gemini"
+          });
+          res.end();
+          server.close();
+          resolve(tokens);
+        } catch (error2) {
+          res.writeHead(500);
+          res.end("Token exchange failed");
+          server.close();
+          reject(error2);
+        }
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function authenticateGemini() {
+  console.log("\u{1F680} Starting Google Gemini authentication...");
+  const { verifier, challenge } = generatePKCE();
+  const state = generateState();
+  let port = DEFAULT_PORT;
+  const portAvailable = await isPortAvailable(port);
+  if (!portAvailable) {
+    console.log(`Port ${port} is in use, finding an available port...`);
+    port = await findAvailablePort();
+  }
+  console.log(`\u{1F4E1} Using callback port: ${port}`);
+  const serverPromise = startCallbackServer(state, verifier, port);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const redirect_uri = `http://localhost:${port}/oauth2callback`;
+  const params = new URLSearchParams({
+    client_id: CLIENT_ID,
+    response_type: "code",
+    redirect_uri,
+    scope: SCOPES,
+    access_type: "offline",
+    // To get refresh token
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state,
+    prompt: "consent"
+    // Force consent to get refresh token
+  });
+  const authUrl = `${AUTHORIZE_URL}?${params}`;
+  console.log("\n\u{1F4CB} Opening browser for authentication...");
+  console.log("If browser doesn't open, visit this URL:");
+  console.log(`
+${authUrl}
+`);
+  const platform = process.platform;
+  const openCommand = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  try {
+    await execAsync(`${openCommand} "${authUrl}"`);
+  } catch {
+    console.log("\u26A0\uFE0F  Could not open browser automatically");
+  }
+  try {
+    const tokens = await serverPromise;
+    console.log("\n\u{1F389} Authentication successful!");
+    console.log("\u2705 OAuth tokens received");
+    return tokens;
+  } catch (error) {
+    console.error("\n\u274C Failed to authenticate with Google");
+    throw error;
+  }
+}
+
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return null;
+    }
+    const payload = parts[1];
+    const decoded = Buffer.from(payload, "base64url").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+
+async function handleConnectCommand(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    showConnectHelp();
+    return;
+  }
+  switch (subcommand.toLowerCase()) {
+    case "codex":
+      await handleConnectVendor("codex", "OpenAI");
+      break;
+    case "claude":
+      await handleConnectVendor("claude", "Anthropic");
+      break;
+    case "gemini":
+      await handleConnectVendor("gemini", "Gemini");
+      break;
+    case "status":
+      await handleConnectStatus();
+      break;
+    default:
+      console.error(chalk.red(`Unknown connect target: ${subcommand}`));
+      showConnectHelp();
+      process.exit(1);
+  }
+}
+function showConnectHelp() {
+  console.log(`
+${chalk.bold("very-happy connect")} - Store AI vendor credentials on your configured relay
+
+${chalk.bold("Usage:")}
+  very-happy connect codex        Store your Codex credential on the relay
+  very-happy connect claude       Store your Anthropic credential on the relay
+  very-happy connect gemini       Store your Gemini credential on the relay
+  very-happy connect status       Show connection status for all vendors
+  very-happy connect help         Show this help message
+
+${chalk.bold("Description:")}
+  Credentials are encrypted at rest but recoverable by the configured relay.
+  The relay is trusted infrastructure, not an end-to-end encrypted vault.
+  Use this only when you trust that relay's operator and backups.
+
+${chalk.bold("Examples:")}
+  very-happy connect codex
+  very-happy connect claude
+  very-happy connect gemini
+  very-happy connect status
+
+${chalk.bold("Notes:")} 
+  \u2022 You must be authenticated with Happy first (run 'very-happy auth login')
+  \u2022 Credentials are sent to and retained by your configured relay
+  \u2022 Remove a credential with the corresponding account/settings controls
+`);
+}
+async function handleConnectVendor(vendor, displayName) {
+  console.log(chalk.bold(`
+\u{1F50C} Connecting ${displayName} to Happy cloud
+`));
+  const credentials = await persistence.readCredentialsForConfiguredRelay();
+  if (!credentials) {
+    console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated with Happy"));
+    console.log(chalk.gray('  Please run "very-happy auth login" first'));
+    process.exit(1);
+  }
+  const api$1 = await api.ApiClient.create(credentials);
+  if (vendor === "codex") {
+    console.log("\u{1F680} Registering Codex token with server");
+    const codexAuthTokens = await authenticateCodex();
+    await api$1.registerVendorToken("openai", { oauth: codexAuthTokens });
+    console.log("\u2705 Codex token registered with server");
+    process.exit(0);
+  } else if (vendor === "claude") {
+    console.log("\u{1F680} Registering Anthropic token with server");
+    const anthropicAuthTokens = await authenticateClaude();
+    await api$1.registerVendorToken("anthropic", { oauth: anthropicAuthTokens });
+    console.log("\u2705 Anthropic token registered with server");
+    process.exit(0);
+  } else if (vendor === "gemini") {
+    console.log("\u{1F680} Registering Gemini token with server");
+    const geminiAuthTokens = await authenticateGemini();
+    await api$1.registerVendorToken("gemini", { oauth: geminiAuthTokens });
+    console.log("\u2705 Gemini token registered with server");
+    updateLocalGeminiCredentials(geminiAuthTokens);
+    process.exit(0);
+  } else {
+    throw new Error(`Unsupported vendor: ${vendor}`);
+  }
+}
+async function handleConnectStatus() {
+  console.log(chalk.bold("\n\u{1F50C} Connection Status\n"));
+  const credentials = await persistence.readCredentialsForConfiguredRelay();
+  if (!credentials) {
+    console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated with Happy"));
+    console.log(chalk.gray('  Please run "very-happy auth login" first'));
+    process.exit(1);
+  }
+  const api$1 = await api.ApiClient.create(credentials);
+  const vendors = [
+    { key: "gemini", name: "Gemini", display: "Google Gemini" },
+    { key: "openai", name: "Codex", display: "OpenAI Codex" },
+    { key: "anthropic", name: "Claude", display: "Anthropic Claude" }
+  ];
+  for (const vendor of vendors) {
+    try {
+      const token = await api$1.getVendorToken(vendor.key);
+      if (token?.oauth) {
+        let userInfo = "";
+        if (token.oauth.id_token) {
+          const payload = decodeJwtPayload(token.oauth.id_token);
+          if (payload?.email) {
+            userInfo = chalk.gray(` (${payload.email})`);
+          }
+        }
+        const expiresAt = token.oauth.expires_at || (token.oauth.expires_in ? Date.now() + token.oauth.expires_in * 1e3 : null);
+        const isExpired = expiresAt && expiresAt < Date.now();
+        if (isExpired) {
+          console.log(`  ${chalk.yellow("\u26A0\uFE0F")}  ${vendor.display}: ${chalk.yellow("expired")}${userInfo}`);
+        } else {
+          console.log(`  ${chalk.green("\u2713")}  ${vendor.display}: ${chalk.green("connected")}${userInfo}`);
+        }
+      } else {
+        console.log(`  ${chalk.gray("\u25CB")}  ${vendor.display}: ${chalk.gray("not connected")}`);
+      }
+    } catch {
+      console.log(`  ${chalk.gray("\u25CB")}  ${vendor.display}: ${chalk.gray("not connected")}`);
+    }
+  }
+  console.log("");
+  console.log(chalk.gray("To connect a vendor, run: very-happy connect <vendor>"));
+  console.log(chalk.gray("Example: very-happy connect gemini"));
+  console.log("");
+}
+function updateLocalGeminiCredentials(tokens) {
+  try {
+    const geminiDir = path.join(os.homedir(), ".gemini");
+    const credentialsPath = path.join(geminiDir, "oauth_creds.json");
+    configuration.ensurePrivateDirectorySync(geminiDir);
+    const credentials = {
+      access_token: tokens.access_token,
+      token_type: tokens.token_type || "Bearer",
+      scope: tokens.scope || "https://www.googleapis.com/auth/cloud-platform",
+      ...tokens.refresh_token && { refresh_token: tokens.refresh_token },
+      ...tokens.id_token && { id_token: tokens.id_token },
+      ...tokens.expires_in && { expires_in: tokens.expires_in }
+    };
+    configuration.writePrivateFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
+    console.log(chalk.gray(`  Updated local credentials: ${credentialsPath}`));
+  } catch (error) {
+    console.log(chalk.yellow(`  \u26A0\uFE0F Could not update local credentials: ${error}`));
+  }
+}
+
+exports.handleConnectCommand = handleConnectCommand;

package/dist/constants-BC4St0xd.mjs

@@ -0,0 +1,11 @@
+import { t as trimIdent } from './trimIdent-BAjmv_TG.mjs';
+
+const GEMINI_API_KEY_ENV = "GEMINI_API_KEY";
+const GOOGLE_API_KEY_ENV = "GOOGLE_API_KEY";
+const GEMINI_MODEL_ENV = "GEMINI_MODEL";
+const DEFAULT_GEMINI_MODEL = "gemini-2.5-pro";
+const CHANGE_TITLE_INSTRUCTION = trimIdent(
+  `Based on this message, call functions.happy__change_title to change chat session title that would represent the current task. If chat idea would change dramatically - call this function again to update the title.`
+);
+
+export { CHANGE_TITLE_INSTRUCTION as C, DEFAULT_GEMINI_MODEL as D, GEMINI_MODEL_ENV as G, GEMINI_API_KEY_ENV as a, GOOGLE_API_KEY_ENV as b };