@ariadng/sheets 0.1.1 → 0.3.0

package/README.md

@@ -1,439 +1,593 @@
-# Sheets
+# @ariadng/sheets
 
-A pragmatic TypeScript client for Google Sheets API v4 with stellar performance, that provides essential features without over-engineering. Start simple and add complexity only when needed.
+A command-line tool and library for reading Google Sheets. Works with personal Google accounts and service accounts.
 
-## Features
+## For AI Agents
 
-- **Progressive Enhancement** - Start with core features, add more as needed
-- **Modular Packages** - Core (~3KB), Plus (~5KB), Advanced (~2KB)
-- **Smart Retry Logic** - Exponential backoff with jitter
-- **Optional Caching** - Reduce API calls with configurable TTL
-- **Type Safety** - Full TypeScript support with type utilities
-- **Rate Limiting** - Adaptive or token bucket strategies
-- **Metrics Collection** - Track performance and errors
-- **Batch Operations** - Efficient bulk reads/writes
+If you are an AI agent (Claude, GPT, Copilot, or other AI assistants), use the npx version of this tool. This allows you to run commands without installing the package globally.
+
+**Authentication**: Before reading spreadsheets, the user must be logged in. Check login status first, then prompt the user to login if needed.
+
+```bash
+# Check if user is logged in
+npx @ariadng/sheets whoami
+
+# If not logged in, ask user to run this command
+npx @ariadng/sheets login
+```
+
+**Reading data**: Use `--format json` for structured output that is easier to parse.
+
+```bash
+# Get spreadsheet metadata
+npx @ariadng/sheets get SPREADSHEET_ID --format json
+
+# List all sheets
+npx @ariadng/sheets list SPREADSHEET_ID --format json
+
+# Read cell values
+npx @ariadng/sheets read SPREADSHEET_ID "Sheet1!A1:D10" --format json
+
+# Read formulas instead of values
+npx @ariadng/sheets read SPREADSHEET_ID "Sheet1!A1:D10" --formula --format json
+```
+
+**Getting the spreadsheet ID**: Extract the ID from the Google Sheets URL. The URL format is `https://docs.google.com/spreadsheets/d/SPREADSHEET_ID/edit`. The spreadsheet ID is the string between `/d/` and `/edit`.
+
+## What This Tool Does
+
+- Read data from Google Sheets spreadsheets
+- View spreadsheet information and sheet lists
+- Read cell values or formulas
+- Authenticate with your Google account or a service account
+
+## Requirements
+
+- Node.js version 18 or higher
+- A Google account (for personal use) or a Google Cloud service account
 
 ## Installation
 
 ```bash
-# Core package only
-npm install @ariadng/sheets
+npm install -g @ariadng/sheets
+```
 
-# With specific packages
-npm install @ariadng/sheets
+After installation, the `sheets` command will be available in your terminal.
+
+## Usage Summary
+
+| Command | Description |
+|---------|-------------|
+| `sheets login` | Login with Google account |
+| `sheets logout` | Remove saved login |
+| `sheets whoami` | Show current login status |
+| `sheets auth <file>` | Test service account credentials |
+| `sheets get <id>` | Get spreadsheet metadata |
+| `sheets list <id>` | List sheets in spreadsheet |
+| `sheets read <id> <range>` | Read cell values |
+| `sheets read <id> <range> --formula` | Read formulas |
+| `sheets read <id> <range> --format json` | Output as JSON |
+| `sheets install-claude-skill` | Install Claude Code skill |
+
+## Using with npx
+
+You can also run this tool without installing it:
+
+```bash
+npx @ariadng/sheets login
+npx @ariadng/sheets read SPREADSHEET_ID "Sheet1!A1:D10"
 ```
 
-## Quick Start
+## Claude Code Integration
 
-### Basic Usage
+This tool includes a Claude Skill that teaches Claude Code how to use the sheets CLI. To install the skill:
 
