@quantiya/codevibe-core 1.0.0

package/dist/appsync/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptions = exports.mutations = exports.queries = exports.AppSyncClient = void 0;
+var appsync_client_1 = require("./appsync-client");
+Object.defineProperty(exports, "AppSyncClient", { enumerable: true, get: function () { return appsync_client_1.AppSyncClient; } });
+var queries_1 = require("./queries");
+Object.defineProperty(exports, "queries", { enumerable: true, get: function () { return queries_1.queries; } });
+Object.defineProperty(exports, "mutations", { enumerable: true, get: function () { return queries_1.mutations; } });
+Object.defineProperty(exports, "subscriptions", { enumerable: true, get: function () { return queries_1.subscriptions; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBwc3luYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxtREFBc0U7QUFBN0QsK0dBQUEsYUFBYSxPQUFBO0FBQ3RCLHFDQUE4RDtBQUFyRCxrR0FBQSxPQUFPLE9BQUE7QUFBRSxvR0FBQSxTQUFTLE9BQUE7QUFBRSx3R0FBQSxhQUFhLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBBcHBTeW5jQ2xpZW50LCBEb3dubG9hZFVybFJlc3BvbnNlIH0gZnJvbSAnLi9hcHBzeW5jLWNsaWVudCc7XG5leHBvcnQgeyBxdWVyaWVzLCBtdXRhdGlvbnMsIHN1YnNjcmlwdGlvbnMgfSBmcm9tICcuL3F1ZXJpZXMnO1xuIl19

package/dist/appsync/queries.d.ts

@@ -0,0 +1,16 @@
+export declare const queries: {
+    getSession: string;
+    listEvents: string;
+    listUserDeviceKeys: string;
+};
+export declare const mutations: {
+    createSession: string;
+    updateSession: string;
+    createEvent: string;
+    updateEventStatus: string;
+    registerDeviceKey: string;
+    getAttachmentDownloadUrl: string;
+};
+export declare const subscriptions: {
+    onEventCreated: string;
+};

package/dist/appsync/queries.js

@@ -0,0 +1,189 @@
+"use strict";
+//
+// queries.ts
+// CodeVibe Core
+//
+// Shared GraphQL queries, mutations, and subscriptions
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptions = exports.mutations = exports.queries = void 0;
+exports.queries = {
+    getSession: /* GraphQL */ `
+    query GetSession($sessionId: ID!) {
+      getSession(sessionId: $sessionId) {
+        sessionId
+        userId
+        agentType
+        projectPath
+        status
+        createdAt
+        updatedAt
+        metadata
+        isEncrypted
+        encryptedKeys {
+          deviceId
+          encryptedKey
+          ephemeralPublicKey
+        }
+        creatorDeviceId
+        encryptionVersion
+      }
+    }
+  `,
+    listEvents: /* GraphQL */ `
+    query ListEvents($sessionId: ID!, $source: EventSource, $limit: Int) {
+      listEvents(sessionId: $sessionId, source: $source, limit: $limit) {
+        items {
+          eventId
+          sessionId
+          type
+          source
+          content
+          timestamp
+          metadata
+          promptId
+          attachments {
+            id
+            type
+            filename
+            s3Key
+            size
+            width
+            height
+            isEncrypted
+          }
+          deliveryStatus
+          deliveredAt
+          executedAt
+          isEncrypted
+        }
+        nextToken
+      }
+    }
+  `,
+    listUserDeviceKeys: /* GraphQL */ `
+    query ListUserDeviceKeys {
+      listUserDeviceKeys {
+        userId
+        deviceId
+        publicKey
+        platform
+        deviceName
+        createdAt
+        lastUsedAt
+      }
+    }
+  `,
+};
+exports.mutations = {
+    createSession: /* GraphQL */ `
+    mutation CreateSession($input: CreateSessionInput!) {
+      createSession(input: $input) {
+        sessionId
+        userId
+        agentType
+        projectPath
+        status
+        createdAt
+        updatedAt
+      }
+    }
+  `,
+    updateSession: /* GraphQL */ `
+    mutation UpdateSession($input: UpdateSessionInput!) {
+      updateSession(input: $input) {
+        sessionId
+        status
+        updatedAt
+        lastHeartbeatAt
+      }
+    }
+  `,
+    createEvent: /* GraphQL */ `
+    mutation CreateEvent($input: CreateEventInput!) {
+      createEvent(input: $input) {
+        eventId
+        sessionId
+        type
+        source
+        content
+        timestamp
+        metadata
+        promptId
+        deliveryStatus
+        deliveredAt
+        executedAt
+        isEncrypted
+      }
+    }
+  `,
+    updateEventStatus: /* GraphQL */ `
+    mutation UpdateEventStatus($input: UpdateEventStatusInput!) {
+      updateEventStatus(input: $input) {
+        eventId
+        sessionId
+        type
+        source
+        content
+        timestamp
+        metadata
+        promptId
+        deliveryStatus
+        deliveredAt
+        executedAt
+      }
+    }
+  `,
+    registerDeviceKey: /* GraphQL */ `
+    mutation RegisterDeviceKey($input: RegisterDeviceKeyInput!) {
+      registerDeviceKey(input: $input) {
+        userId
+        deviceId
+        publicKey
+        platform
+        deviceName
+        createdAt
+        lastUsedAt
+      }
+    }
+  `,
+    getAttachmentDownloadUrl: /* GraphQL */ `
+    mutation GetAttachmentDownloadUrl($s3Key: String!) {
+      getAttachmentDownloadUrl(s3Key: $s3Key) {
+        downloadUrl
+        expiresAt
+      }
+    }
+  `,
+};
+exports.subscriptions = {
+    onEventCreated: /* GraphQL */ `
+    subscription OnEventCreated($sessionId: ID!) {
+      onEventCreated(sessionId: $sessionId) {
+        eventId
+        sessionId
+        type
+        source
+        content
+        timestamp
+        metadata
+        promptId
+        attachments {
+          id
+          type
+          filename
+          s3Key
+          size
+          width
+          height
+          isEncrypted
+        }
+        deliveryStatus
+        deliveredAt
+        executedAt
+        isEncrypted
+      }
+    }
+  `,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/auth/auth-cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * Main CLI entry point
+ */
+export declare function runAuthCli(argv: string[]): Promise<void>;

package/dist/auth/auth-cli.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+"use strict";
+//
+// auth-cli.ts
+// CodeVibe Core
+//
+// CLI commands for authentication
+//
+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.runAuthCli = runAuthCli;
+const auth_service_1 = require("./auth-service");
+const config_1 = require("../config");
+// Terminal colors
+const colors = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    dim: '\x1b[2m',
+};
+/**
+ * Login command
+ */
+async function login() {
+    console.log(`${colors.cyan}CodeVibe Login${colors.reset}\n`);
+    try {
+        const status = await auth_service_1.authService.getStatus();
+        if (status.authenticated && status.tokens) {
+            console.log(`${colors.yellow}Already logged in as: ${status.tokens.email}${colors.reset}`);
+            console.log(`Token expires: ${new Date(status.tokens.expiresAt).toLocaleString()}`);
+            console.log(`\nRun '${colors.dim}codevibe logout${colors.reset}' to sign out first.`);
+            process.exit(0);
+            return;
+        }
+        console.log('Opening browser for authentication...');
+        console.log(`${colors.dim}Waiting for callback...${colors.reset}\n`);
+        const tokens = await auth_service_1.authService.login();
+        if (tokens) {
+            console.log(`\n${colors.green}✓ Authentication successful!${colors.reset}`);
+            console.log(`  User: ${tokens.email}`);
+            console.log(`  User ID: ${tokens.userId}`);
+            console.log(`  Expires: ${new Date(tokens.expiresAt).toLocaleString()}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.log(`\n${colors.red}✗ Authentication failed${colors.reset}`);
+        console.log(`  Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Logout command
+ */
+async function logout() {
+    console.log(`${colors.cyan}CodeVibe Logout${colors.reset}\n`);
+    try {
+        const status = await auth_service_1.authService.getStatus();
+        if (!status.authenticated) {
+            console.log(`${colors.yellow}Not logged in.${colors.reset}`);
+            process.exit(0);
+            return;
+        }
+        const email = status.tokens?.email;
+        const deleted = await auth_service_1.authService.logout();
+        if (deleted) {
+            console.log(`${colors.green}✓ Logged out successfully.${colors.reset}`);
+            console.log(`  Previous user: ${email}`);
+            console.log(`\n${colors.dim}Clearing browser session...${colors.reset}`);
+        }
+        else {
+            console.log(`${colors.red}✗ Failed to log out.${colors.reset}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.log(`${colors.red}✗ Logout failed: ${error.message}${colors.reset}`);
+        process.exit(1);
+    }
+}
+/**
+ * Status command
+ */
+async function status() {
+    console.log(`${colors.cyan}CodeVibe Auth Status${colors.reset}\n`);
+    try {
+        const result = await auth_service_1.authService.getStatus();
+        if (!result.tokens) {
+            console.log(`${colors.yellow}Not authenticated.${colors.reset}`);
+            console.log(`\nRun '${colors.dim}codevibe login${colors.reset}' to sign in.`);
+            process.exit(0);
+            return;
+        }
+        const expired = !result.authenticated;
+        if (expired) {
+            console.log(`${colors.yellow}⚠ Token expired${colors.reset}`);
+        }
+        else {
+            console.log(`${colors.green}✓ Authenticated${colors.reset}`);
+        }
+        console.log(`  User: ${result.tokens.email}`);
+        console.log(`  User ID: ${result.tokens.userId}`);
+        console.log(`  Expires: ${new Date(result.tokens.expiresAt).toLocaleString()}`);
+        if (expired) {
+            console.log(`\n${colors.dim}Token will be refreshed automatically.${colors.reset}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.log(`${colors.red}✗ Status check failed: ${error.message}${colors.reset}`);
+        process.exit(1);
+    }
+}
+/**
+ * Reset device command
+ */
+async function resetDevice() {
+    console.log(`${colors.cyan}CodeVibe Reset Device${colors.reset}\n`);
+    console.log(`${colors.red}⚠ WARNING: This will delete your device identity.${colors.reset}`);
+    console.log(`${colors.red}  Old encrypted sessions will become inaccessible.${colors.reset}\n`);
+    // Import keychain manager here to avoid circular deps
+    const { keychainManager } = await Promise.resolve().then(() => __importStar(require('../keychain')));
+    try {
+        await keychainManager.clearAllData();
+        console.log(`${colors.green}✓ Device reset complete.${colors.reset}`);
+        console.log(`  Run '${colors.dim}codevibe login${colors.reset}' to set up again.`);
+        process.exit(0);
+    }
+    catch (error) {
+        console.log(`${colors.red}✗ Reset failed: ${error.message}${colors.reset}`);
+        process.exit(1);
+    }
+}
+/**
+ * Show help
+ */
+function showHelp() {
+    console.log('CodeVibe Authentication\n');
+    console.log('Usage:');
+    console.log('  codevibe login        - Sign in via browser');
+    console.log('  codevibe logout       - Sign out');
+    console.log('  codevibe status       - Show auth status');
+    console.log('  codevibe reset-device - Reset device identity (destructive)');
+    console.log('\nEnvironment:');
+    console.log('  Set ENVIRONMENT env var to "development" or "production" (default)');
+    console.log('  Example: ENVIRONMENT=development codevibe login');
+}
+/**
+ * Main CLI entry point
+ */
+async function runAuthCli(argv) {
+    // Environment is automatically detected from process.env.ENVIRONMENT
+    const environment = (0, config_1.getEnvironment)();
+    console.log(`${colors.dim}Environment: ${environment}${colors.reset}\n`);
+    // Find command (skip node, script path, and flags)
+    const args = argv.slice(2).filter(a => !a.startsWith('--'));
+    const command = args[0];
+    switch (command) {
+        case 'login':
+            await login();
+            break;
+        case 'logout':
+            await logout();
+            break;
+        case 'status':
+            await status();
+            break;
+        case 'reset-device':
+            await resetDevice();
+            break;
+        default:
+            showHelp();
+            process.exit(command ? 1 : 0);
+    }
+}
+// Run if executed directly
+if (require.main === module) {
+    runAuthCli(process.argv).catch((error) => {
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-cli.js","sourceRoot":"","sources":["../../src/auth/auth-cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n//\n// auth-cli.ts\n// CodeVibe Core\n//\n// CLI commands for authentication\n//\n\nimport { authService } from './auth-service';\nimport { getEnvironment } from '../config';\n\n// Terminal colors\nconst colors = {\n  reset: '\\x1b[0m',\n  green: '\\x1b[32m',\n  red: '\\x1b[31m',\n  yellow: '\\x1b[33m',\n  cyan: '\\x1b[36m',\n  dim: '\\x1b[2m',\n};\n\n/**\n * Login command\n */\nasync function login(): Promise<void> {\n  console.log(`${colors.cyan}CodeVibe Login${colors.reset}\\n`);\n\n  try {\n    const status = await authService.getStatus();\n    if (status.authenticated && status.tokens) {\n      console.log(`${colors.yellow}Already logged in as: ${status.tokens.email}${colors.reset}`);\n      console.log(`Token expires: ${new Date(status.tokens.expiresAt).toLocaleString()}`);\n      console.log(`\\nRun '${colors.dim}codevibe logout${colors.reset}' to sign out first.`);\n      process.exit(0);\n      return;\n    }\n\n    console.log('Opening browser for authentication...');\n    console.log(`${colors.dim}Waiting for callback...${colors.reset}\\n`);\n\n    const tokens = await authService.login();\n\n    if (tokens) {\n      console.log(`\\n${colors.green}✓ Authentication successful!${colors.reset}`);\n      console.log(`  User: ${tokens.email}`);\n      console.log(`  User ID: ${tokens.userId}`);\n      console.log(`  Expires: ${new Date(tokens.expiresAt).toLocaleString()}`);\n    }\n    process.exit(0);\n  } catch (error: any) {\n    console.log(`\\n${colors.red}✗ Authentication failed${colors.reset}`);\n    console.log(`  Error: ${error.message}`);\n    process.exit(1);\n  }\n}\n\n/**\n * Logout command\n */\nasync function logout(): Promise<void> {\n  console.log(`${colors.cyan}CodeVibe Logout${colors.reset}\\n`);\n\n  try {\n    const status = await authService.getStatus();\n    if (!status.authenticated) {\n      console.log(`${colors.yellow}Not logged in.${colors.reset}`);\n      process.exit(0);\n      return;\n    }\n\n    const email = status.tokens?.email;\n    const deleted = await authService.logout();\n\n    if (deleted) {\n      console.log(`${colors.green}✓ Logged out successfully.${colors.reset}`);\n      console.log(`  Previous user: ${email}`);\n      console.log(`\\n${colors.dim}Clearing browser session...${colors.reset}`);\n    } else {\n      console.log(`${colors.red}✗ Failed to log out.${colors.reset}`);\n    }\n    process.exit(0);\n  } catch (error: any) {\n    console.log(`${colors.red}✗ Logout failed: ${error.message}${colors.reset}`);\n    process.exit(1);\n  }\n}\n\n/**\n * Status command\n */\nasync function status(): Promise<void> {\n  console.log(`${colors.cyan}CodeVibe Auth Status${colors.reset}\\n`);\n\n  try {\n    const result = await authService.getStatus();\n\n    if (!result.tokens) {\n      console.log(`${colors.yellow}Not authenticated.${colors.reset}`);\n      console.log(`\\nRun '${colors.dim}codevibe login${colors.reset}' to sign in.`);\n      process.exit(0);\n      return;\n    }\n\n    const expired = !result.authenticated;\n\n    if (expired) {\n      console.log(`${colors.yellow}⚠ Token expired${colors.reset}`);\n    } else {\n      console.log(`${colors.green}✓ Authenticated${colors.reset}`);\n    }\n\n    console.log(`  User: ${result.tokens.email}`);\n    console.log(`  User ID: ${result.tokens.userId}`);\n    console.log(`  Expires: ${new Date(result.tokens.expiresAt).toLocaleString()}`);\n\n    if (expired) {\n      console.log(`\\n${colors.dim}Token will be refreshed automatically.${colors.reset}`);\n    }\n    process.exit(0);\n  } catch (error: any) {\n    console.log(`${colors.red}✗ Status check failed: ${error.message}${colors.reset}`);\n    process.exit(1);\n  }\n}\n\n/**\n * Reset device command\n */\nasync function resetDevice(): Promise<void> {\n  console.log(`${colors.cyan}CodeVibe Reset Device${colors.reset}\\n`);\n  console.log(`${colors.red}⚠ WARNING: This will delete your device identity.${colors.reset}`);\n  console.log(`${colors.red}  Old encrypted sessions will become inaccessible.${colors.reset}\\n`);\n\n  // Import keychain manager here to avoid circular deps\n  const { keychainManager } = await import('../keychain');\n\n  try {\n    await keychainManager.clearAllData();\n    console.log(`${colors.green}✓ Device reset complete.${colors.reset}`);\n    console.log(`  Run '${colors.dim}codevibe login${colors.reset}' to set up again.`);\n    process.exit(0);\n  } catch (error: any) {\n    console.log(`${colors.red}✗ Reset failed: ${error.message}${colors.reset}`);\n    process.exit(1);\n  }\n}\n\n/**\n * Show help\n */\nfunction showHelp(): void {\n  console.log('CodeVibe Authentication\\n');\n  console.log('Usage:');\n  console.log('  codevibe login        - Sign in via browser');\n  console.log('  codevibe logout       - Sign out');\n  console.log('  codevibe status       - Show auth status');\n  console.log('  codevibe reset-device - Reset device identity (destructive)');\n  console.log('\\nEnvironment:');\n  console.log('  Set ENVIRONMENT env var to \"development\" or \"production\" (default)');\n  console.log('  Example: ENVIRONMENT=development codevibe login');\n}\n\n/**\n * Main CLI entry point\n */\nexport async function runAuthCli(argv: string[]): Promise<void> {\n  // Environment is automatically detected from process.env.ENVIRONMENT\n  const environment = getEnvironment();\n  console.log(`${colors.dim}Environment: ${environment}${colors.reset}\\n`);\n\n  // Find command (skip node, script path, and flags)\n  const args = argv.slice(2).filter(a => !a.startsWith('--'));\n  const command = args[0];\n\n  switch (command) {\n    case 'login':\n      await login();\n      break;\n    case 'logout':\n      await logout();\n      break;\n    case 'status':\n      await status();\n      break;\n    case 'reset-device':\n      await resetDevice();\n      break;\n    default:\n      showHelp();\n      process.exit(command ? 1 : 0);\n  }\n}\n\n// Run if executed directly\nif (require.main === module) {\n  runAuthCli(process.argv).catch((error) => {\n    console.error('Error:', error);\n    process.exit(1);\n  });\n}\n"]}

package/dist/auth/auth-service.d.ts

@@ -0,0 +1,53 @@
+import { TokenData } from '../types';
+/**
+ * Authentication service for OAuth flows
+ */
+export declare class AuthService {
+    private static instance;
+    private constructor();
+    static getInstance(): AuthService;
+    /**
+     * Open URL in default browser
+     */
+    private openBrowser;
+    /**
+     * Generate state for CSRF protection
+     */
+    private generateState;
+    /**
+     * Build authorization URL
+     */
+    private buildAuthUrl;
+    /**
+     * Exchange authorization code for tokens
+     */
+    private exchangeCodeForTokens;
+    /**
+     * Decode JWT payload
+     */
+    private decodeJwt;
+    /**
+     * Refresh tokens
+     */
+    refreshTokens(refreshToken: string): Promise<{
+        accessToken: string;
+        idToken: string;
+        expiresIn: number;
+    }>;
+    /**
+     * Login via OAuth browser flow
+     */
+    login(): Promise<TokenData | null>;
+    /**
+     * Logout
+     */
+    logout(): Promise<boolean>;
+    /**
+     * Get current auth status
+     */
+    getStatus(): Promise<{
+        authenticated: boolean;
+        tokens?: TokenData;
+    }>;
+}
+export declare const authService: AuthService;