viepilot 2.47.0 → 2.49.0

package/CHANGELOG.md

@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.49.0] - 2026-05-17
+
+### Added
+- **ENH-083** `vp-intake` — SharePoint sharing link + xlsx direct download support (Phase 124):
+  - **SharePoint anonymous sharing link** adapter: URLs matching `/:x:/g/` or `/:x:/r/` are
+    resolved via the SharePoint WOPI viewer page — `FileGetUrl` (temp-auth token) is scraped
+    from the HTML and used to download the xlsx file without OAuth credentials
+  - **xlsx parser** using SheetJS (`xlsx` npm package): downloaded xlsx Buffer is parsed to
+    `rows[][]` matching the Graph API response format; falls back to first sheet when the
+    configured sheet name is not found
+  - **`sharing_url` field** in `channels.json` (`excel_m365` type): optional alternative to
+    `workbook_id` for SharePoint "Anyone with the link" files; no credentials required
+  - **Redirect-following HTTP client** (`httpsGetRaw`): browser User-Agent, follows 301/302/307
+    chains needed for SharePoint sharing link flow
+  - **Routing logic in `readExcelM365`**: `sharing_url` present → anonymous WOPI flow;
+    `workbook_id` present → Graph API (OAuth); neither present → `AuthRequiredError` with guide
+  - **BUG_KEYWORDS extended**: `performance`, `slow`, `timeout`, `hang`, `freeze`,
+    `unresponsive`, `chậm`, `treo`, `tắc`, `không phản hồi` — "performance issue" now correctly
+    classifies as BUG instead of UNCLEAR
+  - **19 new tests** (1897 total): keyword expansion (8 tests), `isSharingLink` detection (5
+    tests), routing logic (3 tests), `parseXlsxBuffer` (3 tests)
+
+## [2.48.0] - 2026-05-17
+
+### Added
+- **ENH-082** `vp-intake` skill — import and triage tickets from external sources (Phase 123):
+  - **Excel/Microsoft 365 Online** adapter via Microsoft Graph API (client credentials OAuth 2.0)
+  - **Google Sheets** adapter via Sheets API v4 (Service Account OAuth 2.0)
+  - **CSV/TSV local file** adapter with configurable column mapping
+  - **Heuristic classifier** auto-assigns `BUG` / `ENH` / `UNCLEAR` per ticket; supports
+    English and Vietnamese keywords; BUG takes precedence over ENH
+  - **AskUserQuestion triage**: multi-select accept/decline per ticket (paginated at 4/page);
+    UNCLEAR tickets get a 3-choice prompt (Accept as BUG / Accept as ENH / Decline)
+  - **Reason collection**: declined tickets prompt user for decline reason via AUQ single-select
+  - **Auto-create request files**: accepted tickets generate `.viepilot/requests/BUG-N.md` or
+    `ENH-N.md` with source channel attribution
+  - **Write-back engine**: updates `VP_Status`, `VP_Comment`, `VP_RequestID` columns in source
+    (CSV overwrite, Google Sheets batchUpdate); write-back failure is non-fatal
+  - **TRIAGE session report**: `.viepilot/intake/TRIAGE-{timestamp}.md` generated after every
+    session with accepted/declined/unclear summary tables
+  - **`channels.json` config**: `.viepilot/intake/channels.json` supports multiple concurrent
+    channels; validated schema with required field checks
+  - **`vp-tools intake-init`** command: scaffolds `.viepilot/intake/channels.json` (3 example
+    channels), creates `.viepilot/.credentials/` (gitignored) — idempotent
+
 ## [2.47.0] - 2026-05-06
 
 ### Added

package/bin/vp-tools.cjs

@@ -1288,6 +1288,21 @@ ${colors.cyan}Examples:${colors.reset}
     process.exit(0);
   },
 
+  /**
+   * Initialize .viepilot/intake/ directory with channels.json scaffold (ENH-082)
+   */
+  'intake-init': (_args) => {
+    const { initIntakeDir } = require('../lib/intake/channels.cjs');
+    const projectCheck = validators.requireProjectRoot();
+    validateArgs([projectCheck]);
+    const projectRoot = projectCheck.value;
+    const { channelsPath, credentialsDir } = initIntakeDir(projectRoot);
+    console.log(formatSuccess('intake/ initialized'));
+    console.log(`  channels.json : ${channelsPath}`);
+    console.log(`  credentials   : ${credentialsDir}`);
+    console.log('\nEdit .viepilot/intake/channels.json to configure your ticket channels.');
+  },
+
   /**
    * Help
    */

