@qidcloud/sdk 1.2.0 → 1.2.1

package/dist/modules/edge.d.ts

@@ -30,4 +30,32 @@ export declare class EdgeModule {
     delete(name: string, userToken?: string): Promise<{
         success: boolean;
     }>;
+    /**
+     * Deploy a new function or update an existing one
+     * @param data Deployment data including name, code, and optional envVars
+     * @param userToken Optional session token
+     */
+    deploy(data: {
+        name: string;
+        code: string;
+        runtime?: string;
+        envVars?: any;
+        overwrite?: boolean;
+    }, userToken?: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Get available serverless runtimes
+     */
+    getRuntimes(): Promise<string[]>;
+    /**
+     * Toggle centralized logging for the project's edge functions
+     * @param enabled Whether to enable or disable logging
+     * @param userToken Optional session token
+     */
+    toggleLogging(enabled: boolean, userToken?: string): Promise<{
+        success: boolean;
+        loggingEnabled: boolean;
+    }>;
 }

package/dist/modules/vault.d.ts

@@ -23,7 +23,7 @@ export declare class VaultModule {
      */
     download(fileId: string, userToken?: string): Promise<ArrayBuffer>;
     /**
-     * Delete a file from storage
+     * Delete a file from storage (Soft Delete)
      * @param fileId Unique ID of the file
      * @param userToken Session token for user-scoped storage
      */
@@ -31,4 +31,27 @@ export declare class VaultModule {
         success: boolean;
         message: string;
     }>;
+    /**
+     * List deleted files in the project enclave (Recycle Bin)
+     * @param userToken Session token for user-scoped storage
+     */
+    listDeleted(userToken?: string): Promise<QidFile[]>;
+    /**
+     * Restore a deleted file from the recycle bin
+     * @param fileId Unique ID of the file
+     * @param userToken Session token for user-scoped storage
+     */
+    restore(fileId: string, userToken?: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Permanently purge a deleted file
+     * @param fileId Unique ID of the file
+     * @param userToken Session token for user-scoped storage
+     */
+    purge(fileId: string, userToken?: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
 }

package/package.json

@@ -1,52 +1,35 @@
-{
-  "name": "@qidcloud/sdk",
-  "version": "1.2.0",
-  "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": [
-    "pqc",
-    "quantum-resistant",
-    "passwordless",
-    "enclave",
-    "security",
-    "auth"
-  ],
-  "author": "QidCloud Team",
-  "license": "ISC",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/CHANDU32455/QIDCLOUD.git"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "type": "commonjs",
-  "dependencies": {
-    "axios": "^1.13.5",
-    "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"
-  }
+{
+  "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

@@ -0,0 +1,57 @@
+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 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;
+  }
+}