-```typescript
-import { GoogleSheetsCore, createServiceAccountAuth } from '@ariadng/sheets/core';
+```bash
+sheets install-claude-skill
+```
 
-// Setup with service account
-const auth = await createServiceAccountAuth('./service-account-key.json');
-const sheets = new GoogleSheetsCore({ auth });
+Or with npx:
 
-// Simple read
-const data = await sheets.read('spreadsheetId', 'Sheet1!A1:B10');
-console.log(data); // [[value1, value2], [value3, value4], ...]
+```bash
+npx @ariadng/sheets install-claude-skill
+```
 
-// Simple write
-await sheets.write('spreadsheetId', 'Sheet1!A1:B2', [
-  ['Name', 'Score'],
-  ['Alice', 100]
-]);
+After installation, you can use `/sheets` in Claude Code to read Google Sheets data. The skill is installed to `~/.claude/skills/sheets/SKILL.md`.
+
+## Getting Started
+
+### Step 1: Login to Your Google Account
+
+Run this command to connect your Google account:
+
+```bash
+sheets login
 ```
 
-### With Caching
+This will:
+1. Open your web browser
+2. Ask you to sign in to your Google account
+3. Ask you to allow the app to read your spreadsheets
+4. Save your login for future use
 
-```typescript
-import { withCache } from '@ariadng/sheets/plus';
+After login, you will see your email address displayed.
 
-const cachedSheets = withCache(sheets, {
-  ttlSeconds: 300 // 5-minute cache
-});
+### Step 2: Read a Spreadsheet
 
-// First read hits API
-const data1 = await cachedSheets.read(id, 'A1:B10');
+Find the spreadsheet ID from your Google Sheets URL. The URL looks like this:
 
-// Second read uses cache (within 5 minutes)
-const data2 = await cachedSheets.read(id, 'A1:B10'); // Much faster!
+```
+https://docs.google.com/spreadsheets/d/SPREADSHEET_ID/edit
 ```
 
-### With Rate Limiting
+The spreadsheet ID is the long string of letters and numbers between `/d/` and `/edit`.
 
-```typescript
-import { withAdaptiveRateLimit } from '@ariadng/sheets/advanced';
+Now you can read data:
 
-const rateLimitedSheets = withAdaptiveRateLimit(sheets);
+```bash
+# Get spreadsheet information
+sheets get SPREADSHEET_ID
 
-// Automatically handles rate limits
-for (let i = 0; i < 1000; i++) {
-  await rateLimitedSheets.read(id, `A${i}`);
-  // Automatically slows down if hitting limits
-}
+# List all sheets in the spreadsheet
+sheets list SPREADSHEET_ID
+
+# Read cells from a range
+sheets read SPREADSHEET_ID "Sheet1!A1:D10"
 ```
 
 ## Authentication
 
-### Service Account
+This tool supports three ways to authenticate:
 
-```typescript
-import { createServiceAccountAuth } from '@ariadng/sheets/core';
+### 1. Personal Google Account (Recommended for Most Users)
 
-// From file
-const auth = await createServiceAccountAuth('./service-account.json');
+Use the `login` command to authenticate with your personal Google account:
 
-// From object
-const auth = await createServiceAccountAuth({
-  client_email: 'your-service-account@project.iam.gserviceaccount.com',
-  private_key: '-----BEGIN PRIVATE KEY-----...',
-  // ... other fields
-});
+```bash
+sheets login
 ```
 
-### OAuth2
+Your login will be saved and used automatically for future commands. To check your login status:
 
-```typescript
-import { createOAuth2Client, generateAuthUrl, getTokenFromCode } from '@ariadng/sheets/core';
+```bash
+sheets whoami
+```
 
-const client = await createOAuth2Client({
-  client_id: 'your-client-id',
-  client_secret: 'your-client-secret',
-  redirect_uris: ['http://localhost:3000/callback']
-});
+To remove your saved login:
 
-// Generate auth URL
-const authUrl = generateAuthUrl(client);
-console.log('Visit:', authUrl);
+```bash
+sheets logout
+```
 
-// After user authorizes, exchange code for token
-const tokens = await getTokenFromCode(client, authorizationCode);
+### 2. Service Account (For Automated Systems)
+
+Service accounts are special Google accounts for applications and scripts. To use a service account:
+
+1. Create a service account in Google Cloud Console
+2. Download the JSON credentials file
+3. Share your spreadsheet with the service account email address
+4. Use the `--credentials` option with commands:
+
+```bash
+sheets get SPREADSHEET_ID --credentials path/to/credentials.json
 ```
 
-## Core Features
+To test if your service account credentials are valid:
 
-### CRUD Operations
+```bash
+sheets auth path/to/credentials.json
+```
 
-```typescript
-// Read
-const values = await sheets.read(spreadsheetId, 'Sheet1!A1:C10');
+### 3. Access Token (For Advanced Use)
 
