@maudecode/talaria-web 1.19.0 → 1.20.0

package/dist/api/tools-router.js

@@ -7,7 +7,7 @@ import { requestSessionIdGuard } from './session-visibility.js';
 import { activeProfileName, ensureTrustedAuthSession, sessionCanManageServer } from '../auth/gate.js';
 import { currentChatReadiness, HttpFailure } from '../sessions/service.js';
 import { SessionNotFound } from '../sessions/store.js';
-import { insightsSessionRows } from '../sessions/state-db.js';
+import { stateDbSessionReadAsync } from '../sessions/state-db.js';
 import { ConfigUnavailable } from '../config/agent-config.js';
 import { SidecarError } from '../sidecar/client.js';
 import { createPrompt, deletePrompt, externalNotesEnabled, loadPrompts, readMemory, writeMemory } from '../tools/memory.js';
@@ -21,6 +21,8 @@ import { agentHealth, applyDashboardConfig, dashboardConfig, dashboardStatus, ga
 import { restartGateway } from '../tools/gateway-restart.js';
 import { projectOsDashboard } from '../tools/project-os.js';
 import { PluginSettingsInvalid, planPluginSettings, pluginSettingsView, serializePluginSettingsSave } from '../tools/plugin-settings.js';
+import { checkPastedRedirect } from '../tools/plugin-oauth.js';
+import { oauthCall, oauthView } from './settings-router.js';
 import { credentialShadowed, RuntimeCredentialError, writeRuntimeCredential } from '../providers/runtime-env.js';
 import { EnvWriteError, loadEnvFile } from '../providers/env-file.js';
 import { loadGatewaySessionIdentityMap } from '../sessions/list.js';
@@ -30,7 +32,7 @@ import { normalizeChannel, updatesCheckView } from '../tools/updates.js';
 import { pyBool } from '../settings.js';
 import { str } from '../util.js';
 import { redactString } from '../redact.js';
-import { GATEWAY_RESTART_NOW } from '../tools/update-notifications.js';
+import { GATEWAY_RESTART_NOW, updateNotificationOwner } from '../tools/update-notifications.js';
 const os = implement(toolsContract).$context().use(requestSessionIdGuard);
 function failure(error) {
     if (error instanceof HttpError)
@@ -84,6 +86,11 @@ async function pluginSettingsList(ctx) {
     const result = await runningSidecar(ctx).call('plugins.settings', { profile_home: home(ctx) });
     return result.plugins.map((entry) => ({ key: entry.key, fields: pluginSettingsFieldsView(ctx, entry.fields) }));
 }
+/** TAL-1276: each plugin's declared OAuth clients by key; empty on an Agent without plugin OAuth. */
+async function pluginOAuthClients(ctx) {
+    const result = await runningSidecar(ctx).call('plugins.oauth_status', { profile_home: home(ctx) });
+    return new Map(result.supported ? result.plugins.map((entry) => [entry.key, entry.clients.map((client) => ({ ...client, can_sign_out: client.state !== 'logged_out' }))]) : []);
+}
 const pluginSettingsFieldsView = (ctx, fields) => {
     const rootProfile = ctx.deps.isRootProfile(activeProfileName(ctx));
     return pluginSettingsView(fields, (envVar) => credentialShadowed(ctx.deps.config.env, rootProfile, envVar));
@@ -118,9 +125,13 @@ async function connectorNames(ctx) {
 }
 /** An operation as the contract shows it, with the apps' catalog names. */
 const operationView = async (ctx, snapshot) => connectorOperation(snapshot, await connectorNames(ctx));
-/** The rules, or why they cannot be read (a portal refusal or failure): the page then fails closed and says why. */
-const connectorPolicy = (ctx) => connectorCall(ctx, 'connectors.policy.get', {}).then((policy) => ({ policy, error: null }), (error) => { if (error instanceof HttpError)
-    return { policy: null, error: error.message }; throw error; });
+/** Read failures never create an identity. Auth refusals become a page sign-in state; unreadable rules fail closed. */
+const connectorRead = (ctx, method) => connectorCall(ctx, method, {}).then((value) => ({ value, error: null, signInRequired: false }), (error) => {
+    if (error instanceof HttpError && (method === 'connectors.policy.get' || error.data?.code === 'connectors_sign_in')) {
+        return { value: null, error: error.message, signInRequired: error.data?.code === 'connectors_sign_in' };
+    }
+    throw error;
+});
 const health = (ctx) => agentHealth({ env: ctx.deps.config.env, hermesHome: ctx.deps.config.hermesHome, profileHome: () => home(ctx), fetch: () => ctx.deps.fetch, now: ctx.deps.nowSeconds });
 /**
  * TAL-805: the active profile's gateway mode from sidecar `gateway.mode`; null for a remote gateway. A named profile never
@@ -160,11 +171,13 @@ async function gatewayAction(ctx, action) {
         throw new HttpError(500, 'Hermes Agent sidecar is not running', { ok: false, action });
     let outcome;
     try {
-        outcome = await sidecar.call('gateway.control', { profile_home: home(ctx), action, background_wait_seconds: GATEWAY_ACTION_TIMEOUT_S }, { timeoutMs: 300_000 });
+        outcome = await sidecar.call('gateway.control', { profile_home: home(ctx), action, interrupt: true, background_wait_seconds: GATEWAY_ACTION_TIMEOUT_S }, { timeoutMs: 300_000 });
     }
     catch (error) {
         throw new HttpError(500, sanitizeError(error), { ok: false, action });
     }
+    if (outcome.status === 'busy_live_work')
+        throw new HttpError(409, outcome.reason || 'The gateway still has live work.', { ok: false, action });
     if (outcome.status === 'busy')
         throw new HttpError(409, 'Another gateway action is already in progress; try again shortly.', { ok: false, action });
     if (outcome.timed_out)
@@ -178,27 +191,15 @@ async function gatewayAction(ctx, action) {
     return { ok: true, action, message: `Gateway ${action} completed.`, status: await currentGatewayStatus(ctx) };
 }
 const principalHash = (...parts) => createHash('sha256').update(JSON.stringify(parts), 'utf8').digest('hex');
-export function updateNotificationOwner(session) {
-    const authType = str(session?.auth_type).trim();
-    if (authType === 'oidc') {
-        const issuer = str(session?.oidc_issuer).trim();
-        const subject = typeof session?.oidc_subject === 'string' ? session.oidc_subject : '';
-        if (issuer && subject.trim())
-            return `oidc:${principalHash(issuer, subject)}`;
-        const token = str(session?.token).trim();
-        if (token)
-            return `oidc-session:${principalHash(token)}`;
-    }
-    const username = str(session?.username).trim();
-    return username ? `${authType || 'auth'}:${username}` : 'local-owner';
-}
 async function updateNotificationScope(ctx, tab) {
     const session = await ensureTrustedAuthSession(ctx);
+    const profile = activeProfileName(ctx);
     return {
         owner: updateNotificationOwner(session),
-        profile: activeProfileName(ctx),
+        profile,
         serverOwner: await sessionCanManageServer(ctx, session),
         tab: tab ?? null,
+        rootProfile: ctx.deps.isRootProfile(profile),
     };
 }
 async function applyWithNotification(ctx, input, action) {
@@ -208,14 +209,18 @@ async function applyWithNotification(ctx, input, action) {
     const active = ctx.deps.updateNotifications.activeUpdate(scope, target);
     if (active)
         (await ctx.deps.updateNotifications.watch(scope, active.id));
-    if (active && (active.phase === 'applying' || active.phase === 'restarting')) {
+    if (active && (active.phase === 'applying' || active.phase === 'restarting' || active.phase === 'verifying')) {
         return { ok: false, status: 'already_in_progress', message: 'Update already in progress', notification_id: active.id };
     }
     const notification = active ?? (await ctx.deps.updateNotifications.begin(scope, target));
     if (active?.phase === 'awaiting_confirmation' && confirmed)
         (await ctx.deps.updateNotifications.transition(notification.id, 'applying'));
+    // TAL-1138: the gateways running before an Agent update; the update's check needs a new process for each.
+    const gatewaysBefore = target === 'agent' ? await ctx.deps.gatewayRestarts.gateways(scope.profile).catch(() => []) : [];
     try {
-        const options = { agentChannel: input.agent_channel, confirmedRevision: input.confirmed_agent_revision, version: input.version, refreshToken: input.agent_refresh_token, mutationIntent: principalHash(scope.owner, scope.profile, notification.id) };
+        const options = { agentChannel: input.agent_channel, confirmedRevision: input.confirmed_agent_revision, version: input.version, refreshToken: input.agent_refresh_token, mutationIntent: principalHash(scope.owner, scope.profile, notification.id),
+            // TAL-1429: the Updating dialog shows what the running update waits for; a lost refresh only delays that wording.
+            onProgress: (detail) => { ctx.deps.updateNotifications.transition(notification.id, 'applying', null, undefined, detail).catch(() => undefined); } };
         const result = action === 'apply' ? await ctx.deps.updates.apply(target, bodyChannel(input.channel), () => true, options)
             : action === 'force' ? await ctx.deps.updates.force(target, bodyChannel(input.channel), options)
                 : await ctx.deps.updates.clearLock(target, options);
@@ -231,11 +236,27 @@ async function applyWithNotification(ctx, input, action) {
         else if (target === 'webui' && result.restart_scheduled === true) {
             await ctx.deps.updateNotifications.transition(notification.id, 'restarting', str(result.sourceRevision || result.candidate_revision), verifiedIdentity);
         }
+        else if (target === 'agent' && result.gateway_restart === 'resumed') {
+            // TAL-1138: the native updater restarted the gateways inside its writer pause. Agent responding still needs the
+            // new gateway processes and a current Agent runtime; a scheduled Web restart runs that check from the new server.
+            const detail = result.stash_conflict === true ? str(result.message) : null;
+            await ctx.deps.updateNotifications.recordGatewayBaseline(notification.id, gatewaysBefore);
+            await ctx.deps.updateNotifications.transition(notification.id, 'verifying', null, verifiedIdentity, detail);
+            if (result.restart_scheduled === true)
+                (await ctx.deps.updateNotifications.markWebRestart(notification.id));
+            else
+                void ctx.deps.gatewayRestarts.verify(notification.id, scope.profile, gatewaysBefore, detail);
+        }
         else if (result.gateway_restart === 'waiting_for_idle' || (target === 'agent' && ctx.deps.gatewayRestarts.pendingId() !== null)) {
             // TAL-953: the gateway restarts once its own work drains. A restart already waiting covers this update too, and a
             // repeated request that found the Agent current follows that wait rather than reporting success before it.
             const detail = result.stash_conflict === true ? str(result.message) : null;
             await ctx.deps.updateNotifications.transition(notification.id, 'waiting_for_idle', null, verifiedIdentity, detail);
+            // TAL-1138: a scheduled Web restart goes first, and the restarted server resumes this wait.
+            if (result.restart_scheduled === true && ctx.deps.gatewayRestarts.pendingId() === null) {
+                await ctx.deps.updateNotifications.markWebRestart(notification.id);
+                return { ...result, notification_id: notification.id };
+            }
             const pending = (await ctx.deps.gatewayRestarts.schedule(notification.id, scope.profile, detail));
             if (pending !== notification.id)
                 (await ctx.deps.updateNotifications.watch(scope, pending));
@@ -472,12 +493,19 @@ export const toolsRouter = os.router({
             // TAL-904: a chat's command runs under that chat's session and the workspace its next turn would use. An unknown
             // chat (404) or a workspace that turn would refuse (400) refuses the command rather than run it half-bound.
             const chat = sessionId ? { session_id: sessionId, workspace: (await ctx.deps.sessions.turnWorkspace((await ctx.deps.sessionStore.get(sessionId, { metadataOnly: true })))) } : {};
+            let output;
             try {
-                return { output: (await runningSidecar(ctx).call('commands.exec', { profile_home: home(ctx), command, ...chat }, { timeoutMs: 120_000 })).output };
+                output = (await runningSidecar(ctx).call('commands.exec', { profile_home: home(ctx), command, ...chat }, { timeoutMs: 120_000 })).output;
             }
             catch (error) {
                 return commandFailure(error, 'command_not_found', 'Plugin command not found');
             }
+            // TAL-1274: an /autoprune answer typed in the composer withdraws the profile's open auto-prune question.
+            if (name.toLowerCase() === 'autoprune') {
+                const profile = activeProfileName(ctx);
+                await ctx.deps.pruneAdvice.check(ctx.deps.isRootProfile(profile) ? 'default' : profile, home(ctx));
+            }
+            return { output };
         })),
         bundles: os.commands.bundles.handler(({ context: { ctx } }) => run(async () => {
             const sidecar = ctx.deps.sidecar();
@@ -544,9 +572,9 @@ export const toolsRouter = os.router({
         catch {
             entries = [];
         }
-        return buildInsights(entries, input.days, ctx.deps.nowSeconds(), (cutoff) => insightsSessionRows(join(home(ctx), 'state.db'), cutoff));
+        return buildInsights(entries, input.days, ctx.deps.nowSeconds(), (cutoff) => stateDbSessionReadAsync([], 'insightsSessionRows', join(home(ctx), 'state.db'), cutoff));
     })),
-    logs: os.logs.handler(({ input, context: { ctx } }) => run(() => readLogTail(home(ctx), input.file, input.tail))),
+    logs: os.logs.handler(({ input, signal, context: { ctx } }) => run(() => readLogTail(home(ctx), input.file, input.tail, signal))),
     ops: {
         agent: os.ops.agent.handler(({ context: { ctx } }) => run(async () => { const [gateway, chat] = await Promise.all([health(ctx), currentChatReadiness(ctx.deps.sidecar())]); return { ...gateway, chat }; })),
         system: os.ops.system.handler(({ context: { ctx } }) => run(() => systemHealth(ctx.deps.config.homeDir, ctx.deps.runtimeDiagnostics()))),
@@ -554,7 +582,7 @@ export const toolsRouter = os.router({
             const sidecar = ctx.deps.sidecar();
             if (!sidecar)
                 throw new HttpError(500, 'Hermes Agent sidecar is not running');
-            const outcome = await restartGateway(sidecar, home(ctx));
+            const outcome = await restartGateway(sidecar, home(ctx), true);
             if (outcome.status === 'completed')
                 return { ok: true, message: 'Gateway service restarted successfully' };
             if (outcome.status === 'busy')
@@ -611,14 +639,16 @@ export const toolsRouter = os.router({
         available: os.connectors.available.handler(({ context: { ctx } }) => run(async () => ({ available: ctx.deps.sidecar() ? await connectorCall(ctx, 'connectors.available', {}).then((r) => r.available, () => false) : false }))),
         page: os.connectors.page.handler(({ context: { ctx } }) => run(async () => {
             if (!ctx.deps.sidecar() || !(await connectorCall(ctx, 'connectors.available', {})).available)
-                return { available: false, connectors: [], policy_revision: null, rules_error: null };
-            const [catalog, accounts, policy] = await Promise.all([connectorCall(ctx, 'connectors.catalog', {}), connectorCall(ctx, 'connectors.accounts', {}), connectorPolicy(ctx)]);
-            rememberCatalogNames(home(ctx), catalog.connectors);
-            return connectorsPage(catalog.connectors, accounts.accounts, policy.policy, policy.error);
+                return { available: false, connectors: [], policy_revision: null, rules_error: null, sign_in_required: false };
+            const [catalog, accounts, policy] = await Promise.all([
+                connectorRead(ctx, 'connectors.catalog'), connectorRead(ctx, 'connectors.accounts'), connectorRead(ctx, 'connectors.policy.get'),
+            ]);
+            rememberCatalogNames(home(ctx), catalog.value?.connectors ?? []);
+            return connectorsPage(catalog.value?.connectors ?? [], accounts.value?.accounts ?? [], policy.value, policy.error, catalog.signInRequired || accounts.signInRequired || policy.signInRequired);
         })),
         tools: os.connectors.tools.handler(({ input, context: { ctx } }) => run(async () => {
-            const [listing, policy] = await Promise.all([connectorCall(ctx, 'connectors.tools', { connector: input.connector }), connectorPolicy(ctx)]);
-            return connectorTools(listing, policy.policy);
+            const [listing, policy] = await Promise.all([connectorCall(ctx, 'connectors.tools', { connector: input.connector }), connectorRead(ctx, 'connectors.policy.get')]);
+            return connectorTools(listing, policy.value);
         })),
         setPolicy: os.connectors.setPolicy.handler(({ input, context: { ctx } }) => run(async () => {
             const change = input.tool === undefined ? (typeof input.enabled === 'boolean' ? { enabled: input.enabled } : null)
@@ -660,7 +690,14 @@ export const toolsRouter = os.router({
             // A settings failure leaves the list itself readable.
             const declared = await pluginSettingsList(ctx).catch((error) => { ctx.deps.log(`[plugins] settings fields failed: ${str(error.message)}`); return []; });
             const settings = new Map(declared.map((entry) => [entry.key, entry.fields]));
-            const plugins = result.plugins.map((plugin) => settings.has(plugin.key) ? { ...plugin, settings: settings.get(plugin.key) } : plugin);
+            // So does an OAuth status failure.
+            const oauth = await pluginOAuthClients(ctx).catch((error) => { ctx.deps.log(`[plugins] oauth status failed: ${str(error.message)}`); return new Map(); });
+            const plugins = result.plugins.map(({ update_available, latest_revision, ...plugin }) => ({
+                ...plugin,
+                ...(update_available === undefined ? {} : { update: { available: update_available, ...(latest_revision ? { latest_revision } : {}) } }),
+                ...(settings.has(plugin.key) ? { settings: settings.get(plugin.key) } : {}),
+                ...(oauth.has(plugin.key) ? { oauth_clients: oauth.get(plugin.key) } : {}),
+            }));
             // An advisory failure leaves the list itself readable.
             const advisory = await pluginIsolationAdvisory(ctx).catch((error) => { ctx.deps.log(`[plugins] isolation advisory failed: ${str(error.message)}`); return false; });
             return { plugins, empty: plugins.length === 0, supported_hooks: result.supported_hooks, read_only: !editable, plugin_isolation_advisory: advisory };
@@ -670,6 +707,39 @@ export const toolsRouter = os.router({
             return { plugins: [], empty: true, supported_hooks: hooks, read_only: true, unavailable: true };
         }
     })),
+    pluginCatalog: os.pluginCatalog.handler(({ input, context: { ctx } }) => run(async () => {
+        const result = await runningSidecar(ctx).call('plugins.catalog', { profile_home: home(ctx), ...input });
+        const readOnly = !await sessionCanManageServer(ctx, await ensureTrustedAuthSession(ctx));
+        return { ...result, read_only: readOnly, entries: result.entries.map((entry) => ({ ...entry, can_install: !readOnly && entry.can_install })) };
+    })),
+    pluginInstall: os.pluginInstall.handler(({ input, context: { ctx } }) => run(async () => {
+        try {
+            return await runningSidecar(ctx).call('plugins.install', { profile_home: home(ctx), ...input }, { timeoutMs: 0 });
+        }
+        catch (error) {
+            if (error instanceof SidecarError && error.condition === 'plugin_install_consent_changed')
+                throw new HttpError(409, error.message, { condition: error.condition });
+            if (error instanceof SidecarError && error.condition === 'plugin_install_refused')
+                throw new HttpError(409, error.message, { condition: error.condition });
+            if (error instanceof SidecarError && error.condition === 'plugin_catalog_unsupported')
+                throw new HttpError(503, error.message, { condition: error.condition });
+            if (!definitiveRefusal(error))
+                throw new HttpError(503, 'Install outcome is unknown. Refresh Plugins to check the installed identity before trying again.', { condition: 'plugin_install_unconfirmed' });
+            throw error;
+        }
+    })),
+    pluginUpdate: os.pluginUpdate.handler(({ input, context: { ctx } }) => run(async () => {
+        try {
+            return await runningSidecar(ctx).call('plugins.update', { profile_home: home(ctx), key: input.key, accept_caution: input.accept_caution, ...(input.consent_token ? { consent_token: input.consent_token } : {}) }, { timeoutMs: 0 });
+        }
+        catch (error) {
+            if (error instanceof SidecarError && error.condition === 'plugin_not_found')
+                throw new HttpError(404, error.message);
+            if (error instanceof SidecarError && ['plugin_update_refused', 'plugin_update_consent_changed'].includes(error.condition))
+                throw new HttpError(409, error.message, { condition: error.condition });
+            throw error;
+        }
+    })),
     pluginSettings: os.pluginSettings.handler(({ input, context: { ctx } }) => run(() => serializePluginSettingsSave(async () => {
         const sidecar = runningSidecar(ctx);
         const fields = (await pluginSettingsList(ctx)).find((entry) => entry.key === input.key)?.fields;
@@ -720,8 +790,28 @@ export const toolsRouter = os.router({
                 throw new HttpError(error.status, `Failed to save a secret: ${error.message}`, { condition: error.condition });
             throw error;
         }
-        return { ok: true, key: result.key, written: [...result.written, ...secretFields.map((field) => field.key)], settings: pluginSettingsFieldsView(ctx, result.fields) };
+        return { ok: true, key: result.key, runtime_application: result.runtime_application ?? 'restart_required', written: [...result.written, ...secretFields.map((field) => field.key)], settings: pluginSettingsFieldsView(ctx, result.fields) };
     }))),
+    pluginOAuthRedirect: os.pluginOAuthRedirect.handler(({ input, context: { ctx } }) => run(async () => {
+        // Only this flow's own answer reaches the sidecar: its loopback address and its `state`.
+        const verdict = checkPastedRedirect(input.flow_id, home(ctx), input.url);
+        if (verdict === 'unknown')
+            throw new HttpError(404, 'Unknown or expired sign-in.', { condition: 'oauth_flow_not_found' });
+        if (verdict === 'invalid')
+            throw new HttpError(400, 'That is not the address this sign-in sends the browser back to.', { condition: 'oauth_redirect_invalid' });
+        return oauthView(await oauthCall(ctx, 'oauth.submit_redirect', { profile_home: home(ctx), flow_id: input.flow_id, url: input.url }));
+    })),
+    pluginOAuthLogout: os.pluginOAuthLogout.handler(({ input, context: { ctx } }) => run(async () => {
+        try {
+            const result = await runningSidecar(ctx).call('plugins.oauth_logout', { profile_home: home(ctx), key: input.key, id: input.id });
+            return { ok: true, removed: result.removed };
+        }
+        catch (error) {
+            if (error instanceof SidecarError && error.condition === 'oauth_unsupported')
+                throw new HttpError(409, error.message, { condition: error.condition });
+            return failure(error);
+        }
+    })),
     updates: {
         check: os.updates.check.handler(({ context: { ctx } }) => run(async () => {
             const settings = (await ctx.deps.settings.load());
@@ -748,7 +838,7 @@ export const toolsRouter = os.router({
         list: os.updateNotifications.list.handler(({ input, context: { ctx } }) => run(async () => {
             const scope = await updateNotificationScope(ctx, input.tab_id);
             const frontendBuild = (await ctx.deps.updateNotifications.syncTabBuild(scope, input.loaded_build ?? null, ctx.deps.spa.buildId()));
-            return { ...(await ctx.deps.updateNotifications.list(scope)), frontend_build: frontendBuild };
+            return { ...(await ctx.deps.updateNotifications.list(scope, frontendBuild.refresh_required)), frontend_build: frontendBuild };
         })),
         read: os.updateNotifications.read.handler(({ input, context: { ctx } }) => run(async () => {
             const notification = (await ctx.deps.updateNotifications.read(await updateNotificationScope(ctx, input.tab_id), input.id));
@@ -765,7 +855,7 @@ export const toolsRouter = os.router({
         clear: os.updateNotifications.clear.handler(({ input, context: { ctx } }) => run(async () => {
             const scope = await updateNotificationScope(ctx, input.tab_id);
             const frontendBuild = (await ctx.deps.updateNotifications.syncTabBuild(scope, input.loaded_build ?? null, ctx.deps.spa.buildId()));
-            return { ...(await ctx.deps.updateNotifications.clear(scope)), frontend_build: frontendBuild };
+            return { ...(await ctx.deps.updateNotifications.clear(scope, frontendBuild.refresh_required)), frontend_build: frontendBuild };
         })),
         cancel: os.updateNotifications.cancel.handler(({ input, context: { ctx } }) => run(async () => {
             const notification = (await ctx.deps.updateNotifications.cancelUpdate(await updateNotificationScope(ctx), input.id));
@@ -774,7 +864,14 @@ export const toolsRouter = os.router({
             return notification;
         })),
         action: os.updateNotifications.action.handler(({ input, context: { ctx } }) => run(async () => {
-            const notification = (await ctx.deps.updateNotifications.action(await updateNotificationScope(ctx, input.tab_id), input.id, input.action_id));
+            const scope = await updateNotificationScope(ctx, input.tab_id);
+            // TAL-1274: an auto-prune answer runs the Agent's /autoprune for the profile before the question records it.
+            const answer = await ctx.deps.pruneAdvice.answer(scope, input.id, input.action_id, home(ctx));
+            if (answer && 'refused' in answer)
+                throw new HttpError(409, answer.refused);
+            if (answer)
+                return answer.notification;
+            const notification = (await ctx.deps.updateNotifications.action(scope, input.id, input.action_id));
             if (!notification)
                 throw new HttpError(404, 'Notification action not found');
             if (input.action_id === GATEWAY_RESTART_NOW)