vibekit-auth 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const keychain_1 = require("./keychain");
+const upload_1 = require("./upload");
+const VIBEKIT_SERVER = process.env.VIBEKIT_SERVER || 'https://vibekit.bot';
+async function main() {
+    console.log();
+    console.log(chalk_1.default.bold.cyan('  VibeKit Auth'));
+    console.log(chalk_1.default.gray('  Upload your Claude credentials for Auto Mode'));
+    console.log();
+    // Step 1: Extract credentials from Keychain
+    const extractSpinner = (0, ora_1.default)('Looking for Claude credentials...').start();
+    let credentials;
+    try {
+        credentials = (0, keychain_1.extractClaudeCredentials)();
+    }
+    catch (error) {
+        extractSpinner.fail(chalk_1.default.red('Failed to extract credentials'));
+        if (error instanceof Error) {
+            console.log(chalk_1.default.red(`  ${error.message}`));
+        }
+        process.exit(1);
+    }
+    if (!credentials) {
+        extractSpinner.fail(chalk_1.default.red('Claude credentials not found'));
+        console.log();
+        console.log(chalk_1.default.yellow('  Make sure you have Claude Code installed and logged in:'));
+        console.log(chalk_1.default.gray('  1. Install: npm install -g @anthropic-ai/claude-code'));
+        console.log(chalk_1.default.gray('  2. Run: claude'));
+        console.log(chalk_1.default.gray('  3. Complete the login flow in your browser'));
+        console.log();
+        process.exit(1);
+    }
+    // Check expiry
+    const expiry = (0, keychain_1.checkCredentialExpiry)(credentials);
+    if (expiry.expired) {
+        extractSpinner.fail(chalk_1.default.red('Claude credentials have expired'));
+        console.log();
+        console.log(chalk_1.default.yellow('  Please re-authenticate with Claude Code:'));
+        console.log(chalk_1.default.gray('  Run: claude --logout && claude'));
+        console.log();
+        process.exit(1);
+    }
+    const subType = (0, keychain_1.formatSubscriptionType)(credentials.claudeAiOauth.subscriptionType);
+    extractSpinner.succeed(chalk_1.default.green(`Found: ${subType}`));
+    // Show expiry info
+    if (expiry.expiringSoon) {
+        console.log(chalk_1.default.yellow(`  ⚠ Expires in ${expiry.daysUntilExpiry} days (${expiry.expiresAt.toLocaleDateString()})`));
+    }
+    else {
+        console.log(chalk_1.default.gray(`  Expires: ${expiry.expiresAt.toLocaleDateString()} (${expiry.daysUntilExpiry} days)`));
+    }
+    console.log();
+    // Step 2: Get Telegram ID
+    const response = await (0, prompts_1.default)([
+        {
+            type: 'text',
+            name: 'telegramId',
+            message: 'Enter your Telegram ID or username:',
+            hint: 'You can find your ID by messaging @userinfobot on Telegram',
+            validate: (value) => {
+                if (!value.trim()) {
+                    return 'Telegram ID is required';
+                }
+                // Allow numeric ID or @username
+                if (!/^(@?[\w]+|\d+)$/.test(value.trim())) {
+                    return 'Enter a valid Telegram ID (number) or username (@username)';
+                }
+                return true;
+            }
+        }
+    ]);
+    if (!response.telegramId) {
+        console.log(chalk_1.default.yellow('\n  Cancelled.'));
+        process.exit(0);
+    }
+    let telegramId = response.telegramId.trim();
+    // If they entered a username, we need to resolve it
+    // For now, require numeric ID
+    if (telegramId.startsWith('@') || isNaN(Number(telegramId))) {
+        console.log();
+        console.log(chalk_1.default.yellow('  Please enter your numeric Telegram ID, not username.'));
+        console.log(chalk_1.default.gray('  To find your ID:'));
+        console.log(chalk_1.default.gray('  1. Open Telegram'));
+        console.log(chalk_1.default.gray('  2. Message @userinfobot'));
+        console.log(chalk_1.default.gray('  3. It will reply with your numeric ID'));
+        console.log();
+        process.exit(1);
+    }
+    const numericTelegramId = parseInt(telegramId, 10);
+    // Step 3: Upload to server
+    console.log();
+    const uploadSpinner = (0, ora_1.default)('Uploading credentials to VibeKit...').start();
+    try {
+        const result = await (0, upload_1.uploadCredentials)(numericTelegramId, credentials, VIBEKIT_SERVER);
+        if (result.success) {
+            uploadSpinner.succeed(chalk_1.default.green('Credentials uploaded successfully!'));
+            console.log();
+            console.log(chalk_1.default.bold.green('  Auto Mode is ready!'));
+            console.log();
+            console.log(chalk_1.default.white('  Open Telegram and use /auto to start.'));
+            console.log(chalk_1.default.gray('  Your Claude subscription will be used for AI - no credits needed.'));
+            console.log();
+        }
+        else {
+            uploadSpinner.fail(chalk_1.default.red('Upload failed'));
+            console.log(chalk_1.default.red(`  ${result.message}`));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        uploadSpinner.fail(chalk_1.default.red('Upload failed'));
+        if (error instanceof Error) {
+            console.log(chalk_1.default.red(`  ${error.message}`));
+        }
+        process.exit(1);
+    }
+}
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+    console.log(chalk_1.default.yellow('\n  Cancelled.'));
+    process.exit(0);
+});
+main().catch((error) => {
+    console.error(chalk_1.default.red('Unexpected error:'), error);
+    process.exit(1);
+});

