@njeybe/nativ 2.2.0 → 2.3.1

package/dist/server/studio-ui/shell/proposals.js

@@ -0,0 +1,197 @@
+// Self-healing proposal review.
+export const proposalsScript = String.raw `  // ─── Console tab 3: self-healing proposal review (/api/pipeline/escalations) ─
+  /** Shows the tab only while the console's task has a pending escalation; keeps the panel in sync. */
+  function syncHealTab() {
+    var escalation = rc.taskId ? escalationFor(rc.taskId) : null;
+    // Keep the tab while a just-finished resolution is still on screen.
+    var show = !!escalation || !!(rc.heal && (rc.heal.result || rc.heal.triage) && rc.heal.taskId === rc.taskId);
+    $('rc-tab-heal').hidden = !show;
+    $('rc-heal-count').hidden = !(escalation && escalation.proposedPatch);
+    if (!show && rc.tab === 'heal') setConsoleTab('logs');
+    else if (rc.tab === 'heal') renderHeal();
+  }
+
+  function patchLine(sign, p) {
+    if (!p) return '';
+    var value = p.value === undefined ? '' : ' ' + JSON.stringify(p.value);
+    return '<span class="' + (sign === '-' ? 'df-del' : 'df-add') + '">' + sign + ' ' + esc(p.operation + ' ' + p.path + value) + '</span>';
+  }
+
+  function healBody(escalation, opts) {
+    var withActions = !(opts && opts.actions === false);
+    var p = escalation.proposedPatch;
+    var diag = '<p class="heal-diag"><strong>' + esc(escalation.summary || 'Escalated') + '</strong>' +
+      (escalation.details ? '<br>' + esc(escalation.details) : '') + '</p>';
+    if (!p) {
+      return '<div class="heal-head"><h3>No automatic fix could be proven</h3><span class="heal-tag">' + esc(escalation.id) + '</span></div>' + diag +
+        '<p class="heal-diag">' + esc(escalation.recommendedAction || 'Review the affected contracts, then unblock the task or dismiss the escalation.') + '</p>' +
+        (withActions ? '<div class="heal-actions"><button class="rc-btn reject" type="button" data-heal="reject">Dismiss</button>' +
+        '<button class="rc-btn approve" type="button" data-heal="approve">Approve &amp; Unblock Task</button></div>' : '');
+    }
+    var proof = p.verificationProof || {};
+    var verdict = proof.passed
+      ? '<span class="heal-verdict pass">' + ICON.check + 'PASSED in sandbox</span>'
+      : '<span class="heal-verdict fail">' + ICON.x + 'NOT VERIFIED</span>';
+    var patch = p.kind === 'restore_tests'
+      ? (p.files || []).map(function (f) { return '<span class="df-add">+ restore ' + esc(f) + '</span>'; }).join('') +
+        (p.commands || []).map(function (c) { return '<span class="df-meta">$ ' + esc(c) + '</span>'; }).join('')
+      : patchLine('-', p.original) + patchLine('+', p.candidate);
+    var checks = (proof.checks || []).map(function (c) {
+      return '<li><span class="' + (c.passed ? 'ok' : 'bad') + '">' + (c.passed ? ICON.check : ICON.x) + '</span><span><b>' + esc(c.name) + '</b> ' + esc(c.detail) + '</span></li>';
+    }).join('');
+    return '<div class="heal-head"><h3>' + esc(humanize(p.strategy || 'proposal')) + '</h3><span class="heal-tag">' + esc(p.proposalId || escalation.id) + '</span>' + verdict + '</div>' +
+      diag + '<p class="heal-diag">' + esc(p.rationale || '') + '</p>' +
+      '<div class="heal-grid">' +
+        '<section class="heal-section"><h4>' + (p.kind === 'restore_tests' ? 'Restoration plan' : 'Rejected change &#8594; proposed change') + '</h4><pre class="heal-patch">' + patch + '</pre></section>' +
+        '<section class="heal-section"><h4>Isolated verification</h4><ul class="heal-checks">' + (checks || '<li>No checks recorded.</li>') + '</ul></section>' +
+      '</div>' +
+      (withActions ? '<div class="heal-actions"><button class="rc-btn reject" type="button" data-heal="reject">Reject Proposal</button>' +
+      '<button class="rc-btn approve" type="button" data-heal="approve"' + (proof.passed ? '' : ' disabled title="Only sandbox-verified proposals can be applied"') + '>Approve &amp; Apply Patch</button></div>' : '');
+  }
+
+  function renderHeal() {
+    var panel = $('rc-heal');
+    // Live updates must not wipe instructions while they are being typed.
+    if (document.activeElement && document.activeElement.id === 't1-custom' && panel.contains(document.activeElement)) return;
+    var heal = rc.heal && rc.heal.taskId === rc.taskId ? rc.heal : null;
+    var result = heal && heal.result ? '<p class="heal-result' + (heal.result.ok ? '' : ' is-error') + '" role="status">' + esc(heal.result.message) + '</p>' : '';
+    if (!pipe.loaded.escalations) { panel.innerHTML = '<div class="heal-skel"></div><div class="heal-skel"></div><div class="heal-skel" style="width:60%"></div>'; return; }
+    if (pipe.errors.escalations && !pipe.escalations.length) {
+      panel.innerHTML = '<p class="heal-result is-error">Could not load escalations: ' + esc(pipe.errors.escalations) + '</p>' +
+        '<div class="heal-actions"><button class="rc-btn" type="button" data-heal="retry">Retry</button></div>';
+      return;
+    }
+    var escalation = escalationFor(rc.taskId);
+    var tri = triageFor(escalation, heal);
+    if (!escalation && !tri) {
+      panel.innerHTML = result || '<p class="heal-diag">No pending proposal for this task. When the circuit breaker trips on a third failed attempt, a sandbox-verified fix appears here for review.</p>';
+      return;
+    }
+    var html = result;
+    if (escalation) html += triageStrip(escalation, !!tri);
+    if (tri) html += triageVerdictHtml(tri.verdict, tri.escalation);
+    if (escalation) {
+      var deciding = !!tri && tri.verdict.classification === 'REQUIRE_HUMAN_DECISION' && tri.escalation.id === escalation.id;
+      html += healBody(escalation, { actions: !deciding }) + (deciding ? decisionActions(escalation) : '');
+    }
+    panel.innerHTML = html;
+    if (heal && heal.busy) panel.querySelectorAll('[data-heal]').forEach(function (b) { b.disabled = true; });
+  }
+
+  /** One click resolves: approve applies the proposal and unblocks the task, reject dismisses it. */
+  function resolveEscalation(decision, notes, buttonKey) {
+    var escalation = rc.taskId ? escalationFor(rc.taskId) : null;
+    if (!escalation || (rc.heal && rc.heal.busy)) return;
+    var taskId = rc.taskId;
+    rc.heal = { taskId: taskId, busy: true, result: null };
+    renderHeal();
+    var btn = $('rc-heal').querySelector('[data-heal="' + (buttonKey || decision) + '"]');
+    if (btn) btn.innerHTML = '<span class="spinner" aria-hidden="true"></span>' + (decision === 'approve' ? 'Applying…' : 'Rejecting…');
+    var payload = { escalationId: escalation.id, decision: decision };
+    if (notes) payload.notes = notes;
+    postJson('/api/pipeline/escalations/resolve', payload).then(function (body) {
+      rc.heal = { taskId: taskId, busy: false, result: { ok: true, message: body.message || 'Escalation resolved.' } };
+      toast(body.message || 'Escalation resolved', 'ok');
+    }, function (e) {
+      rc.heal = { taskId: taskId, busy: false, result: { ok: false, message: e.message } };
+      toast('Could not ' + decision + ' ' + escalation.id + ': ' + e.message);
+    }).then(function () {
+      renderHeal();
+      return fetchPipeline(['escalations', 'status', 'tasks', 'telemetry', 'triage']);
+    });
+  }
+
+  /** Per-turn usage from the native engine: fold the running total into the run record. */
+  function onRunnerUsage(event) {
+    if (!event || !event.taskId || !event.total) return;
+    var run = runFor(event.taskId);
+    if (run && (!event.runId || run.runId === event.runId)) run.usage = event.total;
+    if (rc.taskId === event.taskId) syncConsole();
+  }
+
+  function openConsole(taskId, quiet, tab) {
+    var drawer = $('runner-console-drawer');
+    if (rc.taskId !== taskId) {
+      rc.taskId = taskId;
+      rc.backfilled = false;
+      rc.stage = 0;
+      rc.diffSeq++;
+      rc.heal = null;
+      setDiffState('Uncommitted changes in the task worktree', [], '', null);
+      // The run list includes restored history, so no run means no log to fetch (the server would 400).
+      if (runFor(taskId)) {
+        $('rc-body').innerHTML = '<span class="rc-empty">Loading runner output…</span>';
+        loadConsoleLogs(taskId);
+      } else {
+        $('rc-body').innerHTML = '<span class="rc-empty">No runner has been dispatched for this task yet.</span>';
+        rc.backfilled = true;
+      }
+    }
+    rc.minimized = false;
+    drawer.hidden = false;
+    drawer.classList.remove('is-min');
+    $('rc-minimize').textContent = 'Minimize';
+    $('rc-minimize').setAttribute('aria-expanded', 'true');
+    document.body.classList.add('has-console');
+    document.body.classList.remove('has-console-min');
+    syncConsole();
+    syncHealTab();
+    rcTick();
+    setConsoleTab(tab || rc.tab);
+    if (!quiet) (rc.tab === 'diff' ? $('rc-diff-body') : rc.tab === 'heal' ? $('rc-heal') : $('rc-body')).focus();
+  }
+
+  function closeConsole() {
+    rc.taskId = null;
+    clearInterval(rc.ticker);
+    rc.ticker = null;
+    clearTimeout(rc.diffTimer);
+    rc.diffTimer = null;
+    $('runner-console-drawer').hidden = true;
+    document.body.classList.remove('has-console', 'has-console-min');
+  }
+
+  function toggleConsoleMinimized() {
+    rc.minimized = !rc.minimized;
+    var drawer = $('runner-console-drawer');
+    drawer.classList.toggle('is-min', rc.minimized);
+    document.body.classList.toggle('has-console', !rc.minimized);
+    document.body.classList.toggle('has-console-min', rc.minimized);
+    var btn = $('rc-minimize');
+    btn.textContent = rc.minimized ? 'Expand' : 'Minimize';
+    btn.setAttribute('aria-expanded', String(!rc.minimized));
+    if (!rc.minimized && rc.tab === 'diff' && rc.taskId) loadConsoleDiff(rc.taskId);
+  }
+
+  function onRunnerStatus(run) {
+    if (!run || !run.taskId) return;
+    upsertRun(run);
+    if (rc.taskId === run.taskId) {
+      syncConsole();
+      if (isRunActive(run)) rcTick();
+      queueConsoleDiff();
+    }
+    refreshUi(['runs']);
+    if (!RUN_ACTIVE[run.status]) {
+      var statusMsg = (RUN_LABEL[run.status] || run.status) + ': ' + run.taskId;
+      if (run.error && run.status !== 'completed') statusMsg += ' (' + run.error + ')';
+      toast(statusMsg, run.status === 'completed' ? 'ok' : 'err');
+      // The agent may have moved the task through "nativ task complete" while it ran.
+      queueRefresh(['status', 'tasks', 'worktrees', 'runs']);
+    }
+  }
+
+  function onRunnerLog(entry) {
+    if (!entry || !entry.taskId) return;
+    var run = runFor(entry.taskId);
+    if (run) run.logBytes = (run.logBytes || 0) + (entry.chunk ? entry.chunk.length : 0);
+    feedLogTail(entry);
+    if (rc.taskId !== entry.taskId || !rc.backfilled) return;
+    var empty = $('rc-body').querySelector('.rc-empty');
+    if (empty) $('rc-body').innerHTML = '';
+    appendConsole(ansiToHtml(entry.chunk, entry.stream === 'stderr' ? 'rc-fg-warn' : ''));
+    $('rc-bytes').textContent = formatBytes((run && run.logBytes) || 0);
+    queueConsoleDiff();
+  }
+
+`;

