tabminal 3.0.34 → 3.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabminal",
-  "version": "3.0.34",
+  "version": "3.0.35",
   "description": "Tab(ter)minal, a Cloud-Native terminal and ACP agent workspace for desktop, tablet, and phone.",
   "type": "module",
   "bin": {

package/public/app.js

@@ -17967,7 +17967,20 @@ document.addEventListener('keydown', (e) => {
 }, true); // Use capture phase to override editor/terminal
 
 
+async function bootApp() {
+    try {
+        bootstrapServers();
+        await initApp();
+        window.__tabminalMarkBootSuccess?.();
+    } catch (error) {
+        console.error('[Boot] Failed to start Tabminal:', error);
+        window.__tabminalMarkBootFailure?.(
+            error?.message || 'app initialization failed'
+        );
+        throw error;
+    }
+}
+
 // Start the app
-bootstrapServers();
-initApp();
+void bootApp();
 // #endregion

package/public/index.html

@@ -277,8 +277,20 @@
             }
 
             const runtimeStorageKey = 'tabminal_runtime_boot_id';
+            const bootRetryStorageKey = 'tabminal_boot_retry_state';
             const versionApiUrl = './api/version';
             const runtimeVersionTimeoutMs = 3000;
+            const bootWatchdogTimeoutMs = 25000;
+            const bootRecoveryProbeIntervalMs = 15000;
+            const bootRecoveryReloadDelayMs = 1200;
+            const bootRetryWindowMs = 90000;
+            const bootMaxReloadsPerWindow = 3;
+            window.__tabminalBootState = {
+                status: 'pending',
+                startedAt: Date.now(),
+                assetKey: '',
+                error: ''
+            };
             const readStoredRuntimeBootId = () => {
                 try {
                     return localStorage.getItem(runtimeStorageKey) || '';
@@ -297,6 +309,159 @@
                 return readStoredRuntimeBootId() || `cold-${Date.now()}`;
             };
             window.__tabminalRuntimeAssetKey = getStartupFallbackAssetKey();
+            window.__tabminalBootState.assetKey =
+                window.__tabminalRuntimeAssetKey;
+
+            const readBootRetryState = () => {
+                try {
+                    const parsed = JSON.parse(
+                        sessionStorage.getItem(bootRetryStorageKey) || '{}'
+                    );
+                    if (!parsed || typeof parsed !== 'object') {
+                        return { firstAt: 0, count: 0 };
+                    }
+                    return {
+                        firstAt: Number.isFinite(parsed.firstAt)
+                            ? parsed.firstAt
+                            : 0,
+                        count: Number.isFinite(parsed.count)
+                            ? parsed.count
+                            : 0
+                    };
+                } catch {
+                    return { firstAt: 0, count: 0 };
+                }
+            };
+
+            const writeBootRetryState = (state) => {
+                try {
+                    sessionStorage.setItem(
+                        bootRetryStorageKey,
+                        JSON.stringify(state)
+                    );
+                } catch {
+                    // Ignore storage failures; the watchdog can still probe.
+                }
+            };
+
+            const clearBootRetryState = () => {
+                try {
+                    sessionStorage.removeItem(bootRetryStorageKey);
+                } catch {
+                    // Ignore storage failures.
+                }
+            };
+
+            const canReloadForBootFailure = () => {
+                const now = Date.now();
+                const retryState = readBootRetryState();
+                const firstAt = (
+                    retryState.firstAt
+                    && now - retryState.firstAt <= bootRetryWindowMs
+                )
+                    ? retryState.firstAt
+                    : now;
+                const count = firstAt === retryState.firstAt
+                    ? retryState.count
+                    : 0;
+                if (count >= bootMaxReloadsPerWindow) {
+                    return false;
+                }
+                writeBootRetryState({
+                    firstAt,
+                    count: count + 1
+                });
+                return true;
+            };
+
+            const probeRuntimeReachable = async () => {
+                const controller = (
+                    typeof AbortController === 'function'
+                        ? new AbortController()
+                        : null
+                );
+                const timeoutId = window.setTimeout(() => {
+                    if (controller) {
+                        controller.abort();
+                    }
+                }, runtimeVersionTimeoutMs);
+                try {
+                    const response = await fetch(versionApiUrl, {
+                        method: 'GET',
+                        cache: 'no-store',
+                        credentials: 'same-origin',
+                        headers: {
+                            'accept': 'application/json'
+                        },
+                        signal: controller?.signal
+                    });
+                    return response.ok;
+                } catch {
+                    return false;
+                } finally {
+                    window.clearTimeout(timeoutId);
+                }
+            };
+
+            const scheduleBootRecovery = (() => {
+                let timer = 0;
+                return (reason, delay = bootRecoveryReloadDelayMs) => {
+                    const state = window.__tabminalBootState;
+                    if (!state || state.status === 'success') {
+                        return;
+                    }
+                    state.status = 'recovering';
+                    state.error = String(reason || 'boot timeout');
+                    if (timer) {
+                        return;
+                    }
+                    timer = window.setTimeout(async () => {
+                        timer = 0;
+                        if (state.status === 'success') {
+                            return;
+                        }
+                        const reachable = await probeRuntimeReachable();
+                        if (!reachable) {
+                            scheduleBootRecovery(
+                                'runtime unavailable',
+                                bootRecoveryProbeIntervalMs
+                            );
+                            return;
+                        }
+                        if (!canReloadForBootFailure()) {
+                            state.status = 'failed';
+                            console.warn(
+                                '[Boot] App shell failed after repeated reloads.',
+                                state.error
+                            );
+                            return;
+                        }
+                        window.location.reload();
+                    }, delay);
+                };
+            })();
+
+            window.__tabminalMarkBootSuccess = () => {
+                const state = window.__tabminalBootState;
+                if (state) {
+                    state.status = 'success';
+                    state.completedAt = Date.now();
+                    state.error = '';
+                }
+                clearBootRetryState();
+            };
+
+            window.__tabminalMarkBootFailure = (reason) => {
+                scheduleBootRecovery(reason || 'boot failure');
+            };
+
+            window.setTimeout(() => {
+                const state = window.__tabminalBootState;
+                if (!state || state.status === 'success') {
+                    return;
+                }
+                scheduleBootRecovery('boot watchdog timeout');
+            }, bootWatchdogTimeoutMs);
 
             window.__tabminalResolveRuntimeVersion = (() => {
                 let promise = null;
@@ -704,10 +869,20 @@
             const link = document.createElement('link');
             link.rel = 'stylesheet';
             link.href = `./styles.css?v=${encodeURIComponent(runtimeBootId)}`;
+            link.onerror = () => {
+                if (window.__tabminalMarkBootFailure) {
+                    window.__tabminalMarkBootFailure('stylesheet load failed');
+                }
+            };
             document.head.appendChild(link);
             const script = document.createElement('script');
             script.type = 'module';
             script.src = `./app.js?v=${encodeURIComponent(runtimeBootId)}`;
+            script.onerror = () => {
+                if (window.__tabminalMarkBootFailure) {
+                    window.__tabminalMarkBootFailure('app module load failed');
+                }
+            };
             document.body.appendChild(script);
         })();
 

package/public/sw.js

@@ -1,16 +1,36 @@
 const WORKER_VERSION = new URL(self.location.href).searchParams.get('rt') || 'stable';
 const CACHE_NAME = `tabminal-cache-${WORKER_VERSION}`;
+const versioned = (path) => `${path}?v=${encodeURIComponent(WORKER_VERSION)}`;
 const STATIC_ASSETS = [
+    '/',
+    '/index.html',
     '/favicon.svg',
+    '/favicon_adaptive.svg',
     '/manifest.json',
-    '/apple-touch-icon.png'
+    '/apple-touch-icon.png',
+    '/android-chrome-192x192.png',
+    '/android-chrome-192x192-any.png',
+    '/android-chrome-512x512.png',
+    '/android-chrome-512x512-any.png',
+    '/fonts/MonaspaceNeon-Regular.woff2',
+    '/fonts/MonaspaceNeon-Bold.woff2',
+    '/icons/map.json'
+];
+const VERSIONED_APP_ASSETS = [
+    versioned('/styles.css'),
+    versioned('/app.js'),
+    versioned('/modules/notifications.js'),
+    versioned('/modules/session-meta.js'),
+    versioned('/modules/url-auth.js')
 ];
 
 async function networkFirst(request) {
     const cache = await caches.open(CACHE_NAME);
     try {
         const response = await fetch(request);
-        cache.put(request, response.clone());
+        if (response.ok) {
+            cache.put(request, response.clone());
+        }
         return response;
     } catch (_err) {
         const cached = await cache.match(request);
@@ -24,15 +44,27 @@ async function cacheFirst(request) {
     const cached = await cache.match(request);
     if (cached) return cached;
     const response = await fetch(request);
-    cache.put(request, response.clone());
+    if (response.ok) {
+        cache.put(request, response.clone());
+    }
     return response;
 }
 
+async function addAllSettled(cache, assets) {
+    await Promise.allSettled(
+        assets.map((asset) => cache.add(asset))
+    );
+}
+
 self.addEventListener('install', event => {
     self.skipWaiting();
-    event.waitUntil(
-        caches.open(CACHE_NAME).then(cache => cache.addAll(STATIC_ASSETS))
-    );
+    event.waitUntil((async () => {
+        const cache = await caches.open(CACHE_NAME);
+        await addAllSettled(cache, [
+            ...STATIC_ASSETS,
+            ...VERSIONED_APP_ASSETS
+        ]);
+    })());
 });
 
 self.addEventListener('activate', event => {
@@ -81,8 +113,23 @@ self.addEventListener('fetch', event => {
         || url.pathname === '/sw.js'
         || url.pathname.startsWith('/modules/')
     );
+    const isVersionedAppShell = (
+        isAppShell
+        && (
+            url.searchParams.get('v') === WORKER_VERSION
+            || url.searchParams.get('rt') === WORKER_VERSION
+        )
+    );
 
-    if (isDocument || isAppShell) {
+    if (isDocument) {
+        event.respondWith(networkFirst(request));
+        return;
+    }
+    if (isVersionedAppShell) {
+        event.respondWith(cacheFirst(request));
+        return;
+    }
+    if (isAppShell) {
         event.respondWith(networkFirst(request));
         return;
     }