package/dist/keychain.d.ts

@@ -0,0 +1,18 @@
+import { ClaudeOAuthCredentials } from './types';
+/**
+ * Extract Claude OAuth credentials from macOS Keychain
+ */
+export declare function extractClaudeCredentials(): ClaudeOAuthCredentials | null;
+/**
+ * Check if credentials are expired or expiring soon
+ */
+export declare function checkCredentialExpiry(credentials: ClaudeOAuthCredentials): {
+    expired: boolean;
+    expiringSoon: boolean;
+    expiresAt: Date;
+    daysUntilExpiry: number;
+};
+/**
+ * Format subscription type for display
+ */
+export declare function formatSubscriptionType(type: string): string;

package/dist/keychain.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractClaudeCredentials = extractClaudeCredentials;
+exports.checkCredentialExpiry = checkCredentialExpiry;
+exports.formatSubscriptionType = formatSubscriptionType;
+const child_process_1 = require("child_process");
+const KEYCHAIN_SERVICE_NAME = 'Claude Code-credentials';
+/**
+ * Extract Claude OAuth credentials from macOS Keychain
+ */
+function extractClaudeCredentials() {
+    // Check if running on macOS
+    if (process.platform !== 'darwin') {
+        throw new Error('vibekit-auth currently only supports macOS. ' +
+            'Linux and Windows support coming soon.');
+    }
+    try {
+        // Use security command to get the password from Keychain
+        const result = (0, child_process_1.execSync)(`security find-generic-password -s "${KEYCHAIN_SERVICE_NAME}" -w`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'] // Suppress stderr
+        });
+        const credentials = JSON.parse(result.trim());
+        return credentials;
+    }
+    catch (error) {
+        // Check if it's a "not found" error
+        if (error instanceof Error && error.message.includes('could not be found')) {
+            return null;
+        }
+        // Check for user cancellation (denied Keychain access)
+        if (error instanceof Error && error.message.includes('User canceled')) {
+            throw new Error('Keychain access was denied. Please allow access when prompted.');
+        }
+        // Re-throw other errors
+        throw error;
+    }
+}
+/**
+ * Check if credentials are expired or expiring soon
+ */
+function checkCredentialExpiry(credentials) {
+    const expiresAt = new Date(credentials.claudeAiOauth.expiresAt);
+    const now = new Date();
+    const msUntilExpiry = expiresAt.getTime() - now.getTime();
+    const daysUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60 * 24));
+    return {
+        expired: msUntilExpiry <= 0,
+        expiringSoon: daysUntilExpiry <= 7,
+        expiresAt,
+        daysUntilExpiry
+    };
+}
+/**
+ * Format subscription type for display
+ */
+function formatSubscriptionType(type) {
+    const types = {
+        'pro': 'Claude Pro',
+        'max': 'Claude Max',
+        'free': 'Claude Free'
+    };
+    return types[type.toLowerCase()] || `Claude ${type}`;
+}