-// Write (replaces existing data)
-await sheets.write(spreadsheetId, 'Sheet1!A1:C3', [
-  ['Header1', 'Header2', 'Header3'],
-  ['Value1', 'Value2', 'Value3']
-]);
+If you have an OAuth access token, you can use it directly:
 
-// Append (adds to end)
-await sheets.append(spreadsheetId, 'Sheet1!A:C', [
-  ['New1', 'New2', 'New3']
-]);
+```bash
+sheets get SPREADSHEET_ID --token YOUR_ACCESS_TOKEN
+```
+
+## CLI Commands Reference
+
+### Authentication Commands
 
-// Clear
-await sheets.clear(spreadsheetId, 'Sheet1!A1:C10');
+#### sheets login
+
+Connect your Google account.
+
+```bash
+sheets login
 ```
 
-### Batch Operations
+Options:
+- `--client <file>`: Use custom OAuth client credentials (optional)
 
-```typescript
-// Batch read multiple ranges
-const results = await sheets.batchRead(spreadsheetId, [
-  'Sheet1!A1:B10',
-  'Sheet2!C1:D5'
-]);
+What happens:
+1. Opens your browser to Google sign-in page
+2. Starts a local server on port 8085 to receive the response
+3. Saves your tokens to `~/.sheets/tokens.json`
 
-// Batch write multiple ranges
-await sheets.batchWrite(spreadsheetId, [
-  { range: 'Sheet1!A1:B2', values: [['A', 'B'], ['C', 'D']] },
-  { range: 'Sheet2!A1:B2', values: [['E', 'F'], ['G', 'H']] }
-]);
+#### sheets logout
+
+Remove your saved login.
+
+```bash
+sheets logout
 ```
 
-## Plus Package Features
+This deletes the stored tokens from your computer.
 
-### Type Utilities
+#### sheets whoami
 
-```typescript
-import { A1, TypedSheets, Parsers, Serializers } from '@ariadng/sheets/plus';
-
-// A1 notation utilities
-const col = A1.columnToIndex('C'); // 2
-const letter = A1.indexToColumn(2); // 'C'
-const range = A1.build('Sheet1', 'A', 1, 'C', 10); // 'Sheet1!A1:C10'
-
-// Type-safe operations
-interface User {
-  name: string;
-  email: string;
-  age: number;
-}
+Show your current login status.
+
+```bash
+sheets whoami
+```
+
+Output includes:
+- Your email address
+- Token expiration time
+- Whether the token is still valid
+
+Exit code: 0 if logged in, 1 if not logged in.
+
+#### sheets auth
+
+Test service account credentials.
 
-const typed = new TypedSheets<User[]>(sheets);
-const users = await typed.read(
-  spreadsheetId,
-  'Users!A1:C100',
-  Parsers.rowsToObjects<User>
-);
+```bash
+sheets auth path/to/credentials.json
+```
+
+This validates the credentials file format and shows:
+- Project ID
+- Service account email
+
+### Spreadsheet Commands
+
+#### sheets get
+
+Get spreadsheet information.
 
-// Data transformation
-const objects = [
-  { name: 'Alice', age: 30 },
-  { name: 'Bob', age: 25 }
-];
-const rows = Serializers.objectsToRows(objects);
-// [['name', 'age'], ['Alice', 30], ['Bob', 25]]
+```bash
+sheets get SPREADSHEET_ID
 ```
 
-### Batch Operations Manager
+Options:
+- `--credentials <file>`: Use service account credentials
+- `--token <token>`: Use OAuth access token
+- `--format <format>`: Output format, either `table` (default) or `json`
 
