gsheet-lvt 0.1.0

package/dist/cli.js

@@ -0,0 +1,3140 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { realpathSync } from "fs";
+import { createRequire } from "module";
+import { basename } from "path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
+
+// src/commands/account/add.ts
+import * as readline from "readline";
+
+// src/auth/oauth-flow.ts
+import { OAuth2Client } from "google-auth-library";
+import http from "http";
+
+// src/config/constants.ts
+import { existsSync, readFileSync } from "fs";
+import * as os from "os";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var packageJsonPath = findPackageJsonPath(__dirname);
+var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+var APP_INFO = {
+  name: "gsheet",
+  packageName: packageJson.name,
+  display_name: "Google Sheets CLI",
+  version: packageJson.version
+};
+var configDirectoryByOS = {
+  ["linux" /* Linux */]: (homeDir) => path.join(homeDir, ".config", APP_INFO.name),
+  ["wsl" /* Wsl */]: (homeDir) => path.join(homeDir, ".config", APP_INFO.name),
+  ["mac" /* Mac */]: (homeDir) => path.join(homeDir, "Library", "Preferences", APP_INFO.name),
+  ["windows" /* Windows */]: (homeDir) => path.join(homeDir, "AppData", "Roaming", APP_INFO.name)
+};
+function getUserOS() {
+  const platform3 = os.platform();
+  if (platform3 === "linux") {
+    try {
+      const release2 = os.release().toLowerCase();
+      if (release2.includes("microsoft") || release2.includes("wsl")) {
+        return "wsl" /* Wsl */;
+      }
+    } catch {
+    }
+    return "linux" /* Linux */;
+  }
+  if (platform3 === "darwin") return "mac" /* Mac */;
+  if (platform3 === "win32") return "windows" /* Windows */;
+  throw new Error(`Unsupported OS: ${platform3}`);
+}
+function getConfigDirectory() {
+  const userOS = getUserOS();
+  const homeDir = os.homedir();
+  return configDirectoryByOS[userOS](homeDir);
+}
+var CONFIG_PATHS = {
+  configDir: getConfigDirectory(),
+  userMetadataFile: path.join(getConfigDirectory(), "user_metadata.json"),
+  defaultConfigFile: path.join(getConfigDirectory(), "config.json")
+};
+var OAUTH_SCOPES = {
+  SPREADSHEETS: "https://www.googleapis.com/auth/spreadsheets",
+  DRIVE_READONLY: "https://www.googleapis.com/auth/drive.readonly",
+  USERINFO_EMAIL: "https://www.googleapis.com/auth/userinfo.email"
+};
+var GOOGLE_API_URLS = {
+  USERINFO: "https://www.googleapis.com/oauth2/v2/userinfo",
+  SHEETS_CREATE: "https://sheets.google.com"
+};
+var GOOGLE_CLOUD_CONSOLE_URLS = {
+  CREDENTIALS: "https://console.cloud.google.com/apis/credentials",
+  CONSENT_SCREEN: "https://console.cloud.google.com/apis/credentials/consent",
+  SCOPES: "https://console.cloud.google.com/auth/scopes",
+  TEST_USERS: "https://console.cloud.google.com/auth/audience",
+  ENABLE_SHEETS_API: "https://console.cloud.google.com/apis/library/sheets.googleapis.com",
+  ENABLE_DRIVE_API: "https://console.cloud.google.com/apis/library/drive.googleapis.com"
+};
+var OAUTH_CONFIG = {
+  REDIRECT_HOST: "127.0.0.1",
+  REDIRECT_PATH: "/callback",
+  ACCESS_TYPE: "offline",
+  PROMPT: "consent"
+};
+var TOKEN_REFRESH_THRESHOLD_MS = 5 * 60 * 1e3;
+function findPackageJsonPath(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const candidate = path.join(currentDir, "package.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not find package.json");
+    }
+    currentDir = parentDir;
+  }
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  static error(message, error) {
+    if (error === void 0) {
+      console.error(chalk.red(`\u274C ${message}`));
+      return;
+    }
+    const errorText = error instanceof Error ? error.message : "Unknown error";
+    console.error(chalk.red(`\u274C ${message}: ${errorText}`));
+  }
+  static success(message) {
+    console.log(chalk.green(`\u2705 ${message}`));
+  }
+  static warning(message) {
+    console.log(chalk.yellow(`\u26A0\uFE0F  ${message}`));
+  }
+  static info(message) {
+    console.log(`${message}`);
+  }
+  static dim(message) {
+    console.log(chalk.dim(message));
+  }
+  static plain(message) {
+    console.log(message);
+  }
+  static json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+  static bold(message) {
+    console.log(chalk.bold(message));
+  }
+  static loading(message) {
+    console.log(`\u{1F504} ${message}`);
+  }
+  static link(url, prefix) {
+    const linkText = prefix ? `${prefix} ${url}` : url;
+    console.log(chalk.dim(`\u{1F517} ${linkText}`));
+  }
+};
+
+// src/auth/oauth-scopes.ts
+var DRIVE_SCOPES = /* @__PURE__ */ new Set([OAUTH_SCOPES.DRIVE_READONLY, "https://www.googleapis.com/auth/drive"]);
+var REQUIRED_OAUTH_SCOPES = [OAUTH_SCOPES.SPREADSHEETS, OAUTH_SCOPES.DRIVE_READONLY];
+function getMissingOAuthScopes(grantedScopes) {
+  return REQUIRED_OAUTH_SCOPES.filter((scope) => {
+    if (scope === OAUTH_SCOPES.DRIVE_READONLY) {
+      return !grantedScopes.some((grantedScope) => DRIVE_SCOPES.has(grantedScope));
+    }
+    return !grantedScopes.includes(scope);
+  });
+}
+function assertRequiredOAuthScopes(grantedScopes) {
+  const missingScopes = getMissingOAuthScopes(grantedScopes);
+  if (missingScopes.length === 0) {
+    return;
+  }
+  throw new Error(
+    [
+      "Google returned an access token without required scopes.",
+      `Missing scopes: ${missingScopes.join(", ")}`,
+      `Granted scopes: ${grantedScopes.length > 0 ? grantedScopes.join(", ") : "none"}`,
+      "Fix: in Google Cloud Console, add the missing scopes to the OAuth consent screen, publish/save the consent screen, then run `gsheet account reauth` again."
+    ].join("\n")
+  );
+}
+
+// src/auth/oauth-flow.ts
+async function performOAuthFlow(clientId, clientSecret, options = {}) {
+  const port = await getRandomAvailablePort();
+  const redirectUri = `http://${OAUTH_CONFIG.REDIRECT_HOST}:${port}${OAUTH_CONFIG.REDIRECT_PATH}`;
+  const oauth2Client = new OAuth2Client(clientId, clientSecret, redirectUri);
+  const authUrl = oauth2Client.generateAuthUrl({
+    access_type: OAUTH_CONFIG.ACCESS_TYPE,
+    scope: [OAUTH_SCOPES.SPREADSHEETS, OAUTH_SCOPES.DRIVE_READONLY, OAUTH_SCOPES.USERINFO_EMAIL],
+    prompt: OAUTH_CONFIG.PROMPT,
+    include_granted_scopes: true,
+    login_hint: options.loginHint
+  });
+  if (options.onAuthUrl) {
+    options.onAuthUrl(authUrl);
+  } else {
+    Logger.info("Opening browser for authentication...");
+    Logger.info(`Visit: ${authUrl}`);
+  }
+  const authCode = await startCallbackServer(port);
+  const { tokens } = await oauth2Client.getToken(authCode);
+  oauth2Client.setCredentials(tokens);
+  if (!tokens.access_token) {
+    throw new Error("No access token received. Try re-authenticating.");
+  }
+  const tokenInfo = await oauth2Client.getTokenInfo(tokens.access_token);
+  assertRequiredOAuthScopes(tokenInfo.scopes);
+  const userInfo = await fetch(GOOGLE_API_URLS.USERINFO, {
+    headers: { Authorization: `Bearer ${tokens.access_token}` }
+  });
+  const userData = await userInfo.json();
+  if (!tokens.refresh_token) {
+    throw new Error("No refresh token received. Try revoking app access and re-authenticating.");
+  }
+  return {
+    email: userData.email,
+    credentials: {
+      client_id: clientId,
+      client_secret: clientSecret,
+      refresh_token: tokens.refresh_token,
+      access_token: tokens.access_token ?? void 0,
+      expiry_date: tokens.expiry_date ?? void 0
+    }
+  };
+}
+async function getRandomAvailablePort() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer();
+    server.listen(0, () => {
+      const address = server.address();
+      if (address && typeof address !== "string") {
+        const port = address.port;
+        server.close(() => resolve(port));
+      } else {
+        reject(new Error("Failed to get port"));
+      }
+    });
+  });
+}
+async function startCallbackServer(port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      if (req.url?.startsWith(OAUTH_CONFIG.REDIRECT_PATH)) {
+        const url = new URL(req.url, `http://${OAUTH_CONFIG.REDIRECT_HOST}:${port}`);
+        const code = url.searchParams.get("code");
+        if (code) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                <h1 style="color: #10b981;">Authentication Successful</h1>
+                <p>You can close this window and return to the terminal.</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          resolve(code);
+        } else {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                <h1 style="color: #ef4444;">\u2717 Authentication Failed</h1>
+                <p>No authorization code received.</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          reject(new Error("No authorization code received"));
+        }
+      }
+    });
+    server.listen(port, OAUTH_CONFIG.REDIRECT_HOST);
+  });
+}
+
+// src/cli/define.ts
+function defineCommand(definition) {
+  return { kind: "command", ...definition };
+}
+function defineSubCommand(definition) {
+  return { kind: "subcommand", ...definition };
+}
+var flag = {
+  string(name, description, options) {
+    return { name, description, type: "string" /* String */, ...options };
+  },
+  boolean(name, description, options) {
+    return { name, description, type: "boolean" /* Boolean */, ...options };
+  }
+};
+var argument = {
+  string(name, description, options) {
+    return { name, description, type: "string", ...options };
+  }
+};
+
+// src/config/config-manager.ts
+import * as fs2 from "fs";
+import { OAuth2Client as OAuth2Client3 } from "google-auth-library";
+
+// src/auth/token-refresh.ts
+import { OAuth2Client as OAuth2Client2 } from "google-auth-library";
+async function refreshTokenIfNeeded(credentials) {
+  const now = Date.now();
+  const expiryDate = credentials.expiry_date || 0;
+  if (now >= expiryDate - TOKEN_REFRESH_THRESHOLD_MS) {
+    return await refreshToken(credentials);
+  }
+  return credentials;
+}
+async function refreshToken(credentials) {
+  const oauth2Client = new OAuth2Client2(credentials.client_id, credentials.client_secret);
+  oauth2Client.setCredentials({
+    refresh_token: credentials.refresh_token
+  });
+  const { credentials: newTokens } = await oauth2Client.refreshAccessToken();
+  const accessToken = newTokens.access_token || credentials.access_token;
+  if (!accessToken) {
+    throw new Error("No access token available after refresh. Run `gsheet account reauth`.");
+  }
+  const tokenInfo = await oauth2Client.getTokenInfo(accessToken);
+  assertRequiredOAuthScopes(tokenInfo.scopes);
+  return {
+    client_id: credentials.client_id,
+    client_secret: credentials.client_secret,
+    refresh_token: credentials.refresh_token,
+    access_token: accessToken,
+    expiry_date: newTokens.expiry_date || credentials.expiry_date
+  };
+}
+
+// src/utils/json.ts
+import * as fs from "fs";
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  try {
+    const rawData = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(rawData);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse JSON file: ${filePath}. Error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function writeJson(filePath, data, pretty = true) {
+  try {
+    const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    fs.writeFileSync(filePath, jsonString, "utf-8");
+  } catch (error) {
+    throw new Error(
+      `Failed to write JSON file: ${filePath}. Error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+// src/config/types.ts
+import { z } from "zod";
+var oauthCredentialsSchema = z.object({
+  client_id: z.string(),
+  client_secret: z.string(),
+  refresh_token: z.string(),
+  access_token: z.string().optional(),
+  expiry_date: z.number().optional()
+});
+var spreadsheetConfigSchema = z.object({
+  spreadsheet_id: z.string(),
+  activeSheet: z.string().optional()
+});
+var accountSchema = z.object({
+  email: z.string(),
+  oauth: oauthCredentialsSchema,
+  activeSpreadsheet: z.string().optional(),
+  spreadsheets: z.record(z.string(), spreadsheetConfigSchema)
+});
+var userMetadataSchema = z.object({
+  config_path: z.string(),
+  activeAccount: z.string().optional(),
+  accounts: z.record(z.string(), accountSchema)
+});
+var sheetsConfigSchema = z.object({
+  $schema: z.string().optional(),
+  settings: z.object({
+    max_results: z.number().default(50),
+    default_columns: z.string().default("A:Z"),
+    completion_installed: z.boolean().optional()
+  }).optional()
+});
+var sheetDataSchema = z.object({
+  title: z.string(),
+  index: z.number()
+});
+
+// src/config/config-manager.ts
+var ConfigManager = class {
+  userMetadata = null;
+  config = null;
+  constructor() {
+    this.ensureConfigDirectory();
+    this.initializeUserMetadata();
+  }
+  ensureConfigDirectory() {
+    if (!fs2.existsSync(CONFIG_PATHS.configDir)) {
+      fs2.mkdirSync(CONFIG_PATHS.configDir, { recursive: true });
+    }
+  }
+  initializeUserMetadata() {
+    if (!fs2.existsSync(CONFIG_PATHS.userMetadataFile)) {
+      this.createDefaultUserMetadata();
+    }
+    this.loadUserMetadata();
+  }
+  createDefaultUserMetadata() {
+    const defaultMetadata = {
+      config_path: CONFIG_PATHS.defaultConfigFile,
+      accounts: {}
+    };
+    writeJson(CONFIG_PATHS.userMetadataFile, defaultMetadata);
+  }
+  loadUserMetadata() {
+    try {
+      const data = readJson(CONFIG_PATHS.userMetadataFile);
+      const validated = userMetadataSchema.parse(data);
+      this.userMetadata = validated;
+    } catch (error) {
+      throw new Error(`Failed to load user metadata: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  saveUserMetadata() {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    writeJson(CONFIG_PATHS.userMetadataFile, this.userMetadata);
+  }
+  getConfigPath() {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    return this.userMetadata.config_path;
+  }
+  loadConfig() {
+    if (this.config) {
+      return this.config;
+    }
+    const configPath = this.getConfigPath();
+    if (!fs2.existsSync(configPath)) {
+      this.createDefaultConfig();
+    }
+    try {
+      const data = readJson(configPath);
+      const validated = sheetsConfigSchema.parse(data);
+      this.config = validated;
+      return this.config;
+    } catch (error) {
+      throw new Error(`Failed to load config: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  createDefaultConfig() {
+    const defaultConfig = {
+      settings: {
+        max_results: 50,
+        default_columns: "A:Z"
+      }
+    };
+    const configPath = this.getConfigPath();
+    writeJson(configPath, defaultConfig);
+  }
+  saveConfig() {
+    if (!this.config) {
+      throw new Error("No config to save");
+    }
+    const configPath = this.getConfigPath();
+    writeJson(configPath, this.config);
+  }
+  async addAccount(email, credentials) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    if (this.userMetadata.accounts[email]) {
+      throw new Error(`Account '${email}' already exists`);
+    }
+    const account = {
+      email,
+      oauth: credentials,
+      spreadsheets: {}
+    };
+    this.userMetadata.accounts[email] = account;
+    this.saveUserMetadata();
+  }
+  async removeAccount(email) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    if (!this.userMetadata.accounts[email]) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    delete this.userMetadata.accounts[email];
+    if (this.userMetadata.activeAccount === email) {
+      this.userMetadata.activeAccount = void 0;
+    }
+    this.saveUserMetadata();
+  }
+  getAllAccounts() {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    return Object.values(this.userMetadata.accounts);
+  }
+  getAccount(email) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    return this.userMetadata.accounts[email] || null;
+  }
+  setActiveAccount(email) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    if (!this.userMetadata.accounts[email]) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    this.userMetadata.activeAccount = email;
+    this.saveUserMetadata();
+  }
+  getActiveAccount() {
+    if (!this.userMetadata?.activeAccount) {
+      return null;
+    }
+    return this.getAccount(this.userMetadata.activeAccount);
+  }
+  getActiveAccountEmail() {
+    return this.userMetadata?.activeAccount || null;
+  }
+  async updateAccountCredentials(email, credentials) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    account.oauth = credentials;
+    this.saveUserMetadata();
+  }
+  async getRefreshedCredentials(email) {
+    const account = this.getAccount(email);
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    const refreshedCredentials = await refreshTokenIfNeeded(account.oauth);
+    await assertCredentialsHaveRequiredScopes(refreshedCredentials);
+    if (refreshedCredentials !== account.oauth) {
+      await this.updateAccountCredentials(email, refreshedCredentials);
+    }
+    return refreshedCredentials;
+  }
+  async addSpreadsheet(email, name, spreadsheetId) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    if (account.spreadsheets[name]) {
+      throw new Error(`Spreadsheet '${name}' already exists for account '${email}'`);
+    }
+    const spreadsheet = {
+      spreadsheet_id: spreadsheetId
+    };
+    account.spreadsheets[name] = spreadsheet;
+    this.saveUserMetadata();
+  }
+  async removeSpreadsheet(email, name) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    if (!account.spreadsheets[name]) {
+      throw new Error(`Spreadsheet '${name}' not found for account '${email}'`);
+    }
+    delete account.spreadsheets[name];
+    if (account.activeSpreadsheet === name) {
+      account.activeSpreadsheet = void 0;
+    }
+    this.saveUserMetadata();
+  }
+  listSpreadsheets(email) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    return Object.entries(account.spreadsheets).map(([name, spreadsheet]) => ({
+      name,
+      spreadsheetId: spreadsheet.spreadsheet_id,
+      activeSheet: spreadsheet.activeSheet
+    }));
+  }
+  getSpreadsheet(email, name) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      return null;
+    }
+    return account.spreadsheets[name] || null;
+  }
+  getSpreadsheetById(email, id) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      return null;
+    }
+    return Object.values(account.spreadsheets).find((s) => s.spreadsheet_id === id) || null;
+  }
+  setActiveSpreadsheet(email, name) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    if (!account.spreadsheets[name]) {
+      throw new Error(`Spreadsheet '${name}' not found for account '${email}'`);
+    }
+    account.activeSpreadsheet = name;
+    this.saveUserMetadata();
+  }
+  getActiveSpreadsheet(email) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account || !account.activeSpreadsheet) {
+      return null;
+    }
+    return account.spreadsheets[account.activeSpreadsheet] || null;
+  }
+  getActiveSpreadsheetName(email) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    return account?.activeSpreadsheet || null;
+  }
+  setActiveSheet(email, spreadsheetName, sheetName) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    const spreadsheet = account.spreadsheets[spreadsheetName];
+    if (!spreadsheet) {
+      throw new Error(`Spreadsheet '${spreadsheetName}' not found for account '${email}'`);
+    }
+    spreadsheet.activeSheet = sheetName;
+    this.saveUserMetadata();
+  }
+  getActiveSheetName(email, spreadsheetName) {
+    if (!this.userMetadata) {
+      throw new Error("User metadata not loaded");
+    }
+    const account = this.userMetadata.accounts[email];
+    if (!account) {
+      return null;
+    }
+    const spreadsheet = account.spreadsheets[spreadsheetName];
+    return spreadsheet?.activeSheet || null;
+  }
+  markCompletionInstalled() {
+    const config = this.loadConfig();
+    if (!config.settings) {
+      config.settings = {
+        max_results: 50,
+        default_columns: "A:Z"
+      };
+    }
+    config.settings.completion_installed = true;
+    this.saveConfig();
+  }
+  isCompletionInstalled() {
+    const config = this.loadConfig();
+    return config.settings?.completion_installed === true;
+  }
+};
+async function assertCredentialsHaveRequiredScopes(credentials) {
+  if (!credentials.access_token) {
+    throw new Error("No access token available. Run `gsheet account reauth`.");
+  }
+  const oauth2Client = new OAuth2Client3(credentials.client_id, credentials.client_secret);
+  const tokenInfo = await oauth2Client.getTokenInfo(credentials.access_token);
+  assertRequiredOAuthScopes(tokenInfo.scopes);
+}
+
+// src/commands/account/add.ts
+async function promptInput(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var addAccountCommand = defineSubCommand({
+  name: "add",
+  description: "Add a Google account via OAuth",
+  errorMessage: "Failed to add account",
+  action: async () => {
+    Logger.bold("=".repeat(70));
+    Logger.bold("  GOOGLE CLOUD CONSOLE SETUP");
+    Logger.bold("=".repeat(70));
+    Logger.plain("");
+    Logger.info("Follow these steps to get OAuth credentials:\n");
+    Logger.bold("STEP 1: Create or Select a Project");
+    Logger.link(`  ${GOOGLE_CLOUD_CONSOLE_URLS.CREDENTIALS}`);
+    Logger.info("  - Go to Google Cloud Console");
+    Logger.info("  - Create a new project OR select an existing one");
+    Logger.info("  - Note: May require setting up billing (free tier available)");
+    Logger.plain("");
+    Logger.bold("STEP 2: Enable Required APIs");
+    Logger.info("  a) Enable Google Sheets API:");
+    Logger.link(`     ${GOOGLE_CLOUD_CONSOLE_URLS.ENABLE_SHEETS_API}`);
+    Logger.info("  b) Enable Google Drive API:");
+    Logger.link(`     ${GOOGLE_CLOUD_CONSOLE_URLS.ENABLE_DRIVE_API}`);
+    Logger.plain("");
+    Logger.bold("STEP 3: Configure OAuth Consent Screen");
+    Logger.link(`  ${GOOGLE_CLOUD_CONSOLE_URLS.CONSENT_SCREEN}`);
+    Logger.info("  - User Type: External");
+    Logger.info("  - App name: gsheet (or any name)");
+    Logger.info("  - User support email: your email");
+    Logger.info("  - Developer contact: your email");
+    Logger.info('  - Click "SAVE AND CONTINUE"');
+    Logger.plain("");
+    Logger.bold("STEP 4: Add Scopes");
+    Logger.link(`  ${GOOGLE_CLOUD_CONSOLE_URLS.SCOPES}`);
+    Logger.info('  - Click "ADD OR REMOVE SCOPES"');
+    Logger.info("  - Search and add:");
+    Logger.info("    \u2192 .../auth/spreadsheets");
+    Logger.info("    \u2192 .../auth/drive.readonly");
+    Logger.info("    \u2192 .../auth/userinfo.email");
+    Logger.info('  - Click "UPDATE" then "SAVE AND CONTINUE"');
+    Logger.plain("");
+    Logger.bold("STEP 5: Add Test Users");
+    Logger.link(`  ${GOOGLE_CLOUD_CONSOLE_URLS.TEST_USERS}`);
+    Logger.info('  - Click "ADD USERS"');
+    Logger.info("  - Add your email address");
+    Logger.info('  - Click "SAVE AND CONTINUE"');
+    Logger.plain("");
+    Logger.bold("STEP 6: Create OAuth 2.0 Client ID");
+    Logger.link(`  ${GOOGLE_CLOUD_CONSOLE_URLS.CREDENTIALS}`);
+    Logger.info('  - Click "CREATE CREDENTIALS" \u2192 "OAuth client ID"');
+    Logger.info("  - Application type: Desktop app");
+    Logger.info("  - Name: gsheet");
+    Logger.info('  - Click "CREATE"');
+    Logger.info("  - Copy the Client ID and Client Secret");
+    Logger.plain("");
+    Logger.bold("=".repeat(70));
+    Logger.plain("");
+    const clientId = await promptInput("Enter OAuth Client ID: ");
+    if (!clientId) {
+      Logger.error("Client ID is required");
+      process.exit(1);
+    }
+    const clientSecret = await promptInput("Enter OAuth Client Secret: ");
+    if (!clientSecret) {
+      Logger.error("Client Secret is required");
+      process.exit(1);
+    }
+    Logger.info("\nStarting OAuth authentication flow...");
+    const result = await performOAuthFlow(clientId, clientSecret);
+    const configManager = new ConfigManager();
+    await configManager.addAccount(result.email, result.credentials);
+    const accounts = configManager.getAllAccounts();
+    if (accounts.length === 1) {
+      configManager.setActiveAccount(result.email);
+      Logger.success(`Account '${result.email}' added and set as active!`);
+    } else {
+      Logger.success(`Account '${result.email}' added successfully!`);
+      Logger.info("Switch to this account: gsheet account select");
+    }
+    process.exit(0);
+  }
+});
+
+// src/commands/account/list.ts
+var listAccountsCommand = defineSubCommand({
+  name: "list",
+  description: "List all configured Google accounts",
+  errorMessage: "Failed to list accounts",
+  action: () => {
+    const configManager = new ConfigManager();
+    const accounts = configManager.getAllAccounts();
+    const activeAccountEmail = configManager.getActiveAccountEmail();
+    if (accounts.length === 0) {
+      Logger.info("No accounts configured.");
+      Logger.info("Add one with: gsheet account add");
+      return;
+    }
+    Logger.info("Configured accounts:");
+    accounts.forEach((account) => {
+      const isActive = account.email === activeAccountEmail;
+      const spreadsheetCount = Object.keys(account.spreadsheets).length;
+      const prefix = isActive ? "->" : "  ";
+      Logger.info(`${prefix} ${account.email} (${spreadsheetCount} spreadsheet${spreadsheetCount !== 1 ? "s" : ""})`);
+    });
+  }
+});
+
+// src/commands/account/reauth.ts
+var reauthAccountCommand = defineSubCommand({
+  name: "reauth",
+  description: "Re-authenticate the active account",
+  errorMessage: "Failed to re-authenticate account",
+  action: async () => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account switch <email>");
+      process.exit(1);
+    }
+    Logger.info(`Re-authenticating account: ${activeAccount.email}`);
+    Logger.info("Opening browser for authentication...\n");
+    const result = await performOAuthFlow(activeAccount.oauth.client_id, activeAccount.oauth.client_secret, {
+      loginHint: activeAccount.email
+    });
+    if (result.email !== activeAccount.email) {
+      Logger.error(`Authentication email mismatch. Expected ${activeAccount.email}, got ${result.email}`);
+      process.exit(1);
+    }
+    await configManager.updateAccountCredentials(result.email, result.credentials);
+    Logger.success(`Account '${result.email}' re-authenticated successfully!`);
+    process.exit(0);
+  }
+});
+
+// src/commands/account/remove.ts
+import inquirer from "inquirer";
+var removeAccountCommand = defineSubCommand({
+  name: "remove",
+  description: "Remove a Google account",
+  arguments: [argument.string("email", "Account email to remove (optional - interactive if not provided)")],
+  errorMessage: "Failed to remove account",
+  action: async ({ args }) => {
+    const configManager = new ConfigManager();
+    const accounts = configManager.getAllAccounts();
+    if (accounts.length === 0) {
+      Logger.warning("No accounts configured.");
+      Logger.info("Use: gsheet account add");
+      process.exit(0);
+    }
+    let selectedEmail = args.email;
+    if (!selectedEmail) {
+      const choices = accounts.map((acc) => ({
+        name: acc.email,
+        value: acc.email
+      }));
+      const answer = await inquirer.prompt([
+        {
+          type: "list",
+          name: "email",
+          message: "Select account to remove:",
+          choices
+        }
+      ]);
+      selectedEmail = answer.email;
+    }
+    if (!selectedEmail) {
+      Logger.error("No account selected");
+      process.exit(1);
+    }
+    const account = configManager.getAccount(selectedEmail);
+    if (!account) {
+      Logger.error(`Account '${selectedEmail}' not found`);
+      process.exit(1);
+    }
+    const spreadsheetCount = Object.keys(account.spreadsheets).length;
+    if (spreadsheetCount > 0) {
+      Logger.warning(
+        `This will remove ${spreadsheetCount} spreadsheet${spreadsheetCount !== 1 ? "s" : ""} associated with this account.`
+      );
+    }
+    const confirmation = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: `Are you sure you want to remove account '${selectedEmail}'?`,
+        default: false
+      }
+    ]);
+    if (!confirmation.confirmed) {
+      Logger.info("Removal cancelled");
+      process.exit(0);
+    }
+    await configManager.removeAccount(selectedEmail);
+    Logger.success(`Account '${selectedEmail}' removed successfully`);
+  }
+});
+
+// src/commands/account/select.ts
+import inquirer2 from "inquirer";
+var selectAccountCommand = defineSubCommand({
+  name: "select",
+  description: "Select active Google account",
+  arguments: [argument.string("email", "Account email to select (optional - interactive if not provided)")],
+  errorMessage: "Failed to select account",
+  action: async ({ args }) => {
+    const configManager = new ConfigManager();
+    const accounts = configManager.getAllAccounts();
+    if (accounts.length === 0) {
+      Logger.warning("No accounts configured.");
+      Logger.info("Use: gsheet account add");
+      process.exit(0);
+    }
+    let selectedEmail = args.email;
+    if (!selectedEmail) {
+      const activeAccount = configManager.getActiveAccount();
+      const choices = accounts.map((acc) => ({
+        name: acc.email === activeAccount?.email ? `${acc.email} (current)` : acc.email,
+        value: acc.email
+      }));
+      const answer = await inquirer2.prompt([
+        {
+          type: "list",
+          name: "email",
+          message: "Select account:",
+          choices
+        }
+      ]);
+      selectedEmail = answer.email;
+    }
+    if (!selectedEmail) {
+      Logger.error("No account selected");
+      process.exit(1);
+    }
+    configManager.setActiveAccount(selectedEmail);
+    Logger.success(`Selected account: ${selectedEmail}`);
+  }
+});
+
+// src/commands/completion.ts
+import { accessSync, constants, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/cli/completion/shared.ts
+var globalOptions = [
+  { description: "Show help", long: "help", names: ["-h", "--help"], short: "h" },
+  { description: "Show version", long: "version", names: ["-V", "--version"], short: "V" }
+];
+function isVisibleCompletionCommand(command) {
+  return command.visible;
+}
+function getCompletionBinNames(binName) {
+  return [.../* @__PURE__ */ new Set([binName, APP_INFO.name, "gs"])];
+}
+function getRootCommands(commands) {
+  const roots = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const parts = command.name.split(" ");
+    const root = parts[0];
+    if (!root || roots.has(root)) continue;
+    roots.set(root, {
+      name: root,
+      description: command.description
+    });
+  }
+  return [...roots.values()];
+}
+function getSubcommandGroups(commands) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const [root, subcommand] = command.name.split(" ");
+    if (!root || !subcommand) continue;
+    const group = groups.get(root) ?? [];
+    if (!group.some((item) => item.name === subcommand)) {
+      group.push({ name: subcommand, description: command.description });
+    }
+    groups.set(root, group);
+  }
+  return groups;
+}
+function getOptionGroups(commands) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const options = command.options.filter((option) => option.visible);
+    if (options.length === 0) continue;
+    groups.set(
+      command.name,
+      options.map((option) => ({
+        description: option.description,
+        long: option.allNotations.find((notation) => notation.startsWith("--"))?.replace(/^--/, ""),
+        names: option.allNotations,
+        short: option.allNotations.find((notation) => /^-[^-]/.test(notation))?.replace(/^-/, "")
+      }))
+    );
+  }
+  return groups;
+}
+function commandKey(command) {
+  return command.replace(/\W+/g, "_");
+}
+function optionWords(items) {
+  return items.flatMap((item) => item.names).join(" ");
+}
+function getFunctionName(binName) {
+  return `_${commandKey(binName)}_completion`;
+}
+
+// src/cli/completion/bash.ts
+function getBashCompletionScript(binNames, roots, subcommands, _options) {
+  const functionName = getFunctionName(binNames[0] ?? APP_INFO.name);
+  return `${functionName}() {
+  local cur root subcommand
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  root="\${COMP_WORDS[1]}"
+  subcommand="\${COMP_WORDS[2]}"
+  COMPREPLY=()
+
+  if [[ "$cur" == -* ]]; then
+    COMPREPLY=($(compgen -W "${optionWords(globalOptions)}" -- "$cur"))
+    return
+  fi
+
+  case "$COMP_CWORD" in
+    1)
+      COMPREPLY=($(compgen -W "${roots.map((item) => item.name).join(" ")}" -- "$cur"))
+      ;;
+    2)
+      case "\${COMP_WORDS[1]}" in
+${formatBashSubcommandCases(subcommands)}
+      esac
+      ;;
+  esac
+}
+
+${binNames.map((binName) => `complete -F ${functionName} ${binName}`).join("\n")}`;
+}
+function formatBashSubcommandCases(groups) {
+  return [...groups.entries()].map(
+    ([root, items]) => `        ${root})
+          COMPREPLY=($(compgen -W "${items.map((item) => item.name).join(" ")}" -- "$cur"))
+          ;;`
+  ).join("\n");
+}
+
+// src/cli/completion/fish.ts
+function getFishCompletionScript(binNames, roots, subcommands, options) {
+  return binNames.map((binName) => getFishCompletionForBin(binName, roots, subcommands, options)).join("\n");
+}
+function getFishCompletionForBin(binName, roots, subcommands, options) {
+  const rootNames = roots.map((item) => item.name).join(" ");
+  return `function __${commandKey(binName)}_seen_command
+  set -l tokens (commandline -opc)
+  for token in $tokens[2..-1]
+    switch $token
+      case ${rootNames}
+        return 0
+    end
+  end
+  return 1
+end
+
+function __${commandKey(binName)}_using_command
+  set -l tokens (commandline -opc)
+  test (count $tokens) -ge 2; and test "$tokens[2]" = "$argv[1]"
+end
+
+function __${commandKey(binName)}_using_subcommand
+  set -l tokens (commandline -opc)
+  test (count $tokens) -ge 3; and test "$tokens[2]" = "$argv[1]"; and test "$tokens[3]" = "$argv[2]"
+end
+
+complete -c ${binName} -f
+${formatFishRootCompletions(binName, roots)}
+${formatFishSubcommandCompletions(binName, subcommands)}
+${formatFishOptionCompletions(binName, subcommands, options)}
+${formatFishGlobalOptionCompletions(binName)}`;
+}
+function formatFishRootCompletions(binName, roots) {
+  return roots.map(
+    (item) => `complete -c ${binName} -f -n "not __${commandKey(binName)}_seen_command" -a ${quoteFish(item.name)} -d ${quoteFish(item.description ?? "")}`
+  ).join("\n");
+}
+function formatFishSubcommandCompletions(binName, groups) {
+  return [...groups.entries()].flatMap(
+    ([root, items]) => items.map(
+      (item) => `complete -c ${binName} -f -n "__${commandKey(binName)}_using_command ${quoteFish(root)}" -a ${quoteFish(item.name)} -d ${quoteFish(item.description ?? "")}`
+    )
+  ).join("\n");
+}
+function formatFishOptionCompletions(binName, subcommands, options) {
+  return [...options.entries()].flatMap(([command, items]) => {
+    const parts = command.split(" ");
+    const condition = parts.length === 1 ? `__${commandKey(binName)}_using_command ${quoteFish(parts[0] ?? "")}` : `__${commandKey(binName)}_using_subcommand ${quoteFish(parts[0] ?? "")} ${quoteFish(parts[1] ?? "")}`;
+    if (parts.length > 1 && !(subcommands.get(parts[0] ?? "") ?? []).some((item) => item.name === parts[1])) {
+      return [];
+    }
+    return items.map((item) => {
+      const flags = [item.short ? `-s ${quoteFish(item.short)}` : "", item.long ? `-l ${quoteFish(item.long)}` : ""].filter(Boolean).join(" ");
+      return `complete -c ${binName} -f -n "${condition}" ${flags} -d ${quoteFish(item.description ?? "")}`;
+    });
+  }).join("\n");
+}
+function formatFishGlobalOptionCompletions(binName) {
+  return globalOptions.map((item) => {
+    const flags = [item.short ? `-s ${quoteFish(item.short)}` : "", item.long ? `-l ${quoteFish(item.long)}` : ""].filter(Boolean).join(" ");
+    return `complete -c ${binName} -f ${flags} -d ${quoteFish(item.description ?? "")}`;
+  }).join("\n");
+}
+function quoteFish(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// src/cli/completion/zsh.ts
+function getZshCompletionScript(binNames, roots, subcommands, options) {
+  const functionName = getFunctionName(binNames[0] ?? APP_INFO.name);
+  return `#compdef ${binNames.join(" ")}
+
+${functionName}() {
+  local -a commands
+  commands=(
+${formatZshItems(roots)}
+  )
+  local -a global_options
+  global_options=(
+${formatZshOptionItems(globalOptions)}
+  )
+${formatSubcommandArrays(subcommands)}
+${formatZshOptionArrays(options)}
+
+  if [[ "$words[CURRENT]" == -* ]]; then
+    _describe '${binNames[0]} options' global_options
+    return
+  fi
+
+  if (( CURRENT == 2 )); then
+    _describe '${binNames[0]} commands' commands
+    return
+  fi
+
+  case $words[2] in
+${formatZshCompletionCases(binNames[0] ?? APP_INFO.name, subcommands, options)}
+  esac
+}
+
+compdef ${functionName} ${binNames.join(" ")}`;
+}
+function formatZshItems(items) {
+  return items.map((item) => `    '${escapeZshItem(item)}'`).join("\n");
+}
+function formatZshOptionItems(items) {
+  return items.flatMap(
+    (item) => item.names.map((name) => ({
+      description: item.description,
+      name
+    }))
+  ).map((item) => `    '${escapeZshItem(item)}'`).join("\n");
+}
+function formatSubcommandArrays(groups) {
+  return [...groups.entries()].map(
+    ([root, items]) => `
+  local -a ${commandKey(root)}_commands
+  ${commandKey(root)}_commands=(
+${formatZshItems(items)}
+  )`
+  ).join("\n");
+}
+function formatZshOptionArrays(groups) {
+  return [...groups.entries()].map(
+    ([command, items]) => `
+  local -a ${commandKey(command)}_options
+  ${commandKey(command)}_options=(
+${formatZshOptionItems(items)}
+  )`
+  ).join("\n");
+}
+function formatZshCompletionCases(binName, subcommands, options) {
+  const rootCommands = new Set(
+    [...subcommands.keys(), ...[...options.keys()].map((command) => command.split(" ")[0])].filter(
+      (command) => Boolean(command)
+    )
+  );
+  return [...rootCommands].map((root) => {
+    const rootOptions = options.get(root);
+    if (rootOptions) {
+      return `    ${root})
+      _describe '${binName} ${root} options' ${commandKey(root)}_options
+      ;;`;
+    }
+    const subcommandCases = (subcommands.get(root) ?? []).map((item) => {
+      const key = `${root} ${item.name}`;
+      if (!options.has(key)) return "";
+      return `        ${item.name})
+          _describe '${binName} ${root} ${item.name} options' ${commandKey(key)}_options
+          ;;`;
+    }).filter(Boolean).join("\n");
+    return `    ${root})
+      if (( CURRENT == 3 )) && [[ $words[CURRENT] != -* ]]; then
+        _describe '${binName} ${root} commands' ${commandKey(root)}_commands
+        return
+      fi
+      case $words[3] in
+${subcommandCases}
+      esac
+      ;;`;
+  }).join("\n");
+}
+function escapeZshItem(item) {
+  const text = item.description ? `${item.name}:${item.description}` : item.name;
+  return text.replace(/'/g, "'\\''");
+}
+
+// src/commands/completion.ts
+var completionShells = ["zsh" /* Zsh */, "bash" /* Bash */, "fish" /* Fish */];
+var completionCommand = defineCommand({
+  name: "completion",
+  description: "Generate shell completion scripts",
+  subcommands: completionShells.map(
+    (shell) => defineSubCommand({
+      name: shell,
+      description: `Generate ${shell} completion script`,
+      action: async () => {
+      }
+    })
+  )
+});
+var completionScriptGenerators = {
+  ["bash" /* Bash */]: getBashCompletionScript,
+  ["fish" /* Fish */]: getFishCompletionScript,
+  ["zsh" /* Zsh */]: getZshCompletionScript
+};
+var shellMatchers = [
+  { shell: "zsh" /* Zsh */, matches: (value) => value.includes("zsh" /* Zsh */) },
+  { shell: "bash" /* Bash */, matches: (value) => value.includes("bash" /* Bash */) },
+  { shell: "fish" /* Fish */, matches: (value) => value.includes("fish" /* Fish */) }
+];
+var silentCompletionInstallers = {
+  ["bash" /* Bash */]: installBashCompletionSilent,
+  ["fish" /* Fish */]: installFishCompletionSilent,
+  ["zsh" /* Zsh */]: async () => {
+    await installZshCompletionSilent();
+    await clearZshCompletionCache();
+  }
+};
+var completionProgram;
+function createCompletionCommand(program2) {
+  completionProgram = program2;
+  program2.command(completionCommand.name, completionCommand.description).action(async () => {
+    Logger.info(`Available shells: ${completionShells.join(", ")}`);
+    Logger.info(`Usage: ${APP_INFO.name} completion <shell>`);
+  });
+  for (const shellCommand of completionCommand.subcommands) {
+    program2.command(`${completionCommand.name} ${shellCommand.name}`, shellCommand.description).action(async ({ program: program3 }) => {
+      if (!isCompletionShell(shellCommand.name)) {
+        throw new Error(`Unsupported shell: ${shellCommand.name}`);
+      }
+      console.log(await getCompletionScript(program3, shellCommand.name));
+      return 0;
+    });
+  }
+}
+function detectShell() {
+  const shell = process.env.SHELL || "";
+  return shellMatchers.find((matcher) => matcher.matches(shell))?.shell ?? "zsh" /* Zsh */;
+}
+async function reinstallCompletionSilently() {
+  const configManager = new ConfigManager();
+  if (!configManager.isCompletionInstalled()) {
+    return false;
+  }
+  const shell = detectShell();
+  try {
+    await silentCompletionInstallers[shell]();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installZshCompletionSilent() {
+  const homeDir = homedir2();
+  const possibleDirs = [
+    join2(homeDir, ".oh-my-zsh", "completions"),
+    join2(homeDir, ".zsh", "completions"),
+    join2(homeDir, ".config", "zsh", "completions"),
+    join2(homeDir, ".local", "share", "zsh", "site-functions"),
+    "/usr/local/share/zsh/site-functions"
+  ];
+  let targetDir = null;
+  for (const dir of possibleDirs) {
+    if (existsSync4(dir)) {
+      try {
+        accessSync(dir, constants.W_OK);
+        targetDir = dir;
+        break;
+      } catch {
+      }
+    }
+  }
+  if (!targetDir) {
+    targetDir = join2(homeDir, ".zsh", "completions");
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  const completionFile = join2(targetDir, `_${APP_INFO.name}`);
+  writeFileSync2(completionFile, await getCurrentCompletionScript("zsh" /* Zsh */));
+}
+async function installBashCompletionSilent() {
+  const homeDir = homedir2();
+  const possibleDirs = [
+    join2(homeDir, ".bash_completion.d"),
+    join2(homeDir, ".local", "share", "bash-completion", "completions"),
+    "/usr/local/etc/bash_completion.d",
+    "/etc/bash_completion.d"
+  ];
+  let targetDir = null;
+  for (const dir of possibleDirs) {
+    if (existsSync4(dir)) {
+      try {
+        accessSync(dir, constants.W_OK);
+        targetDir = dir;
+        break;
+      } catch {
+      }
+    }
+  }
+  if (!targetDir) {
+    targetDir = join2(homeDir, ".bash_completion.d");
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  const completionFile = join2(targetDir, APP_INFO.name);
+  writeFileSync2(completionFile, await getCurrentCompletionScript("bash" /* Bash */));
+}
+async function installFishCompletionSilent() {
+  const homeDir = homedir2();
+  const targetDir = join2(homeDir, ".config", "fish", "completions");
+  mkdirSync2(targetDir, { recursive: true });
+  const completionFile = join2(targetDir, `${APP_INFO.name}.fish`);
+  writeFileSync2(completionFile, await getCurrentCompletionScript("fish" /* Fish */));
+}
+async function clearZshCompletionCache() {
+  const homeDir = homedir2();
+  const zshCacheFile = join2(homeDir, ".zcompdump");
+  try {
+    if (existsSync4(zshCacheFile)) {
+      const fs3 = await import("fs");
+      fs3.unlinkSync(zshCacheFile);
+    }
+  } catch {
+  }
+}
+function isCompletionShell(value) {
+  return completionShells.includes(value);
+}
+async function getCurrentCompletionScript(shell) {
+  if (!completionProgram) {
+    throw new Error("Completion program not initialized");
+  }
+  return getCompletionScript(completionProgram, shell);
+}
+async function getCompletionScript(program2, shell) {
+  const commands = (await program2.getAllCommands()).filter(isVisibleCompletionCommand);
+  const roots = getRootCommands(commands);
+  const subcommands = getSubcommandGroups(commands);
+  subcommands.set(
+    completionCommand.name,
+    completionShells.map((shell2) => ({ name: shell2, description: `Generate ${shell2} completion` }))
+  );
+  const options = getOptionGroups(commands);
+  return completionScriptGenerators[shell](getCompletionBinNames(program2.getBin()), roots, subcommands, options);
+}
+
+// src/core/google-sheets.service.ts
+import { OAuth2Client as OAuth2Client4 } from "google-auth-library";
+import { GoogleSpreadsheet } from "google-spreadsheet";
+var GoogleSheetsService = class {
+  constructor(config) {
+    this.config = config;
+    this.auth = new OAuth2Client4(config.oauthCredentials.client_id, config.oauthCredentials.client_secret);
+    this.auth.setCredentials({
+      access_token: config.oauthCredentials.access_token,
+      refresh_token: config.oauthCredentials.refresh_token,
+      expiry_date: config.oauthCredentials.expiry_date
+    });
+  }
+  config;
+  doc = null;
+  auth;
+  async ensureConnection() {
+    if (!this.doc) {
+      this.doc = new GoogleSpreadsheet(this.config.spreadsheetId, this.auth);
+      await this.doc.loadInfo();
+    }
+  }
+  async getSheetInfo() {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    return {
+      title: this.doc.title,
+      sheets: this.doc.sheetsByIndex.map((sheet, index) => ({
+        title: sheet.title,
+        index,
+        sheetId: sheet.sheetId
+      }))
+    };
+  }
+  async getSheetData(sheetName, includeFormulas = false) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.loadCells();
+    let lastRow = 0;
+    let lastCol = 0;
+    for (let row = 0; row < sheet.rowCount; row++) {
+      for (let col = 0; col < sheet.columnCount; col++) {
+        const cell = sheet.getCell(row, col);
+        const value = includeFormulas && cell.formula ? cell.formula : cell.formattedValue ?? "";
+        if (value !== "") {
+          lastRow = Math.max(lastRow, row);
+          lastCol = Math.max(lastCol, col);
+        }
+      }
+    }
+    if (lastRow === 0 && lastCol === 0) {
+      const firstCell = sheet.getCell(0, 0);
+      const firstValue = includeFormulas && firstCell.formula ? firstCell.formula : firstCell.formattedValue ?? "";
+      if (firstValue === "") {
+        return [];
+      }
+    }
+    const data = [];
+    for (let row = 0; row <= lastRow; row++) {
+      const rowData = [];
+      for (let col = 0; col <= lastCol; col++) {
+        const cell = sheet.getCell(row, col);
+        const value = includeFormulas && cell.formula ? cell.formula : cell.formattedValue ?? "";
+        rowData.push(value);
+      }
+      data.push(rowData);
+    }
+    return data;
+  }
+  async addSheet(sheetName) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    await this.doc.addSheet({ title: sheetName });
+  }
+  async removeSheet(sheetName) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.delete();
+  }
+  async renameSheet(oldName, newName) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[oldName];
+    if (!sheet) {
+      throw new Error(`Sheet '${oldName}' not found`);
+    }
+    await sheet.updateProperties({ title: newName });
+  }
+  async copySheet(sheetName, newSheetName) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.duplicate({ title: newSheetName });
+  }
+  async writeCell(sheetName, cell, value) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.loadCells(cell);
+    const targetCell = sheet.getCellByA1(cell);
+    targetCell.value = value;
+    await sheet.saveUpdatedCells();
+  }
+  async writeCellRange(sheetName, range, values, noPreserve) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.loadCells(range);
+    const [start, end] = range.split(":");
+    const startCell = sheet.getCellByA1(start);
+    const endCell = sheet.getCellByA1(end);
+    let valueRowIndex = 0;
+    for (let row = startCell.rowIndex; row <= endCell.rowIndex; row++) {
+      let valueColIndex = 0;
+      for (let col = startCell.columnIndex; col <= endCell.columnIndex; col++) {
+        const cell = sheet.getCell(row, col);
+        const cellWithRawData = cell;
+        const hasDataValidation = cellWithRawData._rawData?.dataValidation !== void 0;
+        const hasFormula = cellWithRawData._rawData?.userEnteredValue?.formulaValue !== void 0;
+        const isCellEmpty = !cell.value || cell.value === "";
+        if (values[valueRowIndex] && values[valueRowIndex][valueColIndex] !== void 0) {
+          const newValue = values[valueRowIndex][valueColIndex];
+          const isNewValueEmpty = newValue === "" || newValue === null;
+          if (noPreserve) {
+            cell.value = newValue;
+          } else {
+            if (!(hasDataValidation && isCellEmpty && isNewValueEmpty) && !hasFormula) {
+              cell.value = newValue;
+            }
+          }
+        }
+        valueColIndex++;
+      }
+      valueRowIndex++;
+    }
+    await sheet.saveUpdatedCells();
+  }
+  async appendRow(sheetName, values) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.addRow(values);
+  }
+  async getSheetDataRange(sheetName, range, includeFormulas = false) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.loadCells(range);
+    const [start, end] = range.split(":");
+    const startCell = sheet.getCellByA1(start);
+    const endCell = sheet.getCellByA1(end);
+    const data = [];
+    for (let row = startCell.rowIndex; row <= endCell.rowIndex; row++) {
+      const rowData = [];
+      for (let col = startCell.columnIndex; col <= endCell.columnIndex; col++) {
+        const cell = sheet.getCell(row, col);
+        const value = includeFormulas && cell.formula ? cell.formula : cell.formattedValue ?? "";
+        rowData.push(value);
+      }
+      data.push(rowData);
+    }
+    return data;
+  }
+  async insertRows(sheetName, range, inheritFromBefore = false) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.insertDimension("ROWS", range, inheritFromBefore);
+  }
+  async deleteRows(sheetName, range) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet._makeSingleUpdateRequest("deleteDimension", {
+      range: {
+        sheetId: sheet.sheetId,
+        dimension: "ROWS",
+        startIndex: range.startIndex,
+        endIndex: range.endIndex
+      }
+    });
+  }
+  async getRowFormulas(sheetName, rowIndex) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    await sheet.loadCells(`A${rowIndex + 1}:${rowIndex + 1}`);
+    const formulas = /* @__PURE__ */ new Map();
+    for (let col = 0; col < sheet.columnCount; col++) {
+      const cell = sheet.getCell(rowIndex, col);
+      if (cell.formula) {
+        formulas.set(col, cell.formula);
+      }
+    }
+    return formulas;
+  }
+  async copyRowFormulas(sheetName, sourceRowIndex, targetRowIndex) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    const formulas = await this.getRowFormulas(sheetName, sourceRowIndex);
+    if (formulas.size === 0) {
+      return;
+    }
+    await sheet.loadCells(`A${targetRowIndex + 1}:${targetRowIndex + 1}`);
+    const rowDiff = targetRowIndex - sourceRowIndex;
+    for (const [col, formula] of formulas) {
+      const cell = sheet.getCell(targetRowIndex, col);
+      const adjustedFormula = this.adjustFormulaReferences(formula, rowDiff);
+      cell.formula = adjustedFormula;
+    }
+    await sheet.saveUpdatedCells();
+  }
+  async copyRowFormulasBulk(sheetName, sourceRowIndex, startTargetRowIndex, count) {
+    await this.ensureConnection();
+    if (!this.doc) {
+      throw new Error("Failed to connect to Google Sheets");
+    }
+    const sheet = this.doc.sheetsByTitle[sheetName];
+    if (!sheet) {
+      throw new Error(`Sheet '${sheetName}' not found`);
+    }
+    const formulas = await this.getRowFormulas(sheetName, sourceRowIndex);
+    if (formulas.size === 0) {
+      return;
+    }
+    const endTargetRowIndex = startTargetRowIndex + count - 1;
+    await sheet.loadCells(`A${startTargetRowIndex + 1}:${endTargetRowIndex + 1}`);
+    for (let i = 0; i < count; i++) {
+      const targetRowIndex = startTargetRowIndex + i;
+      const rowDiff = targetRowIndex - sourceRowIndex;
+      for (const [col, formula] of formulas) {
+        const cell = sheet.getCell(targetRowIndex, col);
+        const adjustedFormula = this.adjustFormulaReferences(formula, rowDiff);
+        cell.formula = adjustedFormula;
+      }
+    }
+    await sheet.saveUpdatedCells();
+  }
+  adjustFormulaReferences(formula, rowDiff) {
+    return formula.replace(/([A-Z]+)(\d+)/g, (_match, colLetter, rowNum) => {
+      const newRow = parseInt(rowNum, 10) + rowDiff;
+      return `${colLetter}${newRow}`;
+    });
+  }
+};
+
+// src/core/command-helpers.ts
+async function getGoogleSheetsService() {
+  const configManager = new ConfigManager();
+  const activeAccount = configManager.getActiveAccount();
+  if (!activeAccount) {
+    Logger.error("No active account set.");
+    Logger.info("Use: gsheet account add");
+    process.exit(1);
+  }
+  const activeSpreadsheetName = configManager.getActiveSpreadsheetName(activeAccount.email);
+  if (!activeSpreadsheetName) {
+    Logger.error("No active spreadsheet set.");
+    Logger.info("Use: gsheet spreadsheet select");
+    process.exit(1);
+  }
+  const spreadsheet = configManager.getSpreadsheet(activeAccount.email, activeSpreadsheetName);
+  if (!spreadsheet) {
+    Logger.error(`Spreadsheet '${activeSpreadsheetName}' not found. Use "gsheet spreadsheet add" to add one.`);
+    process.exit(1);
+  }
+  const refreshedCredentials = await configManager.getRefreshedCredentials(activeAccount.email);
+  return new GoogleSheetsService({
+    spreadsheetId: spreadsheet.spreadsheet_id,
+    oauthCredentials: refreshedCredentials
+  });
+}
+function getActiveSheetName(sheetName) {
+  if (sheetName) {
+    return sheetName;
+  }
+  const configManager = new ConfigManager();
+  const activeAccount = configManager.getActiveAccount();
+  if (!activeAccount) {
+    Logger.error("No active account set.");
+    Logger.info("Use: gsheet account add");
+    process.exit(1);
+  }
+  const activeSpreadsheetName = configManager.getActiveSpreadsheetName(activeAccount.email);
+  if (!activeSpreadsheetName) {
+    Logger.error("No active spreadsheet set.");
+    Logger.info("Use: gsheet spreadsheet select");
+    process.exit(1);
+  }
+  const activeSheetName = configManager.getActiveSheetName(activeAccount.email, activeSpreadsheetName);
+  if (!activeSheetName) {
+    Logger.error("No active sheet set.");
+    Logger.info("Use: gsheet sheet select");
+    process.exit(1);
+  }
+  return activeSheetName;
+}
+
+// src/commands/sheet/data_operations/append.ts
+var appendCommand = defineSubCommand({
+  name: "append",
+  description: "Append a new row to the end of the sheet",
+  flags: [
+    flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" }),
+    flag.string("--value", "Values to append (comma-separated)", { alias: "-v", required: true })
+  ],
+  errorMessage: "Failed to append row",
+  action: async ({ options }) => {
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    const values = options.value.split(",").map((v) => v.trim());
+    Logger.loading(`Appending row to '${sheetName}'...`);
+    await sheetsService.appendRow(sheetName, values);
+    Logger.success(`Row appended to '${sheetName}' successfully`);
+  }
+});
+
+// src/utils/cell.ts
+function columnLetterToNumber(colLetter) {
+  let result = 0;
+  const letters = colLetter.toUpperCase();
+  for (let i = 0; i < letters.length; i++) {
+    result = result * 26 + (letters.charCodeAt(i) - 64);
+  }
+  return result - 1;
+}
+
+// src/commands/sheet/data_operations/write.ts
+var writeCommand = defineSubCommand({
+  name: "write",
+  description: "Write to a specific cell or range of cells",
+  flags: [
+    flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" }),
+    flag.string("--cell", "Cell address (e.g., A1) - required if --range not provided", { alias: "-c" }),
+    flag.string("--range", "Range (e.g., A1:B2) - required if --cell not provided", { alias: "-r" }),
+    flag.string("--value", "Value to write (use , for columns, ; for rows)", { alias: "-v", required: true }),
+    flag.boolean("--no-preserve", "Overwrite cells with formulas or data validation")
+  ],
+  errorMessage: "Failed to write to sheet",
+  action: async ({ options }) => {
+    if (!options.cell && !options.range) {
+      Logger.error("Either --cell or --range must be specified");
+      process.exit(1);
+    }
+    if (options.cell && options.range) {
+      Logger.error("Cannot use both --cell and --range at the same time");
+      process.exit(1);
+    }
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    if (options.cell) {
+      Logger.loading(`Writing to cell ${options.cell}...`);
+      await sheetsService.writeCell(sheetName, options.cell, options.value);
+      Logger.success(`Cell ${options.cell} updated successfully`);
+    } else if (options.range) {
+      let values;
+      if (options.value.trim().startsWith("[")) {
+        try {
+          values = JSON.parse(options.value);
+          if (!Array.isArray(values) || !Array.isArray(values[0])) {
+            throw new Error("Value must be a 2D array");
+          }
+        } catch (_error) {
+          Logger.error('Invalid JSON array format. Expected 2D array like [["a","b"],["c","d"]]');
+          process.exit(1);
+        }
+      } else {
+        const rows = options.value.split(";").map((row) => row.trim());
+        values = rows.map(
+          (row) => row.split(",").map((cell) => {
+            const trimmed = cell.trim();
+            const numericValue = trimmed.replace(",", ".");
+            if (!Number.isNaN(Number(numericValue)) && numericValue !== "") {
+              return Number(numericValue);
+            }
+            return trimmed;
+          })
+        );
+      }
+      const rangeParts = options.range.split(":");
+      if (rangeParts.length === 2) {
+        const [startCell, endCell] = rangeParts;
+        const startMatch = startCell.match(/^([A-Z]+)(\d+)$/);
+        const endMatch = endCell.match(/^([A-Z]+)(\d+)$/);
+        if (startMatch && endMatch) {
+          const startRow = parseInt(startMatch[2], 10);
+          const endRow = parseInt(endMatch[2], 10);
+          const startCol = startMatch[1];
+          const endCol = endMatch[1];
+          const expectedRows = endRow - startRow + 1;
+          const expectedCols = columnLetterToNumber(endCol) - columnLetterToNumber(startCol) + 1;
+          const actualRows = values.length;
+          const actualCols = Math.max(...values.map((row) => row.length));
+          if (actualRows !== expectedRows || actualCols !== expectedCols) {
+            Logger.error(
+              `Dimension mismatch: Range ${options.range} expects ${expectedRows}x${expectedCols} but got ${actualRows}x${actualCols} values`
+            );
+            Logger.info(`Tip: Provide ${expectedRows} rows with ${expectedCols} columns each`);
+            process.exit(1);
+          }
+        }
+      }
+      const noPreserve = options.preserve === false;
+      Logger.loading(`Writing to range ${options.range}...`);
+      await sheetsService.writeCellRange(sheetName, options.range, values, noPreserve);
+      Logger.success(`Range ${options.range} updated successfully`);
+    }
+  }
+});
+
+// src/commands/sheet/import_export/export.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+
+// src/utils/formatters.ts
+function formatAsMarkdown(data) {
+  if (data.length === 0) return "";
+  const [headers, ...rows] = data;
+  const colWidths = headers.map((_, colIndex) => Math.max(...data.map((row) => (row[colIndex] || "").length)));
+  const separator = `| ${colWidths.map((w) => "-".repeat(w)).join(" | ")} |`;
+  const formatRow = (row) => `| ${row.map((cell, i) => (cell || "").padEnd(colWidths[i])).join(" | ")} |`;
+  return [formatRow(headers), separator, ...rows.map(formatRow)].join("\n");
+}
+function formatAsCSV(data) {
+  return data.map(
+    (row) => row.map((cell) => {
+      const value = cell || "";
+      if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+        return `"${value.replace(/"/g, '""')}"`;
+      }
+      return value;
+    }).join(",")
+  ).join("\n");
+}
+function formatAsJSON(data) {
+  if (data.length === 0) return "[]";
+  const [headers, ...rows] = data;
+  const jsonData = rows.map((row) => {
+    const obj = {};
+    headers.forEach((header, index) => {
+      obj[header] = row[index] || "";
+    });
+    return obj;
+  });
+  return JSON.stringify(jsonData, null, 2);
+}
+
+// src/commands/sheet/import_export/export.ts
+var ExportFormat = /* @__PURE__ */ ((ExportFormat2) => {
+  ExportFormat2["Csv"] = "csv";
+  ExportFormat2["Json"] = "json";
+  return ExportFormat2;
+})(ExportFormat || {});
+var exportFormats = Object.values(ExportFormat);
+var exportFormatters = {
+  ["csv" /* Csv */]: formatAsCSV,
+  ["json" /* Json */]: formatAsJSON
+};
+var exportCommand = defineSubCommand({
+  name: "export",
+  description: "Export sheet data to JSON or CSV format",
+  flags: [
+    flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" }),
+    flag.string("--range", "Range to export (optional)", { alias: "-r" }),
+    flag.string("--format", "Export format", { alias: "-f", required: true }),
+    flag.string("--output", "Output file path", { alias: "-o" })
+  ],
+  errorMessage: "Failed to export data",
+  action: async ({ options }) => {
+    if (!isExportFormat(options.format)) {
+      Logger.error(`Invalid format '${options.format}'. Valid formats: ${exportFormats.join(", ")}`);
+      process.exit(1);
+    }
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    Logger.loading(`Exporting data from '${sheetName}'${options.range ? ` (range: ${options.range})` : ""}...`);
+    let data;
+    if (options.range) {
+      data = await sheetsService.getSheetDataRange(sheetName, options.range);
+    } else {
+      data = await sheetsService.getSheetData(sheetName);
+    }
+    if (data.length === 0) {
+      Logger.warning("No data to export");
+      process.exit(0);
+    }
+    const output = exportFormatters[options.format](data);
+    if (options.output) {
+      writeFileSync3(options.output, output, "utf-8");
+      Logger.success(`Data exported to ${options.output}`);
+    } else {
+      Logger.success("Exported data:\n");
+      Logger.plain(output);
+    }
+  }
+});
+function isExportFormat(value) {
+  return exportFormats.includes(value);
+}
+
+// src/commands/sheet/import_export/import.ts
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/utils/csv.ts
+function parseCSV(content) {
+  const lines = content.split("\n").filter((line) => line.trim() !== "");
+  const result = [];
+  for (const line of lines) {
+    const row = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      if (char === '"') {
+        if (inQuotes && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = !inQuotes;
+        }
+      } else if (char === "," && !inQuotes) {
+        row.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    row.push(current.trim());
+    result.push(row);
+  }
+  return result;
+}
+
+// src/commands/sheet/import_export/import.ts
+var importCommand = defineSubCommand({
+  name: "import",
+  description: "Import CSV file to a sheet",
+  flags: [
+    flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" }),
+    flag.string("--file", "CSV file path", { alias: "-f", required: true }),
+    flag.boolean("--skip-header", "Skip header row when importing")
+  ],
+  errorMessage: "Failed to import data",
+  action: async ({ options }) => {
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    Logger.loading(`Reading CSV file '${options.file}'...`);
+    const csvContent = readFileSync3(options.file, "utf-8");
+    const data = parseCSV(csvContent);
+    if (data.length === 0) {
+      Logger.warning("CSV file is empty");
+      process.exit(0);
+    }
+    const dataToImport = options.skipHeader ? data.slice(1) : data;
+    if (dataToImport.length === 0) {
+      Logger.warning("No data to import after skipping header");
+      process.exit(0);
+    }
+    Logger.loading(`Importing ${dataToImport.length} rows to '${sheetName}'...`);
+    if (options.skipHeader) {
+      if (dataToImport.length > 0) {
+        const firstRowRange = `A1:${String.fromCharCode(65 + dataToImport[0].length - 1)}1`;
+        await sheetsService.writeCellRange(sheetName, firstRowRange, [dataToImport[0]]);
+        for (let i = 1; i < dataToImport.length; i++) {
+          await sheetsService.appendRow(sheetName, dataToImport[i]);
+          if ((i + 1) % 10 === 0) {
+            Logger.loading(`Imported ${i + 1}/${dataToImport.length} rows...`);
+          }
+        }
+      }
+    } else {
+      if (data.length > 0) {
+        const headerRange = `A1:${String.fromCharCode(65 + data[0].length - 1)}1`;
+        await sheetsService.writeCellRange(sheetName, headerRange, [data[0]]);
+        for (let i = 1; i < data.length; i++) {
+          await sheetsService.appendRow(sheetName, data[i]);
+          if ((i + 1) % 10 === 0) {
+            Logger.loading(`Imported ${i + 1}/${data.length} rows...`);
+          }
+        }
+      }
+    }
+    Logger.success(`Successfully imported ${dataToImport.length} rows to '${sheetName}'`);
+  }
+});
+
+// src/commands/sheet/list.ts
+var listCommand = defineSubCommand({
+  name: "list",
+  description: "List all sheets in a spreadsheet",
+  flags: [flag.string("--output", "Output format", { alias: "-o" })],
+  errorMessage: "Failed to list sheets",
+  action: async ({ options }) => {
+    const sheetsService = await getGoogleSheetsService();
+    if (options.output !== "json") {
+      Logger.loading("Fetching spreadsheet info...");
+    }
+    const info = await sheetsService.getSheetInfo();
+    if (options.output === "json") {
+      Logger.json(info);
+      return;
+    }
+    Logger.success(`Connected to spreadsheet: ${info.title}`);
+    Logger.bold(`
+\u{1F4CB} Sheets (${info.sheets.length}):
+`);
+    info.sheets.forEach((sheet) => {
+      Logger.plain(`  ${sheet.index + 1}. ${sheet.title}`);
+      Logger.dim(`     ID: ${sheet.sheetId}`);
+    });
+  }
+});
+
+// src/commands/sheet/read.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+var OutputFormat = /* @__PURE__ */ ((OutputFormat2) => {
+  OutputFormat2["Csv"] = "csv";
+  OutputFormat2["Json"] = "json";
+  OutputFormat2["Markdown"] = "markdown";
+  return OutputFormat2;
+})(OutputFormat || {});
+var outputFormats = Object.values(OutputFormat);
+var outputFormatters = {
+  ["csv" /* Csv */]: formatAsCSV,
+  ["json" /* Json */]: formatAsJSON,
+  ["markdown" /* Markdown */]: formatAsMarkdown
+};
+var readCommand = defineSubCommand({
+  name: "read",
+  description: "Read the complete content of a sheet",
+  flags: [
+    flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" }),
+    flag.string("--output", "Output format", { alias: "-o" }),
+    flag.boolean("--formulas", "Include formulas instead of values", { alias: "-f" }),
+    flag.string("--export", "Export to file", { alias: "-e" }),
+    flag.string("--range", "Range to read (e.g., A1:B10)", { alias: "-r" })
+  ],
+  errorMessage: "Failed to read sheet",
+  action: async ({ options }) => {
+    const outputFormat = options.output ?? "markdown" /* Markdown */;
+    if (!isOutputFormat(outputFormat)) {
+      Logger.error(`Invalid output format '${outputFormat}'. Valid formats: ${outputFormats.join(", ")}`);
+      process.exit(1);
+    }
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    if (outputFormat !== "json" /* Json */ || options.export) {
+      Logger.loading(`Reading sheet '${sheetName}'...`);
+    }
+    const includeFormulas = options.formulas ?? false;
+    const data = options.range ? await sheetsService.getSheetDataRange(sheetName, options.range, includeFormulas) : await sheetsService.getSheetData(sheetName, includeFormulas);
+    if (data.length === 0) {
+      Logger.warning("Sheet is empty");
+      process.exit(0);
+    }
+    const output = outputFormatters[outputFormat](data);
+    if (options.export) {
+      writeFileSync4(options.export, output, "utf-8");
+      Logger.success(`Content exported to ${options.export}`);
+    } else if (outputFormat === "json" /* Json */) {
+      Logger.plain(output);
+    } else {
+      Logger.success(`Content of sheet '${sheetName}':
+`);
+      Logger.plain(output);
+    }
+  }
+});
+function isOutputFormat(value) {
+  return outputFormats.includes(value);
+}
+
+// src/utils/validators.ts
+function validatePositiveInteger(value, fieldName) {
+  const num = parseInt(value, 10);
+  if (Number.isNaN(num) || num < 1) {
+    throw new Error(`${fieldName} must be a positive integer`);
+  }
+  return num;
+}
+function validateRequired(value, fieldName) {
+  if (!value || !value.trim()) {
+    throw new Error(`${fieldName} is required`);
+  }
+  return value.trim();
+}
+
+// src/commands/sheet/row_operations/add.ts
+var rowAddCommand = defineSubCommand({
+  name: "row-add",
+  description: "Add a row to the sheet",
+  flags: [
+    flag.string("--row", "Row number (1-indexed)", { alias: "-r", required: true }),
+    flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" }),
+    flag.boolean("--above", "Insert row above the specified row"),
+    flag.boolean("--below", "Insert row below the specified row"),
+    flag.boolean("--formulas", "Copy formatting, formulas, and data validation from adjacent row", { alias: "-f" }),
+    flag.string("--count", "Number of rows to add (default: 1)", { alias: "-c" })
+  ],
+  errorMessage: "Failed to add row",
+  action: async ({ options }) => {
+    const rowValue = validateRequired(options.row, "Row number");
+    const rowNumber = validatePositiveInteger(rowValue, "Row number");
+    if (options.above && options.below) {
+      Logger.error("Cannot use both --above and --below. Choose one");
+      process.exit(1);
+    }
+    const count = options.count ? validatePositiveInteger(options.count, "Count") : 1;
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    let insertPosition;
+    let inheritFromBefore;
+    let sourceRowForFormulas;
+    if (options.below) {
+      insertPosition = rowNumber;
+      sourceRowForFormulas = rowNumber - 1;
+      inheritFromBefore = false;
+    } else {
+      insertPosition = rowNumber - 1;
+      sourceRowForFormulas = rowNumber - 1;
+      inheritFromBefore = !!options.formulas;
+    }
+    const rowWord = count === 1 ? "row" : "rows";
+    Logger.loading(`Adding ${count} ${rowWord} ${options.below ? "below" : "above"} row ${rowNumber}...`);
+    await sheetsService.insertRows(
+      sheetName,
+      {
+        startIndex: insertPosition,
+        endIndex: insertPosition + count
+      },
+      inheritFromBefore
+    );
+    if (options.formulas) {
+      Logger.loading("Copying formulas from adjacent row...");
+      await sheetsService.copyRowFormulasBulk(sheetName, sourceRowForFormulas, insertPosition, count);
+    }
+    Logger.success(`${count} ${rowWord} added successfully ${options.below ? "below" : "above"} row ${rowNumber}`);
+    if (options.formulas) {
+      Logger.info(`Formatting, formulas, and dropdowns copied from row ${sourceRowForFormulas + 1}`);
+    }
+  }
+});
+
+// src/commands/sheet/row_operations/remove.ts
+var rowRemoveCommand = defineSubCommand({
+  name: "row-remove",
+  description: "Remove a row from the sheet",
+  flags: [
+    flag.string("--row", "Row number (1-indexed)", { alias: "-r", required: true }),
+    flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" }),
+    flag.boolean("--above", "Remove rows above the specified row"),
+    flag.boolean("--below", "Remove rows below the specified row"),
+    flag.string("--count", "Number of rows to remove (default: 1)", { alias: "-c" })
+  ],
+  errorMessage: "Failed to remove row",
+  action: async ({ options }) => {
+    const rowValue = validateRequired(options.row, "Row number");
+    const rowNumber = validatePositiveInteger(rowValue, "Row number");
+    if (options.above && options.below) {
+      Logger.error("Cannot use both --above and --below. Choose one");
+      process.exit(1);
+    }
+    const count = options.count ? validatePositiveInteger(options.count, "Count") : 1;
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    let startIndex;
+    let endIndex;
+    if (options.above) {
+      startIndex = rowNumber - count - 1;
+      endIndex = rowNumber - 1;
+      if (startIndex < 0) {
+        Logger.error(`Cannot remove ${count} rows above row ${rowNumber} (would go above row 1)`);
+        process.exit(1);
+      }
+    } else if (options.below) {
+      startIndex = rowNumber;
+      endIndex = rowNumber + count;
+    } else {
+      startIndex = rowNumber - 1;
+      endIndex = rowNumber + count - 1;
+    }
+    const rowWord = count === 1 ? "row" : "rows";
+    const direction = options.above ? "above" : options.below ? "below" : "starting from";
+    Logger.loading(`Removing ${count} ${rowWord} ${direction} row ${rowNumber}...`);
+    await sheetsService.deleteRows(sheetName, {
+      startIndex,
+      endIndex
+    });
+    Logger.success(`${count} ${rowWord} removed successfully`);
+  }
+});
+
+// src/commands/sheet/sheet_operations/active.ts
+var activeCommand = defineSubCommand({
+  name: "active",
+  description: "Show the currently active sheet",
+  flags: [flag.string("--output", "Output format", { alias: "-o" })],
+  errorMessage: "Failed to get active sheet",
+  action: async ({ options }) => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account add");
+      return;
+    }
+    const activeSpreadsheetName = configManager.getActiveSpreadsheetName(activeAccount.email);
+    if (!activeSpreadsheetName) {
+      Logger.warning("No active spreadsheet set.");
+      Logger.info("Use: gsheet spreadsheet select");
+      return;
+    }
+    const activeSheetName = configManager.getActiveSheetName(activeAccount.email, activeSpreadsheetName);
+    if (!activeSheetName) {
+      Logger.warning("No active sheet set.");
+      Logger.info("Use: gsheet sheet select");
+      return;
+    }
+    const sheetsService = await getGoogleSheetsService();
+    const info = await sheetsService.getSheetInfo();
+    const activeSheet = info.sheets.find((sheet) => sheet.title === activeSheetName);
+    if (options.output === "json") {
+      Logger.json({
+        spreadsheetTitle: info.title,
+        spreadsheetName: activeSpreadsheetName,
+        sheet: activeSheet ? {
+          title: activeSheet.title,
+          index: activeSheet.index,
+          sheetId: activeSheet.sheetId
+        } : {
+          title: activeSheetName,
+          index: null,
+          sheetId: null
+        }
+      });
+      return;
+    }
+    Logger.success(`Active sheet: ${activeSheetName}`);
+    Logger.dim(`  Spreadsheet: ${activeSpreadsheetName}`);
+    if (activeSheet) {
+      Logger.dim(`  Index: ${activeSheet.index + 1}`);
+      Logger.dim(`  ID: ${activeSheet.sheetId}`);
+    }
+  }
+});
+
+// src/commands/sheet/sheet_operations/add.ts
+var addCommand = defineSubCommand({
+  name: "add",
+  description: "Add a new sheet to the spreadsheet",
+  flags: [flag.string("--name", "Tab name", { alias: "-n", required: true })],
+  errorMessage: "Failed to add sheet",
+  action: async ({ options }) => {
+    const sheetsService = await getGoogleSheetsService();
+    Logger.loading(`Creating sheet '${options.name}'...`);
+    await sheetsService.addSheet(options.name);
+    Logger.success(`Sheet '${options.name}' created successfully`);
+  }
+});
+
+// src/commands/sheet/sheet_operations/copy.ts
+var copyCommand = defineSubCommand({
+  name: "copy",
+  description: "Copy a sheet to a new sheet",
+  flags: [
+    flag.string("--name", "Source tab name (uses active if not provided)", { alias: "-n" }),
+    flag.string("--to", "Destination tab name", { required: true })
+  ],
+  errorMessage: "Failed to copy sheet",
+  action: async ({ options }) => {
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    Logger.loading(`Copying sheet '${sheetName}' to '${options.to}'...`);
+    await sheetsService.copySheet(sheetName, options.to);
+    Logger.success(`Sheet '${sheetName}' copied to '${options.to}' successfully`);
+  }
+});
+
+// src/commands/sheet/sheet_operations/remove.ts
+var removeCommand = defineSubCommand({
+  name: "remove",
+  description: "Remove a sheet from the spreadsheet",
+  flags: [flag.string("--name", "Tab name (uses active if not provided)", { alias: "-n" })],
+  errorMessage: "Failed to remove sheet",
+  action: async ({ options }) => {
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    Logger.loading(`Removing sheet '${sheetName}'...`);
+    await sheetsService.removeSheet(sheetName);
+    Logger.success(`Sheet '${sheetName}' removed successfully`);
+  }
+});
+
+// src/commands/sheet/sheet_operations/rename.ts
+var renameCommand = defineSubCommand({
+  name: "rename",
+  description: "Rename a sheet in the spreadsheet",
+  flags: [
+    flag.string("--name", "Current tab name (uses active if not provided)", { alias: "-n" }),
+    flag.string("--new-name", "New tab name", { required: true })
+  ],
+  errorMessage: "Failed to rename sheet",
+  action: async ({ options }) => {
+    const sheetsService = await getGoogleSheetsService();
+    const sheetName = getActiveSheetName(options.name);
+    Logger.loading(`Renaming sheet '${sheetName}' to '${options.newName}'...`);
+    await sheetsService.renameSheet(sheetName, options.newName);
+    Logger.success(`Sheet '${sheetName}' renamed to '${options.newName}' successfully`);
+  }
+});
+
+// src/commands/sheet/sheet_operations/select.ts
+import inquirer3 from "inquirer";
+var selectCommand = defineSubCommand({
+  name: "select",
+  description: "Select a sheet (sets as active)",
+  flags: [flag.string("--name", "Tab name (skips interactive selection)", { alias: "-n" })],
+  errorMessage: "Failed to select sheet",
+  action: async ({ options }) => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account add");
+      process.exit(1);
+    }
+    const activeSpreadsheetName = configManager.getActiveSpreadsheetName(activeAccount.email);
+    if (!activeSpreadsheetName) {
+      Logger.error("No active spreadsheet set.");
+      Logger.info("Use: gsheet spreadsheet select");
+      process.exit(1);
+    }
+    let sheetName = options.name;
+    if (!sheetName) {
+      const sheetsService = await getGoogleSheetsService();
+      Logger.loading("Fetching sheets...");
+      const info = await sheetsService.getSheetInfo();
+      if (info.sheets.length === 0) {
+        Logger.warning("No sheets found in spreadsheet.");
+        return;
+      }
+      const activeSheet = configManager.getActiveSheetName(activeAccount.email, activeSpreadsheetName);
+      const answer = await inquirer3.prompt([
+        {
+          type: "list",
+          name: "sheet",
+          message: "Select sheet:",
+          choices: info.sheets.map((s) => ({
+            name: s.title === activeSheet ? `${s.title} (current)` : s.title,
+            value: s.title
+          }))
+        }
+      ]);
+      sheetName = answer.sheet;
+    }
+    if (!sheetName) {
+      Logger.error("No sheet name provided");
+      return;
+    }
+    configManager.setActiveSheet(activeAccount.email, activeSpreadsheetName, sheetName);
+    Logger.success(`Selected sheet: ${sheetName}`);
+  }
+});
+
+// src/utils/spreadsheet.ts
+function parseSpreadsheetId(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("Spreadsheet ID or URL is required");
+  }
+  try {
+    const url = new URL(trimmed);
+    const match = url.pathname.match(/\/spreadsheets\/d\/([^/]+)/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  } catch {
+  }
+  return trimmed;
+}
+function getSpreadsheetUrl(spreadsheetId) {
+  return `https://docs.google.com/spreadsheets/d/${spreadsheetId}`;
+}
+
+// src/commands/spreadsheet/active.ts
+var activeSpreadsheetCommand = defineSubCommand({
+  name: "active",
+  description: "Show the currently active spreadsheet",
+  flags: [flag.string("--output", "Output format", { alias: "-o" })],
+  errorMessage: "Failed to get active spreadsheet",
+  action: async ({ options }) => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account add");
+      return;
+    }
+    const activeSpreadsheetName = configManager.getActiveSpreadsheetName(activeAccount.email);
+    if (!activeSpreadsheetName) {
+      Logger.warning("No active spreadsheet set.");
+      Logger.info('Use "gsheet spreadsheet select" to set one.');
+      return;
+    }
+    const activeSpreadsheet = configManager.getSpreadsheet(activeAccount.email, activeSpreadsheetName);
+    if (!activeSpreadsheet) {
+      Logger.error("Active spreadsheet not found.");
+      return;
+    }
+    if (options.output === "json") {
+      Logger.json({
+        activeAccount: activeAccount.email,
+        name: activeSpreadsheetName,
+        spreadsheetId: activeSpreadsheet.spreadsheet_id,
+        url: getSpreadsheetUrl(activeSpreadsheet.spreadsheet_id),
+        activeSheet: activeSpreadsheet.activeSheet ?? null
+      });
+      return;
+    }
+    Logger.success(`Active spreadsheet: ${activeSpreadsheetName}`);
+    Logger.dim(`  ID: ${activeSpreadsheet.spreadsheet_id}`);
+    Logger.dim(`  URL: ${getSpreadsheetUrl(activeSpreadsheet.spreadsheet_id)}`);
+    if (activeSpreadsheet.activeSheet) {
+      Logger.dim(`  Active sheet: ${activeSpreadsheet.activeSheet}`);
+    }
+  }
+});
+
+// src/commands/spreadsheet/add.ts
+import inquirer4 from "inquirer";
+
+// src/core/google-drive.service.ts
+import { google } from "googleapis";
+var GoogleDriveService = class {
+  credentials;
+  constructor(oauthCredentials) {
+    this.credentials = oauthCredentials;
+  }
+  async listSpreadsheets() {
+    const oauth2Client = new google.auth.OAuth2(this.credentials.client_id, this.credentials.client_secret);
+    oauth2Client.setCredentials({
+      access_token: this.credentials.access_token,
+      refresh_token: this.credentials.refresh_token,
+      expiry_date: this.credentials.expiry_date
+    });
+    Logger.info("Checking access token...");
+    const tokenInfo = await oauth2Client.getTokenInfo(this.credentials.access_token || "");
+    Logger.info(`Token scopes: ${tokenInfo.scopes?.join(", ") || "none"}`);
+    Logger.info(
+      `Token expires at: ${this.credentials.expiry_date ? new Date(this.credentials.expiry_date).toLocaleString() : "unknown"}`
+    );
+    const drive = google.drive({ version: "v3", auth: oauth2Client });
+    Logger.info("Requesting spreadsheets from Google Drive API...");
+    try {
+      const response = await drive.files.list({
+        q: "mimeType='application/vnd.google-apps.spreadsheet' and trashed=false",
+        fields: "files(id, name, modifiedTime, webViewLink)",
+        orderBy: "modifiedTime desc",
+        pageSize: 100
+      });
+      const files = response.data.files || [];
+      Logger.info(`Found ${files.length} spreadsheet(s)`);
+      return files.map((file) => ({
+        id: file.id || "",
+        name: file.name || "Untitled",
+        modifiedTime: file.modifiedTime || "",
+        webViewLink: file.webViewLink || ""
+      }));
+    } catch (error) {
+      Logger.error("Google Drive API error:", error);
+      Logger.info("\nRequired scopes for this operation:");
+      Logger.info(`  - ${OAUTH_SCOPES.SPREADSHEETS}`);
+      Logger.info(`  - ${OAUTH_SCOPES.DRIVE_READONLY}`);
+      Logger.info("\nTo fix this:");
+      Logger.info("  1. Add Drive API scope in OAuth Consent Screen");
+      Logger.info("  2. Run: gsheet account reauth");
+      throw error;
+    }
+  }
+};
+
+// src/core/spreadsheet-title.ts
+async function getSpreadsheetTitle(configManager, email, spreadsheetId) {
+  const credentials = await configManager.getRefreshedCredentials(email);
+  const sheetsService = new GoogleSheetsService({
+    spreadsheetId,
+    oauthCredentials: credentials
+  });
+  const info = await sheetsService.getSheetInfo();
+  return info.title;
+}
+
+// src/commands/spreadsheet/add.ts
+var addSpreadsheetCommand = defineSubCommand({
+  name: "add",
+  description: "Add a new spreadsheet (interactive by default, use --id for manual)",
+  flags: [
+    flag.string("--id", "Spreadsheet ID or URL (skips interactive selection)", { alias: "-i" }),
+    flag.string("--name", "Local name for the spreadsheet")
+  ],
+  errorMessage: "Failed to add spreadsheet",
+  action: async ({ options }) => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account add");
+      process.exit(1);
+    }
+    let spreadsheetId;
+    let name;
+    const spreadsheetIdOption = options.id ?? options.i;
+    if (spreadsheetIdOption !== void 0) {
+      spreadsheetId = parseSpreadsheetId(String(spreadsheetIdOption));
+      name = options.name?.trim() || "";
+      if (!name) {
+        const defaultName = await getSpreadsheetTitle(configManager, activeAccount.email, spreadsheetId);
+        const answer = await inquirer4.prompt([
+          {
+            type: "input",
+            name: "name",
+            message: "Enter a local name for this spreadsheet:",
+            default: defaultName,
+            validate: (input) => {
+              if (!input.trim()) {
+                return "Name cannot be empty";
+              }
+              return true;
+            }
+          }
+        ]);
+        name = answer.name;
+      }
+    } else {
+      Logger.loading("Fetching your spreadsheets from Google Drive...");
+      const credentials = await configManager.getRefreshedCredentials(activeAccount.email);
+      const driveService = new GoogleDriveService(credentials);
+      const spreadsheets2 = await driveService.listSpreadsheets();
+      if (spreadsheets2.length === 0) {
+        Logger.warning("No spreadsheets found in your Google Drive.");
+        Logger.info(`Create one at: ${GOOGLE_API_URLS.SHEETS_CREATE}`);
+        process.exit(0);
+      }
+      const choices = spreadsheets2.map((s) => ({
+        name: `${s.name} (Modified: ${new Date(s.modifiedTime).toLocaleDateString()})`,
+        value: { id: s.id, name: s.name }
+      }));
+      const selection = await inquirer4.prompt([
+        {
+          type: "list",
+          name: "spreadsheet",
+          message: `Select a spreadsheet (${spreadsheets2.length} found):`,
+          choices,
+          pageSize: 15
+        },
+        {
+          type: "input",
+          name: "localName",
+          message: "Enter a local name for this spreadsheet:",
+          default: (answers) => answers.spreadsheet.name,
+          validate: (input) => {
+            if (!input.trim()) {
+              return "Name cannot be empty";
+            }
+            return true;
+          }
+        }
+      ]);
+      spreadsheetId = selection.spreadsheet.id;
+      name = selection.localName;
+    }
+    await configManager.addSpreadsheet(activeAccount.email, name, spreadsheetId);
+    const spreadsheets = configManager.listSpreadsheets(activeAccount.email);
+    if (spreadsheets.length === 1) {
+      configManager.setActiveSpreadsheet(activeAccount.email, name);
+      Logger.success(`Spreadsheet '${name}' added and set as active!`);
+    } else {
+      Logger.success(`Spreadsheet '${name}' added successfully!`);
+      Logger.info(`Switch to this spreadsheet: gsheet spreadsheet select ${name}`);
+    }
+  }
+});
+
+// src/commands/spreadsheet/list.ts
+var listSpreadsheetsCommand = defineSubCommand({
+  name: "list",
+  description: "List all configured spreadsheets",
+  flags: [flag.string("--output", "Output format", { alias: "-o" })],
+  errorMessage: "Failed to list spreadsheets",
+  action: async ({ options }) => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account add");
+      return;
+    }
+    const spreadsheets = configManager.listSpreadsheets(activeAccount.email);
+    const activeSpreadsheetName = configManager.getActiveSpreadsheetName(activeAccount.email);
+    if (options.output === "json") {
+      Logger.json({
+        activeAccount: activeAccount.email,
+        activeSpreadsheet: activeSpreadsheetName,
+        spreadsheets: spreadsheets.map((spreadsheet) => ({
+          name: spreadsheet.name,
+          spreadsheetId: spreadsheet.spreadsheetId,
+          url: getSpreadsheetUrl(spreadsheet.spreadsheetId),
+          activeSheet: spreadsheet.activeSheet ?? null,
+          active: spreadsheet.name === activeSpreadsheetName
+        }))
+      });
+      return;
+    }
+    if (spreadsheets.length === 0) {
+      Logger.warning('No spreadsheets configured. Use "gsheet spreadsheet add" to add one.');
+      return;
+    }
+    Logger.bold(`
+Spreadsheets for ${activeAccount.email}:`);
+    spreadsheets.forEach((spreadsheet) => {
+      const isActive = spreadsheet.name === activeSpreadsheetName;
+      const marker = isActive ? "* " : "  ";
+      Logger.plain(`${marker}${spreadsheet.name}${isActive ? " (active)" : ""}`);
+      Logger.dim(`    ID: ${spreadsheet.spreadsheetId}`);
+      Logger.dim(`    URL: ${getSpreadsheetUrl(spreadsheet.spreadsheetId)}`);
+      if (spreadsheet.activeSheet) {
+        Logger.dim(`    Active sheet: ${spreadsheet.activeSheet}`);
+      }
+    });
+    if (activeSpreadsheetName) {
+      Logger.plain("");
+      Logger.dim("* = active spreadsheet");
+    }
+  }
+});
+
+// src/commands/spreadsheet/remove.ts
+import inquirer5 from "inquirer";
+var removeSpreadsheetCommand = defineSubCommand({
+  name: "remove",
+  description: "Remove a spreadsheet configuration",
+  flags: [flag.string("--id", "Spreadsheet ID or URL (skips interactive selection)", { alias: "-i" })],
+  errorMessage: "Failed to remove spreadsheet",
+  action: async ({ options }) => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account add");
+      process.exit(1);
+    }
+    const spreadsheetIdOption = options.id ?? options.i;
+    let spreadsheetId = spreadsheetIdOption !== void 0 ? parseSpreadsheetId(String(spreadsheetIdOption)) : void 0;
+    if (!spreadsheetId) {
+      const spreadsheets = configManager.listSpreadsheets(activeAccount.email);
+      if (spreadsheets.length === 0) {
+        Logger.warning("No spreadsheets configured.");
+        return;
+      }
+      const answer = await inquirer5.prompt([
+        {
+          type: "list",
+          name: "spreadsheet",
+          message: "Select spreadsheet to remove:",
+          choices: spreadsheets.map((s) => ({
+            name: s.name,
+            value: s.spreadsheetId
+          }))
+        }
+      ]);
+      spreadsheetId = answer.spreadsheet;
+    }
+    if (!spreadsheetId) {
+      Logger.error("No spreadsheet ID provided");
+      return;
+    }
+    const spreadsheet = configManager.getSpreadsheetById(activeAccount.email, spreadsheetId);
+    if (!spreadsheet) {
+      Logger.error(`Spreadsheet with ID '${spreadsheetId}' not found`);
+      process.exit(1);
+    }
+    const spreadsheetName = Object.entries(configManager.listSpreadsheets(activeAccount.email)).find(
+      ([_, s]) => s.spreadsheetId === spreadsheetId
+    )?.[1]?.name;
+    if (!spreadsheetName) {
+      Logger.error(`Spreadsheet with ID '${spreadsheetId}' not found`);
+      process.exit(1);
+    }
+    const confirm = await inquirer5.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: `Are you sure you want to remove '${spreadsheetName}'?`,
+        default: false
+      }
+    ]);
+    if (!confirm.confirmed) {
+      Logger.info("Cancelled");
+      return;
+    }
+    await configManager.removeSpreadsheet(activeAccount.email, spreadsheetName);
+    Logger.success(`Spreadsheet '${spreadsheetName}' removed successfully!`);
+  }
+});
+
+// src/commands/spreadsheet/select.ts
+import inquirer6 from "inquirer";
+var selectSpreadsheetCommand = defineSubCommand({
+  name: "select",
+  description: "Select a different spreadsheet (sets as active)",
+  flags: [
+    flag.string("--id", "Spreadsheet ID or URL (skips interactive selection)", { alias: "-i" }),
+    flag.boolean("--add", "Add the spreadsheet if it is not configured"),
+    flag.string("--name", "Local name to use with --add")
+  ],
+  errorMessage: "Failed to select spreadsheet",
+  action: async ({ options }) => {
+    const configManager = new ConfigManager();
+    const activeAccount = configManager.getActiveAccount();
+    if (!activeAccount) {
+      Logger.error("No active account set.");
+      Logger.info("Use: gsheet account add");
+      process.exit(1);
+    }
+    const spreadsheetIdOption = options.id ?? options.i;
+    let spreadsheetId = spreadsheetIdOption !== void 0 ? parseSpreadsheetId(String(spreadsheetIdOption)) : void 0;
+    if (!spreadsheetId) {
+      const spreadsheets = configManager.listSpreadsheets(activeAccount.email);
+      if (spreadsheets.length === 0) {
+        Logger.warning('No spreadsheets configured. Use "gsheet spreadsheet add" to add one.');
+        return;
+      }
+      const activeSpreadsheet = configManager.getActiveSpreadsheetName(activeAccount.email);
+      const answer = await inquirer6.prompt([
+        {
+          type: "list",
+          name: "spreadsheet",
+          message: "Select spreadsheet:",
+          choices: spreadsheets.map((s) => ({
+            name: s.name === activeSpreadsheet ? `${s.name} (current)` : s.name,
+            value: s.spreadsheetId
+          }))
+        }
+      ]);
+      spreadsheetId = answer.spreadsheet;
+    }
+    if (!spreadsheetId) {
+      Logger.error("No spreadsheet ID provided");
+      return;
+    }
+    let spreadsheet = configManager.getSpreadsheetById(activeAccount.email, spreadsheetId);
+    if (!spreadsheet) {
+      if (!options.add) {
+        Logger.error(`Spreadsheet with ID '${spreadsheetId}' not found`);
+        Logger.info("Use --add to add and select this spreadsheet.");
+        process.exit(1);
+      }
+      const name = options.name?.trim() || await getSpreadsheetTitle(configManager, activeAccount.email, spreadsheetId);
+      await configManager.addSpreadsheet(activeAccount.email, name, spreadsheetId);
+      spreadsheet = configManager.getSpreadsheetById(activeAccount.email, spreadsheetId);
+      Logger.success(`Added spreadsheet: ${name}`);
+    }
+    const spreadsheetName = Object.entries(configManager.listSpreadsheets(activeAccount.email)).find(
+      ([_, s]) => s.spreadsheetId === spreadsheetId
+    )?.[1]?.name;
+    if (!spreadsheetName) {
+      Logger.error(`Spreadsheet with ID '${spreadsheetId}' not found`);
+      process.exit(1);
+    }
+    configManager.setActiveSpreadsheet(activeAccount.email, spreadsheetName);
+    Logger.success(`Selected spreadsheet: ${spreadsheetName}`);
+  }
+});
+
+// src/commands/update.ts
+import { exec } from "child_process";
+import { readFileSync as readFileSync4 } from "fs";
+import { platform as platform2 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var updateCommandsByPackageManager = {
+  ["npm" /* Npm */]: `npm update -g ${APP_INFO.packageName}`,
+  ["pnpm" /* Pnpm */]: `pnpm update -g ${APP_INFO.packageName}`,
+  ["yarn" /* Yarn */]: `yarn global upgrade ${APP_INFO.packageName}`
+};
+var updateCommand = defineSubCommand({
+  name: "update",
+  description: `Update ${APP_INFO.name} to latest version`,
+  errorMessage: "Failed to check for updates",
+  action: async () => {
+    Logger.loading("Checking current version...");
+    const currentVersion = getCurrentVersion();
+    if (!currentVersion) {
+      Logger.error("Could not determine current version");
+      return;
+    }
+    Logger.loading("Checking latest version...");
+    const latestVersion = await getLatestVersion();
+    if (!latestVersion) {
+      Logger.error("Could not fetch latest version from npm");
+      return;
+    }
+    Logger.info(`\u{1F4E6} Current version: ${currentVersion}`);
+    Logger.info(`\u{1F4E6} Latest version: ${latestVersion}`);
+    if (currentVersion === latestVersion) {
+      Logger.success(`${APP_INFO.name} is already up to date!`);
+      return;
+    }
+    Logger.loading("Detecting package manager...");
+    const packageManager = await detectPackageManager();
+    if (!packageManager) {
+      Logger.error(`Could not detect how ${APP_INFO.name} was installed`);
+      Logger.dim("Please update manually using your package manager");
+      return;
+    }
+    Logger.info(`\u{1F4E6} Detected package manager: ${packageManager}`);
+    Logger.loading(`Updating ${APP_INFO.name} from ${currentVersion} to ${latestVersion}...`);
+    const updateCommand2 = getUpdateCommand(packageManager);
+    const { stdout, stderr } = await execAsync(updateCommand2);
+    if (stderr && !stderr.includes("npm WARN")) {
+      Logger.error(`Error updating: ${stderr}`);
+      return;
+    }
+    Logger.success(`${APP_INFO.name} updated successfully from ${currentVersion} to ${latestVersion}!`);
+    if (stdout) {
+      Logger.dim(stdout);
+    }
+    const completionReinstalled = await reinstallCompletionSilently();
+    if (completionReinstalled) {
+      Logger.dim("\u2728 Shell completion updated");
+      Logger.info("");
+      Logger.info("To activate the updated completion, run:");
+      const currentShell = process.env.SHELL || "";
+      if (currentShell.includes("zsh")) {
+        Logger.info("  exec zsh");
+      } else if (currentShell.includes("bash")) {
+        Logger.info("  exec bash");
+      } else {
+        Logger.info("  # Restart your shell");
+      }
+    }
+  }
+});
+async function detectPackageManager() {
+  const npmPath = await getGlobalNpmPath();
+  if (!npmPath) {
+    return null;
+  }
+  const possiblePaths = [
+    { manager: "npm" /* Npm */, patterns: ["/npm/", "\\npm\\", "/node/", "\\node\\"] },
+    { manager: "yarn" /* Yarn */, patterns: ["/yarn/", "\\yarn\\", "/.yarn/", "\\.yarn\\"] },
+    { manager: "pnpm" /* Pnpm */, patterns: ["/pnpm/", "\\pnpm\\", "/.pnpm/", "\\.pnpm\\"] }
+  ];
+  for (const { manager, patterns } of possiblePaths) {
+    if (patterns.some((pattern) => npmPath.includes(pattern))) {
+      return manager;
+    }
+  }
+  return "npm" /* Npm */;
+}
+async function getGlobalNpmPath() {
+  const isWindows = platform2() === "win32";
+  try {
+    const whereCommand = isWindows ? "where" : "which";
+    const { stdout } = await execAsync(`${whereCommand} ${APP_INFO.name}`);
+    const execPath = stdout.trim();
+    if (execPath) {
+      if (!isWindows) {
+        try {
+          const { stdout: realPath } = await execAsync(`readlink -f "${execPath}"`);
+          return realPath.trim() || execPath;
+        } catch {
+          return execPath;
+        }
+      }
+      return execPath;
+    }
+  } catch {
+    try {
+      const { stdout } = await execAsync(`npm list -g --depth=0 ${APP_INFO.packageName}`);
+      if (stdout.includes(APP_INFO.packageName)) {
+        return "npm" /* Npm */;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getCurrentVersion() {
+  try {
+    const packagePath = join3(__dirname2, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync4(packagePath, "utf8"));
+    return packageJson2.version;
+  } catch {
+    return null;
+  }
+}
+async function getLatestVersion() {
+  try {
+    const { stdout } = await execAsync(`npm view ${APP_INFO.packageName} version`);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function getUpdateCommand(packageManager) {
+  return updateCommandsByPackageManager[packageManager];
+}
+
+// src/cli/catalog.ts
+var accountCommand = defineCommand({
+  name: "account",
+  description: "Manage Google accounts",
+  subcommands: [
+    addAccountCommand,
+    listAccountsCommand,
+    selectAccountCommand,
+    removeAccountCommand,
+    reauthAccountCommand
+  ]
+});
+var spreadsheetCommand = defineCommand({
+  name: "spreadsheet",
+  description: "Manage spreadsheet configurations",
+  subcommands: [
+    addSpreadsheetCommand,
+    listSpreadsheetsCommand,
+    removeSpreadsheetCommand,
+    selectSpreadsheetCommand,
+    activeSpreadsheetCommand
+  ]
+});
+var sheetCommand = defineCommand({
+  name: "sheet",
+  description: "Manage and interact with spreadsheet sheets",
+  subcommands: [
+    listCommand,
+    activeCommand,
+    selectCommand,
+    readCommand,
+    addCommand,
+    removeCommand,
+    renameCommand,
+    copyCommand,
+    writeCommand,
+    appendCommand,
+    importCommand,
+    exportCommand,
+    rowAddCommand,
+    rowRemoveCommand
+  ]
+});
+var cliCommands = [accountCommand, spreadsheetCommand, sheetCommand, updateCommand];
+var docsCommands = [...cliCommands, completionCommand];
+
+// src/utils/error-handler.ts
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return String(error);
+}
+function handleCommandError(baseMessage) {
+  return (error) => {
+    const errorDetails = formatError(error);
+    if (errorDetails.includes("invalid_grant")) {
+      Logger.error("OAuth token refresh failed: invalid_grant");
+      Logger.info("Your refresh token is expired or invalid");
+      Logger.info("Fix: gsheet account reauth");
+      process.exit(1);
+    }
+    const prefix = typeof baseMessage === "function" ? baseMessage(error) : baseMessage;
+    const fullMessage = `${prefix}: ${errorDetails}`;
+    Logger.error(fullMessage);
+    process.exit(1);
+  };
+}
+
+// src/cli/register.ts
+function registerProgram(program2, commands) {
+  for (const command of commands) {
+    if (command.kind === "command") {
+      registerParentCommand(program2, command);
+      for (const subcommand of command.subcommands) {
+        registerSubCommand(program2, command.name, subcommand);
+      }
+      continue;
+    }
+    registerSubCommand(program2, void 0, command);
+  }
+}
+function registerParentCommand(program2, definition) {
+  const command = program2.command(definition.name, definition.description);
+  applyAliases(command, definition.aliases);
+  command.action(async () => {
+    const commandPromise = async () => {
+      console.log(`Usage: ${APP_INFO.name} ${definition.name} <command>`);
+      console.log("");
+      console.log(`Available commands: ${definition.subcommands.map((subcommand) => subcommand.name).join(", ")}`);
+    };
+    await commandPromise().catch(
+      handleCommandError(resolveErrorMessage(definition.errorMessage, `Failed to execute: ${definition.name}`))
+    );
+  });
+  return command;
+}
+function registerSubCommand(program2, parentName, definition) {
+  const commandName = parentName ? `${parentName} ${definition.name}` : definition.name;
+  const command = program2.command(commandName, definition.description);
+  applyAliases(command, definition.aliases);
+  applyArguments(command, definition.arguments);
+  applyFlags(command, definition.flags);
+  command.action(async ({ args, options }) => {
+    const commandPromise = async () => {
+      await definition.action({
+        args,
+        options
+      });
+    };
+    await commandPromise().catch(
+      handleCommandError(resolveErrorMessage(definition.errorMessage, `Failed to execute: ${commandName}`))
+    );
+  });
+  return command;
+}
+function applyAliases(command, aliases) {
+  if (!aliases) return;
+  for (const alias of aliases) {
+    command.alias(alias);
+  }
+}
+function applyArguments(command, args) {
+  if (!args) return;
+  for (const arg of args) {
+    const argString = arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+    command.argument(argString, arg.description);
+  }
+}
+function applyFlags(command, flags) {
+  if (!flags) return;
+  for (const flag2 of flags) {
+    let flagString = flag2.name;
+    if (flag2.alias) {
+      flagString = `${flag2.alias}, ${flagString}`;
+    }
+    if (flag2.type === "string" /* String */) {
+      flagString += " <value>";
+    }
+    command.option(flagString, flag2.description, {
+      required: flag2.required,
+      default: flag2.name.startsWith("--no-") ? true : void 0
+    });
+  }
+}
+function resolveErrorMessage(errorMessage, fallback) {
+  if (!errorMessage) return () => fallback;
+  if (typeof errorMessage === "function") return errorMessage;
+  return () => errorMessage;
+}
+
+// src/cli.ts
+var program = createProgram(getProgramBin());
+registerProgram(program, cliCommands);
+createCompletionCommand(program);
+try {
+  await program.run(process.argv.slice(2).length === 0 ? ["--help"] : process.argv.slice(2));
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.log(`error: ${message}`);
+  process.exitCode = 1;
+}
+function createProgram(binName) {
+  return new (getProgramConstructor())().bin(binName).name(binName).description("Google Sheets CLI - A tool to interact with Google Sheets").version(APP_INFO.version).disableGlobalOption("--no-color").disableGlobalOption("--quiet").disableGlobalOption("--silent").disableGlobalOption("-v");
+}
+function getProgramConstructor() {
+  const require2 = createRequire(import.meta.url);
+  const module = require2("@caporal/core");
+  const Program = module.Program ?? module.default?.Program;
+  if (!Program) throw new Error("Caporal Program constructor not found");
+  return Program;
+}
+function getProgramBin() {
+  if (process.env.SHEET_CMD_PROG_NAME) return process.env.SHEET_CMD_PROG_NAME;
+  if (isDirectRun() && process.argv[1]) return basename(process.argv[1]);
+  return APP_INFO.name;
+}
+function isDirectRun() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath3(import.meta.url));
+  } catch {
+    return import.meta.url === pathToFileURL(process.argv[1]).href;
+  }
+}
+//# sourceMappingURL=cli.js.map