@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.1

package/node_modules/@quantiya/codevibe-core/dist/session/session-resume.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Centralized session resume/create logic for all CodeVibe plugins.
+ *
+ * All three plugins (Claude, Codex, Gemini) need the same pattern:
+ * 1. Check if session exists in backend (getSession)
+ * 2. If exists: reactivate + restore E2E session key from encryptedKeys
+ * 3. If not exists: generate encryption keys + create session
+ *
+ * This module eliminates the duplication across plugins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSessionEncryption = prepareSessionEncryption;
+exports.resumeOrCreateSession = resumeOrCreateSession;
+const crypto_1 = require("../crypto");
+const keychain_1 = require("../keychain");
+const types_1 = require("../types");
+/**
+ * Prepare E2E encryption for a new session.
+ *
+ * Generates a random session key and encrypts it for all registered devices.
+ * Does NOT cache the session key — callers should cache only after the session
+ * is successfully created in the backend.
+ *
+ * @returns Encryption data or null if no device keys found / error
+ */
+async function prepareSessionEncryption(sessionId, appSyncClient, logger) {
+    try {
+        const deviceKeys = await appSyncClient.listUserDeviceKeys();
+        if (deviceKeys.length === 0) {
+            logger.info('No device keys found, session will not be encrypted');
+            return null;
+        }
+        logger.info('Preparing session encryption', {
+            sessionId,
+            deviceCount: deviceKeys.length,
+        });
+        const { sessionKey, encryptedKeys } = keychain_1.keychainManager.createSessionKey(deviceKeys);
+        logger.info('Session encryption prepared', {
+            sessionId,
+            deviceCount: encryptedKeys.length,
+        });
+        return { sessionKey, encryptedKeys };
+    }
+    catch (error) {
+        logger.warn('Failed to prepare session encryption:', error);
+        return null;
+    }
+}
+/**
+ * Resume an existing session or create a new one.
+ *
+ * Resume path (session exists in backend):
+ *   - Reactivates session (status → ACTIVE)
+ *   - Restores E2E session key from encryptedKeys
+ *
+ * Create path (session does not exist):
+ *   - Prepares E2E encryption (generates key, encrypts for all devices)
+ *   - Encrypts projectPath and metadata
+ *   - Creates session in backend
+ *   - Caches session key only after successful creation
+ *
+ * @throws Propagates createSession errors (e.g., SESSION_LIMIT_EXCEEDED)
+ */
+async function resumeOrCreateSession(input, appSyncClient, logger) {
+    const { sessionId, userId, agentType, projectPath, metadata } = input;
+    // Check if session already exists in backend
+    let existingSession = null;
+    try {
+        existingSession = await appSyncClient.getSession(sessionId);
+    }
+    catch (error) {
+        logger.warn('Failed to get session (will attempt to create new)', { sessionId, error });
+    }
+    if (existingSession) {
+        // RESUME PATH: reactivate existing session and restore session key
+        logger.info('Session exists in backend - reactivating', {
+            sessionId,
+            previousStatus: existingSession.status,
+        });
+        try {
+            await appSyncClient.updateSession({
+                sessionId,
+                status: types_1.SessionStatus.ACTIVE,
+            });
+        }
+        catch (error) {
+            logger.warn('Failed to reactivate existing session, will continue', { sessionId, error });
+        }
+        // Restore session key from encryptedKeys
+        let sessionKey = null;
+        const encryptedKeys = existingSession.encryptedKeys;
+        if (existingSession.isEncrypted && encryptedKeys?.length) {
+            try {
+                const cachedKey = await keychain_1.keychainManager.getSessionKey(sessionId, encryptedKeys);
+                if (cachedKey) {
+                    sessionKey = cachedKey;
+                    keychain_1.keychainManager.cacheSessionKey(sessionId, cachedKey);
+                    logger.info('Session key retrieved for resumed session', { sessionId });
+                }
+                else {
+                    logger.warn('No encrypted key for this device; proceeding without decryption', { sessionId });
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to retrieve session key for resumed session', { sessionId, error });
+            }
+        }
+        return { resumed: true, sessionKey };
+    }
+    // NEW SESSION PATH: prepare encryption and create
+    const encryptionData = await prepareSessionEncryption(sessionId, appSyncClient, logger);
+    let sessionProjectPath = projectPath;
+    let sessionMetadata = metadata;
+    if (encryptionData) {
+        sessionProjectPath = crypto_1.cryptoService.encryptContent(projectPath, encryptionData.sessionKey);
+        if (sessionMetadata && Object.keys(sessionMetadata).length > 0) {
+            const encryptedMeta = crypto_1.cryptoService.encryptMetadata(sessionMetadata, encryptionData.sessionKey);
+            sessionMetadata = { encrypted: encryptedMeta };
+        }
+        logger.info('Session data encrypted', { sessionId });
+    }
+    logger.info('Creating new session in backend', {
+        sessionId,
+        userId,
+        agentType,
+        isEncrypted: !!encryptionData,
+    });
+    // createSession errors propagate to caller (e.g., SESSION_LIMIT_EXCEEDED)
+    await appSyncClient.createSession({
+        sessionId,
+        userId,
+        agentType,
+        projectPath: sessionProjectPath,
+        status: types_1.SessionStatus.ACTIVE,
+        metadata: sessionMetadata,
+        // E2E encryption fields
+        isEncrypted: encryptionData ? true : undefined,
+        creatorDeviceId: encryptionData ? await keychain_1.keychainManager.getDeviceId() : undefined,
+        encryptionVersion: encryptionData ? 1 : undefined,
+        encryptedKeys: encryptionData?.encryptedKeys,
+    });
+    const sessionKey = encryptionData?.sessionKey || null;
+    // Cache session key AFTER successful creation (avoids premature caching bug)
+    if (encryptionData) {
+        keychain_1.keychainManager.cacheSessionKey(sessionId, encryptionData.sessionKey);
+    }
+    logger.info('Session created', { sessionId, userId, isEncrypted: !!encryptionData });
+    return { resumed: false, sessionKey };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-resume.js","sourceRoot":"","sources":["../../src/session/session-resume.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Centralized session resume/create logic for all CodeVibe plugins.\n *\n * All three plugins (Claude, Codex, Gemini) need the same pattern:\n * 1. Check if session exists in backend (getSession)\n * 2. If exists: reactivate + restore E2E session key from encryptedKeys\n * 3. If not exists: generate encryption keys + create session\n *\n * This module eliminates the duplication across plugins.\n */\n\nimport { AppSyncClient } from '../appsync';\nimport { cryptoService } from '../crypto';\nimport { keychainManager } from '../keychain';\nimport { Logger } from '../logger';\nimport {\n  AgentType,\n  SessionStatus,\n  EncryptedSessionKey,\n} from '../types';\n\nexport interface ResumeOrCreateSessionInput {\n  sessionId: string;\n  userId: string;\n  agentType: AgentType;\n  projectPath: string;\n  metadata?: Record<string, any>;\n}\n\nexport interface ResumeOrCreateSessionResult {\n  /** Whether an existing session was found and reactivated */\n  resumed: boolean;\n  /** The E2E session key (for encrypting/decrypting events), or null if no encryption */\n  sessionKey: string | null;\n}\n\n/**\n * Prepare E2E encryption for a new session.\n *\n * Generates a random session key and encrypts it for all registered devices.\n * Does NOT cache the session key — callers should cache only after the session\n * is successfully created in the backend.\n *\n * @returns Encryption data or null if no device keys found / error\n */\nexport async function prepareSessionEncryption(\n  sessionId: string,\n  appSyncClient: AppSyncClient,\n  logger: Logger,\n): Promise<{ sessionKey: string; encryptedKeys: EncryptedSessionKey[] } | null> {\n  try {\n    const deviceKeys = await appSyncClient.listUserDeviceKeys();\n\n    if (deviceKeys.length === 0) {\n      logger.info('No device keys found, session will not be encrypted');\n      return null;\n    }\n\n    logger.info('Preparing session encryption', {\n      sessionId,\n      deviceCount: deviceKeys.length,\n    });\n\n    const { sessionKey, encryptedKeys } = keychainManager.createSessionKey(deviceKeys);\n\n    logger.info('Session encryption prepared', {\n      sessionId,\n      deviceCount: encryptedKeys.length,\n    });\n\n    return { sessionKey, encryptedKeys };\n  } catch (error) {\n    logger.warn('Failed to prepare session encryption:', error);\n    return null;\n  }\n}\n\n/**\n * Resume an existing session or create a new one.\n *\n * Resume path (session exists in backend):\n *   - Reactivates session (status → ACTIVE)\n *   - Restores E2E session key from encryptedKeys\n *\n * Create path (session does not exist):\n *   - Prepares E2E encryption (generates key, encrypts for all devices)\n *   - Encrypts projectPath and metadata\n *   - Creates session in backend\n *   - Caches session key only after successful creation\n *\n * @throws Propagates createSession errors (e.g., SESSION_LIMIT_EXCEEDED)\n */\nexport async function resumeOrCreateSession(\n  input: ResumeOrCreateSessionInput,\n  appSyncClient: AppSyncClient,\n  logger: Logger,\n): Promise<ResumeOrCreateSessionResult> {\n  const { sessionId, userId, agentType, projectPath, metadata } = input;\n\n  // Check if session already exists in backend\n  let existingSession = null;\n  try {\n    existingSession = await appSyncClient.getSession(sessionId);\n  } catch (error) {\n    logger.warn('Failed to get session (will attempt to create new)', { sessionId, error });\n  }\n\n  if (existingSession) {\n    // RESUME PATH: reactivate existing session and restore session key\n    logger.info('Session exists in backend - reactivating', {\n      sessionId,\n      previousStatus: existingSession.status,\n    });\n\n    try {\n      await appSyncClient.updateSession({\n        sessionId,\n        status: SessionStatus.ACTIVE,\n      });\n    } catch (error) {\n      logger.warn('Failed to reactivate existing session, will continue', { sessionId, error });\n    }\n\n    // Restore session key from encryptedKeys\n    let sessionKey: string | null = null;\n    const encryptedKeys = existingSession.encryptedKeys;\n    if (existingSession.isEncrypted && encryptedKeys?.length) {\n      try {\n        const cachedKey = await keychainManager.getSessionKey(sessionId, encryptedKeys);\n        if (cachedKey) {\n          sessionKey = cachedKey;\n          keychainManager.cacheSessionKey(sessionId, cachedKey);\n          logger.info('Session key retrieved for resumed session', { sessionId });\n        } else {\n          logger.warn('No encrypted key for this device; proceeding without decryption', { sessionId });\n        }\n      } catch (error) {\n        logger.warn('Failed to retrieve session key for resumed session', { sessionId, error });\n      }\n    }\n\n    return { resumed: true, sessionKey };\n  }\n\n  // NEW SESSION PATH: prepare encryption and create\n  const encryptionData = await prepareSessionEncryption(sessionId, appSyncClient, logger);\n\n  let sessionProjectPath = projectPath;\n  let sessionMetadata = metadata;\n\n  if (encryptionData) {\n    sessionProjectPath = cryptoService.encryptContent(projectPath, encryptionData.sessionKey);\n    if (sessionMetadata && Object.keys(sessionMetadata).length > 0) {\n      const encryptedMeta = cryptoService.encryptMetadata(sessionMetadata, encryptionData.sessionKey);\n      sessionMetadata = { encrypted: encryptedMeta };\n    }\n    logger.info('Session data encrypted', { sessionId });\n  }\n\n  logger.info('Creating new session in backend', {\n    sessionId,\n    userId,\n    agentType,\n    isEncrypted: !!encryptionData,\n  });\n\n  // createSession errors propagate to caller (e.g., SESSION_LIMIT_EXCEEDED)\n  await appSyncClient.createSession({\n    sessionId,\n    userId,\n    agentType,\n    projectPath: sessionProjectPath,\n    status: SessionStatus.ACTIVE,\n    metadata: sessionMetadata,\n    // E2E encryption fields\n    isEncrypted: encryptionData ? true : undefined,\n    creatorDeviceId: encryptionData ? await keychainManager.getDeviceId() : undefined,\n    encryptionVersion: encryptionData ? 1 : undefined,\n    encryptedKeys: encryptionData?.encryptedKeys,\n  });\n\n  const sessionKey = encryptionData?.sessionKey || null;\n\n  // Cache session key AFTER successful creation (avoids premature caching bug)\n  if (encryptionData) {\n    keychainManager.cacheSessionKey(sessionId, encryptionData.sessionKey);\n  }\n\n  logger.info('Session created', { sessionId, userId, isEncrypted: !!encryptionData });\n\n  return { resumed: false, sessionKey };\n}\n"]}

package/node_modules/@quantiya/codevibe-core/dist/types/auth.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stored OAuth tokens
+ */
+export interface TokenData {
+    accessToken: string;
+    idToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    userId: string;
+    email: string;
+}
+/**
+ * Environment configuration
+ */
+export type Environment = 'development' | 'production';

package/node_modules/@quantiya/codevibe-core/dist/types/auth.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9hdXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFN0b3JlZCBPQXV0aCB0b2tlbnNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBUb2tlbkRhdGEge1xuICBhY2Nlc3NUb2tlbjogc3RyaW5nO1xuICBpZFRva2VuOiBzdHJpbmc7XG4gIHJlZnJlc2hUb2tlbjogc3RyaW5nO1xuICBleHBpcmVzQXQ6IG51bWJlcjtcbiAgdXNlcklkOiBzdHJpbmc7XG4gIGVtYWlsOiBzdHJpbmc7XG59XG5cbi8qKlxuICogRW52aXJvbm1lbnQgY29uZmlndXJhdGlvblxuICovXG5leHBvcnQgdHlwZSBFbnZpcm9ubWVudCA9ICdkZXZlbG9wbWVudCcgfCAncHJvZHVjdGlvbic7XG4iXX0=

package/node_modules/@quantiya/codevibe-core/dist/types/encryption.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Encrypted session key for E2E encryption
+ */
+export interface EncryptedSessionKey {
+    deviceId: string;
+    encryptedKey: string;
+    ephemeralPublicKey: string;
+}
+/**
+ * Device key stored with backend
+ */
+export interface DeviceKey {
+    userId: string;
+    deviceId: string;
+    publicKey: string;
+    platform: string;
+    deviceName?: string;
+    createdAt: string;
+    lastUsedAt?: string;
+}
+/**
+ * Key pair for ECDH
+ */
+export interface KeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+/**
+ * Device identity stored in keychain
+ */
+export interface DeviceIdentity {
+    deviceId: string;
+    privateKey: string;
+    publicKey: string;
+    createdAt: string;
+}
+/**
+ * GraphQL input for registering device key
+ */
+export interface RegisterDeviceKeyInput {
+    deviceId: string;
+    publicKey: string;
+    platform: string;
+    deviceName?: string;
+}
+/**
+ * GraphQL input for granting session key
+ */
+export interface GrantSessionKeyInput {
+    sessionId: string;
+    deviceId: string;
+    encryptedKey: string;
+    ephemeralPublicKey: string;
+}

package/node_modules/@quantiya/codevibe-core/dist/types/encryption.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jcnlwdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9lbmNyeXB0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEVuY3J5cHRlZCBzZXNzaW9uIGtleSBmb3IgRTJFIGVuY3J5cHRpb25cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFbmNyeXB0ZWRTZXNzaW9uS2V5IHtcbiAgZGV2aWNlSWQ6IHN0cmluZztcbiAgZW5jcnlwdGVkS2V5OiBzdHJpbmc7XG4gIGVwaGVtZXJhbFB1YmxpY0tleTogc3RyaW5nO1xufVxuXG4vKipcbiAqIERldmljZSBrZXkgc3RvcmVkIHdpdGggYmFja2VuZFxuICovXG5leHBvcnQgaW50ZXJmYWNlIERldmljZUtleSB7XG4gIHVzZXJJZDogc3RyaW5nO1xuICBkZXZpY2VJZDogc3RyaW5nO1xuICBwdWJsaWNLZXk6IHN0cmluZztcbiAgcGxhdGZvcm06IHN0cmluZztcbiAgZGV2aWNlTmFtZT86IHN0cmluZztcbiAgY3JlYXRlZEF0OiBzdHJpbmc7XG4gIGxhc3RVc2VkQXQ/OiBzdHJpbmc7XG59XG5cbi8qKlxuICogS2V5IHBhaXIgZm9yIEVDREhcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBLZXlQYWlyIHtcbiAgcHJpdmF0ZUtleTogc3RyaW5nO1xuICBwdWJsaWNLZXk6IHN0cmluZztcbn1cblxuLyoqXG4gKiBEZXZpY2UgaWRlbnRpdHkgc3RvcmVkIGluIGtleWNoYWluXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGV2aWNlSWRlbnRpdHkge1xuICBkZXZpY2VJZDogc3RyaW5nO1xuICBwcml2YXRlS2V5OiBzdHJpbmc7XG4gIHB1YmxpY0tleTogc3RyaW5nO1xuICBjcmVhdGVkQXQ6IHN0cmluZztcbn1cblxuLyoqXG4gKiBHcmFwaFFMIGlucHV0IGZvciByZWdpc3RlcmluZyBkZXZpY2Uga2V5XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmVnaXN0ZXJEZXZpY2VLZXlJbnB1dCB7XG4gIGRldmljZUlkOiBzdHJpbmc7XG4gIHB1YmxpY0tleTogc3RyaW5nO1xuICBwbGF0Zm9ybTogc3RyaW5nO1xuICBkZXZpY2VOYW1lPzogc3RyaW5nO1xufVxuXG4vKipcbiAqIEdyYXBoUUwgaW5wdXQgZm9yIGdyYW50aW5nIHNlc3Npb24ga2V5XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR3JhbnRTZXNzaW9uS2V5SW5wdXQge1xuICBzZXNzaW9uSWQ6IHN0cmluZztcbiAgZGV2aWNlSWQ6IHN0cmluZztcbiAgZW5jcnlwdGVkS2V5OiBzdHJpbmc7XG4gIGVwaGVtZXJhbFB1YmxpY0tleTogc3RyaW5nO1xufVxuIl19

package/node_modules/@quantiya/codevibe-core/dist/types/events.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Event types matching GraphQL schema
+ */
+export declare enum EventType {
+    USER_PROMPT = "USER_PROMPT",
+    ASSISTANT_RESPONSE = "ASSISTANT_RESPONSE",
+    TOOL_USE = "TOOL_USE",
+    NOTIFICATION = "NOTIFICATION",
+    INTERACTIVE_PROMPT = "INTERACTIVE_PROMPT",
+    PROMPT_RESPONSE = "PROMPT_RESPONSE",
+    REASONING = "REASONING"
+}
+export declare enum EventSource {
+    DESKTOP = "DESKTOP",
+    MOBILE = "MOBILE"
+}
+export declare enum DeliveryStatus {
+    SENT = "SENT",
+    DELIVERED = "DELIVERED",
+    EXECUTED = "EXECUTED"
+}
+/**
+ * Attachment type (for images/files attached to messages)
+ */
+export interface Attachment {
+    id: string;
+    type: string;
+    filename?: string;
+    s3Key: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    isEncrypted?: boolean;
+}
+/**
+ * Event type
+ */
+export interface Event {
+    eventId: string;
+    sessionId: string;
+    type: EventType;
+    source: EventSource;
+    content: string;
+    timestamp: string;
+    metadata?: Record<string, any>;
+    promptId?: string;
+    attachments?: Attachment[];
+    deliveryStatus?: DeliveryStatus;
+    deliveredAt?: string;
+    executedAt?: string;
+    isEncrypted?: boolean;
+}
+/**
+ * GraphQL input for creating events
+ */
+export interface CreateEventInput {
+    sessionId: string;
+    type: EventType;
+    source: EventSource;
+    content: string;
+    metadata?: Record<string, any>;
+    promptId?: string;
+    timestamp?: string;
+    isEncrypted?: boolean;
+}
+/**
+ * GraphQL input for updating event status
+ */
+export interface UpdateEventStatusInput {
+    eventId: string;
+    sessionId: string;
+    timestamp: string;
+    deliveryStatus: DeliveryStatus;
+}

package/node_modules/@quantiya/codevibe-core/dist/types/events.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeliveryStatus = exports.EventSource = exports.EventType = void 0;
+/**
+ * Event types matching GraphQL schema
+ */
+var EventType;
+(function (EventType) {
+    EventType["USER_PROMPT"] = "USER_PROMPT";
+    EventType["ASSISTANT_RESPONSE"] = "ASSISTANT_RESPONSE";
+    EventType["TOOL_USE"] = "TOOL_USE";
+    EventType["NOTIFICATION"] = "NOTIFICATION";
+    EventType["INTERACTIVE_PROMPT"] = "INTERACTIVE_PROMPT";
+    EventType["PROMPT_RESPONSE"] = "PROMPT_RESPONSE";
+    EventType["REASONING"] = "REASONING";
+})(EventType || (exports.EventType = EventType = {}));
+var EventSource;
+(function (EventSource) {
+    EventSource["DESKTOP"] = "DESKTOP";
+    EventSource["MOBILE"] = "MOBILE";
+})(EventSource || (exports.EventSource = EventSource = {}));
+var DeliveryStatus;
+(function (DeliveryStatus) {
+    DeliveryStatus["SENT"] = "SENT";
+    DeliveryStatus["DELIVERED"] = "DELIVERED";
+    DeliveryStatus["EXECUTED"] = "EXECUTED";
+})(DeliveryStatus || (exports.DeliveryStatus = DeliveryStatus = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@quantiya/codevibe-core/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './events';
+export * from './session';
+export * from './encryption';
+export * from './auth';

package/node_modules/@quantiya/codevibe-core/dist/types/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all types
+__exportStar(require("./events"), exports);
+__exportStar(require("./session"), exports);
+__exportStar(require("./encryption"), exports);
+__exportStar(require("./auth"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHNCQUFzQjtBQUN0QiwyQ0FBeUI7QUFDekIsNENBQTBCO0FBQzFCLCtDQUE2QjtBQUM3Qix5Q0FBdUIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBSZS1leHBvcnQgYWxsIHR5cGVzXG5leHBvcnQgKiBmcm9tICcuL2V2ZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL3Nlc3Npb24nO1xuZXhwb3J0ICogZnJvbSAnLi9lbmNyeXB0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aCc7XG4iXX0=

package/node_modules/@quantiya/codevibe-core/dist/types/session.d.ts

@@ -0,0 +1,59 @@
+import { EncryptedSessionKey } from './encryption';
+/**
+ * Session status enum
+ */
+export declare enum SessionStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    PAUSED = "PAUSED"
+}
+/**
+ * Agent type for multi-agent support
+ */
+export declare enum AgentType {
+    CLAUDE = "CLAUDE",
+    GEMINI = "GEMINI",
+    CODEX = "CODEX"
+}
+/**
+ * Session type
+ */
+export interface Session {
+    sessionId: string;
+    userId: string;
+    agentType: AgentType;
+    projectPath: string;
+    status: SessionStatus;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, any>;
+    isEncrypted?: boolean;
+    encryptedKeys?: EncryptedSessionKey[];
+    creatorDeviceId?: string;
+    encryptionVersion?: number;
+    lastHeartbeatAt?: string;
+}
+/**
+ * GraphQL input for creating sessions
+ */
+export interface CreateSessionInput {
+    sessionId?: string;
+    userId: string;
+    agentType?: AgentType;
+    projectPath: string;
+    status?: SessionStatus;
+    metadata?: Record<string, any>;
+    encryptedKeys?: EncryptedSessionKey[];
+    creatorDeviceId?: string;
+    isEncrypted?: boolean;
+    encryptionVersion?: number;
+}
+/**
+ * GraphQL input for updating sessions
+ */
+export interface UpdateSessionInput {
+    sessionId: string;
+    status?: SessionStatus;
+    metadata?: Record<string, any>;
+    lastHeartbeatAt?: string;
+}

package/node_modules/@quantiya/codevibe-core/dist/types/session.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentType = exports.SessionStatus = void 0;
+/**
+ * Session status enum
+ */
+var SessionStatus;
+(function (SessionStatus) {
+    SessionStatus["ACTIVE"] = "ACTIVE";
+    SessionStatus["INACTIVE"] = "INACTIVE";
+    SessionStatus["PAUSED"] = "PAUSED";
+})(SessionStatus || (exports.SessionStatus = SessionStatus = {}));
+/**
+ * Agent type for multi-agent support
+ */
+var AgentType;
+(function (AgentType) {
+    AgentType["CLAUDE"] = "CLAUDE";
+    AgentType["GEMINI"] = "GEMINI";
+    AgentType["CODEX"] = "CODEX";
+})(AgentType || (exports.AgentType = AgentType = {}));
+//# sourceMappingURL=data:application/json;base64,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