package/dist/server/studio-ui/shell/pure.d.ts

@@ -0,0 +1,3 @@
+export declare const pureScript: string;
+/** Runs a page script in its own function scope with the Studio API. */
+export declare const wrapPage: (script: string) => string;

package/dist/server/studio-ui/shell/pure.js

@@ -0,0 +1,9 @@
+import { formatScript } from './format.js';
+import { modelScript } from './model.js';
+import { sidebarViewScript } from './sidebar-view.js';
+import { paletteViewScript } from './palette-view.js';
+import { detailViewScript } from './detail-view.js';
+// Everything that needs no DOM; the test harness runs exactly this in node:vm.
+export const pureScript = [formatScript, modelScript, sidebarViewScript, paletteViewScript, detailViewScript].join('');
+/** Runs a page script in its own function scope with the Studio API. */
+export const wrapPage = (script) => `  (function (Studio) {\n${script}\n  })(Studio);\n`;

package/dist/server/studio-ui/shell/router.d.ts

@@ -0,0 +1 @@
+export declare const routerScript: string;

package/dist/server/studio-ui/shell/router.js

@@ -0,0 +1,95 @@
+// Routing, shell-wide click handling, theme toggle and live timers.
+export const routerScript = String.raw `  // ─── Router and shell-wide events ──────────────────────────────────────────
+  function pageIds() { return Studio.order.map(function (p) { return p.id; }); }
+
+  function setView(view) {
+    Studio.state.view = view;
+    Studio.order.forEach(function (p) {
+      var el = $('panel-' + p.id);
+      if (el) el.hidden = p.id !== view;
+      if (p.id === view) $('crumb-view').textContent = p.label;
+    });
+    if (location.hash !== '#' + view && window.history && history.replaceState) history.replaceState(null, '', '#' + view);
+    paintChrome();
+    var def = Studio.pages[view];
+    if (def && def.onShow) def.onShow();
+    paintPage(view);
+  }
+
+  Studio.go = function (view, opts) {
+    opts = opts || {};
+    if (!Studio.pages[view]) return;
+    var S = Studio.state;
+    if (!opts.keepDetail) closeDetail(true);
+    if (opts.milestoneId) S.milestoneId = opts.milestoneId;
+    S.focusTaskId = opts.focusTaskId || null;
+    setView(view);
+    if (opts.scroll !== false) window.scrollTo(0, 0);
+  };
+
+  window.addEventListener('hashchange', function () {
+    var v = Studio.resolveHash(location.hash, pageIds());
+    if (v !== Studio.state.view) Studio.go(v);
+  });
+
+  function currentActions() {
+    var def = Studio.pages[Studio.state.view];
+    return (def && def.actions) || {};
+  }
+
+  $('main').addEventListener('click', function (e) {
+    var t = e.target;
+    var task = t.closest('[data-task]');
+    if (task) { openDetail(task.getAttribute('data-task')); return; }
+    var go = t.closest('[data-go]');
+    if (go) { Studio.go(go.getAttribute('data-go')); return; }
+    var ms = t.closest('[data-ms]');
+    if (ms) { Studio.go('tasks', { milestoneId: ms.getAttribute('data-ms') }); return; }
+    var act = t.closest('[data-act]');
+    if (!act || act.disabled) return;
+    var name = act.getAttribute('data-act');
+    var handler = currentActions()[name];
+    if (handler) handler(act, pageCtx($('panel-' + Studio.state.view)));
+    else if (name === 'retry' && PIPE_PATHS[act.getAttribute('data-key')]) fetchPipeline([act.getAttribute('data-key')]);
+  });
+  $('side-nav').addEventListener('click', function (e) {
+    var go = e.target.closest('[data-go]');
+    if (go) Studio.go(go.getAttribute('data-go'));
+  });
+
+  $('main').addEventListener('change', function (e) {
+    if (!e.target.hasAttribute || !e.target.hasAttribute('data-ms-select')) return;
+    Studio.state.milestoneId = e.target.value;
+    Studio.state.focusTaskId = null;
+    repaintFor(null);
+  });
+
+  $('banner-retry').addEventListener('click', function () {
+    fetchPipeline(ALL_PARTS);
+    connectEvents();
+  });
+
+  function applyTheme(theme) {
+    document.documentElement.setAttribute('data-theme', theme);
+    try { localStorage.setItem('nativ-studio:theme', theme); } catch (e) { /* private mode */ }
+  }
+  $('btn-theme').addEventListener('click', function () {
+    var root = document.documentElement;
+    var dark = window.matchMedia && matchMedia('(prefers-color-scheme: dark)').matches;
+    var cur = root.getAttribute('data-theme') || (dark ? 'dark' : 'light');
+    applyTheme(cur === 'dark' ? 'light' : 'dark');
+  });
+
+  // Live timers: any element with data-since counts up from that moment.
+  setInterval(function () {
+    var now = Studio.now();
+    document.querySelectorAll('[data-since]').forEach(function (el) {
+      el.textContent = fmt.dur(now - Number(el.getAttribute('data-since')));
+    });
+  }, 1000);
+
+  Studio.api = api;
+  Studio.postJson = postJson;
+  Studio.toast = function (message, kind) { toast(message, kind); };
+
+`;

