libre-webui 0.21.2 → 0.22.0

package/backend/dist/routes/work.js

@@ -38,16 +38,16 @@ router.use(authenticate);
  * state rather than the role cached in a still-valid JWT, so a demotion or
  * a mode change takes effect immediately.
  */
-const requireWorkAccess = (req, res, next) => {
+const requireWorkAccess = async (req, res, next) => {
     if (!req.user) {
         res.status(403).json({ success: false, message: 'Work access required' });
         return;
     }
     try {
-        const currentUser = userModel.getUserById(req.user.userId);
+        const currentUser = await userModel.getUserById(req.user.userId);
         if (!currentUser ||
             currentUser.status !== 'active' ||
-            !userHasWorkAccess(currentUser)) {
+            !(await userHasWorkAccess(currentUser))) {
             res.status(403).json({ success: false, message: 'Work access required' });
             return;
         }
@@ -67,29 +67,29 @@ const requireWorkAccess = (req, res, next) => {
 };
 // Readable by every authenticated user: the interface needs to know whether
 // to offer Work before it may call anything behind requireWorkAccess.
-router.get('/access', (req, res) => {
+router.get('/access', async (req, res) => {
     try {
         const currentUser = req.user
-            ? userModel.getUserById(req.user.userId)
+            ? await userModel.getUserById(req.user.userId)
             : undefined;
         sendSuccess(res, {
-            mode: getWorkAccessMode(),
+            mode: await getWorkAccessMode(),
             allowed: Boolean(currentUser &&
                 currentUser.status === 'active' &&
-                userHasWorkAccess(currentUser)),
+                (await userHasWorkAccess(currentUser))),
         });
     }
     catch (error) {
         sendError(res, error);
     }
 });
-router.put('/access', requireAdmin, (req, res) => {
+router.put('/access', requireAdmin, async (req, res) => {
     try {
         const mode = req.body?.mode;
         if (!isWorkAccessMode(mode)) {
             throw new WorkRouteError('Field "mode" must be "admins" or "all-users".', 400);
         }
-        setWorkAccessMode(mode);
+        await setWorkAccessMode(mode);
         sendSuccess(res, { mode });
     }
     catch (error) {
@@ -99,26 +99,26 @@ router.put('/access', requireAdmin, (req, res) => {
 router.use(requireWorkAccess);
 router.get('/capabilities', async (req, res) => {
     const userId = requireUserId(req);
-    const [dockerAvailable, providers] = await Promise.all([
-        workRuntimeService.isDockerAvailable(),
+    const [runtimeAvailable, providers] = await Promise.all([
+        workRuntimeService.isRuntimeAvailable(),
         workModelProviderService.availability(userId),
     ]);
     const providerAvailable = providers.ollamaAvailable || providers.pluginAvailable;
     const recoveryPending = workRuntimeService.recoveryPending;
-    const available = dockerAvailable && !recoveryPending && providerAvailable;
+    const available = runtimeAvailable && !recoveryPending && providerAvailable;
     const reason = recoveryPending
-        ? `Work is safely retrying ${workRuntimeService.recoveryPendingCount} container cleanup(s). New operations remain blocked until Docker proves they are stopped.`
-        : !dockerAvailable
-            ? workRuntimeService.dockerUnavailableReason ||
-                'Docker is not available to the Libre WebUI backend.'
+        ? `Work is safely retrying ${workRuntimeService.recoveryPendingCount} sandbox cleanup(s). New operations remain blocked until the configured runtime proves they are stopped.`
+        : !runtimeAvailable
+            ? workRuntimeService.runtimeUnavailableReason ||
+                `The ${workRuntimeService.runtimeKind} runtime is not available to the Libre WebUI backend.`
             : !providerAvailable
                 ? 'No Ollama or configured plugin model provider is available.'
                 : undefined;
     sendSuccess(res, {
         available,
-        runtime: 'docker',
+        runtime: workRuntimeService.runtimeKind,
         image: workRuntimeService.image,
-        dockerAvailable,
+        runtimeAvailable,
         ollamaAvailable: providers.ollamaAvailable,
         pluginAvailable: providers.pluginAvailable,
         runtimeImage: workRuntimeService.image,
@@ -126,7 +126,7 @@ router.get('/capabilities', async (req, res) => {
         limits: workRuntimeService.limits,
         activeRuntimes: workRuntimeService.activeRuntimeCounts(userId),
         terminal: {
-            available: dockerAvailable && !workTerminalService.unavailableReason(),
+            available: runtimeAvailable && !workTerminalService.unavailableReason(),
             reason: workTerminalService.unavailableReason() ?? undefined,
             maxSessionsPerTask: workTerminalService.maxSessionsPerTask,
             idleTimeoutMs: workTerminalService.idleTimeoutMs,
@@ -144,36 +144,37 @@ router.get('/capabilities', async (req, res) => {
 // Named runtime policies. Reading is open to every Work user (the picker at
 // task creation needs the list); mutations are admin-only. Registered before
 // the fail-closed gate: policies are configuration, not runtime mutations.
-router.get('/policies', (_req, res) => {
+router.get('/policies', async (_req, res) => {
     try {
-        sendSuccess(res, workPolicyService.list());
+        sendSuccess(res, await workPolicyService.list());
     }
     catch (error) {
         sendError(res, error);
     }
 });
-router.post('/policies', requireAdmin, (req, res) => {
+router.post('/policies', requireAdmin, async (req, res) => {
     try {
-        res
-            .status(201)
-            .json({ success: true, data: workPolicyService.create(req.body) });
+        res.status(201).json({
+            success: true,
+            data: await workPolicyService.create(req.body),
+        });
     }
     catch (error) {
         sendError(res, error);
     }
 });
-router.put('/policies/:id', requireAdmin, (req, res) => {
+router.put('/policies/:id', requireAdmin, async (req, res) => {
     try {
-        sendSuccess(res, workPolicyService.update(String(req.params.id || ''), req.body));
+        sendSuccess(res, await workPolicyService.update(String(req.params.id || ''), req.body));
     }
     catch (error) {
         sendError(res, error);
     }
 });
-router.delete('/policies/:id', requireAdmin, (req, res) => {
+router.delete('/policies/:id', requireAdmin, async (req, res) => {
     try {
         const id = String(req.params.id || '');
-        workPolicyService.remove(id);
+        await workPolicyService.remove(id);
         sendSuccess(res, { id, deleted: true });
     }
     catch (error) {
@@ -214,16 +215,13 @@ router.use((req, res, next) => {
 router.get('/tasks', async (req, res) => {
     try {
         const userId = requireUserId(req);
-        const previews = workTaskService
-            .listTaskRecords(userId)
-            .filter(task => task.previewStatus === 'starting' ||
-            task.previewStatus === 'running');
+        const previews = (await workTaskService.listTaskRecords(userId)).filter(task => task.previewStatus === 'starting' || task.previewStatus === 'running');
         await Promise.allSettled(previews.map(async (task) => {
             if (!(await workRuntimeService.isPreviewRunning(task))) {
-                workTaskService.updatePreview(task.id, 'stopped');
+                await workTaskService.updatePreview(task.id, 'stopped');
             }
         }));
-        sendSuccess(res, workTaskService.listTasks(userId));
+        sendSuccess(res, await workTaskService.listTasks(userId));
     }
     catch (error) {
         sendError(res, error);
@@ -232,7 +230,7 @@ router.get('/tasks', async (req, res) => {
 router.post('/tasks', async (req, res) => {
     try {
         const message = requireBodyString(req.body?.message, 'message', 65536);
-        const model = requireBodyString(req.body?.model, 'model', 500);
+        const model = requirePostgresBodyString(req.body?.model, 'model', 500);
         const userId = requireUserId(req);
         const provider = readProviderSelection(req.body);
         const requestedHostPath = typeof req.body?.hostPath === 'string' ? req.body.hostPath.trim() : '';
@@ -247,18 +245,17 @@ router.post('/tasks', async (req, res) => {
         const requestedPolicyId = typeof req.body?.policyId === 'string' ? req.body.policyId.trim() : '';
         let policy;
         if (requestedPolicyId) {
-            policy = workPolicyService.get(requestedPolicyId);
+            policy = await workPolicyService.get(requestedPolicyId);
             if (!policy) {
                 throw new WorkRouteError('The selected Work policy no longer exists.', 400);
             }
         }
         await workModelProviderService.assertModelSupportsTools(model, provider, userId);
-        const detail = workTaskService.createTaskWithRun(userId, message, model, policy?.networkDefault ?? true, provider, hostPath, policy?.id);
+        const detail = await workTaskService.createTaskWithRun(userId, message, model, policy?.networkDefault ?? true, provider, hostPath, policy?.id);
         const runId = detail.activeRun?.id;
         if (!runId) {
             throw new Error('Work run was not created.');
         }
-        workAgentService.start(detail.id, runId, userId);
         res.status(201).json({ success: true, data: detail });
     }
     catch (error) {
@@ -269,34 +266,34 @@ router.get('/tasks/:id', async (req, res) => {
     try {
         const taskId = readTaskId(req);
         const userId = requireUserId(req);
-        const task = workTaskService.requireTaskRecord(taskId, userId);
+        const task = await workTaskService.requireTaskRecord(taskId, userId);
         if (task.previewStatus === 'running' ||
             task.previewStatus === 'starting') {
             const running = await workRuntimeService.isPreviewRunning(task);
             if (!running)
-                workTaskService.updatePreview(taskId, 'stopped');
+                await workTaskService.updatePreview(taskId, 'stopped');
         }
-        sendSuccess(res, workTaskService.requireTaskDetail(taskId, userId));
+        sendSuccess(res, await workTaskService.requireTaskDetail(taskId, userId));
     }
     catch (error) {
         sendError(res, error);
     }
 });
-router.get('/tasks/:id/messages', (req, res) => {
+router.get('/tasks/:id/messages', async (req, res) => {
     try {
         const taskId = readTaskId(req);
         const userId = requireUserId(req);
-        workTaskService.requireTaskRecord(taskId, userId);
+        await workTaskService.requireTaskRecord(taskId, userId);
         const before = optionalNonNegativeInteger(req.query.before, 'before');
         const limit = optionalPositiveInteger(req.query.limit, 'limit') ?? 200;
-        sendSuccess(res, workTaskService.getMessagePage(taskId, before, Math.min(limit, 200)));
+        sendSuccess(res, await workTaskService.getMessagePage(taskId, before, Math.min(limit, 200)));
     }
     catch (error) {
         sendError(res, error);
     }
 });
-router.get('/tasks/:taskId/runs/:runId/events', (req, res) => {
-    let unsubscribe = () => undefined;
+router.get('/tasks/:taskId/runs/:runId/events', async (req, res) => {
+    let unsubscribe = async () => undefined;
     let heartbeat;
     let backpressureTimer;
     let closed = false;
@@ -314,7 +311,7 @@ router.get('/tasks/:taskId/runs/:runId/events', (req, res) => {
         if (backpressureTimer)
             clearTimeout(backpressureTimer);
         res.off('drain', flushQueuedFrames);
-        unsubscribe();
+        void unsubscribe();
         queuedFrames.length = 0;
         queuedBytes = 0;
         return true;
@@ -404,8 +401,8 @@ router.get('/tasks/:taskId/runs/:runId/events', (req, res) => {
         const taskId = String(req.params.taskId || '').trim();
         const runId = String(req.params.runId || '').trim();
         const userId = requireUserId(req);
-        workTaskService.requireTaskRecord(taskId, userId);
-        const run = workTaskService.getRun(runId);
+        await workTaskService.requireTaskRecord(taskId, userId);
+        const run = await workTaskService.getRun(runId);
         if (!run || run.taskId !== taskId) {
             throw new WorkNotFoundError('Work run not found.');
         }
@@ -429,43 +426,91 @@ router.get('/tasks/:taskId/runs/:runId/events', (req, res) => {
             writeFrame(`id: ${event.id}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`, terminal);
         };
         res.once('close', close);
-        let replaying = true;
-        const bufferedLiveEvents = [];
-        workEventService.advanceCursor(taskId, runId, after);
-        unsubscribe = workEventService.subscribe(taskId, runId, event => {
-            if (replaying) {
-                bufferedLiveEvents.push(event);
+        const checkpoint = await workEventService.checkpoint(taskId, runId);
+        const authorize = async () => {
+            try {
+                const current = await workTaskService.requireTaskRecord(taskId, userId);
+                const currentRun = await workTaskService.getRun(runId);
+                return current.id === taskId && currentRun?.taskId === taskId;
+            }
+            catch {
+                return false;
+            }
+        };
+        let replayingLocal = !checkpoint.durable;
+        const bufferedLocalEvents = [];
+        if (!checkpoint.durable) {
+            // A process-local stream has no SQL catch-up query. Subscribe before
+            // taking its compact snapshot and buffer the live edge so the snapshot
+            // boundary cannot lose an event.
+            const localUnsubscribe = await workEventService.subscribeDurable(taskId, runId, after, authorize, event => {
+                if (replayingLocal)
+                    bufferedLocalEvents.push(event);
+                else if (event.id > latestEventId)
+                    writeEvent(event);
+            }, () => close());
+            unsubscribe = localUnsubscribe;
+            if (closed) {
+                await localUnsubscribe();
                 return;
             }
-            writeEvent(event);
-        });
-        const task = workTaskService.requireTaskDetail(taskId, userId);
-        const replay = workEventService.replay(taskId, runId, after);
-        const snapshotRun = workTaskService.getRun(runId) ?? run;
-        const snapshotStatus = replay.snapshot.status ?? snapshotRun.status;
-        const snapshotTerminal = replay.snapshot.terminal || isTerminalWorkRunStatus(snapshotStatus);
-        workEventService.emitSnapshot(taskId, runId, replay.latestEventId, {
+        }
+        // In durable mode, compact every committed event through this exact SQL
+        // checkpoint into one authoritative persistence snapshot. The gateway
+        // subscribes from that cursor after the snapshot is written; SQL replay
+        // covers every commit in the intervening gap without replaying history.
+        const task = await workTaskService.requireTaskDetail(taskId, userId);
+        const snapshotRun = (await workTaskService.getRun(runId)) ?? run;
+        const localReplay = checkpoint.durable
+            ? undefined
+            : workEventService.replay(taskId, runId, after);
+        const snapshotCursor = checkpoint.durable
+            ? Math.max(after, checkpoint.cursor)
+            : localReplay.latestEventId;
+        const compactSnapshot = checkpoint.durable
+            ? workEventService.snapshotFromPersistence(task, snapshotRun)
+            : localReplay.snapshot;
+        const snapshotStatus = compactSnapshot.status ?? snapshotRun.status;
+        const snapshotTerminal = compactSnapshot.terminal || isTerminalWorkRunStatus(snapshotStatus);
+        workEventService.emitSnapshot(taskId, runId, snapshotCursor, {
             task,
             liveRun: {
-                ...replay.snapshot,
+                ...compactSnapshot,
                 status: snapshotStatus,
-                phase: replay.snapshot.phase ?? snapshotStatus,
-                error: replay.snapshot.error ?? snapshotRun.error,
+                phase: compactSnapshot.phase ?? snapshotStatus,
+                error: compactSnapshot.error ?? snapshotRun.error,
                 terminal: snapshotTerminal,
             },
-            replayTruncated: replay.truncated,
+            replayTruncated: checkpoint.durable
+                ? checkpoint.cursor > after
+                : localReplay.truncated,
         }, writeEvent);
-        replaying = false;
-        for (const event of bufferedLiveEvents
-            .filter(event => event.id > replay.latestEventId)
-            .sort((left, right) => left.id - right.id)) {
-            writeEvent(event);
-            if (closed)
+        if (closed)
+            return;
+        if (checkpoint.durable) {
+            const connectedUnsubscribe = await workEventService.subscribeDurable(taskId, runId, snapshotCursor, authorize, event => {
+                if (event.id > latestEventId)
+                    writeEvent(event);
+            }, () => close());
+            unsubscribe = connectedUnsubscribe;
+            if (closed) {
+                await connectedUnsubscribe();
                 return;
+            }
+        }
+        else {
+            replayingLocal = false;
+            for (const event of bufferedLocalEvents
+                .filter(event => event.id > snapshotCursor)
+                .sort((left, right) => left.id - right.id)) {
+                writeEvent(event);
+                if (closed)
+                    return;
+            }
         }
-        const currentRun = workTaskService.getRun(runId) ?? snapshotRun;
-        const terminalStatus = isTerminalWorkRunStatus(replay.snapshot.status)
-            ? replay.snapshot.status
+        const currentRun = (await workTaskService.getRun(runId)) ?? snapshotRun;
+        const terminalStatus = isTerminalWorkRunStatus(compactSnapshot.status)
+            ? compactSnapshot.status
             : isTerminalWorkRunStatus(currentRun.status)
                 ? currentRun.status
                 : undefined;
@@ -478,8 +523,8 @@ router.get('/tasks/:taskId/runs/:runId/events', (req, res) => {
                 timestamp: Date.now(),
                 data: {
                     status: terminalStatus,
-                    error: replay.snapshot.error ?? currentRun.error,
-                    budgetReason: replay.snapshot.budgetReason,
+                    error: compactSnapshot.error ?? currentRun.error,
+                    budgetReason: compactSnapshot.budgetReason,
                 },
             });
         }
@@ -506,12 +551,15 @@ router.patch('/tasks/:id', async (req, res) => {
     try {
         const taskId = readTaskId(req);
         const userId = requireUserId(req);
-        const before = workTaskService.requireMutableTaskRecord(taskId, userId);
+        const title = typeof req.body?.title === 'string'
+            ? rejectPostgresTextNul(req.body.title, 'title')
+            : undefined;
+        const before = await workTaskService.requireMutableTaskRecord(taskId, userId);
         const networkEnabled = typeof req.body?.networkEnabled === 'boolean'
             ? req.body.networkEnabled
             : undefined;
         const model = typeof req.body?.model === 'string'
-            ? requireBodyString(req.body.model, 'model', 500)
+            ? requirePostgresBodyString(req.body.model, 'model', 500)
             : undefined;
         const providerChanged = req.body?.providerType !== undefined ||
             req.body?.providerId !== undefined;
@@ -521,16 +569,14 @@ router.patch('/tasks/:id', async (req, res) => {
         if (provider) {
             await workModelProviderService.assertModelSupportsTools(model ?? before.model, provider, userId);
         }
-        workTaskService.assertTaskMutationAllowed(taskId, userId);
+        await workTaskService.assertTaskMutationAllowed(taskId, userId);
         if (networkEnabled !== undefined) {
-            const current = workTaskService.beginNetworkPolicyChange(taskId, userId);
+            const current = await workTaskService.beginNetworkPolicyChange(taskId, userId);
             try {
                 const desired = { ...current, networkEnabled };
                 await workRuntimeService.changeNetworkPolicy(current, desired, () => {
-                    workTaskService.commitNetworkChange(taskId, userId, {
-                        title: typeof req.body?.title === 'string'
-                            ? req.body.title
-                            : undefined,
+                    return workTaskService.commitNetworkChange(taskId, userId, {
+                        title,
                         model,
                         providerType: provider?.providerType,
                         providerId: provider?.providerId,
@@ -541,11 +587,11 @@ router.patch('/tasks/:id', async (req, res) => {
             finally {
                 workTaskService.releaseNetworkPolicyChange(taskId);
             }
-            sendSuccess(res, workTaskService.requireTaskDetail(taskId, userId));
+            sendSuccess(res, await workTaskService.requireTaskDetail(taskId, userId));
             return;
         }
-        const detail = workTaskService.updateTask(taskId, userId, {
-            title: typeof req.body?.title === 'string' ? req.body.title : undefined,
+        const detail = await workTaskService.updateTask(taskId, userId, {
+            title,
             model,
             providerType: provider?.providerType,
             providerId: provider?.providerId,
@@ -573,17 +619,16 @@ router.post('/tasks/:id/runs', async (req, res) => {
         const taskId = readTaskId(req);
         const userId = requireUserId(req);
         const message = requireBodyString(req.body?.message, 'message', 65536);
-        const current = workTaskService.requireMutableTaskRecord(taskId, userId);
+        const current = await workTaskService.requireMutableTaskRecord(taskId, userId);
         const model = typeof req.body?.model === 'string' && req.body.model.trim()
-            ? req.body.model.trim()
+            ? requirePostgresBodyString(req.body.model, 'model', 500)
             : current.model;
         const provider = readProviderSelection(req.body, current);
         await workModelProviderService.assertModelSupportsTools(model, provider, userId);
-        const detail = workTaskService.createRun(taskId, userId, message, model, provider);
+        const detail = await workTaskService.createRun(taskId, userId, message, model, provider);
         const runId = detail.activeRun?.id;
         if (!runId)
             throw new Error('Work run was not created.');
-        workAgentService.start(taskId, runId, userId);
         res.status(202).json({ success: true, data: detail });
     }
     catch (error) {
@@ -600,7 +645,7 @@ router.post('/tasks/:id/cancel', async (req, res) => {
 });
 router.get('/tasks/:id/files', async (req, res) => {
     try {
-        const task = workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
+        const task = await workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
         sendSuccess(res, await workRuntimeService.listFiles(task, String(req.query.path || '.')));
     }
     catch (error) {
@@ -609,7 +654,7 @@ router.get('/tasks/:id/files', async (req, res) => {
 });
 router.get('/tasks/:id/file', async (req, res) => {
     try {
-        const task = workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
+        const task = await workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
         sendSuccess(res, await workRuntimeService.readFile(task, String(req.query.path || '')));
     }
     catch (error) {
@@ -618,7 +663,7 @@ router.get('/tasks/:id/file', async (req, res) => {
 });
 router.put('/tasks/:id/file', async (req, res) => {
     try {
-        const task = workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
+        const task = await workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
         const content = typeof req.body?.content === 'string' ? req.body.content : undefined;
         if (content === undefined) {
             throw new WorkRouteError('Field "content" must be a string.', 400);
@@ -636,7 +681,7 @@ router.put('/tasks/:id/file', async (req, res) => {
 });
 router.get('/tasks/:id/git', async (req, res) => {
     try {
-        const task = workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
+        const task = await workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
         sendSuccess(res, await workRuntimeService.getGitStatus(task));
     }
     catch (error) {
@@ -645,7 +690,7 @@ router.get('/tasks/:id/git', async (req, res) => {
 });
 router.get('/tasks/:id/git/diff', async (req, res) => {
     try {
-        const task = workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
+        const task = await workTaskService.requireMutableTaskRecord(readTaskId(req), requireUserId(req));
         const requestedPath = typeof req.query.path === 'string' ? req.query.path : undefined;
         sendSuccess(res, await workRuntimeService.getGitDiff(task, requestedPath));
     }
@@ -655,7 +700,7 @@ router.get('/tasks/:id/git/diff', async (req, res) => {
 });
 router.post('/tasks/:id/git/init', async (req, res) => {
     try {
-        const task = requireIdleGitTask(req);
+        const task = await requireIdleGitTask(req);
         sendSuccess(res, await workRuntimeService.initializeGit(task));
     }
     catch (error) {
@@ -668,7 +713,7 @@ router.post('/tasks/:id/git/stage', async (req, res) => {
             req.body.paths.some((value) => typeof value !== 'string')) {
             throw new WorkRouteError('Field "paths" must be a string array.', 400);
         }
-        const task = requireIdleGitTask(req);
+        const task = await requireIdleGitTask(req);
         sendSuccess(res, await workRuntimeService.stageGitPaths(task, req.body.paths));
     }
     catch (error) {
@@ -678,8 +723,8 @@ router.post('/tasks/:id/git/stage', async (req, res) => {
 router.post('/tasks/:id/git/commit', async (req, res) => {
     try {
         const userId = requireUserId(req);
-        const task = requireIdleGitTask(req);
-        const user = userModel.getUserById(userId);
+        const task = await requireIdleGitTask(req);
+        const user = await userModel.getUserById(userId);
         if (!user)
             throw new WorkRouteError('User account was not found.', 404);
         sendSuccess(res, await workRuntimeService.commitGit(task, requireBodyString(req.body?.message, 'message', 4000), {
@@ -693,7 +738,7 @@ router.post('/tasks/:id/git/commit', async (req, res) => {
 });
 router.post('/tasks/:id/git/branches', async (req, res) => {
     try {
-        const task = requireIdleGitTask(req);
+        const task = await requireIdleGitTask(req);
         sendSuccess(res, await workRuntimeService.createGitBranch(task, requireBodyString(req.body?.name, 'name', 200)));
     }
     catch (error) {
@@ -702,7 +747,7 @@ router.post('/tasks/:id/git/branches', async (req, res) => {
 });
 router.post('/tasks/:id/git/switch', async (req, res) => {
     try {
-        const task = requireIdleGitTask(req);
+        const task = await requireIdleGitTask(req);
         sendSuccess(res, await workRuntimeService.switchGitBranch(task, requireBodyString(req.body?.name, 'name', 200)));
     }
     catch (error) {
@@ -713,13 +758,13 @@ router.post('/tasks/:id/preview/start', async (req, res) => {
     const taskId = readTaskId(req);
     const userId = requireUserId(req);
     try {
-        const task = workTaskService.requireMutableTaskRecord(taskId, userId);
+        const task = await workTaskService.requireMutableTaskRecord(taskId, userId);
         await workRuntimeService.startPreview(task, typeof req.body?.command === 'string' ? req.body.command : undefined, {
             onStarting: () => workTaskService.beginPreview(taskId, userId),
-            onRunning: url => workTaskService.updatePreview(taskId, 'running', url),
+            onRunning: (url, endpoint) => workTaskService.updatePreview(taskId, 'running', url, endpoint),
             onFailed: () => workTaskService.updatePreview(taskId, 'failed'),
         });
-        sendSuccess(res, workTaskService.requireTaskDetail(taskId, userId));
+        sendSuccess(res, await workTaskService.requireTaskDetail(taskId, userId));
     }
     catch (error) {
         sendError(res, error);
@@ -729,11 +774,11 @@ router.post('/tasks/:id/preview/stop', async (req, res) => {
     try {
         const taskId = readTaskId(req);
         const userId = requireUserId(req);
-        const task = workTaskService.requireMutableTaskRecord(taskId, userId);
+        const task = await workTaskService.requireMutableTaskRecord(taskId, userId);
         await workRuntimeService.stopPreview(task, {
             onStopped: () => workTaskService.updatePreview(taskId, 'stopped'),
         });
-        sendSuccess(res, workTaskService.requireTaskDetail(taskId, userId));
+        sendSuccess(res, await workTaskService.requireTaskDetail(taskId, userId));
     }
     catch (error) {
         sendError(res, error);
@@ -754,10 +799,10 @@ function requireUserId(req) {
 function readTaskId(req) {
     return String(req.params.id || '').trim();
 }
-function requireIdleGitTask(req) {
+async function requireIdleGitTask(req) {
     const taskId = readTaskId(req);
-    const task = workTaskService.requireMutableTaskRecord(taskId, requireUserId(req));
-    if (workTaskService.getActiveRun(taskId)) {
+    const task = await workTaskService.requireMutableTaskRecord(taskId, requireUserId(req));
+    if (await workTaskService.getActiveRun(taskId)) {
         throw new WorkRouteError('Stop the active Work run before changing Git state.', 409);
     }
     return task;
@@ -795,6 +840,15 @@ function requireBodyString(value, name, maxLength) {
     }
     return value.trim();
 }
+function rejectPostgresTextNul(value, name) {
+    if (value.includes('\u0000')) {
+        throw new WorkRouteError(`Field "${name}" cannot contain U+0000.`, 400);
+    }
+    return value;
+}
+function requirePostgresBodyString(value, name, maxLength) {
+    return rejectPostgresTextNul(requireBodyString(value, name, maxLength), name);
+}
 function optionalNonNegativeInteger(value, name) {
     if (value === undefined)
         return undefined;