@qidcloud/sdk 1.1.1 → 1.2.1

package/package.json

@@ -1,31 +1,35 @@
-{
-  "name": "@qidcloud/sdk",
-  "version": "1.1.1",
-  "description": "Information-Theoretic Security SDK for Web",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc"
-  },
-  "keywords": [
-    "quantum",
-    "pqc",
-    "security",
-    "kyber",
-    "dilithium"
-  ],
-  "author": "Q-Gate",
-  "license": "ISC",
-  "dependencies": {
-    "@asanrom/dilithium": "^1.0.1",
-    "axios": "^1.6.0",
-    "crystals-kyber-js": "^1.1.1",
-    "eventemitter3": "^5.0.1",
-    "socket.io-client": "^4.7.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.19.27",
-    "typescript": "^5.0.0"
-  }
+{
+  "name": "@qidcloud/sdk",
+  "version": "1.2.1",
+  "description": "The official JavaScript/TypeScript SDK for QidCloud Identity and Enclave Services.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rollup -c",
+    "watch": "rollup -c -w",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "qrcode.react": "^4.2.0",
+    "socket.io-client": "^4.8.3"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/node": "^25.2.3",
+    "@types/react": "^19.2.13",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "rollup": "^4.57.1",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3"
+  }
 }

package/rollup.config.mjs

@@ -0,0 +1,26 @@
+import typescript from '@rollup/plugin-typescript';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import pkg from './package.json' with { type: 'json' };
+
+export default {
+    input: 'src/index.ts',
+    output: [
+        {
+            file: pkg.main,
+            format: 'cjs',
+            sourcemap: true,
+        },
+        {
+            file: pkg.module,
+            format: 'es',
+            sourcemap: true,
+        },
+    ],
+    external: [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.peerDependencies || {})],
+    plugins: [
+        resolve(),
+        commonjs(),
+        typescript({ tsconfig: './tsconfig.json' }),
+    ],
+};

package/src/components/QidSignInButton.tsx