package/lib/intake/adapters/csv.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseCsvLine(line, delimiter) {
+  const result = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === delimiter && !inQuotes) {
+      result.push(current.trim());
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+function applyColumnMap(headers, row, columnMap) {
+  const headerIndex = {};
+  headers.forEach((h, i) => { headerIndex[h.trim()] = i; });
+
+  const get = (fieldName) => {
+    const mapped = columnMap[fieldName];
+    if (!mapped) return '';
+    const idx = headerIndex[mapped];
+    return idx !== undefined ? (row[idx] || '') : '';
+  };
+
+  return {
+    id:          get('id'),
+    title:       get('title'),
+    description: get('description'),
+    reporter:    get('reporter'),
+    date:        get('date'),
+    status:      get('status'),
+  };
+}
+
+async function readCsv(channel, projectRoot) {
+  const filePath = path.resolve(projectRoot || process.cwd(), channel.path);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`CSV file not found: ${filePath}`);
+  }
+
+  const ext = path.extname(filePath).toLowerCase();
+  const delimiter = ext === '.tsv' ? '\t' : ',';
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split(/\r?\n/).filter((l) => l.trim() !== '');
+
+  if (lines.length === 0) return [];
+
+  const headers = parseCsvLine(lines[0], delimiter);
+  const tickets = [];
+
+  for (let i = 1; i < lines.length; i++) {
+    const row = parseCsvLine(lines[i], delimiter);
+    const ticket = applyColumnMap(headers, row, channel.column_map);
+    if (!ticket.title && !ticket.description) continue;
+    ticket._source_row = i;
+    ticket._channel_id = channel.id;
+    tickets.push(ticket);
+  }
+
+  return tickets;
+}
+
+module.exports = { readCsv };

package/lib/intake/adapters/excel-m365.cjs