package/dist/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Claude OAuth credentials as stored in macOS Keychain
+ */
+export interface ClaudeOAuthCredentials {
+    claudeAiOauth: {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: number;
+        scopes: string[];
+        subscriptionType: 'pro' | 'max' | string;
+        rateLimitTier?: string;
+    };
+    organizationUuid?: string;
+}
+/**
+ * Credentials to upload to server (subset of full credentials)
+ */
+export interface UploadPayload {
+    telegramId: number;
+    credentials: string;
+    subscriptionType: string;
+    expiresAt: number;
+}
+/**
+ * Server response after credential upload
+ */
+export interface UploadResponse {
+    success: boolean;
+    message: string;
+    autoModeEnabled?: boolean;
+}
+/**
+ * Configuration for the CLI
+ */
+export interface Config {
+    serverUrl: string;
+    apiEndpoint: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/upload.d.ts

@@ -0,0 +1,13 @@
+import { ClaudeOAuthCredentials, UploadResponse } from './types';
+/**
+ * Upload credentials to VibeKit server
+ */
+export declare function uploadCredentials(telegramId: number, credentials: ClaudeOAuthCredentials, serverUrl?: string): Promise<UploadResponse>;
+/**
+ * Check if user has existing auto mode credentials on server
+ */
+export declare function checkAutoModeStatus(telegramId: number, serverUrl?: string): Promise<{
+    enabled: boolean;
+    subscriptionType?: string;
+    expiresAt?: number;
+}>;

package/dist/upload.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCredentials = uploadCredentials;
+exports.checkAutoModeStatus = checkAutoModeStatus;
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+const DEFAULT_SERVER_URL = 'https://vibekit.bot';
+/**
+ * Upload credentials to VibeKit server
+ */
+async function uploadCredentials(telegramId, credentials, serverUrl = DEFAULT_SERVER_URL) {
+    const url = new url_1.URL('/api/auto/credentials', serverUrl);
+    // Prepare payload - base64 encode the full credentials JSON
+    const payload = JSON.stringify({
+        telegramId,
+        credentials: Buffer.from(JSON.stringify(credentials)).toString('base64'),
+        subscriptionType: credentials.claudeAiOauth.subscriptionType,
+        expiresAt: credentials.claudeAiOauth.expiresAt
+    });
+    return new Promise((resolve, reject) => {
+        const protocol = url.protocol === 'https:' ? https_1.default : http_1.default;
+        const req = protocol.request(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+                'User-Agent': 'vibekit-auth/1.0.0'
+            }
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const response = JSON.parse(data);
+                    if (res.statusCode === 200 || res.statusCode === 201) {
+                        resolve(response);
+                    }
+                    else {
+                        reject(new Error(response.message || `Server returned ${res.statusCode}`));
+                    }
+                }
+                catch {
+                    reject(new Error(`Invalid server response: ${data}`));
+                }
+            });
+        });
+        req.on('error', (error) => {
+            reject(new Error(`Failed to connect to server: ${error.message}`));
+        });
+        req.write(payload);
+        req.end();
+    });
+}
+/**
+ * Check if user has existing auto mode credentials on server
+ */
+async function checkAutoModeStatus(telegramId, serverUrl = DEFAULT_SERVER_URL) {
+    const url = new url_1.URL(`/api/auto/status?telegramId=${telegramId}`, serverUrl);
+    return new Promise((resolve, reject) => {
+        const protocol = url.protocol === 'https:' ? https_1.default : http_1.default;
+        const req = protocol.request(url, {
+            method: 'GET',
+            headers: {
+                'User-Agent': 'vibekit-auth/1.0.0'
+            }
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const response = JSON.parse(data);
+                    resolve(response);
+                }
+                catch {
+                    resolve({ enabled: false });
+                }
+            });
+        });
+        req.on('error', () => {
+            resolve({ enabled: false });
+        });
+        req.end();
+    });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "vibekit-auth",
+  "version": "1.0.0",
+  "description": "Upload your Claude credentials to VibeKit for Auto Mode",
+  "main": "dist/index.js",
+  "bin": {
+    "vibekit-auth": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "claude",
+    "vibekit",
+    "telegram",
+    "ai"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+import prompts from 'prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+  extractClaudeCredentials,
+  checkCredentialExpiry,
+  formatSubscriptionType
+} from './keychain';
+import { uploadCredentials } from './upload';
+
+const VIBEKIT_SERVER = process.env.VIBEKIT_SERVER || 'https://vibekit.bot';
+
+async function main() {
+  console.log();
+  console.log(chalk.bold.cyan('  VibeKit Auth'));
+  console.log(chalk.gray('  Upload your Claude credentials for Auto Mode'));
+  console.log();
+
+  // Step 1: Extract credentials from Keychain
+  const extractSpinner = ora('Looking for Claude credentials...').start();
+
+  let credentials;
+  try {
+    credentials = extractClaudeCredentials();
+  } catch (error: unknown) {
+    extractSpinner.fail(chalk.red('Failed to extract credentials'));
+    if (error instanceof Error) {
+      console.log(chalk.red(`  ${error.message}`));
+    }
+    process.exit(1);
+  }
+
+  if (!credentials) {
+    extractSpinner.fail(chalk.red('Claude credentials not found'));
+    console.log();
+    console.log(chalk.yellow('  Make sure you have Claude Code installed and logged in:'));
+    console.log(chalk.gray('  1. Install: npm install -g @anthropic-ai/claude-code'));
+    console.log(chalk.gray('  2. Run: claude'));
+    console.log(chalk.gray('  3. Complete the login flow in your browser'));
+    console.log();
+    process.exit(1);
+  }
+
+  // Check expiry
+  const expiry = checkCredentialExpiry(credentials);
+
+  if (expiry.expired) {
+    extractSpinner.fail(chalk.red('Claude credentials have expired'));
+    console.log();
+    console.log(chalk.yellow('  Please re-authenticate with Claude Code:'));
+    console.log(chalk.gray('  Run: claude --logout && claude'));
+    console.log();
+    process.exit(1);
+  }
+
+  const subType = formatSubscriptionType(credentials.claudeAiOauth.subscriptionType);
+  extractSpinner.succeed(chalk.green(`Found: ${subType}`));
+
+  // Show expiry info
+  if (expiry.expiringSoon) {
+    console.log(chalk.yellow(`  ⚠ Expires in ${expiry.daysUntilExpiry} days (${expiry.expiresAt.toLocaleDateString()})`));
+  } else {
+    console.log(chalk.gray(`  Expires: ${expiry.expiresAt.toLocaleDateString()} (${expiry.daysUntilExpiry} days)`));
+  }
+  console.log();
+
+  // Step 2: Get Telegram ID
+  const response = await prompts([
+    {
+      type: 'text',
+      name: 'telegramId',
+      message: 'Enter your Telegram ID or username:',
+      hint: 'You can find your ID by messaging @userinfobot on Telegram',
+      validate: (value: string) => {
+        if (!value.trim()) {
+          return 'Telegram ID is required';
+        }
+        // Allow numeric ID or @username
+        if (!/^(@?[\w]+|\d+)$/.test(value.trim())) {
+          return 'Enter a valid Telegram ID (number) or username (@username)';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  if (!response.telegramId) {
+    console.log(chalk.yellow('\n  Cancelled.'));
+    process.exit(0);
+  }
+
+  let telegramId = response.telegramId.trim();
+
+  // If they entered a username, we need to resolve it
+  // For now, require numeric ID
+  if (telegramId.startsWith('@') || isNaN(Number(telegramId))) {
+    console.log();
+    console.log(chalk.yellow('  Please enter your numeric Telegram ID, not username.'));
+    console.log(chalk.gray('  To find your ID:'));
+    console.log(chalk.gray('  1. Open Telegram'));
+    console.log(chalk.gray('  2. Message @userinfobot'));
+    console.log(chalk.gray('  3. It will reply with your numeric ID'));
+    console.log();
+    process.exit(1);
+  }
+
+  const numericTelegramId = parseInt(telegramId, 10);
+
+  // Step 3: Upload to server
+  console.log();
+  const uploadSpinner = ora('Uploading credentials to VibeKit...').start();
+
+  try {
+    const result = await uploadCredentials(numericTelegramId, credentials, VIBEKIT_SERVER);
+
+    if (result.success) {
+      uploadSpinner.succeed(chalk.green('Credentials uploaded successfully!'));
+      console.log();
+      console.log(chalk.bold.green('  Auto Mode is ready!'));
+      console.log();
+      console.log(chalk.white('  Open Telegram and use /auto to start.'));
+      console.log(chalk.gray('  Your Claude subscription will be used for AI - no credits needed.'));
+      console.log();
+    } else {
+      uploadSpinner.fail(chalk.red('Upload failed'));
+      console.log(chalk.red(`  ${result.message}`));
+      process.exit(1);
+    }
+  } catch (error: unknown) {
+    uploadSpinner.fail(chalk.red('Upload failed'));
+    if (error instanceof Error) {
+      console.log(chalk.red(`  ${error.message}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log(chalk.yellow('\n  Cancelled.'));
+  process.exit(0);
+});
+
+main().catch((error) => {
+  console.error(chalk.red('Unexpected error:'), error);
+  process.exit(1);
+});

package/src/keychain.ts

@@ -0,0 +1,80 @@
+import { execSync } from 'child_process';
+import { ClaudeOAuthCredentials } from './types';
+
+const KEYCHAIN_SERVICE_NAME = 'Claude Code-credentials';
+
+/**
+ * Extract Claude OAuth credentials from macOS Keychain
+ */
+export function extractClaudeCredentials(): ClaudeOAuthCredentials | null {
+  // Check if running on macOS
+  if (process.platform !== 'darwin') {
+    throw new Error(
+      'vibekit-auth currently only supports macOS. ' +
+      'Linux and Windows support coming soon.'
+    );
+  }
+
+  try {
+    // Use security command to get the password from Keychain
+    const result = execSync(
+      `security find-generic-password -s "${KEYCHAIN_SERVICE_NAME}" -w`,
+      {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'] // Suppress stderr
+      }
+    );
+
+    const credentials = JSON.parse(result.trim()) as ClaudeOAuthCredentials;
+    return credentials;
+  } catch (error: unknown) {
+    // Check if it's a "not found" error
+    if (error instanceof Error && error.message.includes('could not be found')) {
+      return null;
+    }
+
+    // Check for user cancellation (denied Keychain access)
+    if (error instanceof Error && error.message.includes('User canceled')) {
+      throw new Error(
+        'Keychain access was denied. Please allow access when prompted.'
+      );
+    }
+
+    // Re-throw other errors
+    throw error;
+  }
+}
+
+/**
+ * Check if credentials are expired or expiring soon
+ */
+export function checkCredentialExpiry(credentials: ClaudeOAuthCredentials): {
+  expired: boolean;
+  expiringSoon: boolean;
+  expiresAt: Date;
+  daysUntilExpiry: number;
+} {
+  const expiresAt = new Date(credentials.claudeAiOauth.expiresAt);
+  const now = new Date();
+  const msUntilExpiry = expiresAt.getTime() - now.getTime();
+  const daysUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60 * 24));
+
+  return {
+    expired: msUntilExpiry <= 0,
+    expiringSoon: daysUntilExpiry <= 7,
+    expiresAt,
+    daysUntilExpiry
+  };
+}
+
+/**
+ * Format subscription type for display
+ */
+export function formatSubscriptionType(type: string): string {
+  const types: Record<string, string> = {
+    'pro': 'Claude Pro',
+    'max': 'Claude Max',
+    'free': 'Claude Free'
+  };
+  return types[type.toLowerCase()] || `Claude ${type}`;
+}

package/src/types.ts

@@ -0,0 +1,41 @@
+/**
+ * Claude OAuth credentials as stored in macOS Keychain
+ */
+export interface ClaudeOAuthCredentials {
+  claudeAiOauth: {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number; // Unix timestamp in milliseconds
+    scopes: string[];
+    subscriptionType: 'pro' | 'max' | string;
+    rateLimitTier?: string;
+  };
+  organizationUuid?: string;
+}
+
+/**
+ * Credentials to upload to server (subset of full credentials)
+ */
+export interface UploadPayload {
+  telegramId: number;
+  credentials: string; // Base64 encoded JSON
+  subscriptionType: string;
+  expiresAt: number;
+}
+
+/**
+ * Server response after credential upload
+ */
+export interface UploadResponse {
+  success: boolean;
+  message: string;
+  autoModeEnabled?: boolean;
+}
+
+/**
+ * Configuration for the CLI
+ */
+export interface Config {
+  serverUrl: string;
+  apiEndpoint: string;
+}

package/src/upload.ts

@@ -0,0 +1,115 @@
+import https from 'https';
+import http from 'http';
+import { URL } from 'url';
+import { ClaudeOAuthCredentials, UploadResponse } from './types';
+
+const DEFAULT_SERVER_URL = 'https://vibekit.bot';
+
+/**
+ * Upload credentials to VibeKit server
+ */
+export async function uploadCredentials(
+  telegramId: number,
+  credentials: ClaudeOAuthCredentials,
+  serverUrl: string = DEFAULT_SERVER_URL
+): Promise<UploadResponse> {
+  const url = new URL('/api/auto/credentials', serverUrl);
+
+  // Prepare payload - base64 encode the full credentials JSON
+  const payload = JSON.stringify({
+    telegramId,
+    credentials: Buffer.from(JSON.stringify(credentials)).toString('base64'),
+    subscriptionType: credentials.claudeAiOauth.subscriptionType,
+    expiresAt: credentials.claudeAiOauth.expiresAt
+  });
+
+  return new Promise((resolve, reject) => {
+    const protocol = url.protocol === 'https:' ? https : http;
+
+    const req = protocol.request(
+      url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+          'User-Agent': 'vibekit-auth/1.0.0'
+        }
+      },
+      (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const response = JSON.parse(data) as UploadResponse;
+
+            if (res.statusCode === 200 || res.statusCode === 201) {
+              resolve(response);
+            } else {
+              reject(new Error(response.message || `Server returned ${res.statusCode}`));
+            }
+          } catch {
+            reject(new Error(`Invalid server response: ${data}`));
+          }
+        });
+      }
+    );
+
+    req.on('error', (error) => {
+      reject(new Error(`Failed to connect to server: ${error.message}`));
+    });
+
+    req.write(payload);
+    req.end();
+  });
+}
+
+/**
+ * Check if user has existing auto mode credentials on server
+ */
+export async function checkAutoModeStatus(
+  telegramId: number,
+  serverUrl: string = DEFAULT_SERVER_URL
+): Promise<{ enabled: boolean; subscriptionType?: string; expiresAt?: number }> {
+  const url = new URL(`/api/auto/status?telegramId=${telegramId}`, serverUrl);
+
+  return new Promise((resolve, reject) => {
+    const protocol = url.protocol === 'https:' ? https : http;
+
+    const req = protocol.request(
+      url,
+      {
+        method: 'GET',
+        headers: {
+          'User-Agent': 'vibekit-auth/1.0.0'
+        }
+      },
+      (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const response = JSON.parse(data);
+            resolve(response);
+          } catch {
+            resolve({ enabled: false });
+          }
+        });
+      }
+    );
+
+    req.on('error', () => {
+      resolve({ enabled: false });
+    });
+
+    req.end();
+  });
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}