package/dist/server/studio-ui/shell/sidebar-view.d.ts

@@ -0,0 +1 @@
+export declare const sidebarViewScript: string;

package/dist/server/studio-ui/shell/sidebar-view.js

@@ -0,0 +1,38 @@
+// Pure sidebar markup: grouped navigation with badges, and the workspace footer.
+export const sidebarViewScript = String.raw `  // ─── Sidebar markup (pure) ──────────────────────────────────────────────────
+  var NAV_GROUPS = [['now', 'Now'], ['project', 'Project'], ['system', 'System']];
+
+  function navBadges(env) {
+    var badges = {}, model = env.model;
+    if (model && model.needsYou.length) badges.home = ['warn', model.needsYou.length];
+    if (model && model.running.length) badges.tasks = ['run', model.running.length];
+    if (env.worktreeCount != null) badges.worktrees = ['', env.worktreeCount];
+    if (env.benchmarkText) badges.benchmarks = ['', env.benchmarkText];
+    return badges;
+  }
+
+  /** env = { model, view, worktreeCount, benchmarkText }. */
+  Studio.sidebarHtml = function (env) {
+    var badges = navBadges(env);
+    var item = function (p) {
+      var b = badges[p.id];
+      return '<button type="button" class="nav-item" data-go="' + esc(p.id) + '"' +
+        (env.view === p.id ? ' aria-current="page"' : '') + '>' + ui.svg(p.icon) +
+        '<span class="nav-text">' + esc(p.label) + '</span>' +
+        (b ? '<span class="nav-badge' + (b[0] ? ' ' + b[0] : '') + '">' + esc(b[1]) + '</span>' : '') + '</button>';
+    };
+    var groups = NAV_GROUPS.map(function (g) {
+      var items = Studio.order.filter(function (p) { return p.group === g[0]; });
+      if (!items.length) return '';
+      return '<div class="nav-group"><div class="nav-glabel">' + g[1] + '</div>' + items.map(item).join('') + '</div>';
+    }).join('');
+    return '<nav class="nav" aria-label="Studio">' + groups + '</nav>';
+  };
+
+  /** env = { root, branch }. */
+  Studio.sideFootHtml = function (env) {
+    return '<span>Workspace</span><span class="mono" id="sb-root" title="' + esc(env.root || '') + '">' +
+      esc(env.root || '–') + '</span><span>branch <span class="mono" id="sb-branch-name">' + esc(env.branch || '–') + '</span></span>';
+  };
+
+`;

