loopengine 0.1.66 → 0.1.68

package/dist/web/agents-config-page.js

@@ -39,6 +39,7 @@ export const agentsConfigPageHtml = `<!doctype html>
      panels' own content. */
   #empty { color: var(--ink-muted); font-size: 13px; padding: 24px; }
   .env-cell { display: grid; gap: 6px; }
+  .approvals-nudge { border: 1px solid var(--warn); background: var(--warn-soft); color: var(--ink); border-radius: var(--radius); padding: 12px 14px; margin-bottom: 24px; font-size: 13px; }
   .env-desc { max-width: 340px; display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; }
   form.add-source.env-inline { border: 0; padding: 0; display: flex; flex-wrap: wrap; gap: 6px; max-width: 320px; }
   form.add-source.env-inline input, form.add-source.env-inline select { flex: 1 1 140px; width: auto; min-width: 0; }
@@ -889,7 +890,9 @@ ${consoleShellScript}
   // opened. ----
 
   function renderActauthTabPlaceholder() {
-    return '<section id="actauthSection"><div id="actauthContent"><p class="hint">Loading&hellip;</p></div></section>';
+    return '<div id="pendingContent"></div>' +
+      '<section id="actauthSection"><div id="actauthContent"><p class="hint">Loading&hellip;</p></div></section>' +
+      '<div id="approvalsContent"><p class="hint">Loading&hellip;</p></div>';
   }
 
   function renderActauthRuleRow(r) {
@@ -953,6 +956,246 @@ ${consoleShellScript}
         '</form></section>';
   }
 
+  // ---- Permissions → "Where approval requests and questions are sent": where "ask" decisions go when nobody is
+  // in Chat (web/notifier-admin.ts behind GET/PUT/DELETE .../notifier),
+  // the decisions still waiting (GET .../pending), and recent webhook
+  // deliveries. Reloaded every time the tab opens, so the waiting list is
+  // current. ----
+
+  var NOTIFIER_EVENTS = [
+    ['approval', 'Approvals'], ['question', 'Questions'], ['run_finish', 'Run finished'], ['run_start', 'Run started']
+  ];
+
+  function approvalsContentEl() {
+    return detail.querySelector('#approvalsContent');
+  }
+
+  function renderPendingTable(pending) {
+    if (!pending.length) return '<p class="hint">Nothing is waiting for a decision.</p>';
+    return '<div class="le-table-wrap"><table><thead><tr><th>Waiting</th><th>Details</th><th>Session</th><th></th></tr></thead><tbody>' +
+      pending.map(function (p) {
+        var details = p.kind === 'question'
+          ? escapeHtml((p.args && p.args.question) || p.reason)
+          : '<code>' + escapeHtml(p.tool) + '</code> <span class="hint">' + escapeHtml(JSON.stringify(p.args)) + '</span>';
+        var actions = p.kind === 'question'
+          ? '<form class="pending-answer" data-id="' + escapeHtml(p.pendingId) + '" style="display:flex;gap:6px"><input name="answer" placeholder="Answer" required style="min-width:0"><button type="submit">Answer</button></form>'
+          : '<div style="display:flex;gap:6px"><button type="button" class="primary pending-decide" data-id="' + escapeHtml(p.pendingId) + '" data-decision="approve">Approve</button>' +
+            '<button type="button" class="pending-decide" data-id="' + escapeHtml(p.pendingId) + '" data-decision="deny">Deny</button></div>';
+        if (p.decidePath) {
+          actions += '<button type="button" class="pending-copy" data-path="' + escapeHtml(p.decidePath) + '" title="A link anyone can open to decide, no login needed" style="margin-top:6px">Copy link</button>';
+        }
+        return '<tr><td><span class="le-pill ' + (p.kind === 'question' ? 'accent' : 'ask') + '">' + (p.kind === 'question' ? 'question' : 'approval') + '</span>' +
+          (p.createdAt ? '<div class="hint">' + escapeHtml(new Date(p.createdAt).toLocaleString()) + '</div>' : '') + '</td>' +
+          '<td>' + details + '</td><td><code>' + escapeHtml(p.sessionId) + '</code></td><td>' + actions + '</td></tr>';
+      }).join('') + '</tbody></table></div>';
+  }
+
+  function renderNotifierStatus(n) {
+    if (n.source === 'code') return 'Set in this agent&#39;s <code>index.ts</code> (<code>httpNotifier</code>, ' + escapeHtml(n.channel) + '). Edit it there; code always wins over the form below.';
+    if (n.source === 'file') return 'Sending to <strong>' + escapeHtml(n.channel) + '</strong> for: ' + escapeHtml((n.events || []).join(', ')) + '.';
+    if (n.missingSecret) return 'Saved, but not sending yet: set the secret below (<code>' + escapeHtml(n.missingSecret) + '</code>).';
+    if (n.source === 'default') return 'Using the project-wide default webhook (<code>LOOPENGINE_DEFAULT_WEBHOOK_URL</code>, ' + escapeHtml(n.defaultWebhookUrl) + '). Set one below to use a different target for this agent.';
+    return '<strong>Nowhere yet</strong>, so nobody is notified. Choose a webhook, Slack channel or Lark chat below.';
+  }
+
+  function renderNotifierForm(n) {
+    var f = n.file || { channel: 'webhook', events: ['approval', 'question'] };
+    var events = f.events || [];
+    function eventBox(e) {
+      return '<label class="tool-picker-item" style="border:0;padding:0;justify-content:flex-start"><input type="checkbox" name="events" value="' + e[0] + '"' + (events.indexOf(e[0]) !== -1 ? ' checked' : '') + '> ' + e[1] + '</label>';
+    }
+    function field(channel, html) {
+      return '<div class="notifier-fields" data-channel="' + channel + '"' + (f.channel === channel ? '' : ' hidden') + '>' + html + '</div>';
+    }
+    function secretField(channel, label) {
+      var isSet = n.secretsSet && n.secretsSet[channel];
+      return '<label>' + label + ' <span class="hint">(' + (isSet ? 'set &mdash; leave blank to keep it' : 'not set') + '; stored in this agent&#39;s env as ' + escapeHtml(n.secretVars[channel]) + ')</span>' +
+        '<span style="display:flex;gap:6px"><input type="password" name="secret_' + channel + '" autocomplete="off" style="flex:1;min-width:0">' +
+        (channel === 'webhook' ? '<button type="button" class="notifier-generate">Generate</button>' : '') + '</span></label>';
+    }
+    return '<form class="add-source" id="notifierForm" style="max-width:560px">' +
+      '<label>Send to<select name="channel" id="notifierChannel">' +
+        ['webhook', 'slack', 'lark'].map(function (c) { return '<option value="' + c + '"' + (f.channel === c ? ' selected' : '') + '>' + { webhook: 'Webhook (your app)', slack: 'Slack channel', lark: 'Lark / Feishu chat' }[c] + '</option>'; }).join('') +
+      '</select></label>' +
+      field('webhook', '<label>Webhook URL<input type="url" name="url" placeholder="https://your-app.example.com/hooks/loopengine" value="' + escapeHtml(f.url || '') + '"></label>' + secretField('webhook', 'Signing secret')) +
+      field('slack', '<label>Channel ID<input name="channelId" placeholder="C0123ABC456" value="' + escapeHtml(f.channelId || '') + '"></label>' + secretField('slack', 'Bot token')) +
+      field('lark', '<label>App ID<input name="appId" value="' + escapeHtml(f.appId || '') + '"></label><label>Chat ID<input name="chatId" value="' + escapeHtml(f.chatId || '') + '"></label>' + secretField('lark', 'App secret')) +
+      '<label>Link address <span class="hint">(messages link here so people can approve without logging in; use an address they can reach)</span>' +
+        '<input type="url" name="publicUrl" id="notifierPublicUrl" value="' + escapeHtml(n.publicUrl || f.publicUrl || location.origin) + '"' + (n.publicUrl ? ' disabled title="Set by LOOPENGINE_PUBLIC_URL"' : '') + '></label>' +
+      '<div class="body-field">Send' +
+        '<div style="display:flex;gap:14px;flex-wrap:wrap">' + NOTIFIER_EVENTS.slice(0, 2).map(eventBox).join('') + '</div>' +
+        '<details' + (events.indexOf('run_finish') !== -1 || events.indexOf('run_start') !== -1 ? ' open' : '') + '><summary>More events</summary>' +
+        '<div style="display:flex;gap:14px;flex-wrap:wrap;margin-top:6px">' + NOTIFIER_EVENTS.slice(2).map(eventBox).join('') + '</div>' +
+        '<p class="hint" style="margin:4px 0 0">Run finished tells your app the agent&#39;s final reply once a decision lets it finish.</p></details></div>' +
+      (n.canSave === false ? '<p class="error" style="margin:0">Saving needs <code>LOOPENGINE_ADMIN_AUTH</code> set on the server, because this stores a secret. Add <code>LOOPENGINE_ADMIN_AUTH=user:pass</code> to <code>.env</code> and restart.</p>' : '') +
+      '<div style="display:flex;gap:8px;flex-wrap:wrap"><button type="submit"' + (n.canSave === false ? ' disabled' : '') + '>Save</button><button type="button" id="notifierTestBtn">Send test</button>' +
+        (n.file ? '<button type="button" class="delete-btn" id="notifierRemoveBtn">Remove</button>' : '') + '</div>' +
+      '<div id="notifierResult" class="hint"></div>' +
+      '<p class="hint" style="margin:0">For a webhook: your app checks the <code>X-Actauth-Signature</code> header (HMAC-SHA256 of the body with the signing secret). Each payload carries a <code>decideUrl</code> it can simply forward to a person, or it can decide itself by sending <code>{"decision":"approve"}</code> or <code>{"decision":"deny"}</code> to <code>resolveUrl</code>.</p>' +
+      '</form>';
+  }
+
+  function renderDeliveries(list) {
+    if (!list.length) return '<p class="hint">No deliveries since the server started.</p>';
+    return '<div class="le-table-wrap"><table><thead><tr><th>When</th><th>What</th><th>Attempt</th><th>Result</th></tr></thead><tbody>' +
+      list.slice(0, 15).map(function (d) {
+        return '<tr><td>' + escapeHtml(new Date(d.at).toLocaleTimeString()) + '</td><td>' + escapeHtml(d.kind) + '</td><td>' + d.attempt + '</td>' +
+          '<td>' + (d.ok ? '<span class="le-pill good">' + (d.status || 'ok') + '</span>' : '<span class="le-pill bad">' + escapeHtml(d.error || 'failed') + '</span>') + '</td></tr>';
+      }).join('') + '</tbody></table></div>';
+  }
+
+  // Tools that can stop for approval: a rule that asks, or "ask" as the
+  // decision when no rule matches.
+  function askingTools() {
+    var perms = currentCfg && currentCfg.permissions;
+    if (!perms) return [];
+    var tools = [];
+    perms.rules.forEach(function (r) { if (r.decision === 'ask' && tools.indexOf(r.tool) === -1) tools.push(r.tool); });
+    if (perms.defaultDecision === 'ask') tools.push('any tool without a rule');
+    return tools;
+  }
+
+  // The top of the tab: a nudge when approvals over HTTP would reach
+  // nobody, and whatever is waiting right now.
+  function renderPendingHtml(pending, n) {
+    var html = '';
+    var tools = askingTools();
+    if (tools.length && n && n.source === 'none') {
+      html += '<div class="approvals-nudge"><strong>Approval requests aren&#39;t sent anywhere yet.</strong> ' +
+        escapeHtml(tools.slice(0, 3).join(', ')) + (tools.length > 3 ? ' and more' : '') + ' can stop for approval, but when an app calls this agent over HTTP nobody is notified. ' +
+        '<a href="#approvalsSetup" class="approvals-nudge-link">Choose where they go</a></div>';
+    }
+    if (pending.length) html += '<section><h3>Waiting for a decision (' + pending.length + ')</h3>' + renderPendingTable(pending) + '</section>';
+    return html;
+  }
+
+  function renderApprovalsHtml(n) {
+    return '<section id="approvalsSetup"><h3>Where approval requests and questions are sent</h3>' +
+      '<p class="muted" style="margin:0 0 8px">When an app calls this agent over HTTP and a tool call needs approval, or the agent asks a question, it&#39;s sent here. In Chat it shows up in the conversation instead.</p>' +
+      '<p class="muted" style="margin:0 0 12px">Currently: ' + renderNotifierStatus(n) + '</p>' +
+        (n.error ? '<p class="error">' + escapeHtml(n.error) + '</p>' : '') +
+        (n.source === 'code' ? '' : renderNotifierForm(n)) + '</section>' +
+      '<section><h3>Recent deliveries</h3>' + renderDeliveries(n.deliveries || []) + '</section>';
+  }
+
+  function wirePendingHandlers(name) {
+    var content = detail.querySelector('#pendingContent');
+    if (!content) return;
+    var nudgeLink = content.querySelector('.approvals-nudge-link');
+    if (nudgeLink) {
+      nudgeLink.addEventListener('click', function (ev) {
+        ev.preventDefault();
+        var target = detail.querySelector('#approvalsSetup');
+        if (target) target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+      });
+    }
+    var copyBtns = content.querySelectorAll('.pending-copy');
+    for (var c = 0; c < copyBtns.length; c++) {
+      copyBtns[c].addEventListener('click', function (ev) {
+        var btn = ev.currentTarget;
+        var link = location.origin + btn.dataset.path;
+        var done = function () { btn.textContent = 'Copied'; setTimeout(function () { btn.textContent = 'Copy link'; }, 1500); };
+        if (navigator.clipboard) navigator.clipboard.writeText(link).then(done, function () { window.prompt('Copy this link', link); });
+        else window.prompt('Copy this link', link);
+      });
+    }
+    var decideBtns = content.querySelectorAll('.pending-decide');
+    for (var i = 0; i < decideBtns.length; i++) {
+      decideBtns[i].addEventListener('click', function (ev) {
+        var btn = ev.currentTarget;
+        btn.disabled = true;
+        fetchJsonRetryOnce('/pending-approvals/' + encodeURIComponent(btn.dataset.id) + '/resolve', {
+          method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ decision: btn.dataset.decision }),
+        }).then(function () { loadApprovalsSection(name); });
+      });
+    }
+    var answerForms = content.querySelectorAll('.pending-answer');
+    for (var j = 0; j < answerForms.length; j++) {
+      answerForms[j].addEventListener('submit', function (ev) {
+        ev.preventDefault();
+        var form = ev.currentTarget;
+        fetchJsonRetryOnce('/pending-questions/' + encodeURIComponent(form.dataset.id) + '/answer', {
+          method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ answer: new FormData(form).get('answer') }),
+        }).then(function () { loadApprovalsSection(name); });
+      });
+    }
+  }
+
+  function wireApprovalsHandlers(name) {
+    var content = approvalsContentEl();
+    if (!content) return;
+    var form = content.querySelector('#notifierForm');
+    if (!form) return;
+    var result = content.querySelector('#notifierResult');
+    content.querySelector('#notifierChannel').addEventListener('change', function (ev) {
+      var groups = form.querySelectorAll('.notifier-fields');
+      for (var k = 0; k < groups.length; k++) groups[k].hidden = groups[k].dataset.channel !== ev.currentTarget.value;
+    });
+    var generate = form.querySelector('.notifier-generate');
+    if (generate) {
+      generate.addEventListener('click', function () {
+        var bytes = new Uint8Array(24);
+        crypto.getRandomValues(bytes);
+        var input = form.querySelector('input[name="secret_webhook"]');
+        input.type = 'text';
+        input.value = Array.prototype.map.call(bytes, function (b) { return ('0' + b.toString(16)).slice(-2); }).join('');
+        result.textContent = 'Copy this secret into your app before saving; it is not shown again.';
+      });
+    }
+    form.addEventListener('submit', function (ev) {
+      ev.preventDefault();
+      var data = new FormData(form);
+      var channel = data.get('channel');
+      var body = { channel: channel, events: data.getAll('events'), url: data.get('url'), channelId: data.get('channelId'), appId: data.get('appId'), chatId: data.get('chatId'), publicUrl: data.get('publicUrl') };
+      var secret = data.get('secret_' + channel);
+      if (secret) body.secret = secret;
+      result.textContent = 'Saving…';
+      fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/notifier', {
+        method: 'PUT', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
+      }).then(function (r) {
+        if (!r.ok) { result.textContent = r.body.error || 'Could not save'; return; }
+        loadApprovalsSection(name, 'Saved.');
+      });
+    });
+    content.querySelector('#notifierTestBtn').addEventListener('click', function () {
+      result.textContent = 'Sending…';
+      fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/notifier/test', { method: 'POST' }).then(function (r) {
+        var t = r.body;
+        loadApprovalsSection(name, t.ok ? 'Test delivered (' + (t.status || 'ok') + ').' : 'Test failed: ' + (t.error || 'unknown error'));
+      });
+    });
+    var removeBtn = content.querySelector('#notifierRemoveBtn');
+    if (removeBtn) {
+      removeBtn.addEventListener('click', function () {
+        if (removeBtn.dataset.confirming !== '1') { removeBtn.dataset.confirming = '1'; removeBtn.textContent = 'Click again to remove'; return; }
+        fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/notifier', { method: 'DELETE' }).then(function () { loadApprovalsSection(name, 'Removed.'); });
+      });
+    }
+  }
+
+  function loadApprovalsSection(name, message) {
+    var content = approvalsContentEl();
+    if (!content) return;
+    Promise.all([
+      fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/notifier'),
+      fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/pending'),
+    ]).then(function (results) {
+      if (currentName !== name) return;
+      if (!results[0].ok) throw new Error(results[0].body.error || 'request failed');
+      content.innerHTML = renderApprovalsHtml(results[0].body);
+      wireApprovalsHandlers(name);
+      var pendingEl = detail.querySelector('#pendingContent');
+      if (pendingEl) {
+        pendingEl.innerHTML = renderPendingHtml((results[1].ok && results[1].body.pending) || [], results[0].body);
+        wirePendingHandlers(name);
+      }
+      if (message) { var r = content.querySelector('#notifierResult'); if (r) r.textContent = message; }
+    }).catch(function (err) {
+      if (currentName !== name) return;
+      content.innerHTML = '<p class="error">Could not load approvals: ' + escapeHtml(err.message) + '</p>';
+    });
+  }
+
   function actauthContentEl() {
     return detail.querySelector('#actauthContent');
   }
@@ -2448,6 +2691,7 @@ ${consoleShellScript}
     if (tab === 'actauth' && actauthLoadedFor !== currentName) {
       loadActauthTab(currentName);
     }
+    if (tab === 'actauth') loadApprovalsSection(currentName);
     if (tab === 'env' && envLoadedFor !== currentName) {
       loadEnvTab(currentName);
     }
@@ -2609,7 +2853,9 @@ ${consoleShellScript}
   currentTab = CONFIG_TABS.indexOf(initialParams.get('tab')) === -1 ? 'overview' : initialParams.get('tab');
   leShell.ready.then(function (agents) {
     if (!agents.length) {
-      empty.innerHTML = 'No agents yet. <a href="/agents?new=1">Create one</a> or add a folder under agents/.';
+      empty.innerHTML = leShell.loadError()
+        ? 'Could not load agents: ' + escapeHtml(leShell.loadError()) + '. Reload the page to try again.'
+        : 'No agents yet. <a href="/agents?new=1">Create one</a> or add a folder under agents/.';
       return;
     }
     var requested = initialParams.get('agent');

package/dist/web/console-shell.js

@@ -98,15 +98,23 @@ export const consoleShellScript = `<script>
     });
   }
 
