4runr-os 2.10.69 → 2.10.70

package/dist/tui-handlers.js

@@ -1606,7 +1606,7 @@ async function handleGatewayConnect(ctx) {
                                 level: 'info',
                                 message: 'Attempting to restart Docker containers...',
                             });
-                            const redisUrl = tryTuiAutostartDockerComposeStack(bundleCheck.path, activityLog, getCurrentTime);
+                            const redisUrl = await tryTuiAutostartDockerComposeStack(bundleCheck.path, activityLog, getCurrentTime);
                             if (redisUrl) {
                                 await new Promise((r) => setTimeout(r, 3000));
                                 // Re-verify
@@ -2267,6 +2267,8 @@ async function isGatewayHealthy(url) {
     }
 }
 const TUI_LOCAL_REDIS_DEFAULT = 'redis://127.0.0.1:6379';
+const TUI_DB_CONTAINERS = ['4runr-postgres', '4runr-redis'];
+const TUI_COMPOSE_PROJECT = '4runr';
 function tuiAutostartDockerStackDisabledByEnv() {
     if (process.env['FOURRUNR_NO_AUTO_REDIS'] === '1' || process.env['FOURRUNR_NO_AUTO_REDIS'] === 'true') {
         return true;
@@ -2279,24 +2281,90 @@ function tuiAutostartDockerStackDisabledByEnv() {
     }
     return false;
 }
-/**
- * Start Postgres + Redis together via the same compose file the Gateway uses.
- * Previously we only ran a standalone Redis container, so Postgres never came up and Prisma stayed in memory mode.
- */
-function tryTuiAutostartDockerComposeStack(bundlePath, activityLog, getCurrentTimeFn) {
-    if (tuiAutostartDockerStackDisabledByEnv()) {
+function tuiDockerShell() {
+    return process.platform === 'win32' ? (process.env['ComSpec'] || 'cmd.exe') : '/bin/sh';
+}
+function tuiIsContainerRunning(containerName) {
+    try {
+        const state = execSync(`docker inspect --format="{{.State.Running}}" ${containerName}`, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 5000,
+            windowsHide: true,
+            shell: tuiDockerShell(),
+        }).trim();
+        return state === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+function tuiStartStoppedContainers(activityLog, getCurrentTimeFn) {
+    const stopped = TUI_DB_CONTAINERS.filter((name) => !tuiIsContainerRunning(name));
+    if (stopped.length === 0) {
+        return;
+    }
+    try {
+        execSync(`docker start ${stopped.join(' ')}`, {
+            stdio: 'ignore',
+            windowsHide: true,
+            timeout: 60000,
+            shell: tuiDockerShell(),
+        });
         activityLog.push({
             timestamp: getCurrentTimeFn(),
             level: 'info',
-            message: 'Autostart Docker stack: skipped (FOURRUNR_NO_AUTO_DOCKER / FOURRUNR_NO_AUTO_REDIS / FOURRUNR_SPAWN_REDIS=0).',
+            message: `Docker: started stopped container(s): ${stopped.join(', ')}`,
         });
-        return undefined;
     }
-    if (String(process.env['REDIS_URL'] || '').trim() !== '') {
+    catch {
+        // May not exist yet — compose up will create them
+    }
+}
+async function tuiWaitForContainerHealthy(containerName, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const health = execSync(`docker inspect --format="{{.State.Health.Status}}" ${containerName}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+                timeout: 5000,
+                windowsHide: true,
+                shell: tuiDockerShell(),
+            }).trim();
+            if (health === 'healthy') {
+                return true;
+            }
+            if (health === '' || health === '<no value>') {
+                const running = execSync(`docker inspect --format="{{.State.Running}}" ${containerName}`, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                    timeout: 5000,
+                    windowsHide: true,
+                    shell: tuiDockerShell(),
+                }).trim();
+                if (running === 'true') {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // keep waiting
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+    return false;
+}
+/**
+ * Start Postgres + Redis together via the same compose file the Gateway uses.
+ * Watchdog stops both when 4r exits — always ensure both are back up on connect.
+ */
+async function tryTuiAutostartDockerComposeStack(bundlePath, activityLog, getCurrentTimeFn) {
+    if (tuiAutostartDockerStackDisabledByEnv()) {
         activityLog.push({
             timestamp: getCurrentTimeFn(),
             level: 'info',
-            message: 'Autostart Docker stack: skipped (REDIS_URL already set — manage Postgres yourself if needed).',
+            message: 'Autostart Docker stack: skipped (FOURRUNR_NO_AUTO_DOCKER / FOURRUNR_NO_AUTO_REDIS / FOURRUNR_SPAWN_REDIS=0).',
         });
         return undefined;
     }
@@ -2309,21 +2377,59 @@ function tryTuiAutostartDockerComposeStack(bundlePath, activityLog, getCurrentTi
         });
         return undefined;
     }
-    const dockerShell = process.platform === 'win32' ? (process.env['ComSpec'] || 'cmd.exe') : '/bin/sh';
+    const dockerShell = tuiDockerShell();
+    const allRunning = TUI_DB_CONTAINERS.every((name) => tuiIsContainerRunning(name));
+    if (allRunning) {
+        activityLog.push({
+            timestamp: getCurrentTimeFn(),
+            level: 'info',
+            message: 'Docker: Postgres + Redis already running (4runr-postgres :5432, 4runr-redis :6379).',
+        });
+        return String(process.env['REDIS_URL'] || '').trim() || TUI_LOCAL_REDIS_DEFAULT;
+    }
+    if (String(process.env['REDIS_URL'] || '').trim() !== '') {
+        activityLog.push({
+            timestamp: getCurrentTimeFn(),
+            level: 'info',
+            message: 'REDIS_URL is set in environment — still starting Postgres + Redis Docker stack for persistence.',
+        });
+    }
     try {
-        execSync(`docker compose -f "${composeFile}" up -d`, {
-            cwd: bundlePath,
-            stdio: 'ignore',
-            windowsHide: true,
-            timeout: 120000,
-            shell: dockerShell,
+        tuiStartStoppedContainers(activityLog, getCurrentTimeFn);
+        if (!TUI_DB_CONTAINERS.every((name) => tuiIsContainerRunning(name))) {
+            execSync(`docker compose -p ${TUI_COMPOSE_PROJECT} -f "${composeFile}" up -d`, {
+                cwd: bundlePath,
+                stdio: 'ignore',
+                windowsHide: true,
+                timeout: 120000,
+                shell: dockerShell,
+            });
+        }
+        activityLog.push({
+            timestamp: getCurrentTimeFn(),
+            level: 'info',
+            message: 'Waiting for Postgres + Redis to become healthy...',
         });
+        // Postgres cold start after watchdog stop can take 30–60s
+        const pgOk = await tuiWaitForContainerHealthy('4runr-postgres', 60000);
+        const redisOk = await tuiWaitForContainerHealthy('4runr-redis', 15000);
+        if (!pgOk || !redisOk) {
+            const down = [!pgOk ? '4runr-postgres' : null, !redisOk ? '4runr-redis' : null]
+                .filter(Boolean)
+                .join(', ');
+            activityLog.push({
+                timestamp: getCurrentTimeFn(),
+                level: 'warning',
+                message: `Autostart Docker stack: ${down} did not become healthy in time. Gateway may fall back to memory DB.`,
+            });
+            return undefined;
+        }
         activityLog.push({
             timestamp: getCurrentTimeFn(),
             level: 'success',
             message: 'Docker: Postgres + Redis started via docker-compose.local.yml (4runr-postgres :5432, 4runr-redis :6379).',
         });
-        return TUI_LOCAL_REDIS_DEFAULT;
+        return String(process.env['REDIS_URL'] || '').trim() || TUI_LOCAL_REDIS_DEFAULT;
     }
     catch (e) {
         activityLog.push({
@@ -2387,10 +2493,7 @@ async function startLocalGatewayAndWait(bundlePath, url, activityLog, getCurrent
     });
     shutdownAutostartedGateway(portNum);
     await new Promise((r) => setTimeout(r, 400));
-    const tuiRedisUrl = tryTuiAutostartDockerComposeStack(bundlePath, activityLog, getCurrentTimeFn);
-    if (tuiRedisUrl) {
-        await new Promise((r) => setTimeout(r, 1500));
-    }
+    const tuiRedisUrl = await tryTuiAutostartDockerComposeStack(bundlePath, activityLog, getCurrentTimeFn);
     const passThroughRedis = process.env['REDIS_URL'];
     if (!tuiRedisUrl && !String(passThroughRedis || '').trim()) {
         activityLog.push({
@@ -2414,6 +2517,9 @@ async function startLocalGatewayAndWait(bundlePath, url, activityLog, getCurrent
     };
     if (tuiRedisUrl) {
         childEnv['REDIS_URL'] = tuiRedisUrl;
+        childEnv['DATABASE_URL'] =
+            process.env['DATABASE_URL'] ||
+                'postgresql://4runr:4runr_dev_pass@localhost:5432/4runr_local';
     }
     const commonOpts = {
         cwd: bundlePath,