package/dist/server/studio-ui/shell/sync.d.ts

@@ -0,0 +1 @@
+export declare const syncScript: string;

package/dist/server/studio-ui/shell/sync.js

@@ -0,0 +1,120 @@
+// Live sync over the event stream.
+export const syncScript = String.raw `  // ─── Real-time sync: EventSource on /api/events ────────────────────────────
+  var live = { mode: 'connecting', es: null, retry: 0, timer: null, lastBeat: 0, sawBeat: false, opened: false };
+  var LIVE_TEXT = { connecting: 'Connecting', live: 'Live', offline: 'Reconnecting' };
+  // Keys are SSE event names on the wire; values are the pipeline slices each one invalidates.
+  var EVENT_PARTS = {
+    // .ai/escalation.json writes (circuit-breaker trips, resolutions) arrive as plan changes.
+    'plan_change': ['status', 'tasks', 'worktrees', 'escalations', 'triage'],
+    // The server also reports .ai/benchmark_report.json writes (e.g. a CLI "nativ bench") as telemetry changes.
+    'telemetry_change': ['status', 'benchmarks', 'telemetry'],
+    'benchmark_change': ['benchmarks'],
+    'worktree_change': ['worktrees']
+  };
+
+  function setLive(mode, detail) {
+    live.mode = mode;
+    var el = $('live');
+    el.setAttribute('data-state', mode);
+    $('live-label').textContent = LIVE_TEXT[mode];
+    el.title = detail || (mode === 'live' ? 'Receiving real-time updates from /api/events' : '');
+    paintChrome();
+  }
+
+  function flashLive() {
+    var dot = $('live-dot');
+    dot.classList.remove('flash');
+    void dot.offsetWidth;
+    dot.classList.add('flash');
+  }
+
+  // fs.watch fires several events per write; batch them into one refetch.
+  var queuedParts = {}, queueTimer = null;
+  function queueRefresh(parts) {
+    parts.forEach(function (p) { queuedParts[p] = true; });
+    clearTimeout(queueTimer);
+    queueTimer = setTimeout(function () {
+      var list = Object.keys(queuedParts);
+      queuedParts = {};
+      fetchPipeline(list);
+    }, 150);
+  }
+
+  function onStreamEvent(type) {
+    live.lastBeat = Date.now();
+    if (type === 'heartbeat' || type === 'ping') { live.sawBeat = true; return; }
+    var parts = EVENT_PARTS[type];
+    if (!parts) return;
+    flashLive();
+    queueRefresh(parts);
+    if (parts.indexOf('worktrees') !== -1) queueConsoleDiff();
+  }
+
+  function connectEvents() {
+    clearTimeout(live.timer);
+    if (typeof window.EventSource !== 'function') {
+      setLive('offline', 'This browser has no EventSource support; refreshing every 15 seconds instead.');
+      setInterval(function () { fetchPipeline(ALL_PARTS); }, 15000);
+      return;
+    }
+    if (live.es) live.es.close();
+    setLive('connecting');
+    var es = new EventSource('/api/events');
+    live.es = es;
+    es.onopen = function () {
+      live.retry = 0;
+      live.lastBeat = Date.now();
+      setLive('live');
+      // Catch up on anything written while the stream was down.
+      if (live.opened) queueRefresh(ALL_PARTS);
+      live.opened = true;
+    };
+    es.onerror = function () {
+      if (es.readyState === EventSource.CLOSED) scheduleReconnect();
+      else setLive('connecting', 'Reconnecting to /api/events');
+    };
+    // Unnamed events may carry the type in a JSON payload: { "type": "plan_change" }.
+    es.onmessage = function (e) {
+      var type = 'message';
+      try { type = JSON.parse(e.data).type || type; } catch (err) { /* plain-text payload */ }
+      onStreamEvent(type);
+    };
+    Object.keys(EVENT_PARTS).concat(['heartbeat', 'ping']).forEach(function (name) {
+      es.addEventListener(name, function () { onStreamEvent(name); });
+    });
+    // Runner events carry a payload, so they bypass the slice-invalidation table.
+    es.addEventListener('runner_status', function (e) {
+      live.lastBeat = Date.now();
+      flashLive();
+      onRunnerStatus(parseEventData(e));
+    });
+    es.addEventListener('runner_log', function (e) {
+      live.lastBeat = Date.now();
+      onRunnerLog(parseEventData(e));
+    });
+    // Native engine: one event per API turn with the delta and the run's running total.
+    es.addEventListener('runner_token_usage', function (e) {
+      live.lastBeat = Date.now();
+      flashLive();
+      onRunnerUsage(parseEventData(e));
+    });
+  }
+
+  function parseEventData(e) {
+    try { return JSON.parse(e.data); } catch (err) { return null; }
+  }
+
+  function scheduleReconnect() {
+    if (live.es) { live.es.close(); live.es = null; }
+    var delay = Math.min(30000, 1000 * Math.pow(2, live.retry++));
+    setLive('offline', 'Live stream unavailable; retrying in ' + Math.round(delay / 1000) + 's');
+    clearTimeout(live.timer);
+    live.timer = setTimeout(connectEvents, delay);
+  }
+
+  // Heartbeat watchdog: armed only once the server has shown it sends heartbeats.
+  setInterval(function () {
+    if (live.es && live.sawBeat && Date.now() - live.lastBeat > 45000) scheduleReconnect();
+  }, 15000);
+
+`;