-  var ready = fetch('/agents')
-    .then(function (r) { return r.json(); })
+  var loadError = null;
+  var ready = fetch('/agents', { headers: { accept: 'application/json' } })
+    .then(function (r) {
+      if (!r.ok) throw new Error(r.status === 401 ? 'sign-in required (HTTP 401)' : 'HTTP ' + r.status);
+      return r.json();
+    })
     .then(function (data) {
       agents = data.agents || [];
       renderList();
       loadToSet();
       return agents;
     })
-    .catch(function () { return []; });
+    .catch(function (err) {
+      loadError = err.message;
+      if (list) list.innerHTML = '<li class="le-agent-item"><span></span><span class="le-meta">Could not load agents: ' + esc(err.message) + '</span><span></span></li>';
+      return [];
+    });
 
   // opts: { name, prompt, chips: [{ text, mono }], tab, counts: { tools, skills, abilities, actauth } }
   function renderHead(opts) {
@@ -160,6 +168,6 @@ export const consoleShellScript = `<script>
     if (app.classList.contains('nav-open') && !ev.target.closest('.le-sidebar')) app.classList.remove('nav-open');
   });
 
-  window.leShell = { ready: ready, renderHead: renderHead, setTab: setTab, setActive: setActive, esc: esc, tabHref: tabHref, envCountHtml: envCountHtml, setCount: setCount };
+  window.leShell = { loadError: function () { return loadError; }, ready: ready, renderHead: renderHead, setTab: setTab, setActive: setActive, esc: esc, tabHref: tabHref, envCountHtml: envCountHtml, setCount: setCount };
 })();
 </script>`;

package/dist/web/decide-page.d.ts

@@ -0,0 +1,16 @@
+export interface DecidePageItem {
+    kind: 'approval' | 'question';
+    agent: string;
+    tool: string;
+    args: Record<string, unknown>;
+    reason: string;
+    sessionId: string;
+    tenant: string;
+    createdAt?: string;
+    expiresAt: number;
+}
+/** A link that's malformed, tampered with, or past its expiry. */
+export declare function renderDecideInvalidPage(): string;
+/** A valid link whose decision has already been made. */
+export declare function renderDecideGonePage(): string;
+export declare function renderDecidePage(item: DecidePageItem): string;

package/dist/web/decide-page.js

@@ -0,0 +1,138 @@
+// The page a decision link opens (GET /decide/<token>, see
+// core/approval-links.ts): what's waiting — the tool and its arguments,
+// or the question — and buttons to approve, deny or answer. Anyone with
+// the link can decide; the signed token is the only credential, so this
+// page shows nothing beyond the one decision it names.
+//
+// Rendered on the server; the small script only posts the choice back to
+// the same URL (POST /decide/<token>) and shows the outcome. Written
+// without backticks or backslashes inside the script, same convention as
+// the other embedded pages.
+import { devUiCss } from './dev-ui-styles.js';
+function esc(s) {
+    return String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+}
+const PAGE_CSS = `
+  body { display: grid; place-items: start center; padding: 48px 16px; background: var(--surface); }
+  main { width: 100%; max-width: 560px; background: var(--bg); border: 1px solid var(--line); border-radius: 12px; padding: 24px; display: grid; gap: 16px; }
+  .brand { display: flex; align-items: center; gap: 8px; font-weight: 600; color: var(--ink-muted); font-size: 13px; }
+  .mark { width: 18px; height: 18px; border-radius: 5px; background: var(--accent); }
+  h1 { font-size: 20px; margin: 0; }
+  dl { display: grid; grid-template-columns: max-content minmax(0, 1fr); gap: 6px 16px; margin: 0; font-size: 13px; }
+  dt { color: var(--ink-faint); }
+  dd { margin: 0; overflow-wrap: anywhere; }
+  pre, textarea { font-family: var(--font-mono); font-size: 12.5px; background: var(--code-bg); border-radius: 8px; padding: 12px; margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; }
+  textarea { width: 100%; min-height: 120px; border: 1px solid var(--line); }
+  .actions { display: flex; gap: 8px; flex-wrap: wrap; }
+  .actions button { padding: 8px 16px; }
+  .deny { color: var(--bad); }
+  .note { font-size: 12px; color: var(--ink-faint); margin: 0; }
+  .result { padding: 12px 14px; border-radius: 8px; background: var(--good-soft); color: var(--good); }
+  .result.bad { background: var(--bad-soft); color: var(--bad); }
+  .reply { white-space: pre-wrap; background: var(--surface); border-radius: 8px; padding: 12px 14px; }
+  details summary { cursor: pointer; font-size: 13px; color: var(--ink-muted); }
+`;
+function shell(title, body, script = '') {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex">
+<title>${esc(title)}</title>
+<style>${devUiCss}${PAGE_CSS}</style>
+</head>
+<body>
+<main>
+<div class="brand"><span class="mark" aria-hidden="true"></span>LoopEngine</div>
+${body}
+</main>
+${script}
+</body>
+</html>`;
+}
+/** A link that's malformed, tampered with, or past its expiry. */
+export function renderDecideInvalidPage() {
+    return shell('Link not valid', '<h1>This link isn&#39;t valid</h1><p class="muted">It may have expired or been copied incompletely. Ask for a new one, or decide from the agent&#39;s Permissions tab.</p>');
+}
+/** A valid link whose decision has already been made. */
+export function renderDecideGonePage() {
+    return shell('Already decided', '<h1>Already decided</h1><p class="muted">Someone has already made this decision, so there&#39;s nothing left to do here.</p>');
+}
+const SCRIPT = `<script>
+(function () {
+  var main = document.querySelector('main');
+  var result = document.getElementById('result');
+  function send(body, button) {
+    var buttons = main.querySelectorAll('button');
+    for (var i = 0; i < buttons.length; i++) buttons[i].disabled = true;
+    result.hidden = false;
+    result.className = 'result';
+    result.textContent = 'Sending' + String.fromCharCode(8230);
+    fetch(location.pathname, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
+      .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); })
+      .then(function (r) {
+        if (!r.ok) throw new Error(r.body.error || 'request failed');
+        var form = document.getElementById('decision');
+        if (form) form.hidden = true;
+        result.textContent = r.body.message || (body.decision === 'deny' ? 'Denied.' : body.answer !== undefined ? 'Answer sent.' : 'Approved.');
+        if (r.body.text) {
+          var reply = document.createElement('div');
+          reply.className = 'reply';
+          reply.textContent = r.body.text;
+          result.after(reply);
+        }
+      })
+      .catch(function (err) {
+        result.className = 'result bad';
+        result.textContent = err.message;
+        for (var i = 0; i < buttons.length; i++) buttons[i].disabled = false;
+      });
+  }
+  main.addEventListener('click', function (ev) {
+    var btn = ev.target.closest('button[data-send]');
+    if (!btn) return;
+    var payload = JSON.parse(btn.getAttribute('data-send'));
+    if (payload.editedFrom) {
+      try { payload = { decision: 'approve', editedArgs: JSON.parse(document.getElementById(payload.editedFrom).value) }; }
+      catch (e) { result.hidden = false; result.className = 'result bad'; result.textContent = 'The arguments aren' + String.fromCharCode(39) + 't valid JSON.'; return; }
+    }
+    if (payload.answerFrom) {
+      var text = document.getElementById(payload.answerFrom).value.trim();
+      if (!text) return;
+      payload = { answer: text };
+    }
+    send(payload, btn);
+  });
+})();
+</script>`;
+export function renderDecidePage(item) {
+    const expires = new Date(item.expiresAt).toUTCString();
+    const facts = `<dl><dt>Agent</dt><dd>${esc(item.agent)}</dd>` +
+        `<dt>Conversation</dt><dd><code>${esc(item.sessionId)}</code>${item.tenant && item.tenant !== 'default' ? ` (tenant ${esc(item.tenant)})` : ''}</dd>` +
+        (item.createdAt ? `<dt>Asked</dt><dd>${esc(new Date(item.createdAt).toUTCString())}</dd>` : '') +
+        `</dl>`;
+    const note = `<p class="note">Anyone with this link can make this decision. It works once and expires ${esc(expires)}.</p>`;
+    const result = '<div id="result" class="result" hidden role="status"></div>';
+    if (item.kind === 'question') {
+        const question = typeof item.args.question === 'string' ? item.args.question : item.reason;
+        const options = Array.isArray(item.args.options) ? item.args.options.map(String) : [];
+        const optionButtons = options.map((o) => `<button type="button" data-send="${esc(JSON.stringify({ answer: o }))}">${esc(o)}</button>`).join('');
+        return shell(`Question from ${item.agent}`, `<h1>${esc(item.agent)} has a question</h1>${facts}<pre>${esc(question)}</pre>` +
+            `<div id="decision" style="display:grid;gap:10px">` +
+            (optionButtons ? `<div class="actions">${optionButtons}</div>` : '') +
+            `<label style="display:grid;gap:6px;font-size:13px">${options.length ? 'Or answer in your own words' : 'Your answer'}<textarea id="answerText" style="min-height:80px;font-family:var(--font-sans)"></textarea></label>` +
+            `<div class="actions"><button type="button" class="primary" data-send="${esc(JSON.stringify({ answerFrom: 'answerText' }))}">Send answer</button></div></div>` +
+            result + note, SCRIPT);
+    }
+    return shell(`Approve ${item.tool}?`, `<h1>Approve <code>${esc(item.tool)}</code>?</h1>${facts}` +
+        `<pre>${esc(JSON.stringify(item.args, null, 2))}</pre>` +
+        `<p class="muted" style="margin:0">${esc(item.reason)}</p>` +
+        `<div id="decision" style="display:grid;gap:12px">` +
+        `<div class="actions"><button type="button" class="primary" data-send="${esc(JSON.stringify({ decision: 'approve' }))}">Approve</button>` +
+        `<button type="button" class="deny" data-send="${esc(JSON.stringify({ decision: 'deny' }))}">Deny</button></div>` +
+        `<details><summary>Change the arguments first</summary><div style="display:grid;gap:8px;margin-top:8px">` +
+        `<textarea id="editedArgs">${esc(JSON.stringify(item.args, null, 2))}</textarea>` +
+        `<div class="actions"><button type="button" data-send="${esc(JSON.stringify({ editedFrom: 'editedArgs' }))}">Approve with these arguments</button></div></div></details>` +
+        `</div>` + result + note, SCRIPT);
+}

package/dist/web/notifier-admin.d.ts

@@ -0,0 +1,63 @@
+import type { AgentConfig } from '../core/agent-config.js';
+import type { CheckpointStore } from '../core/durable-approvals.js';
+import { type DeliveryResult } from '../core/http-notify-triggers/webhook.js';
+import { type NotifierFileChannel } from '../core/notifier-file.js';
+/** The deployment-wide default webhook (LOOPENGINE_DEFAULT_WEBHOOK_URL /
+ * _SECRET), which applies to the plain /messages route when an agent has
+ * no notifier of its own. */
+export interface DefaultWebhook {
+    webhookUrl: string;
+    webhookSecret: string;
+}
+export declare function describeAgentNotifier(config: AgentConfig, defaultWebhook?: DefaultWebhook): {
+    source: string;
+    defaultWebhookUrl: string | null;
+    publicUrl: string | null;
+    secretVars: Record<NotifierFileChannel, string>;
+    secretsSet: {
+        [k: string]: boolean;
+    };
+    deliveries: import("../core/notifier-deliveries.js").NotifierDelivery[];
+    channel?: import("../core/agent-config.js").HttpNotifierConfig["channel"];
+    events?: string[];
+    file?: import("../core/notifier-file.js").NotifierFile;
+    missingSecret?: string;
+    error?: string;
+};
+/** Writes agents/<name>/notifier.yml from the console form and, when the
+ * form includes one, the channel's secret into the agent's own env.
+ * Throws NotifierFileError for an invalid form. */
+export declare function saveAgentNotifier(config: AgentConfig, body: Record<string, unknown>): Promise<void>;
+/** Removes notifier.yml; the stored secret is left alone, so turning the
+ * notifier back on doesn't need it re-entered. */
+export declare function removeAgentNotifier(config: AgentConfig): void;
+/** Sends a test through whichever notifier applies to this agent —
+ * webhook or Slack; reports what the receiver answered. */
+export declare function testAgentNotifier(config: AgentConfig, defaultWebhook?: DefaultWebhook): Promise<DeliveryResult & {
+    channel?: string;
+}>;
+/** Every decision still waiting for this agent, oldest first, each with
+ * where to send the answer. */
+export declare function listAgentPending(store: CheckpointStore, agentName: string): Promise<({
+    decidePath: string;
+    answerPath: string;
+    pendingId: string;
+    kind: "approval" | "question";
+    tool: string;
+    args: Record<string, unknown>;
+    reason: string;
+    sessionId: string;
+    tenant: string;
+    createdAt: string | null;
+} | {
+    decidePath: string;
+    resolvePath: string;
+    pendingId: string;
+    kind: "approval" | "question";
+    tool: string;
+    args: Record<string, unknown>;
+    reason: string;
+    sessionId: string;
+    tenant: string;
+    createdAt: string | null;
+})[]>;

package/dist/web/notifier-admin.js

@@ -0,0 +1,91 @@
+import { agentDirFor, createAgentEnv } from '../core/agent-env.js';
+import { decidePath } from '../core/approval-links.js';
+import { describeNotifier } from '../core/http-notifier.js';
+import { sendTestSlackMessage } from '../core/http-notify-triggers/slack.js';
+import { sendTestWebhook } from '../core/http-notify-triggers/webhook.js';
+import { listDeliveries } from '../core/notifier-deliveries.js';
+import { NOTIFIER_SECRET_VARS, notifierConfigFromFile, readNotifierFile, removeNotifierFile, writeNotifierFile } from '../core/notifier-file.js';
+import { setAgentEnvVar } from './env-admin.js';
+export function describeAgentNotifier(config, defaultWebhook) {
+    const described = describeNotifier(config);
+    const env = createAgentEnv(config.name, agentDirFor(config));
+    const secretsSet = Object.fromEntries(Object.keys(NOTIFIER_SECRET_VARS).map((channel) => [channel, env.get(NOTIFIER_SECRET_VARS[channel]) !== undefined]));
+    const source = described.source === 'none' && defaultWebhook ? 'default' : described.source;
+    return {
+        ...described,
+        source,
+        defaultWebhookUrl: defaultWebhook?.webhookUrl ?? null,
+        publicUrl: process.env.LOOPENGINE_PUBLIC_URL ?? null,
+        secretVars: NOTIFIER_SECRET_VARS,
+        secretsSet,
+        deliveries: listDeliveries(config.name),
+    };
+}
+/** Writes agents/<name>/notifier.yml from the console form and, when the
+ * form includes one, the channel's secret into the agent's own env.
+ * Throws NotifierFileError for an invalid form. */
+export async function saveAgentNotifier(config, body) {
+    const file = writeNotifierFile(agentDirFor(config), body);
+    if (typeof body.secret === 'string' && body.secret.trim()) {
+        await setAgentEnvVar(config.name, NOTIFIER_SECRET_VARS[file.channel], body.secret.trim());
+    }
+}
+/** Removes notifier.yml; the stored secret is left alone, so turning the
+ * notifier back on doesn't need it re-entered. */
+export function removeAgentNotifier(config) {
+    removeNotifierFile(agentDirFor(config));
+}
+/** Sends a test through whichever notifier applies to this agent —
+ * webhook or Slack; reports what the receiver answered. */
+export async function testAgentNotifier(config, defaultWebhook) {
+    let target = config.httpNotifier;
+    if (!target) {
+        const dir = agentDirFor(config);
+        const file = readNotifierFile(dir);
+        if (file) {
+            const { config: fromFile, missingSecret } = notifierConfigFromFile(file, createAgentEnv(config.name, dir));
+            if (!fromFile)
+                return { ok: false, channel: file.channel, error: `${missingSecret} is not set for this agent` };
+            target = fromFile;
+        }
+    }
+    if (!target && defaultWebhook) {
+        return { channel: 'webhook', ...(await sendTestWebhook(defaultWebhook.webhookUrl, defaultWebhook.webhookSecret, config.name)) };
+    }
+    if (!target)
+        return { ok: false, error: 'This agent has no notifier set up' };
+    if (target.channel === 'webhook') {
+        return { channel: 'webhook', ...(await sendTestWebhook(target.config.webhookUrl, target.config.webhookSecret, config.name)) };
+    }
+    if (target.channel === 'slack') {
+        return { channel: 'slack', ...(await sendTestSlackMessage(target.config.botToken, target.config.channelId, `Test from LoopEngine: approvals for ${config.name} will be posted here.`)) };
+    }
+    return { ok: false, channel: target.channel, error: `Send test isn't supported for ${target.channel} yet` };
+}
+/** Every decision still waiting for this agent, oldest first, each with
+ * where to send the answer. */
+export async function listAgentPending(store, agentName) {
+    const open = await store.listOpen();
+    const pending = [];
+    for (const checkpoint of open) {
+        if (checkpoint.agent !== agentName)
+            continue;
+        for (const [pendingId, item] of Object.entries(checkpoint.outstanding)) {
+            const kind = item.kind ?? 'approval';
+            pending.push({
+                pendingId,
+                kind,
+                tool: item.tool,
+                args: item.args,
+                reason: item.reason,
+                sessionId: checkpoint.sessionId,
+                tenant: checkpoint.tenant,
+                createdAt: checkpoint.createdAt ?? null,
+                ...(kind === 'question' ? { answerPath: `/pending-questions/${pendingId}/answer` } : { resolvePath: `/pending-approvals/${pendingId}/resolve` }),
+                // A signed link anyone can open to decide (core/approval-links.ts).
+                decidePath: decidePath(pendingId, kind),
+            });
+        }
+    }
+    return pending;
+}