gsheet-lvt 0.1.0

package/dist/index.js

@@ -0,0 +1,1246 @@
+// 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 platform2 = os.platform();
+  if (platform2 === "linux") {
+    try {
+      const release2 = os.release().toLowerCase();
+      if (release2.includes("microsoft") || release2.includes("wsl")) {
+        return "wsl" /* Wsl */;
+      }
+    } catch {
+    }
+    return "linux" /* Linux */;
+  }
+  if (platform2 === "darwin") return "mac" /* Mac */;
+  if (platform2 === "win32") return "windows" /* Windows */;
+  throw new Error(`Unsupported OS: ${platform2}`);
+}
+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 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/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/config/config-manager.ts
+import * as fs2 from "fs";
+import { OAuth2Client as OAuth2Client3 } from "google-auth-library";
+
+// 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/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/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/client.ts
+function createSheetsService(config) {
+  return new GoogleSheetsService(config);
+}
+function createDriveService(oauthCredentials) {
+  return new GoogleDriveService(oauthCredentials);
+}
+var SheetCmdClient = class {
+  configManager;
+  constructor(options = {}) {
+    this.configManager = options.configManager ?? new ConfigManager();
+  }
+  async login(options) {
+    const result = await performOAuthFlow(options.clientId, options.clientSecret, {
+      loginHint: options.loginHint,
+      onAuthUrl: options.onAuthUrl
+    });
+    await this.configManager.addAccount(result.email, result.credentials);
+    if (options.setActive ?? this.configManager.getAllAccounts().length === 1) {
+      this.configManager.setActiveAccount(result.email);
+    }
+    const account = this.configManager.getAccount(result.email);
+    if (!account) {
+      throw new Error(`Account '${result.email}' not found after login`);
+    }
+    return account;
+  }
+  async reauth(options = {}) {
+    const account = options.email ? this.configManager.getAccount(options.email) : this.configManager.getActiveAccount();
+    if (!account) {
+      throw new Error(options.email ? `Account '${options.email}' not found` : "No active account set");
+    }
+    const result = await performOAuthFlow(account.oauth.client_id, account.oauth.client_secret, {
+      loginHint: options.loginHint ?? account.email,
+      onAuthUrl: options.onAuthUrl
+    });
+    await this.configManager.updateAccountCredentials(account.email, result.credentials);
+    const updatedAccount = this.configManager.getAccount(account.email);
+    if (!updatedAccount) {
+      throw new Error(`Account '${account.email}' not found after reauth`);
+    }
+    return updatedAccount;
+  }
+  listAccounts() {
+    return this.configManager.getAllAccounts();
+  }
+  getAccount(email) {
+    return this.configManager.getAccount(email);
+  }
+  getActiveAccount() {
+    return this.configManager.getActiveAccount();
+  }
+  selectAccount(email) {
+    this.configManager.setActiveAccount(email);
+  }
+  async removeAccount(email) {
+    await this.configManager.removeAccount(email);
+  }
+  async addSpreadsheet(email, name, spreadsheetId) {
+    await this.configManager.addSpreadsheet(email, name, spreadsheetId);
+  }
+  async removeSpreadsheet(email, name) {
+    await this.configManager.removeSpreadsheet(email, name);
+  }
+  listSpreadsheets(email = this.requireActiveAccount().email) {
+    return this.configManager.listSpreadsheets(email);
+  }
+  getSpreadsheet(email, name) {
+    return this.configManager.getSpreadsheet(email, name);
+  }
+  selectSpreadsheet(email, name) {
+    this.configManager.setActiveSpreadsheet(email, name);
+  }
+  getActiveSpreadsheet(email = this.requireActiveAccount().email) {
+    return this.configManager.getActiveSpreadsheet(email);
+  }
+  getActiveSpreadsheetName(email = this.requireActiveAccount().email) {
+    return this.configManager.getActiveSpreadsheetName(email);
+  }
+  selectSheet(email, spreadsheetName, sheetName) {
+    this.configManager.setActiveSheet(email, spreadsheetName, sheetName);
+  }
+  getActiveSheetName(email = this.requireActiveAccount().email, spreadsheetName) {
+    return this.configManager.getActiveSheetName(email, spreadsheetName ?? this.requireActiveSpreadsheetName(email));
+  }
+  async getSheetsService(options = {}) {
+    const account = options.accountEmail ? this.requireAccount(options.accountEmail) : this.requireActiveAccount();
+    const spreadsheetName = options.spreadsheetName ?? this.requireActiveSpreadsheetName(account.email);
+    const spreadsheet = this.requireSpreadsheet(account.email, spreadsheetName);
+    const oauthCredentials = await this.configManager.getRefreshedCredentials(account.email);
+    return createSheetsService({
+      spreadsheetId: spreadsheet.spreadsheet_id,
+      oauthCredentials
+    });
+  }
+  async getDriveService(options = {}) {
+    const account = options.accountEmail ? this.requireAccount(options.accountEmail) : this.requireActiveAccount();
+    const oauthCredentials = await this.configManager.getRefreshedCredentials(account.email);
+    return createDriveService(oauthCredentials);
+  }
+  async refreshAccountCredentials(email) {
+    const account = this.requireAccount(email);
+    const credentials = await refreshToken(account.oauth);
+    await this.configManager.updateAccountCredentials(email, credentials);
+    return credentials;
+  }
+  requireActiveAccount() {
+    const account = this.configManager.getActiveAccount();
+    if (!account) {
+      throw new Error("No active account set");
+    }
+    return account;
+  }
+  requireAccount(email) {
+    const account = this.configManager.getAccount(email);
+    if (!account) {
+      throw new Error(`Account '${email}' not found`);
+    }
+    return account;
+  }
+  requireActiveSpreadsheetName(email) {
+    const spreadsheetName = this.configManager.getActiveSpreadsheetName(email);
+    if (!spreadsheetName) {
+      throw new Error(`No active spreadsheet set for account '${email}'`);
+    }
+    return spreadsheetName;
+  }
+  requireSpreadsheet(email, name) {
+    const spreadsheet = this.configManager.getSpreadsheet(email, name);
+    if (!spreadsheet) {
+      throw new Error(`Spreadsheet '${name}' not found for account '${email}'`);
+    }
+    return spreadsheet;
+  }
+};
+
+// 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/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);
+}
+export {
+  APP_INFO,
+  CONFIG_PATHS,
+  ConfigManager,
+  GOOGLE_API_URLS,
+  GoogleDriveService,
+  GoogleSheetsService,
+  OAUTH_CONFIG,
+  OAUTH_SCOPES,
+  SheetCmdClient,
+  TOKEN_REFRESH_THRESHOLD_MS,
+  accountSchema,
+  assertRequiredOAuthScopes,
+  createDriveService,
+  createSheetsService,
+  formatAsCSV,
+  formatAsJSON,
+  formatAsMarkdown,
+  getConfigDirectory,
+  getUserOS,
+  oauthCredentialsSchema,
+  parseCSV,
+  performOAuthFlow,
+  readJson,
+  refreshToken,
+  refreshTokenIfNeeded,
+  sheetDataSchema,
+  sheetsConfigSchema,
+  spreadsheetConfigSchema,
+  userMetadataSchema,
+  writeJson
+};
+//# sourceMappingURL=index.js.map