-```typescript
-import { BatchOperations } from '@ariadng/sheets/plus';
+Output includes:
+- Spreadsheet title
+- Spreadsheet ID
+- Locale and timezone
+- Number of sheets
+- Spreadsheet URL
 
-const batchOps = new BatchOperations(sheets);
+#### sheets list
 
-// Automatically chunks large batches
-const operations = Array.from({ length: 500 }, (_, i) => ({
-  range: `Sheet1!A${i}:B${i}`,
-  values: [[`Row${i}`, `Value${i}`]]
-}));
+List all sheets in a spreadsheet.
 
-await batchOps.batchWrite(spreadsheetId, operations); // Handles chunking
+```bash
+sheets list SPREADSHEET_ID
 ```
 
-### Simple Cache
+Options:
+- `--credentials <file>`: Use service account credentials
+- `--token <token>`: Use OAuth access token
+- `--format <format>`: Output format, either `table` (default) or `json`
 
-```typescript
-import { SimpleCache } from '@ariadng/sheets/plus';
+Output includes:
+- Sheet index
+- Sheet title
+- Grid size (rows and columns)
+- Hidden status
 
-const cache = new SimpleCache({
-  ttlSeconds: 60,
-  maxEntries: 100
-});
+#### sheets read
 
-cache.set('key', data);
-const cached = cache.get('key');
-cache.invalidate('pattern*'); // Wildcard invalidation
-cache.clear(); // Clear all
+Read cell values from a spreadsheet range.
+
+```bash
+sheets read SPREADSHEET_ID "Sheet1!A1:D10"
 ```
 
-## Advanced Package Features
+Options:
+- `--credentials <file>`: Use service account credentials
+- `--token <token>`: Use OAuth access token
+- `--format <format>`: Output format, either `table` (default) or `json`
+- `--formula`: Show formulas instead of calculated values
 
-### Adaptive Rate Limiting
+Examples:
 
-```typescript
-import { AdaptiveRateLimiter } from '@ariadng/sheets/advanced';
+```bash
+# Read a range of cells
+sheets read SPREADSHEET_ID "Sheet1!A1:D10"
 
-const limiter = new AdaptiveRateLimiter();
+# Read an entire column
+sheets read SPREADSHEET_ID "Sheet1!A:A"
 
-// Automatically adjusts delay based on success/failure
-await limiter.execute(async () => {
-  return sheets.read(id, range);
-});
+# Read with formulas visible
+sheets read SPREADSHEET_ID "Sheet1!A1:D10" --formula
 
-// Get current stats
-const stats = limiter.getStats();
-console.log(stats); // { requestsInWindow: 45, successRate: 0.98, baseDelay: 0 }
+# Output as JSON
+sheets read SPREADSHEET_ID "Sheet1!A1:D10" --format json
 ```
 
-### Metrics Collection
+Range format:
+- `Sheet1!A1:D10`: Cells A1 through D10 on Sheet1
+- `Sheet1!A:A`: Entire column A on Sheet1
+- `Sheet1!1:1`: Entire row 1 on Sheet1
+- `A1:D10`: Cells A1 through D10 on the first sheet
 
-```typescript
-import { withMetrics } from '@ariadng/sheets/advanced';
+#### sheets install-claude-skill
+
+Install the Claude Code skill for this tool.
+
+```bash
+sheets install-claude-skill
+```
+
+This installs a skill file to `~/.claude/skills/sheets/SKILL.md` that teaches Claude Code how to use the sheets CLI. After installation, you can use `/sheets` in Claude Code.
 
-const metricsSheets = withMetrics(sheets);
+### Global Options
 
-// Use normally
-await metricsSheets.read(id, range);
-await metricsSheets.write(id, range, values);
+These options work with all spreadsheet commands:
 
-// Get metrics
-const metrics = metricsSheets.metrics.getMetrics();
-console.log(metrics);
-// {
-//   totalRequests: 150,
-//   successfulRequests: 148,
-//   failedRequests: 2,
-//   averageLatency: 123.5,
-//   rateLimitHits: 1,
-//   errorsByCode: Map { 429 => 1, 500 => 1 }
-// }
+| Option | Description |
+|--------|-------------|
+| `--credentials <file>` | Path to service account JSON file |
+| `--token <token>` | OAuth access token string |
+| `--format <format>` | Output format: `table` or `json` |
+| `--version` | Show version number |
+| `--help` | Show help message |
 