@@ -0,0 +1,174 @@
+import React from 'react';
+import { QRCodeSVG } from 'qrcode.react';
+import { QidCloud } from '../index';
+import { QidUser } from '../types';
+import { useQidAuth } from '../hooks/useQidAuth';
+
+interface QidSignInButtonProps {
+    sdk: QidCloud;
+    onSuccess: (user: QidUser, token: string) => void;
+    onError?: (error: string) => void;
+    className?: string;
+    buttonText?: string;
+}
+
+/**
+ * A ready-to-use React component for QidCloud QR identity authentication.
+ */
+export const QidSignInButton: React.FC<QidSignInButtonProps> = ({
+    sdk,
+    onSuccess,
+    onError,
+    className,
+    buttonText = 'Login with QidCloud'
+}: QidSignInButtonProps) => {
+    const {
+        user,
+        token,
+        error,
+        session,
+        initializing,
+        login,
+        cancel
+    } = useQidAuth(sdk);
+
+    // Watch for success
+    React.useEffect(() => {
+        if (user && token) {
+            onSuccess(user, token);
+        }
+    }, [user, token, onSuccess]);
+
+    // Watch for errors
+    React.useEffect(() => {
+        if (error && onError) {
+            onError(error);
+        }
+    }, [error, onError]);
+
+    return (
+        <>
+            <button
+                onClick={login}
+                disabled={initializing || !!session}
+                className={className || 'qid-signin-btn'}
+                style={{
+                    backgroundColor: '#00e5ff',
+                    color: '#000',
+                    padding: '12px 24px',
+                    borderRadius: '12px',
+                    border: 'none',
+                    fontWeight: '900',
+                    cursor: (initializing || !!session) ? 'not-allowed' : 'pointer',
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: '10px',
+                    textTransform: 'uppercase',
+                    fontSize: '0.85rem',
+                    letterSpacing: '0.5px',
+                    boxShadow: '0 4px 15px rgba(0, 229, 255, 0.3)',
+                    transition: 'all 0.2s'
+                }}
+            >
+                <div style={{
+                    width: '8px',
+                    height: '8px',
+                    borderRadius: '50%',
+                    backgroundColor: (initializing || !!session) ? '#333' : '#000',
+                    boxShadow: (initializing || !!session) ? 'none' : '0 0 8px rgba(0,0,0,0.5)'
+                }} />
+                {initializing ? 'Preparing Handshake...' : (session ? 'Awaiting Scan...' : buttonText)}
+            </button>
+
+            {session && (
+                <div className="qid-modal-overlay" style={{
+                    position: 'fixed',
+                    top: 0, left: 0, right: 0, bottom: 0,
+                    backgroundColor: 'rgba(0,0,0,0.92)',
+                    display: 'flex',
+                    justifyContent: 'center',
+                    alignItems: 'center',
+                    zIndex: 9999,
+                    backdropFilter: 'blur(8px)'
+                }}>
+                    <div className="qid-modal-content" style={{
+                        backgroundColor: '#0a0a0a',
+                        padding: '40px',
+                        borderRadius: '28px',
+                        textAlign: 'center',
+                        color: '#fff',
+                        maxWidth: '420px',
+                        width: '90%',
+                        border: '1px solid rgba(0, 229, 255, 0.2)',
+                        boxShadow: '0 25px 50px -12px rgba(0, 0, 0, 0.5)'
+                    }}>
+                        <div style={{ marginBottom: '25px' }}>
+                            <div style={{
+                                display: 'inline-block',
+                                padding: '12px 20px',
+                                borderRadius: '30px',
+                                backgroundColor: 'rgba(0, 229, 255, 0.1)',
+                                border: '1px solid rgba(0, 229, 255, 0.3)',
+                                marginBottom: '15px'
+                            }}>
+                                <span style={{ color: '#00e5ff', fontSize: '0.7rem', fontWeight: '900', letterSpacing: '2px' }}>PQC ENCLAVE SECURED</span>
+                            </div>
+                            <h2 style={{ fontSize: '1.75rem', fontWeight: '900', marginBottom: '10px', letterSpacing: '-0.5px' }}>Identity Handshake</h2>
+                            <p style={{ fontSize: '0.95rem', color: '#94a3b8', lineHeight: '1.6' }}>
+                                Scan this encrypted gateway with your QidCloud app to authorize access.
+                            </p>
+                        </div>
+
+                        <div style={{
+                            backgroundColor: '#fff',
+                            padding: '24px',
+                            display: 'inline-block',
+                            borderRadius: '24px',
+                            marginBottom: '30px',
+                            boxShadow: '0 10px 40px rgba(0,0,0,0.3)'
+                        }}>
+                            <QRCodeSVG
+                                value={session.qrData}
+                                size={220}
+                                level="H"
+                                includeMargin={false}
+                                imageSettings={{
+                                    src: "https://api.qidcloud.com/favicon.ico",
+                                    x: undefined,
+                                    y: undefined,
+                                    height: 40,
+                                    width: 40,
+                                    excavate: true,
+                                }}
+                            />
+                        </div>
+
+                        <div style={{ display: 'flex', flexDirection: 'column', gap: '15px' }}>
+                            <div style={{ height: '4px', width: '60px', backgroundColor: '#00e5ff', margin: '0 auto', borderRadius: '2px', opacity: 0.5 }} />
+
+                            <button onClick={cancel} style={{
+                                display: 'block',
+                                width: '100%',
+                                padding: '16px',
+                                backgroundColor: 'transparent',
+                                color: '#64748b',
+                                border: '1px solid rgba(148, 163, 184, 0.2)',
+                                borderRadius: '16px',
+                                cursor: 'pointer',
+                                fontWeight: '700',
+                                transition: 'all 0.2s',
+                                fontSize: '0.9rem'
+                            }}>
+                                Cancel Handshake
+                            </button>
+                        </div>
+
+                        <div style={{ marginTop: '25px', fontSize: '0.75rem', color: '#475569' }}>
+                            Session ID: {session.sessionId.slice(0, 8)}...
+                        </div>
+                    </div>
+                </div>
+            )}
+        </>
+    );
+};

