googleformsubmitter 1.0.0 → 1.1.1

package/.env.example

@@ -2,3 +2,16 @@
 
 # CDP Web Socket endpoint for connecting to the Lightpanda browser engine
 LIGHTPANDA_CDP_URL=ws://127.0.0.1:9222/
+
+# Path to the Google Forms session cookies JSON file (required for testing file upload fields)
+GOOGLE_COOKIES_PATH=./.data/google-cookies.json
+
+# Google OAuth2 Credentials (Option A: Direct Env configuration - recommended for Production/CI)
+# GOOGLE_CLIENT_ID=your-client-id
+# GOOGLE_CLIENT_SECRET=your-client-secret
+# GOOGLE_REFRESH_TOKEN=your-refresh-token
+
+# Google OAuth2 Credentials Paths (Option B: Custom File-based configuration - fallback option)
+# GOOGLE_OAUTH_CREDENTIALS_PATH=./.data/credentials.json
+# GOOGLE_OAUTH_TOKEN_PATH=./.data/forms-auth.json
+

package/README.md

@@ -2,29 +2,32 @@
 
 Пакет для строго типизированной, валидируемой и кэшируемой отправки данных во внешние (в том числе сторонние) Google Формы с использованием Lightpanda (CDP-соединение) или стандартного Chromium.
 
+---
+
 ## 🚀 Возможности
 
 1. **Строгая валидация (JSON Schema)**: Входные данные проверяются через стандартную JSON схему с использованием библиотеки `Ajv` перед любой сетевой отправкой.
 2. **Декларативное описание полей**: Позволяет сопоставлять программные свойства (например, `fullName`, `exitDate`) с русскими заголовками вопросов в Google Форме.
 3. **Ленивый парсинг DOM (Lazy Loading)**: При первой отправке модуль автоматически открывает форму в безголовом браузере, сканирует структуру вопросов, находит соответствующие им бэкенд `entryId` и сохраняет карту соответствий в локальный кэш-файл.
 4. **Сверхбыстрые повторные отправки**: После наполнения кэша последующие отправки выполняются мгновенно через прямой HTTP POST-запрос, эмулируя отправку формы без запуска графического браузера.
-5. **Авторизация (Куки)**: Поддерживает инжекцию файлов куки для прохождения авторизации в формах, требующих аккаунт Google (например, если в форме есть поле загрузки файла).
+5. **Авторизация и загрузка файлов (Google Drive)**: Поддерживает инжекцию файлов куки для прохождения авторизации в формах, требующих аккаунт Google. Также инкапсулирует автоматическую загрузку файлов резюме (`Buffer`) на Google Диск через Google Drive API на лету с подстановкой ID файла в форму.
 6. **Поддержка опции «Другое»**: Автоматически распознает кастомные текстовые ответы для радио-кнопок/чекбоксов с выбором «Другое» и правильно их кодирует.
+7. **Инфраструктурная чистота**: Библиотека полностью независима от файловой структуры или конкретных `env`-переменных вашего приложения. Все настройки и пути передаются в конструктор.
 
 ---
 
 ## 🛠️ Установка и Запуск
 
-Перейдите в каталог `googleformsubmitter` и установите зависимости:
+Перейдите в каталог библиотеки и установите зависимости:
 ```bash
 cd googleformsubmitter
 bun install
 ```
 
 ### Доступные скрипты:
-* **Запуск тестов**:
+* **Запуск тестов (стандартный Bun BDD runner)**:
   ```bash
-  bun run test
+  bun test
   ```
 * **Проверка типов (tsgo)**:
   ```bash
@@ -41,17 +44,42 @@ bun install
 
 ---
 
+## 🐼 Запуск Lightpanda
+
+Для динамического разрешения DOM-структуры (когда кэш еще не заполнен) библиотека использует CDP-соединение с ультра-легким JS-движком **Lightpanda**. 
+
+Для его локального запуска выполните:
+```bash
+docker run --rm -p 9222:9222 lightpanda/browser:latest
+```
+
+*При отсутствии запущенного инстанса Lightpanda библиотека автоматически переключится на стандартный headless Chromium в качестве безопасного fallback.*
+
+---
+
+## 🩹 Патч Playwright для работы под Bun
+
+В среде выполнения **Bun** есть известная проблема совместимости с CDP-событиями WebSocket, из-за которой стандартный Playwright зависает (hangs) при подключении к Lightpanda.
+
+Для решения этой проблемы библиотека поставляется со встроенным патчем:
+* Файл патча: `patches/playwright-core@1.61.1.patch`
+* Регистрация в `package.json` через `"patchedDependencies"`.
+
+При запуске `bun install` патч применяется автоматически.
+
+---
+
 ## 📋 Описание Схемы данных
 
 Отправка настраивается с помощью двух схем:
 
-1. **JSON Schema** — описывает типы данных, ограничения, обязательность и формат (например, регулярные выражения для дат).
+1. **JSON Schema** — описывает типы данных, ограничения, обязательность и формат.
 2. **Mapping Schema** — описывает связь между ключом в JSON схеме и человекочитаемым заголовком вопроса в Google Форме.
 
 ### Пример декларативной конфигурации:
 
 ```typescript