-const summary = metricsSheets.metrics.getSummary();
-console.log(summary);
-// {
-//   successRate: 0.987,
-//   requestsPerSecond: 2.5,
-//   uptimeSeconds: 60
-// }
+## Library Usage
+
+You can also use this package as a library in your Node.js applications.
+
+### Installation
+
+```bash
+npm install @ariadng/sheets
 ```
 
-## Error Handling
+### Basic Example
 
 ```typescript
-import { GoogleSheetsError } from '@ariadng/sheets/core';
+import { createClient } from '@ariadng/sheets';
 
-try {
-  await sheets.read(spreadsheetId, range);
-} catch (error) {
-  if (error instanceof GoogleSheetsError) {
-    console.error(`API Error ${error.code}: ${error.message}`);
+// Create a client with user authentication (after running "sheets login")
+const client = createClient({
+    auth: { type: 'user' }
+});
 
-    if (error.isRetryable) {
-      console.log('This error is retryable');
-    }
+// Get spreadsheet information
+const spreadsheet = await client.getSpreadsheet('SPREADSHEET_ID');
+console.log(spreadsheet.properties.title);
+
+// Read cell values
+const values = await client.getValues('SPREADSHEET_ID', 'Sheet1!A1:D10');
+console.log(values.values);
+```
 