@@ -0,0 +1,328 @@
+'use strict';
+
+const fs    = require('fs');
+const os    = require('os');
+const path  = require('path');
+const https = require('https');
+
+const CREDENTIALS_REL = path.join('.viepilot', '.credentials', 'm365-credentials.json');
+
+const SETUP_GUIDE = `
+Microsoft 365 / Excel setup:
+  1. Go to portal.azure.com → Azure Active Directory → App Registrations → New
+  2. Add API permission: Microsoft Graph → Files.Read.All (Application) → Grant admin consent
+  3. Certificates & Secrets → New client secret → copy value immediately
+  4. Save credentials to: .viepilot/.credentials/m365-credentials.json
+     { "tenant_id": "...", "client_id": "...", "client_secret": "..." }
+  5. In channels.json, set "workbook_id" to the file's drive item ID
+     (visible in the file's URL on SharePoint/OneDrive)
+  6. Re-run vp-intake
+
+For SharePoint sharing links ("Anyone with the link"), use "sharing_url" in channels.json
+instead of "workbook_id" — no credentials required.
+`;
+
+class AuthRequiredError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = 'AuthRequiredError';
+  }
+}
+
+let _tokenCache = null;
+
+function colLetterToIndex(letter) {
+  let index = 0;
+  for (const ch of letter.toUpperCase()) {
+    index = index * 26 + ch.charCodeAt(0) - 64;
+  }
+  return index - 1;
+}
+
+// ─── HTTP helpers ─────────────────────────────────────────────────────────────
+
+function httpsPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const payload = typeof body === 'string' ? body : JSON.stringify(body);
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(payload), ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(data); } });
+    });
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+function httpsGet(url, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'GET',
+      headers: { Accept: 'application/json', ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(data); } });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+/** Follow redirects and return {status, headers, body} */
+function httpsGetRaw(url, headers = {}, maxRedirects = 6) {
+  return new Promise((resolve, reject) => {
+    function doGet(currentUrl, remaining) {
+      const urlObj = new URL(currentUrl);
+      const req = https.request({
+        hostname: urlObj.hostname,
+        path: urlObj.pathname + urlObj.search,
+        method: 'GET',
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+          ...headers,
+        },
+      }, (res) => {
+        if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location && remaining > 0) {
+          let nextUrl = res.headers.location;
+          if (!nextUrl.startsWith('http')) {
+            nextUrl = `${urlObj.protocol}//${urlObj.host}${nextUrl}`;
+          }
+          return doGet(nextUrl, remaining - 1);
+        }
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: Buffer.concat(chunks) }));
+      });
+      req.on('error', reject);
+      req.end();
+    }
+    doGet(url, maxRedirects);
+  });
+}
+
+function encodeFormData(obj) {
+  return Object.entries(obj)
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join('&');
+}
+
+// ─── Graph API (client credentials) ──────────────────────────────────────────
+
+async function getAccessToken(creds) {
+  const now = Math.floor(Date.now() / 1000);
+  if (_tokenCache && _tokenCache.expires_at > now + 60) {
+    return _tokenCache.access_token;
+  }
+
+  const url = `https://login.microsoftonline.com/${creds.tenant_id}/oauth2/v2.0/token`;
+  const res = await httpsPost(url, encodeFormData({
+    grant_type: 'client_credentials',
+    client_id: creds.client_id,
+    client_secret: creds.client_secret,
+    scope: 'https://graph.microsoft.com/.default',
+  }));
+
+  if (!res.access_token) {
+    throw new Error(`M365 auth failed: ${JSON.stringify(res)}`);
+  }
+
+  _tokenCache = { access_token: res.access_token, expires_at: now + (res.expires_in || 3600) };
+  return res.access_token;
+}
+
+async function readViaGraphApi(channel, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const credPath = path.join(root, CREDENTIALS_REL);
+
+  if (!fs.existsSync(credPath)) {
+    throw new AuthRequiredError(SETUP_GUIDE);
+  }
+
+  let creds;
+  try {
+    creds = JSON.parse(fs.readFileSync(credPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to parse m365-credentials.json: ${e.message}`);
+  }
+
+  if (!creds.tenant_id || !creds.client_id || !creds.client_secret) {
+    throw new AuthRequiredError(`m365-credentials.json is incomplete.${SETUP_GUIDE}`);
+  }
+
+  const token = await getAccessToken(creds);
+  const sheetName = encodeURIComponent(channel.sheet_name || 'Sheet1');
+  const url = `https://graph.microsoft.com/v1.0/me/drive/items/${channel.workbook_id}/workbook/worksheets/${sheetName}/usedRange`;
+  const response = await httpsGet(url, { Authorization: `Bearer ${token}` });
+
+  if (!response.values || response.values.length === 0) return [];
+  return parseRowsWithColumnMap(response.values, channel.column_map);
+}
+
+// ─── SharePoint sharing link (anonymous WOPI) ─────────────────────────────────
+
+/** Detect sharing link type: /:x:/g/ or /:x:/r/ paths */
+function isSharingLink(url) {
+  return /\/:x:\/[gr]\//.test(url);
+}
+
+/**
+ * Resolve a SharePoint anonymous sharing link to a direct download URL.
+ * Technique: load WOPI viewer page → scrape FileGetUrl (temp auth token embedded in HTML).
+ */
+async function resolveSharePointDownloadUrl(sharingUrl) {
+  // First request: follow redirects to the WOPI viewer page
+  const { status, body } = await httpsGetRaw(sharingUrl);
+  if (status !== 200) {
+    throw new Error(`SharePoint sharing link returned HTTP ${status}. The link may be expired or restricted.`);
+  }
+
+  const html = body.toString('utf8');
+
+  // Scrape FileGetUrl — SharePoint embeds a temp-auth download URL in the viewer HTML
+  const match = html.match(/"FileGetUrl"\s*:\s*"([^"]+)"/);
+  if (!match) {
+    throw new Error('Could not extract download URL from SharePoint viewer page. The file may require sign-in.');
+  }
+
+  // Unescape JSON unicode escapes (\\u0026 → &)
+  return match[1].replace(/\\u([\da-fA-F]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+
+/** Download xlsx bytes from a URL (no auth, temp token already embedded) */
+async function downloadXlsx(downloadUrl) {
+  const { status, body } = await httpsGetRaw(downloadUrl, {
+    Accept: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,*/*',
+  });
+  if (status !== 200) {
+    throw new Error(`Failed to download xlsx: HTTP ${status}`);
+  }
+  return body; // Buffer
+}
+
+// ─── xlsx parser (SheetJS) ────────────────────────────────────────────────────
+
+/**
+ * Parse xlsx Buffer → array of row arrays (like response.values from Graph API).
+ * Uses the `xlsx` npm package (SheetJS).
+ */
+function parseXlsxBuffer(buffer, sheetName) {
+  let XLSX;
+  try {
+    XLSX = require('xlsx');
+  } catch {
+    throw new Error(
+      'The "xlsx" package is required to parse xlsx files from sharing links.\n' +
+      'Install it: npm install xlsx'
+    );
+  }
+
+  const workbook = XLSX.read(buffer, { type: 'buffer' });
+
+  let sheet;
+  if (sheetName && workbook.SheetNames.includes(sheetName)) {
+    sheet = workbook.Sheets[sheetName];
+  } else {
+    // Default to first sheet; warn if requested sheet not found
+    if (sheetName) {
+      process.stderr.write(`[vp-intake] Sheet "${sheetName}" not found. Using "${workbook.SheetNames[0]}" instead.\n`);
+    }
+    sheet = workbook.Sheets[workbook.SheetNames[0]];
+  }
+
+  if (!sheet) return [];
+
+  // Convert to array of arrays (raw values)
+  const rows = XLSX.utils.sheet_to_json(sheet, { header: 1, defval: '' });
+  return rows;
+}
+
+async function readViaSharingLink(channel) {
+  const sharingUrl = channel.sharing_url;
+  const downloadUrl = await resolveSharePointDownloadUrl(sharingUrl);
+  const xlsxBuffer = await downloadXlsx(downloadUrl);
+  const rows = parseXlsxBuffer(xlsxBuffer, channel.sheet_name || null);
+
+  if (!rows || rows.length === 0) return [];
+  return parseRowsWithColumnMap(rows, channel.column_map);
+}
+
+// ─── Common row → ticket mapper ───────────────────────────────────────────────
+
+function parseRowsWithColumnMap(values, colMap) {
+  const tickets = [];
+
+  for (let i = 1; i < values.length; i++) {
+    const row = values[i];
+    const get = (field) => {
+      const col = colMap[field];
+      if (!col) return '';
+      const idx = colLetterToIndex(col);
+      return row[idx] !== undefined ? String(row[idx]) : '';
+    };
+
+    const ticket = {
+      id:          get('id'),
+      title:       get('title'),
+      description: get('description'),
+      reporter:    get('reporter'),
+      date:        get('date'),
+      status:      get('status'),
+      _source_row: i,
+      _channel_id: channel ? channel.id : undefined,
+    };
+
+    if (!ticket.title && !ticket.description) continue;
+    tickets.push(ticket);
+  }
+
+  return tickets;
+}
+
+// ─── Public entry point ───────────────────────────────────────────────────────
+
+async function readExcelM365(channel, projectRoot) {
+  // Sharing link mode: no credentials required
+  if (channel.sharing_url) {
+    if (isSharingLink(channel.sharing_url)) {
+      return readViaSharingLink(channel);
+    }
+    throw new Error(
+      `sharing_url "${channel.sharing_url}" is not a SharePoint sharing link.\n` +
+      'Sharing links look like: https://xxx.sharepoint.com/:x:/g/personal/xxx/EdXXX...\n' +
+      'For direct document links (Doc.aspx?sourcedoc=...), use workbook_id + credentials instead.'
+    );
+  }
+
+  // Graph API mode: requires workbook_id + credentials
+  if (!channel.workbook_id) {
+    throw new AuthRequiredError(
+      'excel_m365 channel requires either "sharing_url" (for SharePoint sharing links) or ' +
+      '"workbook_id" (for Graph API).' + SETUP_GUIDE
+    );
+  }
+
+  return readViaGraphApi(channel, projectRoot);
+}
+
+function clearTokenCache() { _tokenCache = null; }
+
+module.exports = {
+  readExcelM365,
+  AuthRequiredError,
+  clearTokenCache,
+  // exported for testing
+  isSharingLink,
+  resolveSharePointDownloadUrl,
+  parseXlsxBuffer,
+};

package/lib/intake/adapters/google-sheets.cjs

@@ -0,0 +1,161 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const https = require('https');
+
+const CREDENTIALS_REL = path.join('.viepilot', '.credentials', 'google-service-account.json');
+
+const SETUP_GUIDE = `
+Google Sheets setup:
+  1. Go to console.cloud.google.com → Create project → Enable Sheets API
+  2. IAM → Service Accounts → Create → Download JSON key
+  3. Save key to: .viepilot/.credentials/google-service-account.json
+  4. Share your Google Sheet with the service account email (viewer access)
+  5. Re-run vp-intake
+`;
+
+class AuthRequiredError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = 'AuthRequiredError';
+  }
+}
+
+function colLetterToIndex(letter) {
+  let index = 0;
+  for (const ch of letter.toUpperCase()) {
+    index = index * 26 + ch.charCodeAt(0) - 64;
+  }
+  return index - 1;
+}
+
+function httpsPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const payload = typeof body === 'string' ? body : JSON.stringify(body);
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(payload), ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve(data); }
+      });
+    });
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+function httpsGet(url, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'GET',
+      headers: { Accept: 'application/json', ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve(data); }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function encodeFormData(obj) {
+  return Object.entries(obj)
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join('&');
+}
+
+async function getAccessToken(keyJson, projectRoot) {
+  const now = Math.floor(Date.now() / 1000);
+  const header = Buffer.from(JSON.stringify({ alg: 'RS256', typ: 'JWT' })).toString('base64url');
+  const payload = Buffer.from(JSON.stringify({
+    iss: keyJson.client_email,
+    scope: 'https://www.googleapis.com/auth/spreadsheets.readonly',
+    aud: 'https://oauth2.googleapis.com/token',
+    exp: now + 3600,
+    iat: now,
+  })).toString('base64url');
+
+  const crypto = require('crypto');
+  const sign = crypto.createSign('RSA-SHA256');
+  sign.update(`${header}.${payload}`);
+  const signature = sign.sign(keyJson.private_key, 'base64url');
+  const jwt = `${header}.${payload}.${signature}`;
+
+  const tokenRes = await httpsPost(
+    'https://oauth2.googleapis.com/token',
+    encodeFormData({ grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer', assertion: jwt }),
+  );
+  if (!tokenRes.access_token) {
+    throw new Error(`Google auth failed: ${JSON.stringify(tokenRes)}`);
+  }
+  return tokenRes.access_token;
+}
+
+async function readGoogleSheet(channel, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const credPath = path.join(root, CREDENTIALS_REL);
+
+  if (!fs.existsSync(credPath)) {
+    throw new AuthRequiredError(SETUP_GUIDE);
+  }
+
+  let keyJson;
+  try {
+    keyJson = JSON.parse(fs.readFileSync(credPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to parse google-service-account.json: ${e.message}`);
+  }
+
+  const accessToken = await getAccessToken(keyJson, root);
+  const sheetName = encodeURIComponent(channel.sheet_name || 'Sheet1');
+  const url = `https://sheets.googleapis.com/v4/spreadsheets/${channel.spreadsheet_id}/values/${sheetName}!A:Z`;
+  const response = await httpsGet(url, { Authorization: `Bearer ${accessToken}` });
+
+  if (!response.values || response.values.length === 0) return [];
+
+  const colMap = channel.column_map;
+  const tickets = [];
+
+  for (let i = 1; i < response.values.length; i++) {
+    const row = response.values[i];
+    const get = (field) => {
+      const col = colMap[field];
+      if (!col) return '';
+      const idx = colLetterToIndex(col);
+      return row[idx] || '';
+    };
+
+    const ticket = {
+      id:          get('id'),
+      title:       get('title'),
+      description: get('description'),
+      reporter:    get('reporter'),
+      date:        get('date'),
+      status:      get('status'),
+      _source_row: i,
+      _channel_id: channel.id,
+    };
+
+    if (!ticket.title && !ticket.description) continue;
+    tickets.push(ticket);
+  }
+
+  return tickets;
+}
+
+module.exports = { readGoogleSheet, AuthRequiredError };