package/src/hooks/useQidAuth.ts

@@ -0,0 +1,104 @@
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { QidCloud } from '../index';
+import { QidUser, QidAuthSession } from '../types';
+
+export interface UseQidAuthReturn {
+    user: QidUser | null;
+    token: string | null;
+    loading: boolean;
+    error: string | null;
+    session: QidAuthSession | null;
+    initializing: boolean;
+    login: () => Promise<void>;
+    logout: () => void;
+    cancel: () => void;
+}
+
+/**
+ * A React hook for managing QidCloud authentication lifecycle.
+ * Handles handshake initialization, WebSocket listeners, and profile fetching.
+ */
+export function useQidAuth(sdk: QidCloud): UseQidAuthReturn {
+    const [user, setUser] = useState<QidUser | null>(null);
+    const [token, setToken] = useState<string | null>(null);
+    const [session, setSession] = useState<QidAuthSession | null>(null);
+    const [loading, setLoading] = useState(false);
+    const [initializing, setInitializing] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    // Use ref to track if we should still be listening (to avoid state updates after unmount/cancel)
+    const activeSessionId = useRef<string | null>(null);
+
+    const logout = useCallback(() => {
+        setUser(null);
+        setToken(null);
+        setSession(null);
+        sdk.auth.disconnect();
+    }, [sdk]);
+
+    const cancel = useCallback(() => {
+        activeSessionId.current = null;
+        setSession(null);
+        setInitializing(false);
+        sdk.auth.disconnect();
+    }, [sdk]);
+
+    const login = useCallback(async () => {
+        setInitializing(true);
+        setError(null);
+        try {
+            const newSession = await sdk.auth.createSession();
+            setSession(newSession);
+            activeSessionId.current = newSession.sessionId;
+
+            sdk.auth.listen(
+                newSession.sessionId,
+                async (receivedToken: string) => {
+                    // Safety check: is this still the active session?
+                    if (activeSessionId.current !== newSession.sessionId) return;
+
+                    setLoading(true);
+                    setInitializing(false);
+                    try {
+                        const profile = await sdk.auth.getProfile(receivedToken);
+                        setToken(receivedToken);
+                        setUser(profile);
+                    } catch (err: any) {
+                        setError(err.message || 'Failed to fetch user profile');
+                    } finally {
+                        setLoading(false);
+                        setSession(null);
+                    }
+                },
+                (err: string) => {
+                    if (activeSessionId.current !== newSession.sessionId) return;
+                    setError(err);
+                    setInitializing(false);
+                    setSession(null);
+                }
+            );
+        } catch (err: any) {
+            setError(err.message || 'Failed to initiate login handshake');
+            setInitializing(false);
+        }
+    }, [sdk]);
+
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            sdk.auth.disconnect();
+        };
+    }, [sdk]);
+
+    return {
+        user,
+        token,
+        loading,
+        error,
+        session,
+        initializing,
+        login,
+        logout,
+        cancel
+    };
+}

package/src/index.ts

@@ -1,7 +1,57 @@
-import { QidCloud, QidConfig, UserProfile } from './QidCloud';
-import UnifiedStorage from './storage';
-import * as PQC from './crypto/pqc';
+import axios, { AxiosInstance } from 'axios';
+import { QidConfig } from './types';
+import { AuthModule } from './modules/auth';
+import { DbModule } from './modules/db';
+import { EdgeModule } from './modules/edge';
+import { VaultModule } from './modules/vault';
+import { LogsModule } from './modules/logs';
 
