@quantiya/codevibe-claude-plugin 1.0.11 → 1.0.13

package/dist/prompt-responder.js

@@ -1,132 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptResponder = void 0;
-const child_process_1 = require("child_process");
-const util_1 = require("util");
-const logger_1 = require("./logger");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
-class PromptResponder {
-    /**
-     * Answer an interactive prompt by sending input to the waiting Claude process
-     * Requires tmux session (set by codevibe-claude wrapper)
-     */
-    async answerInteractivePrompt(sessionId, response) {
-        logger_1.logger.info('Attempting to answer interactive prompt', {
-            sessionId,
-            response,
-        });
-        try {
-            // Check if running in tmux (set by codevibe-claude wrapper)
-            const tmuxSession = process.env.CODEVIBE_TMUX_SESSION;
-            logger_1.logger.info('Checking tmux session environment', {
-                tmuxSession: tmuxSession || '(not set)',
-                allEnvKeys: Object.keys(process.env).filter(k => k.includes('CODEVIBE') || k.includes('TMUX')),
-            });
-            if (!tmuxSession) {
-                logger_1.logger.error('No tmux session found - codevibe-claude wrapper is required', {
-                    sessionId,
-                    hint: 'Start Claude Code using the codevibe-claude wrapper script',
-                });
-                return false;
-            }
-            // Use tmux send-keys (works even when screen is locked)
-            logger_1.logger.info('Using tmux send-keys', { tmuxSession });
-            await this.sendViaTmux(tmuxSession, response);
-            logger_1.logger.info('Successfully sent response to interactive prompt', {
-                sessionId,
-                response,
-            });
-            return true;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to answer interactive prompt', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return false;
-        }
-    }
-    /**
-     * Send input via tmux send-keys
-     * Works even when screen is locked - this is the only supported method
-     */
-    async sendViaTmux(sessionName, input) {
-        // Escape special characters for tmux
-        // tmux send-keys interprets certain sequences, so we need to escape them
-        const escaped = input
-            .replace(/\\/g, '\\\\') // Escape backslashes first
-            .replace(/"/g, '\\"') // Escape double quotes
-            .replace(/\$/g, '\\$') // Escape dollar signs
-            .replace(/`/g, '\\`'); // Escape backticks
-        logger_1.logger.info('Sending via tmux', { sessionName, inputLength: input.length });
-        try {
-            // Step 1: Send the input text (without Enter)
-            const textCmd = `tmux send-keys -t "${sessionName}" -l "${escaped}"`;
-            const textResult = await execAsync(textCmd);
-            logger_1.logger.info('tmux send-keys (text) completed', {
-                stdout: textResult.stdout || '(empty)',
-                stderr: textResult.stderr || '(empty)'
-            });
-            // Step 2: Wait for the text to be processed by the terminal
-            // Longer delay needed for Claude Code's interactive prompts
-            await this.delay(500);
-            // Step 3: Send Enter key separately
-            const enterCmd = `tmux send-keys -t "${sessionName}" Enter`;
-            const enterResult = await execAsync(enterCmd);
-            logger_1.logger.info('tmux send-keys (Enter) completed', {
-                stdout: enterResult.stdout || '(empty)',
-                stderr: enterResult.stderr || '(empty)'
-            });
-        }
-        catch (error) {
-            logger_1.logger.error('tmux send-keys failed', { sessionName, error });
-            throw error;
-        }
-    }
-    /**
-     * Simple delay helper
-     */
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Check if a response looks like an answer to an interactive prompt
-     * Covers Y/N prompts, numbered choices, and other common responses
-     */
-    isPromptResponse(content) {
-        const normalized = content.trim().toLowerCase();
-        // Y/N responses
-        if (normalized === 'y' ||
-            normalized === 'n' ||
-            normalized === 'yes' ||
-            normalized === 'no') {
-            return true;
-        }
-        // Numbered choices (1-9, or just digits)
-        if (/^[0-9]+$/.test(normalized)) {
-            return true;
-        }
-        // Single letter choices (a, b, c, etc.)
-        if (/^[a-z]$/.test(normalized)) {
-            return true;
-        }
-        // Common terminal control inputs
-        // These are typically responses to prompts, not new commands
-        const controlInputs = [
-            'exit',
-            'quit',
-            'q',
-            'continue',
-            'skip',
-            'abort',
-            'retry',
-            'cancel',
-        ];
-        if (controlInputs.includes(normalized)) {
-            return true;
-        }
-        return false;
-    }
-}
-exports.PromptResponder = PromptResponder;
-//# sourceMappingURL=prompt-responder.js.map

package/dist/token-storage.js

@@ -1,169 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.saveTokens = saveTokens;
-exports.loadTokens = loadTokens;
-exports.deleteTokens = deleteTokens;
-exports.isTokenExpired = isTokenExpired;
-exports.isAuthenticated = isAuthenticated;
-exports.getTokenFilePath = getTokenFilePath;
-exports.getTokenExpiration = getTokenExpiration;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const logger_1 = require("./logger");
-// Token storage location - environment-specific
-const TOKEN_DIR = path.join(os.homedir(), '.codevibe-claude');
-// Get environment-specific token file
-function getTokenFile() {
-    const environment = process.env.ENVIRONMENT || 'production';
-    return path.join(TOKEN_DIR, `tokens-${environment}.json`);
-}
-/**
- * Ensure the token directory exists with proper permissions
- */
-function ensureTokenDir() {
-    if (!fs.existsSync(TOKEN_DIR)) {
-        fs.mkdirSync(TOKEN_DIR, { mode: 0o700 }); // rwx------
-        logger_1.logger.debug('Created token directory', { path: TOKEN_DIR });
-    }
-}
-/**
- * Save tokens to secure file storage
- */
-function saveTokens(tokens) {
-    try {
-        ensureTokenDir();
-        const tokenFile = getTokenFile();
-        const content = JSON.stringify(tokens, null, 2);
-        fs.writeFileSync(tokenFile, content, { mode: 0o600 }); // rw-------
-        logger_1.logger.info('Tokens saved successfully', {
-            userId: tokens.userId,
-            email: tokens.email,
-            expiresAt: new Date(tokens.expiresAt).toISOString(),
-            environment: process.env.ENVIRONMENT || 'production',
-        });
-    }
-    catch (error) {
-        logger_1.logger.error('Failed to save tokens:', error);
-        throw new Error(`Failed to save tokens: ${error}`);
-    }
-}
-/**
- * Load tokens from secure file storage
- * Returns null if no tokens are stored or if they're invalid
- */
-function loadTokens() {
-    try {
-        const tokenFile = getTokenFile();
-        if (!fs.existsSync(tokenFile)) {
-            logger_1.logger.debug('No tokens file found', { environment: process.env.ENVIRONMENT || 'production' });
-            return null;
-        }
-        const content = fs.readFileSync(tokenFile, 'utf-8');
-        const tokens = JSON.parse(content);
-        // Validate required fields
-        if (!tokens.accessToken || !tokens.refreshToken || !tokens.expiresAt) {
-            logger_1.logger.warn('Invalid tokens file - missing required fields');
-            return null;
-        }
-        logger_1.logger.debug('Tokens loaded', {
-            userId: tokens.userId,
-            email: tokens.email,
-            expiresAt: new Date(tokens.expiresAt).toISOString(),
-            isExpired: isTokenExpired(tokens),
-        });
-        return tokens;
-    }
-    catch (error) {
-        logger_1.logger.error('Failed to load tokens:', error);
-        return null;
-    }
-}
-/**
- * Delete stored tokens (logout)
- */
-function deleteTokens() {
-    try {
-        const tokenFile = getTokenFile();
-        if (fs.existsSync(tokenFile)) {
-            fs.unlinkSync(tokenFile);
-            logger_1.logger.info('Tokens deleted successfully', { environment: process.env.ENVIRONMENT || 'production' });
-            return true;
-        }
-        logger_1.logger.debug('No tokens file to delete', { environment: process.env.ENVIRONMENT || 'production' });
-        return false;
-    }
-    catch (error) {
-        logger_1.logger.error('Failed to delete tokens:', error);
-        return false;
-    }
-}
-/**
- * Check if the access token is expired or about to expire
- * Considers token expired if less than 5 minutes remaining
- */
-function isTokenExpired(tokens) {
-    const bufferMs = 5 * 60 * 1000; // 5 minutes buffer
-    return Date.now() >= (tokens.expiresAt - bufferMs);
-}
-/**
- * Check if user is authenticated (has valid, non-expired tokens)
- */
-function isAuthenticated() {
-    const tokens = loadTokens();
-    if (!tokens) {
-        return false;
-    }
-    // Even if access token is expired, we can refresh if we have a refresh token
-    return !!tokens.refreshToken;
-}
-/**
- * Get the token file path (for display purposes)
- */
-function getTokenFilePath() {
-    return getTokenFile();
-}
-/**
- * Get token expiration date
- */
-function getTokenExpiration() {
-    const tokens = loadTokens();
-    if (!tokens) {
-        return null;
-    }
-    return new Date(tokens.expiresAt);
-}
-//# sourceMappingURL=token-storage.js.map

package/dist/types.js

@@ -1,17 +0,0 @@
-"use strict";
-//
-// types.ts
-// CodeVibe Claude Plugin
-//
-// Re-export shared types from codevibe-core and define plugin-specific types
-//
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentType = exports.SessionStatus = exports.DeliveryStatus = exports.EventSource = exports.EventType = void 0;
-// Re-export all shared types from core
-var codevibe_core_1 = require("@quantiya/codevibe-core");
-Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return codevibe_core_1.EventType; } });
-Object.defineProperty(exports, "EventSource", { enumerable: true, get: function () { return codevibe_core_1.EventSource; } });
-Object.defineProperty(exports, "DeliveryStatus", { enumerable: true, get: function () { return codevibe_core_1.DeliveryStatus; } });
-Object.defineProperty(exports, "SessionStatus", { enumerable: true, get: function () { return codevibe_core_1.SessionStatus; } });
-Object.defineProperty(exports, "AgentType", { enumerable: true, get: function () { return codevibe_core_1.AgentType; } });
-//# sourceMappingURL=types.js.map

