@ariadng/sheets 0.4.0 → 0.4.2

package/dist/cli.js

@@ -1,16 +1,811 @@
 #!/usr/bin/env node
-/**
- * Google Sheets CLI
- * Command-line interface for Google Sheets operations
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { createClient } from './api/index.js';
-import { login, loadStoredTokens, deleteTokens } from './auth/index.js';
-const VERSION = '0.3.4';
-// Claude Skill content embedded in the CLI
-const CLAUDE_SKILL_CONTENT = `---
+
+// src/cli.ts
+import * as fs3 from "fs/promises";
+import * as path2 from "path";
+import * as os2 from "os";
+
+// src/types/index.ts
+var SheetsError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(error) {
+    super(error.message);
+    this.name = "SheetsError";
+    this.code = error.code;
+    this.status = error.status;
+    this.details = error.details;
+  }
+};
+
+// src/http/index.ts
+var BASE_URL = "https://sheets.googleapis.com/v4";
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 1e3;
+var HttpClient = class {
+  getAccessToken;
+  constructor(options) {
+    this.getAccessToken = options.getAccessToken;
+  }
+  async request(path3, options = {}) {
+    const { method = "GET", body, params } = options;
+    let url = `${BASE_URL}${path3}`;
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      url += `?${searchParams.toString()}`;
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const accessToken = await this.getAccessToken();
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Authorization": `Bearer ${accessToken}`,
+            "Content-Type": "application/json"
+          },
+          body: body ? JSON.stringify(body) : void 0
+        });
+        if (response.status === 429) {
+          const backoffMs = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+          await this.sleep(backoffMs);
+          continue;
+        }
+        const data = await response.json();
+        if (!response.ok) {
+          if (data.error) {
+            throw new SheetsError({
+              code: data.error.code,
+              message: data.error.message,
+              status: data.error.status
+            });
+          }
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof SheetsError && error.code !== 429 && error.code !== 500 && error.code !== 503) {
+          throw error;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          const backoffMs = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+          await this.sleep(backoffMs);
+        }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/auth/constants.ts
+var OAUTH_CLIENT_ID = "344941894490-jmdvo5ghomqi7vuisfrf80hfassk1ma5.apps.googleusercontent.com";
+var OAUTH_CLIENT_SECRET = "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";
+var OAUTH_REDIRECT_URI = "http://localhost:8085/callback";
+var OAUTH_CALLBACK_PORT = 8085;
+var OAUTH_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var OAUTH_USERINFO_URL = "https://www.googleapis.com/oauth2/v2/userinfo";
+var OAUTH_SCOPES = [
+  "https://www.googleapis.com/auth/spreadsheets",
+  "https://www.googleapis.com/auth/userinfo.email"
+];
+
+// src/auth/oauth.ts
+var OAuthAuth = class {
+  config;
+  cachedToken;
+  expiresAt;
+  constructor(config) {
+    this.config = config;
+    this.cachedToken = config.accessToken;
+    this.expiresAt = config.expiresAt || 0;
+  }
+  async getAccessToken() {
+    if (!this.canRefresh()) {
+      return this.cachedToken;
+    }
+    if (this.isExpired()) {
+      await this.refreshToken();
+    }
+    return this.cachedToken;
+  }
+  canRefresh() {
+    return !!(this.config.refreshToken && this.config.clientId && this.config.clientSecret && this.expiresAt > 0);
+  }
+  isExpired() {
+    return Date.now() >= this.expiresAt - 6e4;
+  }
+  async refreshToken() {
+    if (!this.config.refreshToken || !this.config.clientId || !this.config.clientSecret) {
+      throw new Error("Token expired and missing refresh credentials (refreshToken, clientId, clientSecret)");
+    }
+    const response = await fetch(OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        client_id: this.config.clientId,
+        client_secret: this.config.clientSecret,
+        refresh_token: this.config.refreshToken,
+        grant_type: "refresh_token"
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Token refresh failed: ${error}`);
+    }
+    const tokenResponse = await response.json();
+    this.cachedToken = tokenResponse.access_token;
+    this.expiresAt = Date.now() + tokenResponse.expires_in * 1e3;
+    if (tokenResponse.refresh_token) {
+      this.config.refreshToken = tokenResponse.refresh_token;
+    }
+  }
+  /**
+   * Get current token state for persistence in automation tools
+   * Returns updated tokens after any refresh operations
+   */
+  getTokenState() {
+    return {
+      accessToken: this.cachedToken,
+      refreshToken: this.config.refreshToken,
+      expiresAt: this.expiresAt
+    };
+  }
+};
+
+// src/auth/service-account.ts
+import * as crypto from "crypto";
+import * as fs from "fs/promises";
+var TOKEN_URI = "https://oauth2.googleapis.com/token";
+var SCOPE = "https://www.googleapis.com/auth/spreadsheets";
+var TOKEN_LIFETIME_SECONDS = 3600;
+var ServiceAccountAuth = class {
+  config;
+  credentials = null;
+  cachedToken = null;
+  tokenExpiresAt = 0;
+  constructor(config) {
+    this.config = config;
+  }
+  async getAccessToken() {
+    if (this.cachedToken && Date.now() < this.tokenExpiresAt - 6e4) {
+      return this.cachedToken;
+    }
+    await this.loadCredentials();
+    const jwt = this.createJwt();
+    const token = await this.exchangeJwtForToken(jwt);
+    this.cachedToken = token.access_token;
+    this.tokenExpiresAt = Date.now() + token.expires_in * 1e3;
+    return this.cachedToken;
+  }
+  async loadCredentials() {
+    if (this.credentials) return;
+    if (this.config.credentials) {
+      this.credentials = this.config.credentials;
+      return;
+    }
+    if (!this.config.credentialsPath) {
+      throw new Error("Service account requires credentialsPath or credentials");
+    }
+    const content = await fs.readFile(this.config.credentialsPath, "utf-8");
+    this.credentials = JSON.parse(content);
+  }
+  createJwt() {
+    if (!this.credentials) {
+      throw new Error("Credentials not loaded");
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const header = {
+      alg: "RS256",
+      typ: "JWT"
+    };
+    const payload = {
+      iss: this.credentials.client_email,
+      scope: SCOPE,
+      aud: TOKEN_URI,
+      iat: now,
+      exp: now + TOKEN_LIFETIME_SECONDS
+    };
+    const encodedHeader = this.base64UrlEncode(JSON.stringify(header));
+    const encodedPayload = this.base64UrlEncode(JSON.stringify(payload));
+    const signatureInput = `${encodedHeader}.${encodedPayload}`;
+    const sign = crypto.createSign("RSA-SHA256");
+    sign.update(signatureInput);
+    const signature = sign.sign(this.credentials.private_key);
+    const encodedSignature = this.base64UrlEncode(signature);
+    return `${signatureInput}.${encodedSignature}`;
+  }
+  base64UrlEncode(input) {
+    const buffer = typeof input === "string" ? Buffer.from(input) : input;
+    return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  }
+  async exchangeJwtForToken(jwt) {
+    const response = await fetch(TOKEN_URI, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        assertion: jwt
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Token exchange failed: ${error}`);
+    }
+    return await response.json();
+  }
+};
+
+// src/auth/user-auth.ts
+import * as crypto2 from "crypto";
+import * as fs2 from "fs/promises";
+import * as http from "http";
+import * as os from "os";
+import * as path from "path";
+import { exec } from "child_process";
+var CONFIG_DIR = path.join(os.homedir(), ".sheets");
+var TOKENS_FILE = path.join(CONFIG_DIR, "tokens.json");
+function generatePKCE() {
+  const codeVerifier = crypto2.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto2.createHash("sha256").update(codeVerifier).digest("base64url");
+  return { codeVerifier, codeChallenge };
+}
+function openBrowser(url) {
+  return new Promise((resolve, reject) => {
+    const platform = process.platform;
+    let command;
+    if (platform === "darwin") {
+      command = `open "${url}"`;
+    } else if (platform === "win32") {
+      command = `start "" "${url}"`;
+    } else {
+      command = `xdg-open "${url}"`;
+    }
+    exec(command, (error) => {
+      if (error) {
+        reject(new Error(`Failed to open browser: ${error.message}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+function startCallbackServer() {
+  return new Promise((resolve, reject) => {
+    let timeoutId;
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "", `http://localhost:${OAUTH_CALLBACK_PORT}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end("<html><body><h1>Authorization Failed</h1><p>You can close this window.</p></body></html>");
+          clearTimeout(timeoutId);
+          server.close();
+          reject(new Error(`Authorization error: ${error}`));
+          return;
+        }
+        if (code) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end("<html><body><h1>Authorization Successful</h1><p>You can close this window.</p></body></html>");
+          clearTimeout(timeoutId);
+          server.close();
+          resolve(code);
+          return;
+        }
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h1>Missing Code</h1></body></html>");
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    server.on("error", (err) => {
+      clearTimeout(timeoutId);
+      reject(new Error(`Callback server error: ${err.message}`));
+    });
+    server.listen(OAUTH_CALLBACK_PORT, () => {
+    });
+    timeoutId = setTimeout(() => {
+      server.close();
+      reject(new Error("Authorization timeout"));
+    }, 5 * 60 * 1e3);
+  });
+}
+function getAuthorizationUrl(codeChallenge, clientId) {
+  const params = new URLSearchParams({
+    client_id: clientId || OAUTH_CLIENT_ID,
+    redirect_uri: OAUTH_REDIRECT_URI,
+    response_type: "code",
+    scope: OAUTH_SCOPES.join(" "),
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    access_type: "offline",
+    prompt: "consent"
+  });
+  return `${OAUTH_AUTH_URL}?${params.toString()}`;
+}
+async function exchangeCodeForTokens(code, codeVerifier, credentials) {
+  const response = await fetch(OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: credentials?.clientId || OAUTH_CLIENT_ID,
+      client_secret: credentials?.clientSecret || OAUTH_CLIENT_SECRET,
+      code,
+      code_verifier: codeVerifier,
+      grant_type: "authorization_code",
+      redirect_uri: OAUTH_REDIRECT_URI
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${error}`);
+  }
+  return await response.json();
+}
+async function refreshAccessToken(refreshToken) {
+  const response = await fetch(OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: OAUTH_CLIENT_ID,
+      client_secret: OAUTH_CLIENT_SECRET,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token refresh failed: ${error}`);
+  }
+  return await response.json();
+}
+async function getUserInfo(accessToken) {
+  const response = await fetch(OAUTH_USERINFO_URL, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!response.ok) {
+    throw new Error("Failed to get user info");
+  }
+  return await response.json();
+}
+async function ensureConfigDir() {
+  try {
+    await fs2.mkdir(CONFIG_DIR, { recursive: true });
+  } catch {
+  }
+}
+async function loadStoredTokens() {
+  try {
+    const content = await fs2.readFile(TOKENS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveTokens(tokens) {
+  await ensureConfigDir();
+  await fs2.writeFile(TOKENS_FILE, JSON.stringify(tokens, null, 2));
+}
+async function deleteTokens() {
+  try {
+    await fs2.unlink(TOKENS_FILE);
+  } catch {
+  }
+}
+async function login(credentials) {
+  const { codeVerifier, codeChallenge } = generatePKCE();
+  const authUrl = getAuthorizationUrl(codeChallenge, credentials?.clientId);
+  console.log("Opening browser for Google login...");
+  const codePromise = startCallbackServer();
+  await openBrowser(authUrl);
+  console.log("Waiting for authorization...");
+  const code = await codePromise;
+  console.log("Exchanging code for tokens...");
+  const tokenResponse = await exchangeCodeForTokens(code, codeVerifier, credentials);
+  const userInfo = await getUserInfo(tokenResponse.access_token);
+  const tokens = {
+    accessToken: tokenResponse.access_token,
+    refreshToken: tokenResponse.refresh_token || "",
+    expiresAt: Date.now() + tokenResponse.expires_in * 1e3,
+    email: userInfo.email
+  };
+  await saveTokens(tokens);
+  return tokens;
+}
+var UserAuth = class {
+  tokens = null;
+  async getAccessToken() {
+    if (!this.tokens) {
+      this.tokens = await loadStoredTokens();
+    }
+    if (!this.tokens) {
+      throw new Error('Not logged in. Run "sheets login" first.');
+    }
+    if (Date.now() >= this.tokens.expiresAt - 6e4) {
+      if (!this.tokens.refreshToken) {
+        throw new Error('Token expired and no refresh token. Run "sheets login" again.');
+      }
+      const tokenResponse = await refreshAccessToken(this.tokens.refreshToken);
+      this.tokens.accessToken = tokenResponse.access_token;
+      this.tokens.expiresAt = Date.now() + tokenResponse.expires_in * 1e3;
+      if (tokenResponse.refresh_token) {
+        this.tokens.refreshToken = tokenResponse.refresh_token;
+      }
+      await saveTokens(this.tokens);
+    }
+    return this.tokens.accessToken;
+  }
+};
+
+// src/auth/index.ts
+function createAuthProvider(config) {
+  switch (config.type) {
+    case "oauth":
+      return new OAuthAuth(config);
+    case "service-account":
+      return new ServiceAccountAuth(config);
+    case "user":
+      return new UserAuth();
+    default:
+      throw new Error(`Unknown auth type: ${config.type}`);
+  }
+}
+
+// src/api/index.ts
+function columnLetterToNumber(letters) {
+  let result = 0;
+  for (let i = 0; i < letters.length; i++) {
+    result = result * 26 + (letters.charCodeAt(i) - 64);
+  }
+  return result;
+}
+function columnNumberToLetter(num) {
+  let result = "";
+  while (num > 0) {
+    const remainder = (num - 1) % 26;
+    result = String.fromCharCode(65 + remainder) + result;
+    num = Math.floor((num - 1) / 26);
+  }
+  return result;
+}
+function parseA1Range(range) {
+  const cellRef = range.includes("!") ? range.split("!")[1] : range;
+  const firstCell = cellRef.split(":")[0];
+  const match = firstCell.match(/^([A-Z]+)(\d+)$/i);
+  if (!match) {
+    return { startRow: 1, startCol: 1 };
+  }
+  return {
+    startCol: columnLetterToNumber(match[1].toUpperCase()),
+    startRow: parseInt(match[2], 10)
+  };
+}
+var SheetsClient = class {
+  http;
+  constructor(options) {
+    const authProvider = createAuthProvider(options.auth);
+    this.http = new HttpClient({
+      getAccessToken: () => authProvider.getAccessToken()
+    });
+  }
+  /**
+   * Get a spreadsheet by ID
+   */
+  async getSpreadsheet(spreadsheetId) {
+    return this.http.request(`/spreadsheets/${spreadsheetId}`);
+  }
+  /**
+   * Get list of sheets in a spreadsheet
+   */
+  async getSheets(spreadsheetId) {
+    const spreadsheet = await this.getSpreadsheet(spreadsheetId);
+    return spreadsheet.sheets.map((sheet) => sheet.properties);
+  }
+  /**
+   * Read cell values from a range
+   */
+  async getValues(spreadsheetId, range, options) {
+    const params = {};
+    if (options?.valueRenderOption) {
+      params.valueRenderOption = options.valueRenderOption;
+    }
+    if (options?.dateTimeRenderOption) {
+      params.dateTimeRenderOption = options.dateTimeRenderOption;
+    }
+    if (options?.majorDimension) {
+      params.majorDimension = options.majorDimension;
+    }
+    const encodedRange = encodeURIComponent(range);
+    const response = await this.http.request(
+      `/spreadsheets/${spreadsheetId}/values/${encodedRange}`,
+      { params }
+    );
+    return this.normalizeValueRange(response);
+  }
+  /**
+   * Read cell formulas from a range
+   */
+  async getFormulas(spreadsheetId, range) {
+    return this.getValues(spreadsheetId, range, { valueRenderOption: "FORMULA" });
+  }
+  /**
+   * Read multiple ranges at once
+   */
+  async batchGetValues(spreadsheetId, ranges, options) {
+    const params = {
+      ranges: ranges.join(",")
+    };
+    if (options?.valueRenderOption) {
+      params.valueRenderOption = options.valueRenderOption;
+    }
+    if (options?.dateTimeRenderOption) {
+      params.dateTimeRenderOption = options.dateTimeRenderOption;
+    }
+    if (options?.majorDimension) {
+      params.majorDimension = options.majorDimension;
+    }
+    const response = await this.http.request(
+      `/spreadsheets/${spreadsheetId}/values:batchGet`,
+      { params }
+    );
+    return {
+      spreadsheetId: response.spreadsheetId,
+      valueRanges: (response.valueRanges || []).map((vr) => this.normalizeValueRange(vr))
+    };
+  }
+  /**
+   * Clear values from a single range
+   */
+  async clearValues(spreadsheetId, range) {
+    const encodedRange = encodeURIComponent(range);
+    return this.http.request(
+      `/spreadsheets/${spreadsheetId}/values/${encodedRange}:clear`,
+      { method: "POST" }
+    );
+  }
+  /**
+   * Clear values from multiple ranges
+   */
+  async batchClearValues(spreadsheetId, ranges) {
+    return this.http.request(
+      `/spreadsheets/${spreadsheetId}/values:batchClear`,
+      { method: "POST", body: { ranges } }
+    );
+  }
+  /**
+   * Write values to a range (or starting cell)
+   * Range can be "A1" or "A1:D10" - data array determines actual extent
+   */
+  async updateValues(spreadsheetId, range, values, options) {
+    const params = {
+      valueInputOption: options?.valueInputOption || "USER_ENTERED"
+    };
+    if (options?.includeValuesInResponse) {
+      params.includeValuesInResponse = "true";
+    }
+    if (options?.responseValueRenderOption) {
+      params.responseValueRenderOption = options.responseValueRenderOption;
+    }
+    if (options?.responseDateTimeRenderOption) {
+      params.responseDateTimeRenderOption = options.responseDateTimeRenderOption;
+    }
+    const encodedRange = encodeURIComponent(range);
+    return this.http.request(
+      `/spreadsheets/${spreadsheetId}/values/${encodedRange}`,
+      {
+        method: "PUT",
+        params,
+        body: {
+          majorDimension: options?.majorDimension || "ROWS",
+          values
+        }
+      }
+    );
+  }
+  /**
+   * Write to multiple ranges in one request
+   */
+  async batchUpdateValues(spreadsheetId, data, options) {
+    return this.http.request(
+      `/spreadsheets/${spreadsheetId}/values:batchUpdate`,
+      {
+        method: "POST",
+        body: {
+          valueInputOption: options?.valueInputOption || "USER_ENTERED",
+          data: data.map((d) => ({
+            range: d.range,
+            majorDimension: options?.majorDimension || "ROWS",
+            values: d.values
+          })),
+          includeValuesInResponse: options?.includeValuesInResponse || false,
+          responseValueRenderOption: options?.responseValueRenderOption,
+          responseDateTimeRenderOption: options?.responseDateTimeRenderOption
+        }
+      }
+    );
+  }
+  /**
+   * Append rows after the last row of detected table
+   */
+  async appendValues(spreadsheetId, range, values, options) {
+    const params = {
+      valueInputOption: options?.valueInputOption || "USER_ENTERED"
+    };
+    if (options?.insertDataOption) {
+      params.insertDataOption = options.insertDataOption;
+    }
+    if (options?.includeValuesInResponse) {
+      params.includeValuesInResponse = "true";
+    }
+    if (options?.responseValueRenderOption) {
+      params.responseValueRenderOption = options.responseValueRenderOption;
+    }
+    if (options?.responseDateTimeRenderOption) {
+      params.responseDateTimeRenderOption = options.responseDateTimeRenderOption;
+    }
+    const encodedRange = encodeURIComponent(range);
+    return this.http.request(
+      `/spreadsheets/${spreadsheetId}/values/${encodedRange}:append`,
+      {
+        method: "POST",
+        params,
+        body: {
+          majorDimension: options?.majorDimension || "ROWS",
+          values
+        }
+      }
+    );
+  }
+  /**
+   * Search for values matching a query across sheets
+   */
+  async searchValues(spreadsheetId, query, options) {
+    const caseSensitive = options?.caseSensitive ?? false;
+    const exactMatch = options?.exactMatch ?? false;
+    const useRegex = options?.regex ?? false;
+    const limit = options?.limit;
+    const matchType = useRegex ? "regex" : exactMatch ? "exact" : "contains";
+    let matcher;
+    if (useRegex) {
+      const flags = caseSensitive ? "" : "i";
+      const regex = new RegExp(query, flags);
+      matcher = (cellValue) => regex.test(cellValue);
+    } else if (exactMatch) {
+      if (caseSensitive) {
+        matcher = (cellValue) => cellValue === query;
+      } else {
+        const lowerQuery = query.toLowerCase();
+        matcher = (cellValue) => cellValue.toLowerCase() === lowerQuery;
+      }
+    } else {
+      if (caseSensitive) {
+        matcher = (cellValue) => cellValue.includes(query);
+      } else {
+        const lowerQuery = query.toLowerCase();
+        matcher = (cellValue) => cellValue.toLowerCase().includes(lowerQuery);
+      }
+    }
+    const matches = [];
+    const allSheets = await this.getSheets(spreadsheetId);
+    let sheetsToSearch;
+    if (options?.sheetIndex !== void 0) {
+      const sheet = allSheets.find((s) => s.index === options.sheetIndex);
+      if (!sheet) {
+        throw new Error(`Sheet index ${options.sheetIndex} not found.`);
+      }
+      sheetsToSearch = [sheet];
+    } else if (options?.gid !== void 0) {
+      const sheet = allSheets.find((s) => s.sheetId === options.gid);
+      if (!sheet) {
+        throw new Error(`Sheet with gid ${options.gid} not found.`);
+      }
+      sheetsToSearch = [sheet];
+    } else if (options?.range && options.range.includes("!")) {
+      sheetsToSearch = [];
+    } else {
+      sheetsToSearch = allSheets.filter((s) => !s.hidden);
+    }
+    if (options?.range && options.range.includes("!")) {
+      const valueRange = await this.getValues(spreadsheetId, options.range);
+      const sheetName = options.range.split("!")[0].replace(/^'|'$/g, "").replace(/''/g, "'");
+      const sheet = allSheets.find((s) => s.title === sheetName);
+      const { startRow, startCol } = parseA1Range(options.range);
+      this.collectMatches(
+        valueRange,
+        sheetName,
+        sheet?.sheetId ?? 0,
+        startRow,
+        startCol,
+        matcher,
+        matches,
+        limit
+      );
+    } else {
+      for (const sheet of sheetsToSearch) {
+        if (limit && matches.length >= limit) break;
+        const escapedTitle = sheet.title.replace(/'/g, "''");
+        const range = options?.range ? `'${escapedTitle}'!${options.range}` : `'${escapedTitle}'`;
+        try {
+          const valueRange = await this.getValues(spreadsheetId, range);
+          const { startRow, startCol } = parseA1Range(valueRange.range);
+          this.collectMatches(
+            valueRange,
+            sheet.title,
+            sheet.sheetId,
+            startRow,
+            startCol,
+            matcher,
+            matches,
+            limit
+          );
+        } catch {
+          continue;
+        }
+      }
+    }
+    return {
+      query,
+      matchType,
+      caseSensitive,
+      totalMatches: matches.length,
+      matches
+    };
+  }
+  collectMatches(valueRange, sheetName, sheetId, startRow, startCol, matcher, matches, limit) {
+    for (let rowIndex = 0; rowIndex < valueRange.values.length; rowIndex++) {
+      if (limit && matches.length >= limit) return;
+      const row = valueRange.values[rowIndex];
+      for (let colIndex = 0; colIndex < row.length; colIndex++) {
+        if (limit && matches.length >= limit) return;
+        const cell = row[colIndex];
+        const cellValue = cell.value;
+        if (cellValue == null) continue;
+        const stringValue = String(cellValue);
+        if (matcher(stringValue)) {
+          const actualRow = startRow + rowIndex;
+          const actualCol = startCol + colIndex;
+          matches.push({
+            sheet: sheetName,
+            sheetId,
+            address: columnNumberToLetter(actualCol) + actualRow,
+            row: actualRow,
+            column: actualCol,
+            value: cellValue
+          });
+        }
+      }
+    }
+  }
+  normalizeValueRange(raw) {
+    const values = (raw.values || []).map(
+      (row) => row.map((cell) => ({
+        value: cell
+      }))
+    );
+    return {
+      range: raw.range,
+      majorDimension: raw.majorDimension || "ROWS",
+      values
+    };
+  }
+};
+function createClient(options) {
+  return new SheetsClient(options);
+}
+
+// src/cli.ts
+var VERSION = "0.3.4";
+var CLAUDE_SKILL_CONTENT = `---
 name: sheets
 description: Read data from Google Sheets spreadsheets. Use this skill when the user wants to fetch, read, or analyze data from a Google Sheets URL or spreadsheet ID.
 ---
@@ -168,72 +963,55 @@ npx -y @ariadng/sheets search SPREADSHEET_ID "Term" --case-sensitive --limit 10
 - Handle errors gracefully and inform the user
 `;
 function parseArgs(args) {
-    const options = { format: 'table', formula: false };
-    const positionals = [];
-    let command = '';
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--credentials' && args[i + 1]) {
-            options.credentials = args[++i];
-        }
-        else if (arg === '--token' && args[i + 1]) {
-            options.token = args[++i];
-        }
-        else if (arg === '--client' && args[i + 1]) {
-            options.client = args[++i];
-        }
-        else if (arg === '--format' && args[i + 1]) {
-            options.format = args[++i];
-        }
-        else if (arg === '--formula') {
-            options.formula = true;
-        }
-        else if ((arg === '--sheet-index' || arg === '-i') && args[i + 1]) {
-            options.sheetIndex = parseInt(args[++i], 10);
-        }
-        else if (arg === '--gid' && args[i + 1]) {
-            options.gid = parseInt(args[++i], 10);
-        }
-        else if (arg === '--input' && args[i + 1]) {
-            options.input = args[++i];
-        }
-        else if (arg === '--raw') {
-            options.raw = true;
-        }
-        else if (arg === '--by-columns') {
-            options.byColumns = true;
-        }
-        else if (arg === '--insert-rows') {
-            options.insertRows = true;
-        }
-        else if (arg === '--case-sensitive') {
-            options.caseSensitive = true;
-        }
-        else if (arg === '--exact') {
-            options.exact = true;
-        }
-        else if (arg === '--regex') {
-            options.regex = true;
-        }
-        else if (arg === '--limit' && args[i + 1]) {
-            options.limit = parseInt(args[++i], 10);
-        }
-        else if (arg === '--version' || arg === '--help') {
-            command = arg;
-        }
-        else if (!arg.startsWith('-')) {
-            if (!command) {
-                command = arg;
-            }
-            else {
-                positionals.push(arg);
-            }
-        }
+  const options = { format: "table", formula: false };
+  const positionals = [];
+  let command = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--credentials" && args[i + 1]) {
+      options.credentials = args[++i];
+    } else if (arg === "--token" && args[i + 1]) {
+      options.token = args[++i];
+    } else if (arg === "--client" && args[i + 1]) {
+      options.client = args[++i];
+    } else if (arg === "--format" && args[i + 1]) {
+      options.format = args[++i];
+    } else if (arg === "--formula") {
+      options.formula = true;
+    } else if ((arg === "--sheet-index" || arg === "-i") && args[i + 1]) {
+      options.sheetIndex = parseInt(args[++i], 10);
+    } else if (arg === "--gid" && args[i + 1]) {
+      options.gid = parseInt(args[++i], 10);
+    } else if (arg === "--input" && args[i + 1]) {
+      options.input = args[++i];
+    } else if (arg === "--raw") {
+      options.raw = true;
+    } else if (arg === "--by-columns") {
+      options.byColumns = true;
+    } else if (arg === "--insert-rows") {
+      options.insertRows = true;
+    } else if (arg === "--case-sensitive") {
+      options.caseSensitive = true;
+    } else if (arg === "--exact") {
+      options.exact = true;
+    } else if (arg === "--regex") {
+      options.regex = true;
+    } else if (arg === "--limit" && args[i + 1]) {
+      options.limit = parseInt(args[++i], 10);
+    } else if (arg === "--version" || arg === "--help") {
+      command = arg;
+    } else if (!arg.startsWith("-")) {
+      if (!command) {
+        command = arg;
+      } else {
+        positionals.push(arg);
+      }
     }
-    return { command, positionals, options };
+  }
+  return { command, positionals, options };
 }
 function printHelp() {
-    console.log(`
+  console.log(`
 Google Sheets CLI v${VERSION}
 
 Usage:
@@ -281,584 +1059,529 @@ Examples:
 `);
 }
 function printVersion() {
-    console.log(VERSION);
+  console.log(VERSION);
 }
 function getRangeErrorSuggestions(errorMessage, range) {
-    const suggestions = [];
-    // Check for "Unable to parse range" errors
-    if (errorMessage.includes('Unable to parse range')) {
-        // Detect backslash escaping (shell issue)
-        if (range && range.includes('\\')) {
-            suggestions.push('Detected backslash in range - this may be caused by shell escaping.');
-            suggestions.push('Try using single quotes around the entire command or avoid piping.');
-        }
-        // Check for special characters that need quoting
-        if (range && (range.includes('[') || range.includes(']') || range.includes(' '))) {
-            suggestions.push('Sheet names with brackets or spaces need proper quoting.');
-            suggestions.push('Example: sheets read ID "[Sheet Name]!A1:B10"');
-        }
-        // General suggestions
-        suggestions.push('Verify the sheet name matches exactly (including trailing spaces).');
-        suggestions.push('Use: sheets list <spreadsheet-id> to see all sheet names.');
+  const suggestions = [];
+  if (errorMessage.includes("Unable to parse range")) {
+    if (range && range.includes("\\")) {
+      suggestions.push("Detected backslash in range - this may be caused by shell escaping.");
+      suggestions.push("Try using single quotes around the entire command or avoid piping.");
     }
-    return suggestions;
+    if (range && (range.includes("[") || range.includes("]") || range.includes(" "))) {
+      suggestions.push("Sheet names with brackets or spaces need proper quoting.");
+      suggestions.push('Example: sheets read ID "[Sheet Name]!A1:B10"');
+    }
+    suggestions.push("Verify the sheet name matches exactly (including trailing spaces).");
+    suggestions.push("Use: sheets list <spreadsheet-id> to see all sheet names.");
+  }
+  return suggestions;
 }
 async function getAuthConfig(options) {
-    // Priority: --token > --credentials > stored user tokens
-    if (options.token) {
-        return { type: 'oauth', accessToken: options.token };
-    }
-    if (options.credentials) {
-        return { type: 'service-account', credentialsPath: options.credentials };
-    }
-    // Check for stored user tokens
-    const storedTokens = await loadStoredTokens();
-    if (storedTokens) {
-        return { type: 'user' };
-    }
-    throw new Error('Not authenticated. Run "sheets login" or use --credentials');
+  if (options.token) {
+    return { type: "oauth", accessToken: options.token };
+  }
+  if (options.credentials) {
+    return { type: "service-account", credentialsPath: options.credentials };
+  }
+  const storedTokens = await loadStoredTokens();
+  if (storedTokens) {
+    return { type: "user" };
+  }
+  throw new Error('Not authenticated. Run "sheets login" or use --credentials');
 }
-// === Login Commands ===
 async function loadClientCredentials(clientPath) {
-    const content = await fs.readFile(clientPath, 'utf-8');
-    const data = JSON.parse(content);
-    // Support Google's client_secret JSON format
-    const installed = data.installed || data.web;
-    if (installed) {
-        return {
-            clientId: installed.client_id,
-            clientSecret: installed.client_secret,
-        };
-    }
-    // Support simple {clientId, clientSecret} format
-    if (data.clientId && data.clientSecret) {
-        return data;
-    }
-    throw new Error('Invalid client credentials file');
+  const content = await fs3.readFile(clientPath, "utf-8");
+  const data = JSON.parse(content);
+  const installed = data.installed || data.web;
+  if (installed) {
+    return {
+      clientId: installed.client_id,
+      clientSecret: installed.client_secret
+    };
+  }
+  if (data.clientId && data.clientSecret) {
+    return data;
+  }
+  throw new Error("Invalid client credentials file");
 }
 async function cmdLogin(options) {
-    try {
-        let credentials;
-        if (options.client) {
-            credentials = await loadClientCredentials(options.client);
-        }
-        const tokens = await login(credentials);
-        console.log(`\nLogin successful! Logged in as ${tokens.email}`);
-    }
-    catch (error) {
-        const e = error;
-        console.error(`Login failed: ${e.message}`);
-        process.exit(1);
+  try {
+    let credentials;
+    if (options.client) {
+      credentials = await loadClientCredentials(options.client);
     }
+    const tokens = await login(credentials);
+    console.log(`
+Login successful! Logged in as ${tokens.email}`);
+  } catch (error) {
+    const e = error;
+    console.error(`Login failed: ${e.message}`);
+    process.exit(1);
+  }
 }
 async function cmdLogout() {
-    await deleteTokens();
-    console.log('Logged out successfully.');
+  await deleteTokens();
+  console.log("Logged out successfully.");
 }
 async function cmdWhoami() {
-    const tokens = await loadStoredTokens();
-    if (!tokens) {
-        console.log('Not logged in. Run "sheets login" to authenticate.');
-        process.exit(1);
-    }
-    console.log(`Logged in as: ${tokens.email || 'Unknown'}`);
-    const expiresAt = new Date(tokens.expiresAt);
-    const isExpired = Date.now() >= tokens.expiresAt;
-    console.log(`Token expires: ${expiresAt.toLocaleString()}${isExpired ? ' (expired, will refresh)' : ''}`);
+  const tokens = await loadStoredTokens();
+  if (!tokens) {
+    console.log('Not logged in. Run "sheets login" to authenticate.');
+    process.exit(1);
+  }
+  console.log(`Logged in as: ${tokens.email || "Unknown"}`);
+  const expiresAt = new Date(tokens.expiresAt);
+  const isExpired = Date.now() >= tokens.expiresAt;
+  console.log(`Token expires: ${expiresAt.toLocaleString()}${isExpired ? " (expired, will refresh)" : ""}`);
 }
-// === Service Account Auth ===
 async function cmdAuth(credentialsPath) {
-    try {
-        await fs.access(credentialsPath);
-        const content = await fs.readFile(credentialsPath, 'utf-8');
-        const credentials = JSON.parse(content);
-        if (credentials.type !== 'service_account') {
-            throw new Error('Invalid credentials file: expected service_account type');
-        }
-        const client = createClient({
-            auth: { type: 'service-account', credentialsPath },
-        });
-        console.log('Testing authentication...');
-        console.log(`  Project: ${credentials.project_id}`);
-        console.log(`  Client Email: ${credentials.client_email}`);
-        try {
-            await client.getSpreadsheet('test-auth-only');
-        }
-        catch (error) {
-            const e = error;
-            if (e.code === 404 || e.code === 403) {
-                console.log('\nAuthentication successful!');
-                return;
-            }
-            throw error;
-        }
+  try {
+    await fs3.access(credentialsPath);
+    const content = await fs3.readFile(credentialsPath, "utf-8");
+    const credentials = JSON.parse(content);
+    if (credentials.type !== "service_account") {
+      throw new Error("Invalid credentials file: expected service_account type");
     }
-    catch (error) {
-        const e = error;
-        console.error(`Authentication failed: ${e.message}`);
-        process.exit(1);
+    const client = createClient({
+      auth: { type: "service-account", credentialsPath }
+    });
+    console.log("Testing authentication...");
+    console.log(`  Project: ${credentials.project_id}`);
+    console.log(`  Client Email: ${credentials.client_email}`);
+    try {
+      await client.getSpreadsheet("test-auth-only");
+    } catch (error) {
+      const e = error;
+      if (e.code === 404 || e.code === 403) {
+        console.log("\nAuthentication successful!");
+        return;
+      }
+      throw error;
     }
+  } catch (error) {
+    const e = error;
+    console.error(`Authentication failed: ${e.message}`);
+    process.exit(1);
+  }
 }
-// === Claude Skill Installation ===
 async function cmdInstallClaudeSkill() {
-    const homeDir = os.homedir();
-    const skillDir = path.join(homeDir, '.claude', 'skills', 'sheets');
-    const skillFile = path.join(skillDir, 'SKILL.md');
-    try {
-        // Create the skill directory
-        await fs.mkdir(skillDir, { recursive: true });
-        // Write the skill file
-        await fs.writeFile(skillFile, CLAUDE_SKILL_CONTENT, 'utf-8');
-        console.log('Claude skill installed successfully!');
-        console.log(`Location: ${skillFile}`);
-        console.log('');
-        console.log('You can now use /sheets in Claude Code to read Google Sheets data.');
-    }
-    catch (error) {
-        const e = error;
-        console.error(`Failed to install Claude skill: ${e.message}`);
-        process.exit(1);
-    }
+  const homeDir = os2.homedir();
+  const skillDir = path2.join(homeDir, ".claude", "skills", "sheets");
+  const skillFile = path2.join(skillDir, "SKILL.md");
+  try {
+    await fs3.mkdir(skillDir, { recursive: true });
+    await fs3.writeFile(skillFile, CLAUDE_SKILL_CONTENT, "utf-8");
+    console.log("Claude skill installed successfully!");
+    console.log(`Location: ${skillFile}`);
+    console.log("");
+    console.log("You can now use /sheets in Claude Code to read Google Sheets data.");
+  } catch (error) {
+    const e = error;
+    console.error(`Failed to install Claude skill: ${e.message}`);
+    process.exit(1);
+  }
 }
-// === Spreadsheet Commands ===
 async function cmdGet(spreadsheetId, options) {
-    const authConfig = await getAuthConfig(options);
-    const client = createClient({ auth: authConfig });
-    const spreadsheet = await client.getSpreadsheet(spreadsheetId);
-    if (options.format === 'json') {
-        console.log(JSON.stringify(spreadsheet, null, 2));
-    }
-    else {
-        console.log(`Title: ${spreadsheet.properties.title}`);
-        console.log(`ID: ${spreadsheet.spreadsheetId}`);
-        console.log(`Locale: ${spreadsheet.properties.locale || 'N/A'}`);
-        console.log(`Timezone: ${spreadsheet.properties.timeZone || 'N/A'}`);
-        console.log(`Sheets: ${spreadsheet.sheets.length}`);
-        if (spreadsheet.spreadsheetUrl) {
-            console.log(`URL: ${spreadsheet.spreadsheetUrl}`);
-        }
+  const authConfig = await getAuthConfig(options);
+  const client = createClient({ auth: authConfig });
+  const spreadsheet = await client.getSpreadsheet(spreadsheetId);
+  if (options.format === "json") {
+    console.log(JSON.stringify(spreadsheet, null, 2));
+  } else {
+    console.log(`Title: ${spreadsheet.properties.title}`);
+    console.log(`ID: ${spreadsheet.spreadsheetId}`);
+    console.log(`Locale: ${spreadsheet.properties.locale || "N/A"}`);
+    console.log(`Timezone: ${spreadsheet.properties.timeZone || "N/A"}`);
+    console.log(`Sheets: ${spreadsheet.sheets.length}`);
+    if (spreadsheet.spreadsheetUrl) {
+      console.log(`URL: ${spreadsheet.spreadsheetUrl}`);
     }
+  }
 }
 async function cmdList(spreadsheetId, options) {
-    const authConfig = await getAuthConfig(options);
-    const client = createClient({ auth: authConfig });
-    const sheets = await client.getSheets(spreadsheetId);
-    if (options.format === 'json') {
-        console.log(JSON.stringify(sheets, null, 2));
-    }
-    else {
-        console.log('Sheets:');
-        sheets.forEach((sheet) => {
-            const grid = sheet.gridProperties;
-            const size = grid ? ` (${grid.rowCount} x ${grid.columnCount})` : '';
-            const hidden = sheet.hidden ? ' [hidden]' : '';
-            console.log(`  ${sheet.index}. ${sheet.title}${size}${hidden}`);
-            console.log(`     gid: ${sheet.sheetId}`);
-        });
-    }
+  const authConfig = await getAuthConfig(options);
+  const client = createClient({ auth: authConfig });
+  const sheets = await client.getSheets(spreadsheetId);
+  if (options.format === "json") {
+    console.log(JSON.stringify(sheets, null, 2));
+  } else {
+    console.log("Sheets:");
+    sheets.forEach((sheet) => {
+      const grid = sheet.gridProperties;
+      const size = grid ? ` (${grid.rowCount} x ${grid.columnCount})` : "";
+      const hidden = sheet.hidden ? " [hidden]" : "";
+      console.log(`  ${sheet.index}. ${sheet.title}${size}${hidden}`);
+      console.log(`     gid: ${sheet.sheetId}`);
+    });
+  }
 }
 async function cmdRead(spreadsheetId, range, options) {
-    const authConfig = await getAuthConfig(options);
-    const client = createClient({ auth: authConfig });
-    // Resolve sheet name from index or gid if provided
-    let resolvedRange = range;
-    if (options.sheetIndex !== undefined || options.gid !== undefined) {
-        const sheets = await client.getSheets(spreadsheetId);
-        let targetSheet;
-        if (options.sheetIndex !== undefined) {
-            targetSheet = sheets.find(s => s.index === options.sheetIndex);
-            if (!targetSheet) {
-                throw new Error(`Sheet index ${options.sheetIndex} not found. Use 'sheets list' to see available sheets.`);
-            }
-        }
-        else if (options.gid !== undefined) {
-            targetSheet = sheets.find(s => s.sheetId === options.gid);
-            if (!targetSheet) {
-                throw new Error(`Sheet with gid ${options.gid} not found. Use 'sheets list' to see available sheets.`);
-            }
-        }
-        if (targetSheet) {
-            // Escape single quotes in sheet name and wrap in quotes
-            const escapedTitle = targetSheet.title.replace(/'/g, "''");
-            resolvedRange = `'${escapedTitle}'!${range}`;
-        }
+  const authConfig = await getAuthConfig(options);
+  const client = createClient({ auth: authConfig });
+  let resolvedRange = range;
+  if (options.sheetIndex !== void 0 || options.gid !== void 0) {
+    const sheets = await client.getSheets(spreadsheetId);
+    let targetSheet;
+    if (options.sheetIndex !== void 0) {
+      targetSheet = sheets.find((s) => s.index === options.sheetIndex);
+      if (!targetSheet) {
+        throw new Error(`Sheet index ${options.sheetIndex} not found. Use 'sheets list' to see available sheets.`);
+      }
+    } else if (options.gid !== void 0) {
+      targetSheet = sheets.find((s) => s.sheetId === options.gid);
+      if (!targetSheet) {
+        throw new Error(`Sheet with gid ${options.gid} not found. Use 'sheets list' to see available sheets.`);
+      }
     }
-    const valueRange = options.formula
-        ? await client.getFormulas(spreadsheetId, resolvedRange)
-        : await client.getValues(spreadsheetId, resolvedRange);
-    if (options.format === 'json') {
-        console.log(JSON.stringify(valueRange, null, 2));
-    }
-    else {
-        console.log(`Range: ${valueRange.range}`);
-        console.log('');
-        if (valueRange.values.length === 0) {
-            console.log('(empty)');
-            return;
-        }
-        // Calculate column widths
-        const colWidths = [];
-        valueRange.values.forEach(row => {
-            row.forEach((cell, i) => {
-                const len = String(cell.value ?? '').length;
-                colWidths[i] = Math.max(colWidths[i] || 0, len, 3);
-            });
-        });
-        // Print table
-        valueRange.values.forEach(row => {
-            const cells = row.map((cell, i) => {
-                const val = String(cell.value ?? '');
-                return val.padEnd(colWidths[i]);
-            });
-            console.log(cells.join(' | '));
-        });
+    if (targetSheet) {
+      const escapedTitle = targetSheet.title.replace(/'/g, "''");
+      resolvedRange = `'${escapedTitle}'!${range}`;
+    }
+  }
+  const valueRange = options.formula ? await client.getFormulas(spreadsheetId, resolvedRange) : await client.getValues(spreadsheetId, resolvedRange);
+  if (options.format === "json") {
+    console.log(JSON.stringify(valueRange, null, 2));
+  } else {
+    console.log(`Range: ${valueRange.range}`);
+    console.log("");
+    if (valueRange.values.length === 0) {
+      console.log("(empty)");
+      return;
     }
+    const colWidths = [];
+    valueRange.values.forEach((row) => {
+      row.forEach((cell, i) => {
+        const len = String(cell.value ?? "").length;
+        colWidths[i] = Math.max(colWidths[i] || 0, len, 3);
+      });
+    });
+    valueRange.values.forEach((row) => {
+      const cells = row.map((cell, i) => {
+        const val = String(cell.value ?? "");
+        return val.padEnd(colWidths[i]);
+      });
+      console.log(cells.join(" | "));
+    });
+  }
 }
 async function cmdClear(spreadsheetId, ranges, options) {
-    const authConfig = await getAuthConfig(options);
-    const client = createClient({ auth: authConfig });
-    // Resolve sheet name from index or gid if provided
-    let resolvedRanges = ranges;
-    if (options.sheetIndex !== undefined || options.gid !== undefined) {
-        const sheets = await client.getSheets(spreadsheetId);
-        let targetSheet;
-        if (options.sheetIndex !== undefined) {
-            targetSheet = sheets.find(s => s.index === options.sheetIndex);
-            if (!targetSheet) {
-                throw new Error(`Sheet index ${options.sheetIndex} not found. Use 'sheets list' to see available sheets.`);
-            }
-        }
-        else if (options.gid !== undefined) {
-            targetSheet = sheets.find(s => s.sheetId === options.gid);
-            if (!targetSheet) {
-                throw new Error(`Sheet with gid ${options.gid} not found. Use 'sheets list' to see available sheets.`);
-            }
-        }
-        if (targetSheet) {
-            // Escape single quotes in sheet name and wrap in quotes
-            const escapedTitle = targetSheet.title.replace(/'/g, "''");
-            resolvedRanges = ranges.map(range => `'${escapedTitle}'!${range}`);
-        }
-    }
-    const result = await client.batchClearValues(spreadsheetId, resolvedRanges);
-    if (options.format === 'json') {
-        console.log(JSON.stringify(result, null, 2));
+  const authConfig = await getAuthConfig(options);
+  const client = createClient({ auth: authConfig });
+  let resolvedRanges = ranges;
+  if (options.sheetIndex !== void 0 || options.gid !== void 0) {
+    const sheets = await client.getSheets(spreadsheetId);
+    let targetSheet;
+    if (options.sheetIndex !== void 0) {
+      targetSheet = sheets.find((s) => s.index === options.sheetIndex);
+      if (!targetSheet) {
+        throw new Error(`Sheet index ${options.sheetIndex} not found. Use 'sheets list' to see available sheets.`);
+      }
+    } else if (options.gid !== void 0) {
+      targetSheet = sheets.find((s) => s.sheetId === options.gid);
+      if (!targetSheet) {
+        throw new Error(`Sheet with gid ${options.gid} not found. Use 'sheets list' to see available sheets.`);
+      }
     }
-    else {
-        console.log('Cleared ranges:');
-        result.clearedRanges.forEach(range => {
-            console.log(`  - ${range}`);
-        });
+    if (targetSheet) {
+      const escapedTitle = targetSheet.title.replace(/'/g, "''");
+      resolvedRanges = ranges.map((range) => `'${escapedTitle}'!${range}`);
     }
+  }
+  const result = await client.batchClearValues(spreadsheetId, resolvedRanges);
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log("Cleared ranges:");
+    result.clearedRanges.forEach((range) => {
+      console.log(`  - ${range}`);
+    });
+  }
 }
 async function parseWriteValues(valuesArg, inputPath) {
-    let jsonStr;
-    if (inputPath) {
-        if (inputPath === '-') {
-            // Read from stdin
-            const chunks = [];
-            for await (const chunk of process.stdin) {
-                chunks.push(chunk);
-            }
-            jsonStr = Buffer.concat(chunks).toString('utf-8').trim();
-        }
-        else {
-            jsonStr = await fs.readFile(inputPath, 'utf-8');
-        }
-    }
-    else if (valuesArg) {
-        jsonStr = valuesArg;
-    }
-    else {
-        throw new Error('No values provided. Use inline JSON or --input <file>');
+  let jsonStr;
+  if (inputPath) {
+    if (inputPath === "-") {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      jsonStr = Buffer.concat(chunks).toString("utf-8").trim();
+    } else {
+      jsonStr = await fs3.readFile(inputPath, "utf-8");
     }
-    // Try to parse as JSON array
-    try {
-        const parsed = JSON.parse(jsonStr);
-        // If it's a 2D array, return as-is
-        if (Array.isArray(parsed) && (parsed.length === 0 || Array.isArray(parsed[0]))) {
-            return parsed;
-        }
-        // If it's a 1D array, wrap it
-        if (Array.isArray(parsed)) {
-            return [parsed];
-        }
-        // Single value
-        return [[parsed]];
+  } else if (valuesArg) {
+    jsonStr = valuesArg;
+  } else {
+    throw new Error("No values provided. Use inline JSON or --input <file>");
+  }
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (Array.isArray(parsed) && (parsed.length === 0 || Array.isArray(parsed[0]))) {
+      return parsed;
     }
-    catch {
-        // Not JSON - treat as single string value
-        return [[jsonStr]];
+    if (Array.isArray(parsed)) {
+      return [parsed];
     }
+    return [[parsed]];
+  } catch {
+    return [[jsonStr]];
+  }
 }
 async function cmdWrite(spreadsheetId, range, valuesArg, options) {
-    const authConfig = await getAuthConfig(options);
-    const client = createClient({ auth: authConfig });
-    // Resolve sheet name from index or gid if provided
-    let resolvedRange = range;
-    if (options.sheetIndex !== undefined || options.gid !== undefined) {
-        const sheets = await client.getSheets(spreadsheetId);
-        let targetSheet;
-        if (options.sheetIndex !== undefined) {
-            targetSheet = sheets.find(s => s.index === options.sheetIndex);
-            if (!targetSheet) {
-                throw new Error(`Sheet index ${options.sheetIndex} not found.`);
-            }
-        }
-        else if (options.gid !== undefined) {
-            targetSheet = sheets.find(s => s.sheetId === options.gid);
-            if (!targetSheet) {
-                throw new Error(`Sheet with gid ${options.gid} not found.`);
-            }
-        }
-        if (targetSheet) {
-            const escapedTitle = targetSheet.title.replace(/'/g, "''");
-            resolvedRange = `'${escapedTitle}'!${range}`;
-        }
-    }
-    const values = await parseWriteValues(valuesArg, options.input);
-    const result = await client.updateValues(spreadsheetId, resolvedRange, values, {
-        valueInputOption: options.raw ? 'RAW' : 'USER_ENTERED',
-        majorDimension: options.byColumns ? 'COLUMNS' : 'ROWS',
-    });
-    if (options.format === 'json') {
-        console.log(JSON.stringify(result, null, 2));
+  const authConfig = await getAuthConfig(options);
+  const client = createClient({ auth: authConfig });
+  let resolvedRange = range;
+  if (options.sheetIndex !== void 0 || options.gid !== void 0) {
+    const sheets = await client.getSheets(spreadsheetId);
+    let targetSheet;
+    if (options.sheetIndex !== void 0) {
+      targetSheet = sheets.find((s) => s.index === options.sheetIndex);
+      if (!targetSheet) {
+        throw new Error(`Sheet index ${options.sheetIndex} not found.`);
+      }
+    } else if (options.gid !== void 0) {
+      targetSheet = sheets.find((s) => s.sheetId === options.gid);
+      if (!targetSheet) {
+        throw new Error(`Sheet with gid ${options.gid} not found.`);
+      }
     }
-    else {
-        console.log(`Updated: ${result.updatedRange}`);
-        console.log(`  Rows: ${result.updatedRows}`);
-        console.log(`  Columns: ${result.updatedColumns}`);
-        console.log(`  Cells: ${result.updatedCells}`);
+    if (targetSheet) {
+      const escapedTitle = targetSheet.title.replace(/'/g, "''");
+      resolvedRange = `'${escapedTitle}'!${range}`;
     }
+  }
+  const values = await parseWriteValues(valuesArg, options.input);
+  const result = await client.updateValues(spreadsheetId, resolvedRange, values, {
+    valueInputOption: options.raw ? "RAW" : "USER_ENTERED",
+    majorDimension: options.byColumns ? "COLUMNS" : "ROWS"
+  });
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`Updated: ${result.updatedRange}`);
+    console.log(`  Rows: ${result.updatedRows}`);
+    console.log(`  Columns: ${result.updatedColumns}`);
+    console.log(`  Cells: ${result.updatedCells}`);
+  }
 }
 async function cmdAppend(spreadsheetId, range, valuesArg, options) {
-    const authConfig = await getAuthConfig(options);
-    const client = createClient({ auth: authConfig });
-    // Resolve sheet name from index or gid
-    let resolvedRange = range;
-    if (options.sheetIndex !== undefined || options.gid !== undefined) {
-        const sheets = await client.getSheets(spreadsheetId);
-        let targetSheet;
-        if (options.sheetIndex !== undefined) {
-            targetSheet = sheets.find(s => s.index === options.sheetIndex);
-            if (!targetSheet) {
-                throw new Error(`Sheet index ${options.sheetIndex} not found.`);
-            }
-        }
-        else if (options.gid !== undefined) {
-            targetSheet = sheets.find(s => s.sheetId === options.gid);
-            if (!targetSheet) {
-                throw new Error(`Sheet with gid ${options.gid} not found.`);
-            }
-        }
-        if (targetSheet) {
-            const escapedTitle = targetSheet.title.replace(/'/g, "''");
-            resolvedRange = `'${escapedTitle}'!${range}`;
-        }
+  const authConfig = await getAuthConfig(options);
+  const client = createClient({ auth: authConfig });
+  let resolvedRange = range;
+  if (options.sheetIndex !== void 0 || options.gid !== void 0) {
+    const sheets = await client.getSheets(spreadsheetId);
+    let targetSheet;
+    if (options.sheetIndex !== void 0) {
+      targetSheet = sheets.find((s) => s.index === options.sheetIndex);
+      if (!targetSheet) {
+        throw new Error(`Sheet index ${options.sheetIndex} not found.`);
+      }
+    } else if (options.gid !== void 0) {
+      targetSheet = sheets.find((s) => s.sheetId === options.gid);
+      if (!targetSheet) {
+        throw new Error(`Sheet with gid ${options.gid} not found.`);
+      }
     }
-    const values = await parseWriteValues(valuesArg, options.input);
-    const result = await client.appendValues(spreadsheetId, resolvedRange, values, {
-        valueInputOption: options.raw ? 'RAW' : 'USER_ENTERED',
-        majorDimension: options.byColumns ? 'COLUMNS' : 'ROWS',
-        insertDataOption: options.insertRows ? 'INSERT_ROWS' : 'OVERWRITE',
-    });
-    if (options.format === 'json') {
-        console.log(JSON.stringify(result, null, 2));
+    if (targetSheet) {
+      const escapedTitle = targetSheet.title.replace(/'/g, "''");
+      resolvedRange = `'${escapedTitle}'!${range}`;
     }
-    else {
-        console.log(`Appended to: ${result.updates.updatedRange}`);
-        if (result.tableRange) {
-            console.log(`  Table range: ${result.tableRange}`);
-        }
-        console.log(`  Rows: ${result.updates.updatedRows}`);
-        console.log(`  Columns: ${result.updates.updatedColumns}`);
-        console.log(`  Cells: ${result.updates.updatedCells}`);
+  }
+  const values = await parseWriteValues(valuesArg, options.input);
+  const result = await client.appendValues(spreadsheetId, resolvedRange, values, {
+    valueInputOption: options.raw ? "RAW" : "USER_ENTERED",
+    majorDimension: options.byColumns ? "COLUMNS" : "ROWS",
+    insertDataOption: options.insertRows ? "INSERT_ROWS" : "OVERWRITE"
+  });
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`Appended to: ${result.updates.updatedRange}`);
+    if (result.tableRange) {
+      console.log(`  Table range: ${result.tableRange}`);
     }
+    console.log(`  Rows: ${result.updates.updatedRows}`);
+    console.log(`  Columns: ${result.updates.updatedColumns}`);
+    console.log(`  Cells: ${result.updates.updatedCells}`);
+  }
 }
 async function cmdSearch(spreadsheetId, query, range, options) {
-    const authConfig = await getAuthConfig(options);
-    const client = createClient({ auth: authConfig });
-    const result = await client.searchValues(spreadsheetId, query, {
-        range,
-        sheetIndex: options.sheetIndex,
-        gid: options.gid,
-        caseSensitive: options.caseSensitive,
-        exactMatch: options.exact,
-        regex: options.regex,
-        limit: options.limit,
-    });
-    if (options.format === 'json') {
-        console.log(JSON.stringify(result, null, 2));
-    }
-    else {
-        if (result.matches.length === 0) {
-            console.log(`No matches found for "${query}"`);
-            return;
-        }
-        console.log(`Found ${result.totalMatches} match${result.totalMatches === 1 ? '' : 'es'} for "${query}":`);
-        console.log('');
-        // Calculate column widths
-        const headers = ['Sheet', 'Address', 'Row', 'Col', 'Value'];
-        const colWidths = headers.map(h => h.length);
-        result.matches.forEach(m => {
-            colWidths[0] = Math.max(colWidths[0], m.sheet.length);
-            colWidths[1] = Math.max(colWidths[1], m.address.length);
-            colWidths[2] = Math.max(colWidths[2], String(m.row).length);
-            colWidths[3] = Math.max(colWidths[3], String(m.column).length);
-            const valueStr = String(m.value ?? '').substring(0, 50);
-            colWidths[4] = Math.max(colWidths[4], valueStr.length);
-        });
-        // Print header
-        console.log(headers.map((h, i) => h.padEnd(colWidths[i])).join(' | '));
-        console.log(colWidths.map(w => '-'.repeat(w)).join('-+-'));
-        // Print matches
-        result.matches.forEach(m => {
-            const valueStr = String(m.value ?? '').substring(0, 50);
-            const row = [
-                m.sheet.padEnd(colWidths[0]),
-                m.address.padEnd(colWidths[1]),
-                String(m.row).padEnd(colWidths[2]),
-                String(m.column).padEnd(colWidths[3]),
-                valueStr.padEnd(colWidths[4]),
-            ];
-            console.log(row.join(' | '));
-        });
+  const authConfig = await getAuthConfig(options);
+  const client = createClient({ auth: authConfig });
+  const result = await client.searchValues(spreadsheetId, query, {
+    range,
+    sheetIndex: options.sheetIndex,
+    gid: options.gid,
+    caseSensitive: options.caseSensitive,
+    exactMatch: options.exact,
+    regex: options.regex,
+    limit: options.limit
+  });
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    if (result.matches.length === 0) {
+      console.log(`No matches found for "${query}"`);
+      return;
     }
+    console.log(`Found ${result.totalMatches} match${result.totalMatches === 1 ? "" : "es"} for "${query}":`);
+    console.log("");
+    const headers = ["Sheet", "Address", "Row", "Col", "Value"];
+    const colWidths = headers.map((h) => h.length);
+    result.matches.forEach((m) => {
+      colWidths[0] = Math.max(colWidths[0], m.sheet.length);
+      colWidths[1] = Math.max(colWidths[1], m.address.length);
+      colWidths[2] = Math.max(colWidths[2], String(m.row).length);
+      colWidths[3] = Math.max(colWidths[3], String(m.column).length);
+      const valueStr = String(m.value ?? "").substring(0, 50);
+      colWidths[4] = Math.max(colWidths[4], valueStr.length);
+    });
+    console.log(headers.map((h, i) => h.padEnd(colWidths[i])).join(" | "));
+    console.log(colWidths.map((w) => "-".repeat(w)).join("-+-"));
+    result.matches.forEach((m) => {
+      const valueStr = String(m.value ?? "").substring(0, 50);
+      const row = [
+        m.sheet.padEnd(colWidths[0]),
+        m.address.padEnd(colWidths[1]),
+        String(m.row).padEnd(colWidths[2]),
+        String(m.column).padEnd(colWidths[3]),
+        valueStr.padEnd(colWidths[4])
+      ];
+      console.log(row.join(" | "));
+    });
+  }
 }
-// === Main ===
 async function main() {
-    const { command, positionals, options } = parseArgs(process.argv.slice(2));
-    if (!command || command === 'help' || command === '--help') {
-        printHelp();
-        return;
-    }
-    if (command === '--version') {
-        printVersion();
-        return;
-    }
-    try {
-        switch (command) {
-            case 'login':
-                await cmdLogin(options);
-                break;
-            case 'logout':
-                await cmdLogout();
-                break;
-            case 'whoami':
-                await cmdWhoami();
-                break;
-            case 'auth': {
-                const credentialsPath = positionals[0];
-                if (!credentialsPath) {
-                    console.error('Usage: sheets auth <credentials-file>');
-                    process.exit(1);
-                }
-                await cmdAuth(credentialsPath);
-                break;
-            }
-            case 'get': {
-                const spreadsheetId = positionals[0];
-                if (!spreadsheetId) {
-                    console.error('Usage: sheets get <spreadsheet-id>');
-                    process.exit(1);
-                }
-                await cmdGet(spreadsheetId, options);
-                break;
-            }
-            case 'list': {
-                const spreadsheetId = positionals[0];
-                if (!spreadsheetId) {
-                    console.error('Usage: sheets list <spreadsheet-id>');
-                    process.exit(1);
-                }
-                await cmdList(spreadsheetId, options);
-                break;
-            }
-            case 'read': {
-                const spreadsheetId = positionals[0];
-                const range = positionals[1];
-                if (!spreadsheetId || !range) {
-                    console.error('Usage: sheets read <spreadsheet-id> <range>');
-                    process.exit(1);
-                }
-                await cmdRead(spreadsheetId, range, options);
-                break;
-            }
-            case 'write': {
-                const spreadsheetId = positionals[0];
-                const range = positionals[1];
-                const values = positionals[2];
-                if (!spreadsheetId || !range) {
-                    console.error('Usage: sheets write <spreadsheet-id> <range> [values]');
-                    console.error('       sheets write <id> <range> --input <file>');
-                    process.exit(1);
-                }
-                await cmdWrite(spreadsheetId, range, values, options);
-                break;
-            }
-            case 'append': {
-                const spreadsheetId = positionals[0];
-                const range = positionals[1];
-                const values = positionals[2];
-                if (!spreadsheetId || !range) {
-                    console.error('Usage: sheets append <spreadsheet-id> <range> [values]');
-                    console.error('       sheets append <id> <range> --input <file>');
-                    process.exit(1);
-                }
-                await cmdAppend(spreadsheetId, range, values, options);
-                break;
-            }
-            case 'clear': {
-                const spreadsheetId = positionals[0];
-                const ranges = positionals.slice(1);
-                if (!spreadsheetId || ranges.length === 0) {
-                    console.error('Usage: sheets clear <spreadsheet-id> <range> [range2] [range3] ...');
-                    process.exit(1);
-                }
-                await cmdClear(spreadsheetId, ranges, options);
-                break;
-            }
-            case 'search': {
-                const spreadsheetId = positionals[0];
-                const query = positionals[1];
-                const range = positionals[2];
-                if (!spreadsheetId || !query) {
-                    console.error('Usage: sheets search <spreadsheet-id> <query> [range]');
-                    console.error('       sheets search <id> "search term" "Sheet1!A1:D100"');
-                    process.exit(1);
-                }
-                await cmdSearch(spreadsheetId, query, range, options);
-                break;
-            }
-            case 'install-claude-skill':
-                await cmdInstallClaudeSkill();
-                break;
-            default:
-                console.error(`Unknown command: ${command}`);
-                printHelp();
-                process.exit(1);
+  const { command, positionals, options } = parseArgs(process.argv.slice(2));
+  if (!command || command === "help" || command === "--help") {
+    printHelp();
+    return;
+  }
+  if (command === "--version") {
+    printVersion();
+    return;
+  }
+  try {
+    switch (command) {
+      case "login":
+        await cmdLogin(options);
+        break;
+      case "logout":
+        await cmdLogout();
+        break;
+      case "whoami":
+        await cmdWhoami();
+        break;
+      case "auth": {
+        const credentialsPath = positionals[0];
+        if (!credentialsPath) {
+          console.error("Usage: sheets auth <credentials-file>");
+          process.exit(1);
         }
-    }
-    catch (error) {
-        const e = error;
-        console.error(`Error: ${e.message}`);
-        // Check if this is a SheetsError with additional context
-        if (e.name === 'SheetsError') {
-            const sheetsErr = e;
-            if (sheetsErr.status) {
-                console.error(`Status: ${sheetsErr.status}`);
-            }
+        await cmdAuth(credentialsPath);
+        break;
+      }
+      case "get": {
+        const spreadsheetId = positionals[0];
+        if (!spreadsheetId) {
+          console.error("Usage: sheets get <spreadsheet-id>");
+          process.exit(1);
+        }
+        await cmdGet(spreadsheetId, options);
+        break;
+      }
+      case "list": {
+        const spreadsheetId = positionals[0];
+        if (!spreadsheetId) {
+          console.error("Usage: sheets list <spreadsheet-id>");
+          process.exit(1);
+        }
+        await cmdList(spreadsheetId, options);
+        break;
+      }
+      case "read": {
+        const spreadsheetId = positionals[0];
+        const range = positionals[1];
+        if (!spreadsheetId || !range) {
+          console.error("Usage: sheets read <spreadsheet-id> <range>");
+          process.exit(1);
+        }
+        await cmdRead(spreadsheetId, range, options);
+        break;
+      }
+      case "write": {
+        const spreadsheetId = positionals[0];
+        const range = positionals[1];
+        const values = positionals[2];
+        if (!spreadsheetId || !range) {
+          console.error("Usage: sheets write <spreadsheet-id> <range> [values]");
+          console.error("       sheets write <id> <range> --input <file>");
+          process.exit(1);
         }
-        // Get the range from positionals if available
+        await cmdWrite(spreadsheetId, range, values, options);
+        break;
+      }
+      case "append": {
+        const spreadsheetId = positionals[0];
         const range = positionals[1];
-        const suggestions = getRangeErrorSuggestions(e.message, range);
-        if (suggestions.length > 0) {
-            console.error('');
-            console.error('Suggestions:');
-            suggestions.forEach(s => console.error(`  - ${s}`));
+        const values = positionals[2];
+        if (!spreadsheetId || !range) {
+          console.error("Usage: sheets append <spreadsheet-id> <range> [values]");
+          console.error("       sheets append <id> <range> --input <file>");
+          process.exit(1);
+        }
+        await cmdAppend(spreadsheetId, range, values, options);
+        break;
+      }
+      case "clear": {
+        const spreadsheetId = positionals[0];
+        const ranges = positionals.slice(1);
+        if (!spreadsheetId || ranges.length === 0) {
+          console.error("Usage: sheets clear <spreadsheet-id> <range> [range2] [range3] ...");
+          process.exit(1);
+        }
+        await cmdClear(spreadsheetId, ranges, options);
+        break;
+      }
+      case "search": {
+        const spreadsheetId = positionals[0];
+        const query = positionals[1];
+        const range = positionals[2];
+        if (!spreadsheetId || !query) {
+          console.error("Usage: sheets search <spreadsheet-id> <query> [range]");
+          console.error('       sheets search <id> "search term" "Sheet1!A1:D100"');
+          process.exit(1);
         }
+        await cmdSearch(spreadsheetId, query, range, options);
+        break;
+      }
+      case "install-claude-skill":
+        await cmdInstallClaudeSkill();
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
         process.exit(1);
     }
+  } catch (error) {
+    const e = error;
+    console.error(`Error: ${e.message}`);
+    if (e.name === "SheetsError") {
+      const sheetsErr = e;
+      if (sheetsErr.status) {
+        console.error(`Status: ${sheetsErr.status}`);
+      }
+    }
+    const range = positionals[1];
+    const suggestions = getRangeErrorSuggestions(e.message, range);
+    if (suggestions.length > 0) {
+      console.error("");
+      console.error("Suggestions:");
+      suggestions.forEach((s) => console.error(`  - ${s}`));
+    }
+    process.exit(1);
+  }
 }
 main();
 //# sourceMappingURL=cli.js.map