-import { GoogleFormSubmitter } from './GoogleFormSubmitter';
+import { GoogleFormSubmitter } from 'googleformsubmitter';
 
 // 1. Описание типов данных формы (JSON Schema)
 const jsonSchema = {
@@ -63,11 +91,11 @@ const jsonSchema = {
     cvFile: {
       type: 'object',
       properties: {
-        fileId: { type: 'string' },
+        buffer: { type: 'object' },
         filename: { type: 'string' },
         mimeType: { type: 'string' }
       },
-      required: ['fileId', 'filename', 'mimeType']
+      required: ['filename', 'mimeType']
     }
   },
   required: ['fullName', 'birthDate', 'inStaff', 'cvFile']
@@ -87,7 +115,20 @@ const submitter = new GoogleFormSubmitter({
   jsonSchema,
   mappingSchema,
   cdpUrl: 'ws://127.0.0.1:9222/', // CDP-сервер Lightpanda
-  cookies: loadedCookies          // Сессионные куки (необязательно)
+  cacheDir: './.data',            // Папка для кэширования entryId
+  cookies: loadedCookies,         // Сессионные куки (для авторизованных форм)
+  
+  // Конфигурация авторизации Google Auth (Drive API)
+  auth: {
+    // Вариант А: Программная передача токенов напрямую (рекомендуется для Production/CI)
+    clientId: process.env.GOOGLE_CLIENT_ID,
+    clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+    refreshToken: process.env.GOOGLE_REFRESH_TOKEN,
+
+    // Вариант Б: Явные пути к конфигурационным файлам на диске
+    // credentialsPath: './.data/credentials.json',
+    // tokenPath: './.data/forms-auth.json'
+  }
 });
 
 // 4. Отправка данных
@@ -96,7 +137,7 @@ const result = await submitter.submit({
   birthDate: '1990-01-01',
   inStaff: 'С рынка, на предоффере', // Будет передано в "Другое"
   cvFile: {
-    fileId: '1BRVwwPlohb_4g7DUZ3HTz...',
+    buffer: resumeBuffer,
     filename: 'resume.docx',
     mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
   }
@@ -107,9 +148,11 @@ const result = await submitter.submit({
 
 ## 📂 Структура каталогов проекта
 
-* `GoogleFormSubmitter.ts` — основной класс управления, парсинга DOM и сетевых запросов.
-* `create-form.ts` — скрипт автоматического создания тестовой Google-формы со всеми необходимыми типами полей (включая текстовые, списки, даты, переключатели) через официальный Google Forms API.
-* `test.ts` — интеграционный тест, эмулирующий первую отправку (с динамическим парсингом) и повторную отправку (из кэша).
-* `types.ts` — TypeScript-интерфейсы и типы данных.
-* `.data/` — каталог для хранения временных кэшей сопоставлений entryId (`form-cache-*.json`).
-* `.env.example` — шаблон конфигурационного файла.
+* `src/google-form-submitter.ts` — основной класс управления, парсинга DOM и сетевых запросов.
+* `src/google-auth-service.ts` — сервис авторизации Google OAuth2 (поддерживает как токены из конструктора/env, так и из файлов).
+* `src/google-drive-service.ts` — сервис загрузки файлов на Google Диск через Google Drive API.
+* `src/types.ts` — TypeScript-интерфейсы и типы данных.
+* `src/index.ts` — точка входа (публичные экспорты библиотеки).
+* `src/google-form-submitter.test.ts` — BDD интеграционный тест (запускается через `bun test`).
+* `tools/create-form.ts` — вспомогательный скрипт создания тестовой формы через Google Forms API.
+* `patches/` — содержит патч для решения проблем с CDP Playwright под Bun.

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "googleformsubmitter",
-  "version": "1.0.0",
-  "module": "index.ts",
+  "version": "1.1.1",
+  "module": "src/index.ts",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
   "type": "module",
   "scripts": {
-    "test": "bun run ./test.ts",
+    "test": "bun test",
     "lint": "oxlint",
     "validate": "tsgo --noEmit",
-    "create-form": "bun run ./create-form.ts"
+    "create-form": "bun run ./tools/create-form.ts",
+    "introspect-form": "bun run ./tools/introspect-form.ts"
   },
   "devDependencies": {
     "@types/bun": "latest",
@@ -22,5 +25,8 @@
     "ajv": "^8.20.0",
     "googleapis": "^173.0.0",
     "playwright": "^1.61.1"
+  },
+  "patchedDependencies": {
+    "playwright-core@1.61.1": "patches/playwright-core@1.61.1.patch"
   }
 }

package/patches/playwright-core@1.61.1.patch

@@ -0,0 +1,31 @@
+diff --git a/lib/coreBundle.js b/lib/coreBundle.js
+index 7d8468fd89fd4d292eade471c36e757c23cbec44..6540f61c85efbb3e14d02cd06400750ed754731b 100644
+--- a/lib/coreBundle.js
++++ b/lib/coreBundle.js
+@@ -38873,7 +38873,7 @@ var init_transport = __esm({
+     "use strict";
+     init_happyEyeballs();
+     init_task();
+-    ws = require("./utilsBundle").ws;
++    ws = "Bun" in globalThis ? require(require.resolve("ws", { paths: ["/"] })) : require("./utilsBundle").ws;
+     perMessageDeflate2 = {
+       clientNoContextTakeover: true,
+       zlibDeflateOptions: {
+@@ -49404,7 +49404,7 @@ var init_wvBrowser = __esm({
+     init_dialogBridge();
+     init_wvConnection();
+     init_wvPage();
+-    ws2 = require("./utilsBundle").ws;
++    ws2 = "Bun" in globalThis ? require(require.resolve("ws", { paths: ["/"] })) : require("./utilsBundle").ws;
+     DeferredWebSocketTransport = class {
+       constructor(url2, headers) {
+         this._closed = false;
+@@ -71153,7 +71153,7 @@ var init_cdpRelay = __esm({
+     init_cdpRelayV2();
+     init_protocol();
+     debug15 = require("./utilsBundle").debug;
+-    ws3 = require("./utilsBundle").ws;
++    ws3 = "Bun" in globalThis ? require(require.resolve("ws", { paths: ["/"] })) : require("./utilsBundle").ws;
+     ({ wsServer: wsServer3 } = require("./utilsBundle"));
+     debugLogger2 = debug15("pw:mcp:relay");
+     CDPRelayServer = class {

package/src/google-auth-service.ts

@@ -0,0 +1,64 @@
+import fs from 'fs/promises';
+import { google } from 'googleapis';
+import type { GoogleAuthOptions } from './types';
+
+export class GoogleAuthService {
+  private authOptions?: GoogleAuthOptions;
+
+  constructor(authOptions?: GoogleAuthOptions) {
+    this.authOptions = authOptions;
+  }
+
+  /**
+   * Resolves Google Auth OAuth2 Client using explicitly provided credentials or paths.
+   */
+  public async getGoogleAuthClient(): Promise<any> {
+    // 1. Try explicit programmatic credentials
+    const clientId = this.authOptions?.clientId;
+    const clientSecret = this.authOptions?.clientSecret;
+    const refreshToken = this.authOptions?.refreshToken;
+
+    if (clientId && clientSecret && refreshToken) {
+      const oauth2Client = new google.auth.OAuth2(clientId, clientSecret);
+      oauth2Client.setCredentials({ refresh_token: refreshToken });
+      await oauth2Client.getAccessToken();
+      return oauth2Client;
+    }
+
+    // 2. Try explicit file paths
+    const credentialsPath = this.authOptions?.credentialsPath;
+    const tokenPath = this.authOptions?.tokenPath;
+
+    if (!credentialsPath || !tokenPath) {
+      throw new Error(
+        '[GoogleFormSubmitter] Google OAuth credentials are not configured. ' +
+        'Please pass { clientId, clientSecret, refreshToken } programmatically, ' +
+        'or specify both { credentialsPath, tokenPath } in auth options.'
+      );
+    }
+
+    // Load credentials from credentials.json
+    const credentialsContent = await fs.readFile(credentialsPath, 'utf-8');
+    const credentials = JSON.parse(credentialsContent);
+    const fileClientId = credentials.client_id || credentials.web?.client_id || credentials.installed?.client_id;
+    const fileClientSecret = credentials.client_secret || credentials.web?.client_secret || credentials.installed?.client_secret;
+
+    // Load token from forms-auth.json
+    const tokenContent = await fs.readFile(tokenPath, 'utf-8');
+    const token = JSON.parse(tokenContent);
+    const fileRefreshToken = token.refresh_token;
+
+    if (!fileClientId || !fileClientSecret || !fileRefreshToken) {
+      throw new Error(
+        '[GoogleFormSubmitter] Invalid OAuth configuration in provided credential files: ' +
+        'client_id, client_secret, or refresh_token is missing.'
+      );
+    }
+
+    const oauth2Client = new google.auth.OAuth2(fileClientId, fileClientSecret);
+    oauth2Client.setCredentials({ refresh_token: fileRefreshToken });
+    
+    await oauth2Client.getAccessToken();
+    return oauth2Client;
+  }
+}

package/src/google-drive-service.ts

@@ -0,0 +1,36 @@
+import { google } from 'googleapis';
+import { Readable } from 'stream';
+import type { GoogleAuthService } from './google-auth-service';
+
+export class GoogleDriveService {
+  private authService: GoogleAuthService;
+
+  constructor(authService: GoogleAuthService) {
+    this.authService = authService;
+  }
+
+  /**
+   * Uploads a file buffer directly to Google Drive.
+   */
+  public async uploadFile(filename: string, mimeType: string, buffer: Buffer): Promise<string> {
+    const auth = await this.authService.getGoogleAuthClient();
+    const drive = google.drive({ version: 'v3', auth });
+    
+    const response = await drive.files.create({
+      requestBody: {
+        name: filename
+      },
+      media: {
+        mimeType,
+        body: Readable.from(buffer)
+      },
+      fields: 'id'
+    });
+
+    const id = response.data.id;
+    if (!id) {
+      throw new Error('[GoogleFormSubmitter] Failed to upload file to Google Drive: response did not contain file ID');
+    }
+    return id;
+  }
+}

package/{test.ts → src/google-form-submitter.test.ts}

@@ -1,4 +1,5 @@
-import { GoogleFormSubmitter } from './GoogleFormSubmitter';
+import { describe, expect, test, beforeAll } from 'bun:test';
+import { GoogleFormSubmitter } from './google-form-submitter';
 import type { FormSchemaMapping } from './types';
 import fs from 'fs/promises';
 import path from 'path';
@@ -21,10 +22,11 @@ const jsonSchema = {
       type: 'object',
       properties: {
         fileId: { type: 'string' },
+        buffer: { type: 'object' },
         filename: { type: 'string' },
         mimeType: { type: 'string' }
       },
-      required: ['fileId', 'filename', 'mimeType']
+      required: ['filename', 'mimeType']
     },
     company: { type: 'string' },
     checklist: { type: 'string' },
@@ -65,75 +67,74 @@ const mappingSchema: FormSchemaMapping = {
   comment: { label: 'Комментарий', type: 'paragraph' }
 };
 
-async function run() {
-  console.log('🚀 Starting Google Form Submitter Integration Test...');
-
-  // Load cookies from local scratch path if it exists
+describe('GoogleFormSubmitter E2E Integration', () => {
   let cookies: any[] = [];
-  const localCookiesPath = path.join(__dirname, '..', 'scratch', 'playwright-submit', 'google-cookies.json');
-  try {
-    const cookiesStr = await fs.readFile(localCookiesPath, 'utf8');
-    cookies = JSON.parse(cookiesStr);
-    console.log(`[Test] Loaded ${cookies.length} session cookies from ${localCookiesPath}`);
-  } catch (err: any) {
-    console.warn(`[Test] Warning: Could not load local session cookies: ${err.message}`);
-  }
+  let submitter: GoogleFormSubmitter;
+
+  beforeAll(async () => {
+    // Load cookies from local environment path if it exists
+    const localCookiesPath = process.env.GOOGLE_COOKIES_PATH || path.join(__dirname, '..', '.data', 'google-cookies.json');
+    try {
+      const cookiesStr = await fs.readFile(localCookiesPath, 'utf8');
+      cookies = JSON.parse(cookiesStr);
+      console.log(`[Test] Loaded ${cookies.length} session cookies from ${localCookiesPath}`);
+    } catch (err: any) {
+      console.warn(`[Test] Warning: Could not load local session cookies: ${err.message}`);
+    }
+
+    const formUrl = 'https://docs.google.com/forms/d/e/1FAIpQLSc1aiEAhxWCMSNjZ1asGDtXV_mT8vTiJRquiqfdjsoMkKT9tw/viewform';
+    const credentialsPath = path.join(__dirname, '..', '..', 'imatching', '.data', 'credentials.json');
+    const tokenPath = path.join(__dirname, '..', '..', 'imatching', '.data', 'forms-auth.json');
 
-  // 3. Instantiate the Submitter
-  const formUrl = 'https://docs.google.com/forms/d/e/1FAIpQLSc1aiEAhxWCMSNjZ1asGDtXV_mT8vTiJRquiqfdjsoMkKT9tw/viewform';
-  const submitter = new GoogleFormSubmitter({
-    formUrl,
-    jsonSchema,
-    mappingSchema,
-    cdpUrl: 'ws://127.0.0.1:9222/', // CDP endpoint to Lightpanda
-    cacheDir: './.data',
-    cookies
+    submitter = new GoogleFormSubmitter({
+      formUrl,
+      jsonSchema,
+      mappingSchema,
+      cdpUrl: 'ws://127.0.0.1:9222/', // CDP endpoint to Lightpanda
+      cacheDir: './.data',
+      auth: {
+        credentialsPath,
+        tokenPath
+      },
+      cookies
+    });
   });
 
-  // Mock candidate payload matching the JSON Schema
-  const candidateData = {
-    requestId: '910',
-    fullName: 'Багманов Алмаз (Схема)',
-    birthDate: '1996-07-03',
-    grade: 'Middle',
-    location: 'Россия, Набережные Челны',
-    rate: '2000',
-    nds: 'Нет',
-    exitDate: 'через 21 дней',
-    vacation: 'нет',
-    inStaff: 'Да', // Standard predefined value
-    cvFile: {
-      fileId: '1BRVwwPlohb_4g7DUZ3HTzHTwe6yQz2f7', // Real Drive File ID from earlier successful run
-      filename: 'cv_Багманов_Алмаз.docx',
-      mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-    },
-    company: 'Iconicompany',
-    checklist: '📊 Чек-лист: 77% (Kotlin, Android, Compose, Coroutines)',
-    comment: 'Отправлено автоматически через типизированный маппер.'
-  };
+  test('should dynamically resolve fields, upload file, and submit successfully', async () => {
+    const candidateData = {
+      requestId: '910',
+      fullName: 'Багманов Алмаз (Схема)',
+      birthDate: '1996-07-03',
+      grade: 'Middle',
+      location: 'Россия, Набережные Челны',
+      rate: '2000',
+      nds: 'Нет',
+      exitDate: 'через 21 дней',
+      vacation: 'нет',
+      inStaff: 'Да',
+      cvFile: {
+        buffer: Buffer.from('mock cv file contents for integration test'),
+        filename: 'cv_Багманов_Алмаз.docx',
+        mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+      },
+      company: 'Iconicompany',
+      checklist: '📊 Чек-лист: 77% (Kotlin, Android, Compose, Coroutines)',
+      comment: 'Отправлено автоматически через типизированный маппер.'
+    };
 
-  try {
-    // Perform first submission (will trigger lazy DOM-resolution and save cache)
     console.log('\n--- FIRST RUN: Performing dynamic DOM-resolution and submission ---');
     const result1 = await submitter.submit(candidateData);
-    console.log('Result 1 Success:', result1.success);
-    console.log('Result 1 Status Code:', result1.statusCode);
     console.log('Result 1 Fields Submitted:', JSON.stringify(result1.fieldsSubmitted, null, 2));
 
-    // Perform second submission (will load resolved entryIds instantly from cache)
+    expect(result1.success).toBe(true);
+    expect(result1.statusCode).toBe(200);
+
     console.log('\n--- SECOND RUN: Submitting instantly using cache ---');
-    // Change name slightly to verify a new answer is posted
     candidateData.fullName = 'Багманов Алмаз (Схема-Кэш)';
     const result2 = await submitter.submit(candidateData);
-    console.log('Result 2 Success:', result2.success);
-    console.log('Result 2 Status Code:', result2.statusCode);
     console.log('Result 2 Fields Submitted:', JSON.stringify(result2.fieldsSubmitted, null, 2));
 
-    console.log('\n🎉 Integration test completed successfully!');
-  } catch (error) {
-    console.error('❌ Integration test failed:', error);
-    process.exit(1);
-  }
-}
-
-run();
+    expect(result2.success).toBe(true);
+    expect(result2.statusCode).toBe(200);
+  }, 45000); // 45 seconds timeout
+});

package/{GoogleFormSubmitter.ts → src/google-form-submitter.ts}

@@ -2,7 +2,9 @@ import { chromium } from 'playwright';
 import Ajv from 'ajv';
 import fs from 'fs/promises';
 import path from 'path';
-import type { FormSchemaMapping, SubmissionResult } from './types';
+import type { FormSchemaMapping, SubmissionResult, GoogleAuthOptions } from './types';
+import { GoogleAuthService } from './google-auth-service';
+import { GoogleDriveService } from './google-drive-service';
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -15,6 +17,8 @@ export class GoogleFormSubmitter {
   private entryIdCache: Record<string, string> | null = null;
   private validateFn: ReturnType<typeof ajv.compile>;
   private cookies?: Array<any>;
+  private authService: GoogleAuthService;
+  private driveService: GoogleDriveService;
 
   constructor(options: {
     formUrl: string;
@@ -23,13 +27,17 @@ export class GoogleFormSubmitter {
     cdpUrl?: string;
     cacheDir?: string;
     cookies?: Array<any>;
+    auth?: GoogleAuthOptions;
   }) {
     this.formUrl = options.formUrl;
     this.jsonSchema = options.jsonSchema;
     this.mappingSchema = options.mappingSchema;
     this.cdpUrl = options.cdpUrl || 'ws://127.0.0.1:9222/';
     this.cookies = options.cookies;
-    
+
+    this.authService = new GoogleAuthService(options.auth);
+    this.driveService = new GoogleDriveService(this.authService);
+
     // Compile JSON Schema validation function
     this.validateFn = ajv.compile(this.jsonSchema);
 
@@ -37,7 +45,7 @@ export class GoogleFormSubmitter {
     const formIdMatch = this.formUrl.match(/\/d\/e\/([a-zA-Z0-9_-]+)/) || this.formUrl.match(/\/d\/([a-zA-Z0-9_-]+)/);
     const formHash = formIdMatch ? formIdMatch[1] : Buffer.from(this.formUrl).toString('base64').substring(0, 16);
     
-    const cacheDir = options.cacheDir || path.join(process.cwd(), '.data');
+    const cacheDir = options.cacheDir || process.cwd();
     this.cacheFilePath = path.join(cacheDir, `form-cache-${formHash}.json`);
   }
 
@@ -83,13 +91,13 @@ export class GoogleFormSubmitter {
 
     try {
       await page.goto(this.formUrl);
-      // Wait for fields to load
-      await page.locator('.Qr7Oae').first().waitFor({ state: 'attached', timeout: 15000 });
+      // Wait for page load and check if form is closed
+      await this.checkClosedAndGetPage(page);
 
       // Scan DOM for question containers
       const domMappings = await page.evaluate(() => {
         const result: Record<string, string> = {};
-        const containers = document.querySelectorAll('.Qr7Oae');
+        const containers = (globalThis as any).document.querySelectorAll('.Qr7Oae');
 
         containers.forEach((container: any) => {
           const headerEl = container.querySelector('[role="heading"], .M7eMe, .HoRgec');
@@ -111,24 +119,19 @@ export class GoogleFormSubmitter {
             }
           }
 
-          // Strategy B: Parse from data-params if Strategy A fails
+          // Strategy B: Parse data-params attribute in container or child elements
           if (!entryId) {
-            let dataParams = container.getAttribute('data-params') || '';
-            if (!dataParams) {
-              const el = container.querySelector('[data-params]');
-              if (el) {
-                dataParams = el.getAttribute('data-params') || '';
-              }
-            }
-            if (dataParams) {
-              const match = dataParams.match(/\[\[(\d+)/);
+            const paramsEl = container.hasAttribute('data-params') ? container : container.querySelector('[data-params]');
+            if (paramsEl) {
+              const dataParams = paramsEl.getAttribute('data-params');
+              const match = dataParams?.match(/\[\[(\d+)/);
               if (match && match[1]) {
                 entryId = match[1];
               }
             }
           }
 
-          if (labelText && entryId) {
+          if (entryId) {
             result[labelText] = entryId;
           }
         });
@@ -136,26 +139,13 @@ export class GoogleFormSubmitter {
         return result;
       });
 
-      // 3. Map mappingSchema properties to resolved entry IDs
+      console.log(`[GoogleFormSubmitter] Discovered ${Object.keys(domMappings).length} fields in Form DOM.`);
+
+      // 3. Map properties from mappingSchema to Google Forms entryIds
       const resolvedCache: Record<string, string> = {};
       for (const [propName, fieldMapping] of Object.entries(this.mappingSchema)) {
-        // Try finding a match in the scraped titles
-        let matchedEntryId: string | undefined = undefined;
-
-        // Try exact match first
-        matchedEntryId = domMappings[fieldMapping.label];
-
-        // Try substring match as fallback
-        if (!matchedEntryId) {
-          const lowerLabel = fieldMapping.label.toLowerCase();
-          const scrapedTitle = Object.keys(domMappings).find(
-            (t) => t.toLowerCase().includes(lowerLabel) || lowerLabel.includes(t.toLowerCase())
-          );
-          if (scrapedTitle) {
-            matchedEntryId = domMappings[scrapedTitle];
-          }
-        }
-
+        // Find matching entryId by label
+        const matchedEntryId = domMappings[fieldMapping.label];
         if (matchedEntryId) {
           resolvedCache[propName] = matchedEntryId;
         } else {
@@ -176,6 +166,26 @@ export class GoogleFormSubmitter {
     }
   }
 
+  /**
+   * Safe check to determine if the form is closed, throwing a clear error instead of timing out.
+   */
+  private async checkClosedAndGetPage(page: any): Promise<void> {
+    await Promise.any([
+      page.locator('.Qr7Oae').first().waitFor({ state: 'attached', timeout: 15000 }),
+      page.waitForURL(/\/closedform/, { timeout: 15000 }).catch(() => {})
+    ]).catch(() => {});
+
+    const isClosed = page.url().includes('/closedform') || (await page.locator('form').count() === 0);
+
+    if (isClosed) {
+      throw new Error('Google Form is closed (no longer accepting responses)');
+    }
+
+    if (await page.locator('.Qr7Oae').count() === 0) {
+      throw new Error('Could not find question containers on the page.');
+    }
+  }
+
   /**
    * Validates input data and submits the form via direct HTTP POST.
    */
@@ -186,7 +196,7 @@ export class GoogleFormSubmitter {
       const errorMsg = this.validateFn.errors
         ?.map((err) => `${err.instancePath} ${err.message}`)
         .join(', ');
-      throw new Error(`Validation failed: ${errorMsg}`);
+      throw new Error("Validation failed: " + errorMsg);
     }
 
     const typedData = data as Record<string, any>;
@@ -215,11 +225,18 @@ export class GoogleFormSubmitter {
       const currentList = fieldsMap[entryId];
 
       if (fieldMapping.type === 'file') {
-        if (value && typeof value === 'object' && 'fileId' in value) {
-          const filePayload = [[[value.fileId, value.filename, value.mimeType]]];
-          const serialized = JSON.stringify(filePayload);
-          currentList?.push(serialized);
-          fieldsSubmitted[fieldMapping.label] = serialized;
+        if (value && typeof value === 'object' && ('fileId' in value || 'buffer' in value)) {
+          let fileId = value.fileId;
+          if (!fileId && value.buffer) {
+            console.log(`[GoogleFormSubmitter] File buffer detected. Uploading "${value.filename}" to Google Drive...`);
+            fileId = await this.driveService.uploadFile(value.filename, value.mimeType, value.buffer);
+          }
+          if (fileId) {
+            const filePayload = [[[fileId, value.filename, value.mimeType]]];
+            const serialized = JSON.stringify(filePayload);
+            currentList?.push(serialized);
+            fieldsSubmitted[fieldMapping.label] = serialized;
+          }
         }
       } else if (fieldMapping.type === 'choice' && fieldMapping.allowOther && value) {
         const isPredefined = fieldMapping.options?.choices?.includes(value);
@@ -264,7 +281,7 @@ export class GoogleFormSubmitter {
 
     try {
       await page.goto(this.formUrl);
-      await page.locator('.Qr7Oae').first().waitFor({ state: 'attached', timeout: 15000 });
+      await this.checkClosedAndGetPage(page);
 
       console.log(`[GoogleFormSubmitter] Sending HTTP POST request in page context...`);
       const responseInfo = await page.evaluate(async ({ fieldsMap }) => {
@@ -282,34 +299,38 @@ export class GoogleFormSubmitter {
         }
 
         for (const [entryId, values] of Object.entries(fieldsMap)) {
-          for (const val of values as string[]) {
+          const list = values as string[];
+          for (const val of list) {
             searchParams.append(`entry.${entryId}`, val);
           }
         }
 
-        const actionUrl = form.action || g.location.href.replace('/viewform', '/formResponse');
-        
-        const res = await g.fetch(actionUrl, {
+        const actionUrl = form.getAttribute('action') || '';
+        const resolvedActionUrl = new URL(actionUrl, g.location.href).href;
+
+        console.log(`Sending POST to ${resolvedActionUrl}...`);
+        const response = await g.fetch(resolvedActionUrl, {
           method: 'POST',
-          body: searchParams,
           headers: {
             'Content-Type': 'application/x-www-form-urlencoded'
-          }
+          },
+          body: searchParams.toString()
         });
 
         return {
-          status: res.status,
-          text: await res.text()
+          status: response.status,
+          url: response.url,
+          bodyText: await response.text()
         };
       }, { fieldsMap });
 
-      const isSuccess = responseInfo.status === 200 || responseInfo.text.includes('v-confirmation-msg') || responseInfo.text.toLowerCase().includes('confirmation');
+      const success = responseInfo.status === 200;
 
       return {
-        success: isSuccess,
+        success,
         statusCode: responseInfo.status,
-        message: isSuccess ? 'Form submitted successfully!' : 'Google Form rejected submission.',
-        fieldsSubmitted,
+        message: success ? 'Form submitted successfully' : `Server responded with status ${responseInfo.status}`,
+        fieldsSubmitted
       };
     } finally {
       await context.close();

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './google-form-submitter';
+export * from './google-auth-service';
+export * from './google-drive-service';

package/{types.ts → src/types.ts}

@@ -16,3 +16,11 @@ export interface SubmissionResult {
   message?: string;
   fieldsSubmitted: Record<string, string>;
 }
+
+export interface GoogleAuthOptions {
+  clientId?: string;
+  clientSecret?: string;
+  refreshToken?: string;
+  credentialsPath?: string;
+  tokenPath?: string;
+}

package/tools/introspect-form.ts

@@ -0,0 +1,264 @@
+import { chromium } from 'playwright';
+import fs from 'fs/promises';
+import path from 'path';
+
+function toCamelCase(str: string): string {
+  // Map common Russian terms to standard project English keys
+  const translations: Record<string, string> = {
+    'фио': 'fullName',
+    'дата рождения': 'birthDate',
+    'грейд': 'grade',
+    'локация': 'location',
+    'рейт': 'rate',
+    'ндс': 'nds',
+    'когда кандидат': 'exitDate',
+    'отпуск': 'vacation',
+    'штате': 'inStaff',
+    'cv': 'cvFile',
+    'резюме': 'cvFile',
+    'компания': 'company',
+    'контакты': 'contacts',
+    'требованиям': 'checklist',
+    'комментарий': 'comment',
+    'номер запроса': 'requestId'
+  };
+
+  const lower = str.toLowerCase();
+  for (const [key, val] of Object.entries(translations)) {
+    if (lower.includes(key)) {
+      return val;
+    }
+  }
+
+  // Fallback to transliteration + camelCase
+  const clean = str
+    .replace(/[^a-zA-Zа-яА-Я0-9\s]/g, '')
+    .trim()
+    .replace(/\s+/g, ' ');
+
+  const ru: Record<string, string> = {
+    'а':'a', 'б':'b', 'в':'v', 'г':'g', 'д':'d', 'е':'e', 'ё':'yo', 'ж':'zh', 'з':'z', 'и':'i', 'й':'y', 'к':'k', 'л':'l', 'м':'m', 'н':'n', 'о':'o', 'п':'p', 'р':'r', 'с':'s', 'т':'t', 'у':'u', 'ф':'f', 'х':'h', 'ц':'ts', 'ч':'ch', 'ш':'sh', 'щ':'sch', 'ъ':'', 'ы':'y', 'ь':'', 'э':'e', 'ю':'yu', 'я':'ya',
+    'А':'A', 'Б':'B', 'В':'V', 'Г':'G', 'Д':'D', 'Е':'E', 'Ё':'Yo', 'Ж':'Zh', 'З':'Z', 'И':'I', 'Й':'Y', 'К':'K', 'Л':'L', 'М':'M', 'Н':'N', 'О':'O', 'П':'P', 'Р':'R', 'С':'S', 'Т':'T', 'У':'U', 'Ф':'F', 'Х':'H', 'Ц':'Ts', 'Ч':'Ch', 'Ш':'Sh', 'Щ':'Sch', 'Ъ':'', 'Ы':'Y', 'Ь':'', 'Э':'E', 'Ю':'Yu', 'Я':'Ya'
+  };
+  
+  let transliterated = '';
+  for (const char of clean) {
+    const replacement = ru[char] !== undefined ? ru[char] : char;
+    transliterated += replacement;
+  }
+
+  const words = transliterated.split(' ');
+  return words
+    .map((word, idx) => {
+      if (idx === 0) return word.toLowerCase();
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+    .join('');
+}
+
+async function main() {
+  const url = process.argv[2];
+  if (!url) {
+    console.error('Usage: bun run ./tools/introspect-form.ts <google-form-url>');
+    process.exit(1);
+  }
+
+  console.log(`🔍 Connecting to Google Form at: ${url}...`);
+
+  let browser;
+  try {
+    // Attempt connecting to local Lightpanda first
+    browser = await chromium.connectOverCDP(process.env.LIGHTPANDA_CDP_URL || 'ws://127.0.0.1:9222/', { timeout: 5000 });
+  } catch {
+    console.log('Lightpanda not found, falling back to local headless Chromium...');
+    browser = await chromium.launch({ headless: true });
+  }
+
+  const context = await browser.newContext();
+
+  // Load session cookies if GOOGLE_COOKIES_PATH is configured
+  const cookiesPath = process.env.GOOGLE_COOKIES_PATH;
+  if (cookiesPath) {
+    try {
+      const cookiesStr = await fs.readFile(cookiesPath, 'utf8');
+      const cookies = JSON.parse(cookiesStr);
+      await context.addCookies(cookies);
+      console.log(`[Introspect] Injected ${cookies.length} session cookies from ${cookiesPath}`);
+    } catch (e: any) {
+      console.warn(`[Introspect] Warning: Could not inject cookies: ${e.message}`);
+    }
+  }
+
+  const page = await context.newPage();
+  page.on('console', msg => console.log('PAGE LOG:', msg.text()));
+
+  try {
+    await page.goto(url);
+
+    // Wait for the form contents to load
+    await Promise.any([
+      page.locator('.Qr7Oae').first().waitFor({ state: 'attached', timeout: 15000 }),
+      page.waitForURL(/\/closedform/, { timeout: 15000 }).catch(() => {})
+    ]).catch(() => {});
+
+    if (page.url().includes('/closedform') || (await page.locator('form').count() === 0)) {
+      throw new Error('This Google Form is closed or redirecting to login. Make sure your session cookies are valid.');
+    }
+
+    // Inspect DOM
+    const questions = await page.evaluate(() => {
+      const g = globalThis as any;
+      const result: any[] = [];
+      const containers = g.document.querySelectorAll('.Qr7Oae');
+
+      containers.forEach((container: any) => {
+        const headerEl = container.querySelector('[role="heading"], .M7eMe, .HoRgec');
+        if (!headerEl) return;
+
+        let labelText = (headerEl.textContent || '').trim();
+        const isRequired = labelText.endsWith('*');
+        labelText = labelText.replace(/\s*\*$/, '').trim();
+
+        let type = 'text';
+        let choices: string[] = [];
+        let allowOther = false;
+
+        const paramsEl = container.hasAttribute('data-params') ? container : container.querySelector('[data-params]');
+        if (paramsEl) {
+          const dataParams = paramsEl.getAttribute('data-params');
+          try {
+            // Replace Google Forms prefix with '[' to restore the outer array opening bracket
+            const jsonText = dataParams.replace(/^%\.@\./, '[');
+            const parsed = JSON.parse(jsonText);
+            const questionInfo = parsed[0];
+            const typeId = questionInfo[3];
+            
+            if (typeId === 11 || typeId === 13) {
+              type = 'file';
+            } else if (typeId === 9) {
+              type = 'date';
+            } else if (typeId === 1) {
+              type = 'paragraph';
+            } else if (typeId === 2 || typeId === 3 || typeId === 4) {
+              type = 'choice';
+              const choicesArray = questionInfo[4]?.[0]?.[1];
+              if (choicesArray && Array.isArray(choicesArray)) {
+                choices = choicesArray.map((c: any) => c[0]).filter((val) => val !== null && val !== undefined && val !== '');
+              }
+              allowOther = !!questionInfo[4]?.[0]?.[2];
+            }
+          } catch (e: any) {
+            console.error('PAGE LOG [Parser Error]:', e.message, 'Data:', dataParams);
+            // Fallback to legacy DOM checks if parse fails
+            if (container.querySelector('[type="file"]') || container.querySelector('[data-params*="file"]')) {
+              type = 'file';
+            } else if (container.querySelector('input[type="date"]') || container.querySelector('[data-params*="[[3,"]')) {
+              type = 'date';
+            } else if (container.querySelector('[role="radio"], [role="checkbox"], select, .SGZTVe')) {
+              type = 'choice';
+              const optionEls = container.querySelectorAll('[role="radio"] + *, [role="checkbox"] + *, option, .fwW70c, .text');
+              optionEls.forEach((opt: any) => {
+                const text = (opt.textContent || '').trim();
+                if (text && !text.toLowerCase().includes('другое') && !text.toLowerCase().includes('other')) {
+                  choices.push(text);
+                }
+              });
+            } else if (container.querySelector('textarea')) {
+              type = 'paragraph';
+            }
+          }
+        } else {
+          console.warn('PAGE LOG: paramsEl not found for label:', labelText);
+        }
+
+        result.push({
+          label: labelText,
+          type,
+          required: isRequired,
+          choices: choices.length > 0 ? [...new Set(choices)] : undefined,
+          allowOther: allowOther || undefined
+        });
+      });
+
+      return result;
+    });
+
+    console.log(`\n🎉 Introspected ${questions.length} fields successfully. Generating schema objects...\n`);
+
+    const jsonProperties: Record<string, any> = {};
+    const jsonRequired: string[] = [];
+    const mappingSchema: Record<string, any> = {};
+
+    for (const q of questions) {
+      const key = toCamelCase(q.label);
+
+      // JSON Schema building
+      if (q.type === 'file') {
+        jsonProperties[key] = {
+          type: 'object',
+          properties: {
+            fileId: { type: 'string' },
+            buffer: { type: 'object' },
+            filename: { type: 'string' },
+            mimeType: { type: 'string' }
+          },
+          required: ['filename', 'mimeType']
+        };
+      } else if (q.type === 'choice') {
+        jsonProperties[key] = {
+          type: 'string'
+        };
+        if (q.choices && q.choices.length > 0) {
+          jsonProperties[key].enum = q.choices;
+        }
+      } else {
+        jsonProperties[key] = {
+          type: 'string'
+        };
+        if (q.type === 'date') {
+          jsonProperties[key].pattern = '^\\d{4}-\\d{2}-\\d{2}$';
+        }
+      }
+
+      if (q.required) {
+        jsonRequired.push(key);
+      }
+
+      // Mapping Schema building
+      mappingSchema[key] = {
+        label: q.label,
+        type: q.type
+      };
+      if (q.type === 'choice') {
+        mappingSchema[key].options = {
+          choices: q.choices || []
+        };
+        if (q.allowOther) {
+          mappingSchema[key].options.allowOther = true;
+        }
+      }
+    }
+
+    const finalJsonSchema = {
+      type: 'object',
+      properties: jsonProperties,
+      required: jsonRequired
+    };
+
+    // Print TypeScript output
+    console.log('// ==========================================');
+    console.log('// GENERATED SCHEMAS FOR GOOGLE FORM');
+    console.log('// ==========================================');
+    console.log('\nexport const JSON_SCHEMA = ' + JSON.stringify(finalJsonSchema, null, 2) + ';\n');
+    console.log('export const MAPPING_SCHEMA = ' + JSON.stringify(mappingSchema, null, 2) + ';\n');
+
+  } finally {
+    await context.close();
+    await browser.close();
+  }
+}
+
+main().catch((err) => {
+  console.error('❌ Error during form introspection:', err.message);
+  process.exit(1);
+});

package/index.ts

@@ -1,2 +0,0 @@
-export * from './types';
-export * from './GoogleFormSubmitter';