package/node_modules/@quantiya/codevibe-core/README.md

@@ -1,170 +0,0 @@
-# @quantiya/codevibe-core
-
-Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and authentication functionality.
-
-## Installation
-
-```bash
-npm install @quantiya/codevibe-core
-```
-
-## Features
-
-- **Keychain Management** - Secure storage for device keys and OAuth tokens using native keychain (macOS Keychain, Linux libsecret, Windows Credential Manager)
-- **Cryptographic Services** - E2E encryption using ECDH P-256 and AES-256-GCM
-- **AppSync Client** - GraphQL API and WebSocket subscriptions for AWS AppSync
-- **Authentication CLI** - Browser-based OAuth login/logout commands
-- **Shared Types** - TypeScript interfaces for events, sessions, encryption
-
-## CLI Usage
-
-```bash
-# Sign in via browser (opens Cognito Hosted UI)
-codevibe login
-
-# Sign out
-codevibe logout
-
-# Check authentication status
-codevibe status
-
-# Reset device identity (destructive - old sessions become inaccessible)
-codevibe reset-device
-
-# Use specific environment
-codevibe --env development login
-```
-
-## API Usage
-
-### Keychain Manager
-
-```typescript
-import { keychainManager, DeviceIdentity } from '@quantiya/codevibe-core';
-
-// Get or create device identity (stored in native keychain)
-const identity = await keychainManager.getOrCreateDeviceIdentity();
-console.log(identity.deviceId, identity.publicKey);
-
-// Get OAuth tokens
-const tokens = await keychainManager.getTokens('production');
-if (tokens) {
-  console.log(tokens.email, tokens.userId);
-}
-```
-
-### Crypto Service
-
-```typescript
-import { cryptoService } from '@quantiya/codevibe-core';
-
-// Generate key pair
-const keyPair = cryptoService.generateKeyPair();
-
-// Generate session key
-const sessionKey = cryptoService.generateSessionKey();
-
-// Encrypt content
-const encrypted = cryptoService.encryptContent('Hello World', sessionKey);
-
-// Decrypt content
-const decrypted = cryptoService.decryptContent(encrypted, sessionKey);
-```
-
-### AppSync Client
-
-```typescript
-import { AppSyncClient, loadConfig } from '@quantiya/codevibe-core';
-
-// Load environment configuration
-loadConfig('production');
-
-// Create client
-const client = new AppSyncClient('production');
-
-// Authenticate with stored tokens
-const authenticated = await client.authenticateWithStoredTokens();
-if (!authenticated) {
-  console.log('Run "codevibe login" first');
-  process.exit(1);
-}
-
-// Create session
-const session = await client.createSession({
-  userId: client.getCurrentUserId(),
-  agentType: 'CLAUDE',
-  projectPath: '/path/to/project',
-});
-
-// Subscribe to events
-const unsubscribe = client.subscribeToEvents(session.sessionId, (event) => {
-  console.log('Event received:', event);
-});
-
-// Clean up
-unsubscribe();
-```
-
-### Auth Service
-
-```typescript
-import { authService, loadConfig } from '@quantiya/codevibe-core';
-
-// Set environment
-loadConfig('production');
-authService.setEnvironment('production');
-
-// Login (opens browser)
-const tokens = await authService.login();
-
-// Check status
-const status = await authService.getStatus();
-console.log(status.authenticated, status.tokens?.email);
-
-// Logout
-await authService.logout();
-```
-
-## Keychain Storage
-
-All sensitive data is stored in the native system keychain:
-
-- **Service Name:** `ai.quantiya.app.codevibe`
-- **Device Identity:** Stored as `device-identity` account
-- **Tokens:** Stored as `tokens-{environment}` accounts (e.g., `tokens-production`)
-
-This ensures:
-- Data persists across terminal sessions
-- Data is encrypted at rest by the OS
-- Data survives plugin reinstalls/updates
-- Device identity is shared across all CodeVibe plugins
-
-## Security
-
-- Device keys are ECDH P-256 key pairs
-- Session keys are 256-bit AES keys
-- Content is encrypted with AES-256-GCM
-- Session keys are encrypted per-device using ECDH
-- OAuth tokens are stored securely in native keychain
-
-## Development
-
-```bash
-# Install dependencies
-npm install
-
-# Build
-npm run build
-
-# Watch mode
-npm run watch
-
-# Local development with plugin
-npm link
-cd ../codevibe-claude-plugin
-npm link @quantiya/codevibe-core
-```
-
-## License
-
-MIT