-    if (error.isPermissionError()) {
-      console.log('Share the sheet with service account');
+### Service Account Example
+
+```typescript
+import { createClient } from '@ariadng/sheets';
+
+const client = createClient({
+    auth: {
+        type: 'service-account',
+        credentialsPath: './credentials.json'
     }
+});
+
+const values = await client.getValues('SPREADSHEET_ID', 'Sheet1!A1:D10');
+```
+
+### OAuth Token Example
 
-    if (error.isRateLimitError()) {
-      console.log('Hit rate limit, slow down');
+```typescript
+import { createClient } from '@ariadng/sheets';
+
+const client = createClient({
+    auth: {
+        type: 'oauth',
+        accessToken: 'YOUR_ACCESS_TOKEN'
     }
+});
 
-    // User-friendly message
-    console.log(error.getUserMessage());
-  }
-}
+const values = await client.getValues('SPREADSHEET_ID', 'Sheet1!A1:D10');
 ```
 
-## Common Patterns
+### Available Methods
+
+#### getSpreadsheet(spreadsheetId)
 
-### Progressive Enhancement
+Get spreadsheet metadata.
 
 ```typescript
-import { GoogleSheetsCore } from '@ariadng/sheets/core';
-import { withCache } from '@ariadng/sheets/plus';
-import { withAdaptiveRateLimit, withMetrics } from '@ariadng/sheets/advanced';
+const spreadsheet = await client.getSpreadsheet('SPREADSHEET_ID');
+// Returns: { spreadsheetId, properties, sheets, spreadsheetUrl }
+```
 
-// Start simple
-let sheets = new GoogleSheetsCore({ auth });
+#### getSheets(spreadsheetId)
 
-// Add features as needed
-sheets = withCache(sheets, { ttlSeconds: 300 });
-sheets = withAdaptiveRateLimit(sheets);
-sheets = withMetrics(sheets);
+Get list of sheets in a spreadsheet.
 
-// Now have all features!
+```typescript
+const sheets = await client.getSheets('SPREADSHEET_ID');
+// Returns: [{ sheetId, title, index, gridProperties, hidden }]
 ```
 
-### Data Processing Pipeline
+#### getValues(spreadsheetId, range, options?)
+
+Read cell values from a range.
 
 ```typescript
-import { Parsers, Serializers } from '@ariadng/sheets/plus';
+const values = await client.getValues('SPREADSHEET_ID', 'Sheet1!A1:D10');
+// Returns: { range, majorDimension, values }
 
-// Read raw data
-const raw = await sheets.read(id, 'Data!A1:Z1000');
+// With options
+const values = await client.getValues('SPREADSHEET_ID', 'Sheet1!A1:D10', {
+    valueRenderOption: 'UNFORMATTED_VALUE',
+    dateTimeRenderOption: 'SERIAL_NUMBER'
+});
+```
 
-// Parse to objects
-const records = Parsers.rowsToObjects(raw);
+Options:
+- `valueRenderOption`: How values should be rendered
+  - `FORMATTED_VALUE` (default): Values as displayed in the UI
+  - `UNFORMATTED_VALUE`: Raw values without formatting
+  - `FORMULA`: Formulas instead of calculated values
+- `dateTimeRenderOption`: How dates should be rendered
+  - `FORMATTED_STRING` (default): Date as formatted string
+  - `SERIAL_NUMBER`: Date as serial number
+- `majorDimension`: How data is organized
+  - `ROWS` (default): Data organized by rows
+  - `COLUMNS`: Data organized by columns
 
-// Process data
-const processed = records
-  .filter(r => r.status === 'active')
-  .map(r => ({ ...r, processed: true }));
+#### getFormulas(spreadsheetId, range)
 
-// Convert back to rows
-const rows = Serializers.objectsToRows(processed);
+Read formulas from a range. This is a shortcut for `getValues` with `valueRenderOption: 'FORMULA'`.
 
-// Write back
-await sheets.write(id, 'Processed!A1', rows);
+```typescript
+const formulas = await client.getFormulas('SPREADSHEET_ID', 'Sheet1!A1:D10');
 ```
 
-### Efficient Batch Processing
+#### batchGetValues(spreadsheetId, ranges, options?)
+
+Read multiple ranges in a single request.
 
 ```typescript
-import { BatchOperations } from '@ariadng/sheets/plus';
+const result = await client.batchGetValues('SPREADSHEET_ID', [
+    'Sheet1!A1:D10',
+    'Sheet2!A1:B5'
+]);
+// Returns: { spreadsheetId, valueRanges: [...] }
+```
 
-const batch = new BatchOperations(sheets);
+### Authentication Functions
 
-// Mixed operations
-const results = await batch.executeBatch(spreadsheetId, {
-  reads: ['Summary!A1:Z1', 'Config!A1:B10'],
-  writes: [
-    { range: 'Output!A1:B100', values: outputData }
-  ],
-  clears: ['Temp!A:Z']
-});
+```typescript
+import { login, loadStoredTokens, deleteTokens } from '@ariadng/sheets';
 
-// All executed efficiently in parallel when possible
+// Perform OAuth login flow
+const tokens = await login();
+console.log(tokens.email);
+
+// Load stored tokens
+const stored = await loadStoredTokens();
+if (stored) {
+    console.log('Logged in as:', stored.email);
+}
+
+// Delete stored tokens
+await deleteTokens();
 ```
 
-## API Reference
+## Troubleshooting
 
-### Core Package
+### "Not logged in" Error
 
-#### GoogleSheetsCore
+Run `sheets login` to authenticate with your Google account.
 
-- `constructor(config: GoogleSheetsConfig)`
-- `read(spreadsheetId: string, range: string): Promise<any[][]>`
-- `write(spreadsheetId: string, range: string, values: any[][]): Promise<UpdateValuesResponse>`
-- `append(spreadsheetId: string, range: string, values: any[][]): Promise<AppendValuesResponse>`
-- `clear(spreadsheetId: string, range: string): Promise<ClearValuesResponse>`
-- `batchRead(spreadsheetId: string, ranges: string[]): Promise<ValueRange[]>`
-- `batchWrite(spreadsheetId: string, data: BatchWriteData[]): Promise<BatchUpdateValuesResponse>`
-- `getSpreadsheet(spreadsheetId: string): Promise<Spreadsheet>`
-- `getApi(): sheets_v4.Sheets`
+### "Access denied" or "Permission denied" Error
 
-### Plus Package
+Make sure you have access to the spreadsheet:
+- For personal accounts: The spreadsheet must be shared with your Google account
+- For service accounts: Share the spreadsheet with the service account email address
 
-#### A1 Utilities
+### "Invalid credentials" Error
 
-- `A1.columnToIndex(column: string): number`
-- `A1.indexToColumn(index: number): string`
-- `A1.parse(notation: string): A1Components`
-- `A1.build(sheet?, startCol, startRow, endCol?, endRow?): string`
-- `A1.getDimensions(notation: string): { rows: number, columns: number }`
-- `A1.offset(notation: string, rowOffset: number, colOffset: number): string`
+For service accounts:
+- Check that the JSON file is valid
+- Make sure the file contains `type: "service_account"`
+- Verify the private key is correct
 
-#### Parsers
+### Browser Does Not Open During Login
 
-- `Parsers.rowsToObjects<T>(data: any[][]): T[]`
-- `Parsers.asNumbers(data: any[][]): number[][]`
-- `Parsers.asStrings(data: any[][]): string[][]`
-- `Parsers.asMap<V>(data: any[][]): Map<string, V>`
-- `Parsers.column<T>(data: any[][], columnIndex: number): T[]`
+Try these solutions:
+- Open the URL manually (it will be displayed in the terminal)
+- Make sure port 8085 is not in use by another application
 
-#### Serializers
+### Token Expired
 
-- `Serializers.objectsToRows<T>(objects: T[], headers?: string[]): any[][]`
-- `Serializers.mapToRows<K,V>(map: Map<K,V>): any[][]`
-- `Serializers.arrayToColumn<T>(array: T[]): any[][]`
-- `Serializers.transpose(data: any[][]): any[][]`
+Tokens are automatically refreshed when they expire. If you see token errors, try logging out and logging in again:
 
-## Performance
+```bash
+sheets logout
+sheets login
+```
 
-| Operation | Base Latency | With Cache | With Rate Limit |
-|-----------|-------------|------------|-----------------|
-| Single Read | 100-200ms | 0-1ms (hit) | +0-50ms |
-| Batch Read (10) | 150-250ms | 0-1ms (hit) | +0-50ms |
-| Single Write | 150-300ms | N/A | +0-50ms |
-| Batch Write (100) | 300-500ms | N/A | +0-100ms |
+## Token Storage
 
-## Best Practices
+When you run `sheets login`, your authentication tokens are saved to:
 
-1. **Use batch operations** when reading/writing multiple ranges
-2. **Enable caching** for frequently read, rarely changed data
-3. **Add rate limiting** for bulk operations or scripts
-4. **Use type utilities** for better type safety and code clarity
-5. **Handle errors gracefully** with proper retry logic
-6. **Monitor with metrics** in production environments
+```
+~/.sheets/tokens.json
+```
 
-## Requirements
+This file contains:
+- Access token (used to make API requests)
+- Refresh token (used to get new access tokens)
+- Token expiration time
+- Your email address
 
-- Node.js 14+
-- Google Sheets API enabled in Google Cloud Console
-- Service account or OAuth2 credentials
+Keep this file secure. Do not share it with others.
 
-## License
+## How It Works
 
-MIT
+This tool uses the Google Sheets API v4 to read spreadsheet data. It does not use the official Google SDK. Instead, it makes direct HTTP requests to the API.
 
-## Contributing
+Authentication methods:
+- Personal accounts: OAuth 2.0 with PKCE (Proof Key for Code Exchange)
+- Service accounts: JWT (JSON Web Token) signed with RS256
 
-Contributions are welcome! Please read our contributing guidelines before submitting PRs.
+The tool only requests read-only access to your spreadsheets. It cannot modify your data.
 
-## Support
+## Project Structure
 
-For issues and feature requests, please use the [GitHub issues page](https://github.com/ariadng/sheets/issues).
+```
+src/
+  index.ts              Public API exports
+  cli.ts                CLI entry point
+  api/index.ts          SheetsClient class
+  auth/
+    index.ts            Auth provider factory
+    constants.ts        OAuth configuration
+    oauth.ts            OAuth token wrapper
+    user-auth.ts        User OAuth with PKCE
+    service-account.ts  Service account JWT auth
+  http/index.ts         HTTP client with retry
+  types/index.ts        TypeScript definitions
+```
+
+## Development
+
+### Build
+
+```bash
+npm run build
+```
+
+This compiles TypeScript to JavaScript in the `dist` folder.
+
+### Development Mode
+
+```bash
+npm run dev
+```
+
+This runs the CLI with automatic reloading when files change.
+
+### Run Without Building
+
+```bash
+npx tsx src/cli.ts <command>
+```
+
+## License
+
+MIT