-export { QidCloud, QidCloud as PQAuth, QidConfig, UserProfile, UnifiedStorage, PQC };
+export class QidCloud {
+    private config: QidConfig;
+    public api: AxiosInstance;
+
+    public auth: AuthModule;
+    public db: DbModule;
+    public edge: EdgeModule;
+    public vault: VaultModule;
+    public logs: LogsModule;
+
+    constructor(config: QidConfig) {
+        this.config = {
+            baseUrl: 'https://api.qidcloud.com',
+            ...config,
+        };
+
+        this.api = axios.create({
+            baseURL: this.config.baseUrl,
+            headers: {
+                'x-api-key': this.config.apiKey,
+                'Content-Type': 'application/json',
+            },
+        });
+
+        this.auth = new AuthModule(this);
+        this.db = new DbModule(this);
+        this.edge = new EdgeModule(this);
+        this.vault = new VaultModule(this);
+        this.logs = new LogsModule(this);
+    }
+
+    /**
+     * Get the current project configuration
+     */
+    getConfig(): QidConfig {
+        return { ...this.config };
+    }
+
+    // Modules will be initialized here
+    // public auth = new AuthModule(this);
+    // public db = new DbModule(this);
+    // public storage = new StorageModule(this);
+    // public edge = new EdgeModule(this);
+}
 
 export default QidCloud;
+export * from './types';
+export { QidSignInButton } from './components/QidSignInButton';
+export { useQidAuth } from './hooks/useQidAuth';

package/src/modules/auth.ts

