Fix: console update

package.json

@@ -20,7 +20,7 @@
     },
     "dependencies": {
         "@ai-sdk/svelte": "^1.1.24",
-        "@appwrite.io/console": "https://pkg.vc/-/@appwrite/@appwrite.io/console@c6f60aa",
+        "@appwrite.io/console": "https://pkg.vc/-/@appwrite/@appwrite.io/console@e264dec",
         "@appwrite.io/pink-icons": "0.25.0",
         "@appwrite.io/pink-icons-svelte": "https://pkg.vc/-/@appwrite/@appwrite.io/pink-icons-svelte@df765cc",
         "@appwrite.io/pink-legacy": "^1.0.3",

src/lib/helpers/fingerprint.ts

@@ -0,0 +1,217 @@
+import { env } from '$env/dynamic/public';
+
+const SECRET = env.PUBLIC_CONSOLE_FINGERPRINT_KEY ?? '';
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+async function sha256(message: string): Promise<string> {
+    const data = new TextEncoder().encode(message);
+    const hash = await crypto.subtle.digest('SHA-256', data);
+    return Array.from(new Uint8Array(hash))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+
+async function hmacSha256(message: string, secret: string): Promise<string> {
+    const key = await crypto.subtle.importKey(
+        'raw',
+        new TextEncoder().encode(secret),
+        { name: 'HMAC', hash: 'SHA-256' },
+        false,
+        ['sign']
+    );
+    const sig = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(message));
+    return Array.from(new Uint8Array(sig))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+
+function getCanvasFingerprint(): string {
+    try {
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        if (!ctx) return '';
+
+        canvas.width = 200;
+        canvas.height = 50;
+
+        ctx.textBaseline = 'top';
+        ctx.font = '14px Arial';
+        ctx.fillStyle = '#f60';
+        ctx.fillRect(125, 1, 62, 20);
+        ctx.fillStyle = '#069';
+        ctx.fillText('Appwrite Console', 2, 15);
+        ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
+        ctx.fillText('Appwrite Console', 4, 17);
+
+        return canvas.toDataURL();
+    } catch {
+        return '';
+    }
+}
+
+function getWebGLFingerprint(): string {
+    try {
+        const canvas = document.createElement('canvas');
+        const gl =
+            canvas.getContext('webgl') ||
+            (canvas.getContext('experimental-webgl') as WebGLRenderingContext | null);
+        if (!gl) return '';
+
+        const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+        if (!debugInfo) return 'webgl-no-debug';
+
+        const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || '';
+        const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || '';
+
+        return `${vendor}~${renderer}`;
+    } catch {
+        return '';
+    }
+}
+
+function getAudioFingerprint(): Promise<string> {
+    return new Promise((resolve) => {
+        try {
+            const AudioContext =
+                window.AudioContext ||
+                (window as unknown as { webkitAudioContext: typeof window.AudioContext })
+                    .webkitAudioContext;
+            if (!AudioContext) {
+                resolve('');
+                return;
+            }
+
+            const context = new AudioContext();
+            const oscillator = context.createOscillator();
+            const analyser = context.createAnalyser();
+            const gain = context.createGain();
+            const processor = context.createScriptProcessor(4096, 1, 1);
+
+            gain.gain.value = 0;
+            oscillator.type = 'triangle';
+            oscillator.frequency.value = 10000;
+
+            oscillator.connect(analyser);
+            analyser.connect(processor);
+            processor.connect(gain);
+            gain.connect(context.destination);
+
+            oscillator.start(0);
+
+            const dataArray = new Float32Array(analyser.frequencyBinCount);
+            analyser.getFloatFrequencyData(dataArray);
+
+            let sum = 0;
+            for (let i = 0; i < dataArray.length; i++) {
+                sum += Math.abs(dataArray[i]);
+            }
+
+            oscillator.stop();
+            processor.disconnect();
+            context.close();
+
+            resolve(sum.toString());
+        } catch {
+            resolve('');
+        }
+    });
+}
+
+interface StaticSignals {
+    userAgent: string;
+    language: string;
+    languages: string[];
+    platform: string;
+    hardwareConcurrency: number;
+    deviceMemory: number | undefined;
+    maxTouchPoints: number;
+    screenWidth: number;
+    screenHeight: number;
+    screenColorDepth: number;
+    screenPixelDepth: number;
+    devicePixelRatio: number;
+    timezoneOffset: number;
+    timezone: string;
+    canvas: string;
+    webgl: string;
+    audio: string;
+}
+
+interface BrowserSignals extends StaticSignals {
+    timestamp: number;
+}
+
+interface SignalsCache {
+    signals: StaticSignals;
+    collectedAt: number;
+}
+
+let cache: SignalsCache | null = null;
+let cachePromise: Promise<StaticSignals> | null = null;
+
+async function collectStaticSignals(): Promise<StaticSignals> {
+    const [canvasRaw, webgl, audio] = await Promise.all([
+        Promise.resolve(getCanvasFingerprint()),
+        Promise.resolve(getWebGLFingerprint()),
+        getAudioFingerprint()
+    ]);
+
+    const canvas = canvasRaw ? await sha256(canvasRaw) : '';
+
+    return {
+        userAgent: navigator.userAgent,
+        language: navigator.language,
+        languages: [...(navigator.languages || [])],
+        platform: navigator.platform,
+        hardwareConcurrency: navigator.hardwareConcurrency || 0,
+        deviceMemory: (navigator as Navigator & { deviceMemory?: number }).deviceMemory,
+        maxTouchPoints: navigator.maxTouchPoints || 0,
+        screenWidth: screen.width,
+        screenHeight: screen.height,
+        screenColorDepth: screen.colorDepth,
+        screenPixelDepth: screen.pixelDepth,
+        devicePixelRatio: window.devicePixelRatio || 1,
+        timezoneOffset: new Date().getTimezoneOffset(),
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        canvas,
+        webgl,
+        audio
+    };
+}
+
+async function getCachedSignals(): Promise<StaticSignals> {
+    const now = Date.now();
+
+    if (cache && now - cache.collectedAt < CACHE_TTL_MS) {
+        return cache.signals;
+    }
+
+    if (cachePromise) {
+        return cachePromise;
+    }
+
+    cachePromise = collectStaticSignals();
+
+    try {
+        const signals = await cachePromise;
+        cache = { signals, collectedAt: now };
+        return signals;
+    } finally {
+        cachePromise = null;
+    }
+}
+
+export async function generateFingerprintToken(): Promise<string> {
+    const staticSignals = await getCachedSignals();
+
+    const signals: BrowserSignals = {
+        ...staticSignals,
+        timestamp: Math.floor(Date.now() / 1000)
+    };
+
+    const payload = JSON.stringify(signals);
+    const encoded = btoa(payload);
+    const signature = await hmacSha256(encoded, SECRET);
+
+    return `${encoded}.${signature}`;
+}

src/routes/(console)/organization-[organization]/+page.svelte

@@ -29,6 +29,7 @@
         IconAndroid,
         IconApple,
         IconCode,
+        IconExclamationCircle,
         IconFlutter,
         IconPlus,
         IconReact,
@@ -272,7 +273,12 @@
                     </svelte:fragment>
 
                     <svelte:fragment slot="status">
-                        {#if isSetToArchive(project)}
+                        {#if project.status === 'paused'}
+                            <Tag size="s" style="white-space: nowrap;">
+                                <Icon icon={IconExclamationCircle} size="s" slot="start" />
+                                Paused
+                            </Tag>
+                        {:else if isSetToArchive(project)}
                             <Tag
                                 size="s"
                                 style="white-space: nowrap;"

src/routes/(console)/organization-[organization]/+page.ts

@@ -30,7 +30,7 @@ export const load: PageLoad = async ({ params, url, route, depends, parent }) =>
         : [];
     const commonQueries = [Query.equal('teamId', params.organization)];
     const activeQueries = isCloud
-        ? [Query.or([Query.equal('status', 'active'), Query.isNull('status')])]
+        ? [Query.or([Query.equal('status', ['active', 'paused']), Query.isNull('status')])]
         : [];
 
     const [activeProjects, archivedProjects, activeTotal, archivedTotal] = await Promise.all([

src/routes/(console)/project-[region]-[project]/+layout.svelte

@@ -25,6 +25,11 @@
         canWriteSites
     } from '$lib/stores/roles';
     import CsvImportBox from '$lib/components/csvImportBox.svelte';
+    import { isCloud } from '$lib/system';
+    import PausedProjectModal from './pausedProjectModal.svelte';
+    import type { LayoutData } from './$types';
+
+    export let data: LayoutData;
 
     onMount(() => {
         return realtime.forProject(page.params.region, ['project', 'console'], (response) => {
@@ -114,6 +119,10 @@
 
 <slot />
 
+{#if isCloud && data.project?.status === 'paused'}
+    <PausedProjectModal show={true} projectId={data.project.$id} />
+{/if}
+
 <div class="layout-level-progress-bars">
     <UploadBox />
     <MigrationBox />

src/routes/(console)/project-[region]-[project]/+layout.ts

@@ -11,6 +11,7 @@ import { loadAvailableRegions } from '$routes/(console)/regions';
 import { type Models, Platform } from '@appwrite.io/console';
 import { redirect } from '@sveltejs/kit';
 import { resolve } from '$app/paths';
+import { generateFingerprintToken } from '$lib/helpers/fingerprint';
 import { normalizeConsoleVariables } from '$lib/helpers/domains';
 
 export const load: LayoutLoad = async ({ params, depends, parent }) => {
@@ -92,6 +93,33 @@ export const load: LayoutLoad = async ({ params, depends, parent }) => {
         plansInfo.set(organization.billingPlanId, organizationPlan);
     }
 
+    // Track console access for cloud only (fire-and-forget, backend has 6-day cooldown)
+    // Don't call if project is paused - user must explicitly resume via createConsoleAccess
+    if (isCloud) {
+        const projectInactivityDays = organizationPlan?.projectInactivityDays ?? 0;
+        const consoleAccessedAt = (project as { consoleAccessedAt?: string }).consoleAccessedAt;
+
+        let isPaused = false;
+        if (projectInactivityDays > 0 && consoleAccessedAt) {
+            const lastAccess = new Date(consoleAccessedAt);
+            const now = new Date();
+            const diffDays = Math.floor((now.getTime() - lastAccess.getTime()) / (1000 * 60 * 60 * 24));
+            isPaused = diffDays >= projectInactivityDays;
+        }
+
+        if (!isPaused) {
+            generateFingerprintToken()
+                .then((fingerprint) => {
+                    sdk.forConsole.client.headers['X-Appwrite-Console-Fingerprint'] = fingerprint;
+                    return sdk.forConsole.projects.updateConsoleAccess({ projectId: params.project });
+                })
+                .catch(() => {})
+                .finally(() => {
+                    delete sdk.forConsole.client.headers['X-Appwrite-Console-Fingerprint'];
+                });
+        }
+    }
+
     return {
         project,
         organization,