package/dist/server/studio-ui/shell/toasts-format.d.ts

@@ -0,0 +1 @@
+export declare const toastsFormatScript: string;

package/dist/server/studio-ui/shell/toasts-format.js

@@ -0,0 +1,89 @@
+// Toasts and formatting helpers.
+export const toastsFormatScript = String.raw `  // ─── Toasts ────────────────────────────────────────────────────────────────
+  function hintFor(message) {
+    var m = String(message || '');
+    if (/ECONNREFUSED|ETIMEDOUT|timeout|EHOSTUNREACH/i.test(m)) return 'Check that the database server is running and the host/port are reachable from this machine.';
+    if (/ENOTFOUND|getaddrinfo/i.test(m)) return 'The hostname could not be resolved. Verify the host in your connection string.';
+    if (/password|authentication|access denied/i.test(m)) return 'Credentials were rejected. Re-enter the connection string in Connection Settings.';
+    if (/unable to open database file/i.test(m)) return 'The SQLite file was not found. Check the path relative to where nativ was started.';
+    if (/not configured|NOT_CONNECTED/i.test(m)) return 'Open Connection Settings to connect a database.';
+    if (/default credentials|UNAUTHENTICATED|PERMISSION_DENIED/i.test(m)) return 'For Firestore, run "gcloud auth application-default login" or connect to the emulator instead.';
+    if (/Server selection timed out|MongoServerSelectionError/i.test(m)) return 'MongoDB did not respond. Check the host, port, and network access list.';
+    return '';
+  }
+
+  function toast(message, kind) {
+    var el = document.createElement('div');
+    el.className = 'toast' + (kind === 'ok' ? ' ok' : '');
+    var hint = kind === 'ok' ? '' : hintFor(message);
+    el.innerHTML = '<div class="t-body"><div>' + esc(message) + '</div>' + (hint ? '<div class="t-hint">' + esc(hint) + '</div>' : '') +
+      '</div><button type="button" aria-label="Dismiss">×</button>';
+    el.querySelector('button').addEventListener('click', function () { el.remove(); });
+    $('toasts').appendChild(el);
+    setTimeout(function () { el.remove(); }, kind === 'ok' ? 3500 : 8000);
+  }
+
+  function flashCopied(button) {
+    var wrap = button.parentElement;
+    var tip = wrap && wrap.querySelector('.tooltip');
+    if (!tip) return;
+    tip.classList.add('show');
+    setTimeout(function () { tip.classList.remove('show'); }, 1200);
+  }
+
+  function copyText(text, button) {
+    var done = function () { flashCopied(button); };
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard.writeText(text).then(done, function () { fallbackCopy(text); done(); });
+    } else { fallbackCopy(text); done(); }
+  }
+
+  function fallbackCopy(text) {
+    var ta = document.createElement('textarea');
+    ta.value = text; ta.setAttribute('readonly', ''); ta.style.position = 'fixed'; ta.style.opacity = '0';
+    document.body.appendChild(ta); ta.select();
+    try { document.execCommand('copy'); } catch (e) { /* ignore */ }
+    ta.remove();
+  }
+
+  // ─── Formatting ────────────────────────────────────────────────────────────
+  function num(n) {
+    if (n == null || n === '' || isNaN(n)) return '–';
+    return Number(n).toLocaleString('en-US', { maximumFractionDigits: 3 });
+  }
+  function usd(n) {
+    if (n == null || isNaN(n)) return '–';
+    n = Number(n);
+    return '$' + (n >= 100 ? n.toFixed(0) : n >= 1 ? n.toFixed(2) : n.toFixed(3));
+  }
+  function fmtMs(ms) {
+    if (ms == null || isNaN(ms)) return '–';
+    if (ms < 1000) return Math.round(ms) + ' ms';
+    if (ms < 60000) return (ms / 1000).toFixed(2) + ' s';
+    return Math.floor(ms / 60000) + 'm ' + Math.round((ms % 60000) / 1000) + 's';
+  }
+  function clampPct(v) { return Math.max(0, Math.min(100, Math.round(Number(v) || 0))); }
+  /** Telemetry stores the gatekeeper pass rate as a 0..1 ratio; tolerate a 0..100 percentage too. */
+  function passRatePct(v) {
+    if (v == null || isNaN(v)) return null;
+    return clampPct(v <= 1 ? v * 100 : v);
+  }
+  function fmtDate(iso) {
+    var d = new Date(iso);
+    if (isNaN(d.getTime())) return String(iso);
+    try { return d.toLocaleString(undefined, { dateStyle: 'medium', timeStyle: 'short' }); } catch (e) { return d.toLocaleString(); }
+  }
+  function humanize(key) {
+    var words = String(key).replace(/[_-]+/g, ' ').replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase();
+    words = words.replace(/ ms$/, ' (ms)').replace(/ usd$/, ' (USD)');
+    return words.charAt(0).toUpperCase() + words.slice(1);
+  }
+  function detailValue(v) {
+    if (typeof v === 'boolean') return v ? 'Yes' : 'No';
+    if (typeof v === 'number') return num(v);
+    if (Array.isArray(v)) return v.map(String).join(', ');
+    if (v && typeof v === 'object') return JSON.stringify(v);
+    return String(v == null ? '–' : v);
+  }
+
+`;

package/dist/server/studio-ui/shell/triage.d.ts

@@ -0,0 +1 @@
+export declare const triageScript: string;