@@ -0,0 +1,77 @@
+import { io, Socket } from 'socket.io-client';
+import { QidCloud } from '../index';
+import { QidAuthSession, QidUser } from '../types';
+
+export class AuthModule {
+    private sdk: QidCloud;
+    private socket: Socket | null = null;
+
+    constructor(sdk: QidCloud) {
+        this.sdk = sdk;
+    }
+
+    /**
+     * Initialize a new handshake session for QR login
+     */
+    async createSession(): Promise<QidAuthSession> {
+        const resp = await this.sdk.api.post('/api/initiate-generic');
+        const { sessionId, nonce } = resp.data;
+
+        // Construct QR data
+        const qrData = `qid: handshake:${sessionId}:${nonce} `;
+
+        return {
+            sessionId,
+            qrData,
+            expiresAt: Date.now() + 120000 // 2 minutes
+        };
+    }
+
+    /**
+     * Listen for authorization events for a specific session
+     */
+    listen(sessionId: string, onAuthorized: (token: string) => void, onDenied?: (msg: string) => void) {
+        if (!this.socket) {
+            const baseUrl = this.sdk.getConfig().baseUrl || 'https://api.qidcloud.com';
+            this.socket = io(baseUrl);
+        }
+
+        this.socket.emit('join', sessionId);
+
+        this.socket.on('authenticated', (token: string) => {
+            onAuthorized(token);
+        });
+
+        this.socket.on('identity_authorized', (data: any) => {
+            // Some backend routes wrap the token in an object
+            const token = typeof data === 'string' ? data : data.token;
+            onAuthorized(token);
+        });
+
+        this.socket.on('identity_denied', (data: any) => {
+            if (onDenied) onDenied(data.message || 'Authorization denied');
+        });
+    }
+
+    /**
+     * Stop listening and disconnect socket
+     */
+    disconnect() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+
+    /**
+     * Fetch user profile using a session token
+     */
+    async getProfile(token: string): Promise<QidUser> {
+        const resp = await this.sdk.api.get('/api/me', {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        return resp.data;
+    }
+}

package/src/modules/db.ts

@@ -0,0 +1,40 @@
+import { QidCloud } from '../index';
+import { QidDbResponse } from '../types';
+
+export class DbModule {
+  private sdk: QidCloud;
+
+  constructor(sdk: QidCloud) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Execute a SQL query against the project's enclave database
+   * @param sql The SQL query string
+   * @param params Parameterized values for the query
+   * @param userToken Optional session token for user-scoped access
+   */
+  async query<T = any>(sql: string, params: any[] = [], userToken?: string): Promise<QidDbResponse<T>> {
+    const headers: any = {};
+    if (userToken) {
+      headers['Authorization'] = `Bearer ${userToken}`;
+    }
+
+    const resp = await this.sdk.api.post('/api/db/query', { sql, params }, { headers });
+    return resp.data;
+  }
+
+  /**
+   * Initialize the project's enclave database schema
+   * Useful for first-time project setup
+   */
+  async setup(userToken?: string): Promise<{ success: boolean; schemaName: string }> {
+    const headers: any = {};
+    if (userToken) {
+      headers['Authorization'] = `Bearer ${userToken}`;
+    }
+
+    const resp = await this.sdk.api.post('/api/db/setup', {}, { headers });
+    return resp.data;
+  }
+}

package/src/modules/edge.ts

@@ -0,0 +1,98 @@
+import { QidCloud } from '../index';
+import { QidEdgeResponse } from '../types';
+
+export class EdgeModule {
+    private sdk: QidCloud;
+
+    constructor(sdk: QidCloud) {
+        this.sdk = sdk;
+    }
+
+    /**
+     * Invoke a serverless edge function
+     * @param name Name of the function to invoke
+     * @param params Arguments passed to the function
+     * @param userToken Optional session token for user-scoped access
+     */
+    async invoke(name: string, params: any = {}, userToken?: string): Promise<QidEdgeResponse> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.post('/api/edge/invoke', { name, params }, { headers });
+        return resp.data;
+    }
+
+    /**
+     * List all functions in the project enclave
+     */
+    async list(): Promise<any[]> {
+        const resp = await this.sdk.api.get('/api/edge/list');
+        return resp.data;
+    }
+
+    /**
+     * Get logs for a specific function
+     * @param name Function name
+     * @param userToken Optional session token
+     */
+    async getLogs(name: string, userToken?: string): Promise<any[]> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.get(`/api/edge/${name}/logs`, { headers });
+        return resp.data;
+    }
+
+    /**
+     * Get project-wide enclave logs
+     */
+    async getProjectLogs(userToken?: string): Promise<any[]> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.get('/api/edge/logs/project', { headers });
+        return resp.data;
+    }
+
+    /**
+     * Delete a function from the enclave
+     */
+    async delete(name: string, userToken?: string): Promise<{ success: boolean }> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.delete(`/api/edge/${name}`, { headers });
+        return resp.data;
+    }
+
+    /**
+     * Deploy a new function or update an existing one
+     * @param data Deployment data including name, code, and optional envVars
+     * @param userToken Optional session token
+     */
+    async deploy(data: { name: string; code: string; runtime?: string; envVars?: any; overwrite?: boolean }, userToken?: string): Promise<{ success: boolean; message: string }> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.post('/api/edge/deploy', data, { headers });
+        return resp.data;
+    }
+
+    /**
+     * Get available serverless runtimes
+     */
+    async getRuntimes(): Promise<string[]> {
+        const resp = await this.sdk.api.get('/api/edge/runtimes');
+        return resp.data;
+    }
+
+    /**
+     * Toggle centralized logging for the project's edge functions
+     * @param enabled Whether to enable or disable logging
+     * @param userToken Optional session token
+     */
+    async toggleLogging(enabled: boolean, userToken?: string): Promise<{ success: boolean; loggingEnabled: boolean }> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.post('/api/edge/logs/settings', { enabled }, { headers });
+        return resp.data;
+    }
+}

package/src/modules/logs.ts

@@ -0,0 +1,30 @@
+import { QidCloud } from '../index';
+
+export class LogsModule {
+    private sdk: QidCloud;
+
+    constructor(sdk: QidCloud) {
+        this.sdk = sdk;
+    }
+
+    /**
+     * Write a custom application log to the project enclave
+     * @param message The log message
+     * @param source The source of the log (e.g. 'auth-service', 'frontend')
+     * @param level Log level (info, warn, error)
+     * @param metadata Structured data for searching/filtering
+     */
+    async write(message: string, source: string = 'app', level: string = 'info', metadata: any = {}): Promise<{ success: boolean }> {
+        const resp = await this.sdk.api.post('/api/logs', { message, source, level, metadata });
+        return resp.data;
+    }
+
+    /**
+     * Retrieve application logs for the project
+     * @param query Filters (limit, level, etc.)
+     */
+    async fetch(query: any = {}): Promise<any[]> {
+        const resp = await this.sdk.api.get('/api/logs', { params: query });
+        return resp.data;
+    }
+}