package/node_modules/@quantiya/codevibe-core/bin/codevibe.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-//
-// codevibe CLI entry point
-// @quantiya/codevibe-core
-//
-
-require('../dist/auth/auth-cli').runAuthCli(process.argv);

package/node_modules/@quantiya/codevibe-core/dist/appsync/appsync-client.d.ts

@@ -1,132 +0,0 @@
-import { CreateEventInput, CreateSessionInput, UpdateSessionInput, UpdateEventStatusInput, Event, Session, EventSource, DeviceKey } from '../types';
-/**
- * Download URL response
- */
-export interface DownloadUrlResponse {
-    downloadUrl: string;
-    expiresAt: string;
-}
-/**
- * AppSync GraphQL client with WebSocket subscriptions
- */
-export declare class AppSyncClient {
-    private authenticated;
-    private currentUserId;
-    private currentEmail;
-    private tokens;
-    private activeSubscriptions;
-    private environment;
-    constructor();
-    /**
-     * Get the current authenticated user ID
-     */
-    getCurrentUserId(): string;
-    /**
-     * Get the current authenticated user email
-     */
-    getCurrentUserEmail(): string | null;
-    /**
-     * Authenticate using stored OAuth tokens from keychain
-     */
-    authenticateWithStoredTokens(): Promise<boolean>;
-    /**
-     * Refresh expired tokens
-     */
-    private refreshTokens;
-    /**
-     * Check if authenticated
-     */
-    isAuthenticated(): boolean;
-    /**
-     * Sign out
-     */
-    signOut(): void;
-    /**
-     * Make a GraphQL request
-     */
-    private graphqlRequest;
-    /**
-     * Create a session
-     */
-    createSession(input: CreateSessionInput): Promise<Session>;
-    /**
-     * Update a session
-     */
-    updateSession(input: UpdateSessionInput): Promise<Session>;
-    /**
-     * Get a session
-     */
-    getSession(sessionId: string): Promise<Session | null>;
-    /**
-     * Create an event
-     */
-    createEvent(input: CreateEventInput): Promise<Event>;
-    /**
-     * Update event status
-     */
-    updateEventStatus(input: UpdateEventStatusInput): Promise<Event>;
-    /**
-     * List events for a session
-     */
-    listEvents(sessionId: string, source?: EventSource, limit?: number): Promise<Event[]>;
-    /**
-     * List user device keys
-     */
-    listUserDeviceKeys(): Promise<DeviceKey[]>;
-    /**
-     * Register device key
-     */
-    registerDeviceKey(deviceId: string, publicKey: string, platform: string, deviceName: string): Promise<void>;
-    /**
-     * Get attachment download URL
-     */
-    getAttachmentDownloadUrl(s3Key: string): Promise<DownloadUrlResponse>;
-    /**
-     * Subscribe to events for a session
-     */
-    subscribeToEvents(sessionId: string, onEvent: (event: Event) => void, onError?: (error: Error) => void): () => void;
-    /**
-     * Build WebSocket URL
-     */
-    private buildRealtimeUrl;
-    /**
-     * Create WebSocket subscription
-     */
-    private createSubscription;
-    /**
-     * Send subscription start message
-     */
-    private sendSubscriptionStart;
-    /**
-     * Reset keep-alive timer
-     */
-    private resetKeepAliveTimer;
-    /**
-     * Handle subscription error with two-phase reconnection:
-     * Phase 1 (urgent): Exponential backoff for first N attempts
-     * Phase 2 (persistent): Fixed interval retry indefinitely
-     */
-    private handleSubscriptionError;
-    /**
-     * Cleanup subscription state
-     */
-    private cleanupSubscriptionState;
-    private heartbeatTimers;
-    /**
-     * Start periodic heartbeat for a session.
-     * Updates lastHeartbeatAt on the session every intervalMs (default 2 minutes).
-     */
-    startHeartbeat(sessionId: string, intervalMs?: number): void;
-    /**
-     * Stop heartbeat for a session.
-     */
-    stopHeartbeat(sessionId: string): void;
-    /**
-     * Send a single heartbeat update.
-     */
-    private sendHeartbeat;
-    /**
-     * Cleanup all subscriptions and heartbeats
-     */
-    cleanupSubscriptions(): void;
-}