synabun 2.0.10 → 2.1.0

package/neural-interface/public/shared/skills/studio/sx-operations-view.js

@@ -0,0 +1,98 @@
+// Health/usage and Discover share the Studio shell in both variants. Requests die with this render's lifetime.
+import { scanFindingText } from './sx-scan.js';
+import { studioErrorText } from './sx-errors.js';
+import { protectionEntries, scannerState } from './sx-operations.js';
+import { html, setHTML, attr, ICONS } from './sx-dom.js';
+
+let life = null;
+export function leaveOperationsPlace() { life?.abort(); life = null; }
+export async function renderOperationsPlace(host, ctx, place) {
+  leaveOperationsPlace();
+  const controller = life = new AbortController();
+  const { signal } = controller;
+  const alive = () => !signal.aborted && host.isConnected;
+  const t = (key, args) => ctx.t(`skillsStudio.operations.${key}`, args);
+  setHTML(host, html`<section class="sx-place"><div class="sx-place-scroll"><div class="sx-create" id="sx-operations">
+    <h3 class="sx-place-title" tabindex="-1" data-autofocus>${t(place)}</h3><p role="status">${t('loading')}</p>
+  </div></div></section>`);
+  if (!ctx.caps.has(place === 'discover' ? 'discover' : 'health')) {
+    setHTML(host.querySelector('#sx-operations'), html`<p class="sx-note">${t('restart')}</p>`); return;
+  }
+  try {
+    const config = await ctx.api.fetchSkillOperations();
+    const data = place === 'discover' ? await ctx.api.fetchSkillDiscover() : await ctx.api.fetchSkillHealth();
+    const usage = place === 'health' ? await ctx.api.fetchSkillUsage() : null;
+    if (!alive()) return;
+    const settings = config.settings;
+    const box = host.querySelector('#sx-operations');
+    setHTML(box, html`<h3 class="sx-place-title" tabindex="-1" data-autofocus>${t(place)}</h3>
+      <p class="sx-help">${t(place === 'discover' ? 'discoverHelp' : 'healthHelp')}</p>
+      <p id="sx-ops-message" role="status" aria-live="polite"></p>
+      ${place === 'discover' ? discoverHTML(data) : healthHTML(data, usage, settings, config.scanners)}`);
+    async function action(fn) {
+      box.querySelectorAll('button, input').forEach((e) => { e.disabled = true; });
+      try { await fn(); if (alive()) renderOperationsPlace(host, ctx, place); }
+      catch (e) { if (alive()) { box.querySelectorAll('button, input').forEach((e) => { e.disabled = ctx.guest; }); setHTML(box.querySelector('#sx-ops-message'), html`<span class="sx-err-text">${t('failed', { error: studioErrorText(ctx.t, e) })}</span>`); } }
+    }
+    box.addEventListener('click', (event) => {
+      const button = event.target.closest('button[data-ops]'); if (!button || ctx.guest) return;
+      const act = button.dataset.ops;
+      if (act === 'save') action(() => ctx.api.configureSkillOperations({ telemetryEnabled: box.querySelector('#sx-usage-enabled').checked, retentionDays: Number(box.querySelector('#sx-retention').value), healthEnabled: box.querySelector('#sx-health-enabled').checked, cadenceHours: Number(box.querySelector('#sx-cadence').value), protectedSkillIds: [...box.querySelectorAll('input[data-protect]:checked')].map((e) => e.dataset.protect) }));
+      if (act === 'check') action(() => ctx.api.checkSkillHealth());
+      if (act === 'clear') action(async () => {
+        const answer = await ctx.ask({ title: t('clear'), lines: [t('clearHelp')], buttons: [{ id: 'cancel', label: ctx.t('skillsStudio.dialog.cancel') }, { id: 'go', label: t('clear'), kind: 'danger' }], focus: 'cancel' });
+        if (answer === 'go' && alive()) await ctx.api.clearSkillUsage();
+      });
+      if (act === 'enable') action(() => ctx.api.configureSkillOperations({ sources: settings.sources.includes(button.dataset.source) ? settings.sources.filter((s) => s !== button.dataset.source) : [...settings.sources, button.dataset.source] }));
+      if (act === 'refresh') action(() => ctx.api.refreshSkillDiscover(button.dataset.source));
+      if (act === 'stage') action(async () => { const result = await ctx.api.stageSkillDiscover(button.dataset.item); if (alive()) { ctx.openReview(result.reviewId); await ctx.reload(); } });
+      if (act === 'import-catalog') box.querySelector(`input[data-source="${button.dataset.source}"]`)?.click();
+    }, { signal });
+    box.addEventListener('change', (event) => {
+      const input = event.target;
+      if (!input.matches('input[type="file"]') || ctx.guest || !input.files?.[0]) return;
+      const file = input.files[0];
+      action(async () => { if (file.size > 1024 * 1024) throw new Error(t('catalogLimit')); const entries = JSON.parse(await file.text()); if (alive()) await ctx.api.importSkillDiscoverCatalog(input.dataset.source, entries); });
+    }, { signal });
+    box.querySelector('#sx-discover-search')?.addEventListener('input', (e) => { const q = e.target.value.toLowerCase(); box.querySelectorAll('[data-discover-search]').forEach((el) => { el.hidden = !el.dataset.discoverSearch.includes(q); }); }, { signal });
+  } catch (e) { if (alive()) setHTML(host.querySelector('#sx-operations'), html`<p class="sx-note sx-note--warn" role="alert">${t('failed', { error: studioErrorText(ctx.t, e) })}</p>`); }
+
+  function discoverHTML(data) {
+    return html`<p class="sx-note">${t('disclosure')}</p><div class="sx-ops-grid">${data.sources.map((s) => html`<section class="sx-ops-card">
+      <h4 class="sx-section-title">${s.label}${s.deprecated ? ` · ${t('deprecated')}` : ''}</h4><p class="sx-help">${s.licenseCode ? t(`licenses.${s.licenseCode}`) : s.license}</p>
+      <p class="sx-help">${t(s.enabled ? 'enabled' : 'disabled')}${s.error ? html` · ${studioErrorText(ctx.t, { code: s.error })}` : ''}</p>
+      <div class="sx-row"><button class="sx-btn" type="button" data-ops="enable" data-source="${s.id}"${attr('disabled', ctx.guest)}>${t(s.enabled ? 'disableSource' : 'enableSource')}</button>
+      ${s.enabled ? html`<button class="sx-btn" type="button" data-ops="${s.transport === 'github' ? 'refresh' : 'import-catalog'}" data-source="${s.id}"${attr('disabled', ctx.guest)}>${t(s.transport === 'github' ? 'refresh' : 'importCatalog')}</button>` : ''}</div>
+      ${s.transport === 'catalog-import' ? html`<p class="sx-help">${t('catalogHelp')}</p><input type="file" accept="application/json,.json" data-source="${s.id}" hidden>` : ''}
+    </section>`)}</div>
+    <label class="sx-field-label" for="sx-discover-search">${t('search')}</label><input class="sx-input" id="sx-discover-search" type="search">
+    <p class="sx-help">${t('cached', { count: data.items.length })}</p>
+    <div class="sx-ops-grid">${data.items.map((i) => html`<article class="sx-ops-card" data-discover-search="${`${i.name} ${i.repo} ${i.subpath}`.toLowerCase()}">
+      <h4 class="sx-section-title">${i.name}</h4><p class="sx-help">${i.repo} · ${i.subpath}</p><code>${i.commit}</code><p class="sx-help">${i.licenseCode ? t(`licenses.${i.licenseCode}`) : i.license}</p>
+      <button class="sx-btn" type="button" data-ops="stage" data-item="${i.id}"${attr('disabled', ctx.guest)}>${ICONS.review} ${t('stage')}</button>
+    </article>`)}</div>`;
+  }
+  function healthHTML(data, usage, settings, scanners) {
+    const nameOf = (id) => ctx.data?.skills?.find((s) => s.skillId === id)?.name || id;
+    return html`<div class="sx-ops-grid"><section class="sx-ops-card">
+      <h4 class="sx-section-title">${t('collection')}</h4><label class="sx-choice"><input type="checkbox" id="sx-usage-enabled"${attr('checked', settings.telemetryEnabled)}${attr('disabled', ctx.guest)}> ${t('collect')}</label>
+      <label class="sx-field-label" for="sx-retention">${t('retention')}</label><input class="sx-input" type="number" id="sx-retention" min="1" max="365" value="${settings.retentionDays}"${attr('disabled', ctx.guest)}>
+      <p class="sx-help">${t('privacy')}</p><button class="sx-btn" type="button" data-ops="clear"${attr('disabled', ctx.guest)}>${t('clear')}</button>
+    </section><section class="sx-ops-card"><h4 class="sx-section-title">${t('scheduleTitle')}</h4>
+      <label class="sx-choice"><input type="checkbox" id="sx-health-enabled"${attr('checked', settings.healthEnabled)}${attr('disabled', ctx.guest)}> ${t('schedule')}</label>
+      <label class="sx-field-label" for="sx-cadence">${t('cadence')}</label><input class="sx-input" type="number" id="sx-cadence" min="1" max="168" value="${settings.cadenceHours}"${attr('disabled', ctx.guest)}>
+      <p class="sx-help">${t('lastCheck', { at: data.checkedAt ? new Date(data.checkedAt).toLocaleString() : t('never') })}</p>
+      <button class="sx-btn" type="button" data-ops="check"${attr('disabled', ctx.guest || data.running)}>${t('check')}</button>
+    </section></div><button class="sx-btn sx-btn--primary" type="button" data-ops="save"${attr('disabled', ctx.guest)}>${t('save')}</button>
+    <h4 class="sx-section-title">${t('protected')}</h4><p class="sx-help">${t('protectedHelp')}</p><div class="sx-ops-grid">${protectionEntries(ctx.data?.skills || []).map((s) => html`<label class="sx-choice"><input type="checkbox" data-protect="${s.skillId}"${attr('checked', settings.protectedSkillIds.includes(s.skillId))}${attr('disabled', ctx.guest)}> ${s.name} · ${ctx.t(`skillsStudio.versions.source.${s.sourceCode}`)} · ${s.detail}</label>`)}</div>
+    <h4 class="sx-section-title">${t('coverage')}</h4><ul class="sx-plain-list">${['claude', 'codex', 'opencode'].map((r) => html`<li>${t(`coverage_${r}`)}</li>`)}</ul>
+    <h4 class="sx-section-title">${t('usage')}</h4>${usage.rows.length ? html`<div class="sx-ops-grid">${usage.rows.map((r) => html`<article class="sx-ops-card"><strong>${nameOf(r.skillId)} · ${r.runtime}</strong><p class="sx-help">${r.revisionId}</p><p>${t('counts', r)}</p></article>`)}</div>` : html`<p class="sx-help">${t('noUsage')}</p>`}
+    <h4 class="sx-section-title">${t('installations')}</h4>${data.rows.length ? html`<div class="sx-ops-grid">${data.rows.map((r) => html`<article class="sx-ops-card"><strong>${r.name || nameOf(r.skillId)} · ${r.runtime}</strong>
+      <p class="sx-help">${r.revisionId}</p><p class="${r.issues.length ? 'sx-warn-text' : 'sx-help'}">${t(`state_${r.status}`)}</p>
+      <ul class="sx-plain-list">${r.issues.map((i) => html`<li>${t(`issue_${i}`)}</li>`)}</ul>
+      ${r.scan ? html`<p class="sx-help">${r.scan.engine} ${r.scan.engineVersion} · ${r.scan.policy}</p><ul class="sx-plain-list">${r.scan.findings.slice(0, 12).map((f) => html`<li>${f.severity} · ${f.ruleId} · ${f.file || ''}${f.line ? `:${f.line}` : ''} — ${scanFindingText(t, f)}</li>`)}</ul>` : ''}
+    </article>`)}</div>` : html`<p class="sx-help">${t('noChecks')}</p>`}
+    <h4 class="sx-section-title">${t('proposals')}</h4><p class="sx-help">${t('proposalHelp')}</p><ul class="sx-plain-list">${data.proposals.map((p) => html`<li>${nameOf(p.skillId)} · ${p.runtime} · ${t('proposalFailures', { count: p.evidence.failures })}</li>`)}</ul>
+    <h4 class="sx-section-title">${t('scanners')}</h4><p class="sx-help">${t('scannerHelp')}</p><ul class="sx-plain-list">${scanners.map((s) => html`<li>${s.id} · ${s.licenseCode ? t(`licenses.${s.licenseCode}`) : s.license} · ${s.enabled ? `${t('enabled')} · ` : ''}${t(scannerState(s))}</li>`)}</ul>`;
+  }
+}

package/neural-interface/public/shared/skills/studio/sx-operations.js

@@ -0,0 +1,11 @@
+// Protection is per immutable library identity. Distinct records with the same name must remain separately selectable.
+export function protectionEntries(skills) {
+  return [...new Map(skills.map((s) => [s.skillId, s])).values()].map((s) => ({ ...s,
+    sourceCode: ['bundled', 'adopted', 'import', 'local', 'assistant', 'github'].includes(s.origin?.kind) ? s.origin.kind : 'local',
+    detail: [s.origin?.path, s.skillId].filter(Boolean).join(' · '),
+  }));
+}
+
+export function scannerState(scanner) {
+  return !scanner.enabled ? 'disabled' : scanner.available && scanner.status === 'ready' ? 'ready' : 'unavailable';
+}

package/neural-interface/public/shared/skills/studio/sx-plan.js

@@ -0,0 +1,158 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Skills Studio 2.0: an install plan, its outcome and its checks, as codes
+// ═══════════════════════════════════════════
+//
+// The Publish tab installs one revision into the targets the owner picks, in the service's two steps
+// (lib/skills/deploy.js): a plan (POST /v2/installations/plan: per target where it goes, who reads that folder,
+// what is there now, the checks of the exported bytes, what blocks it, what needs the owner's confirmation, how a
+// running session picks it up), then an install of exactly that plan (its digest) with only what the owner
+// confirmed. This module turns a plan, an install's answer and a verify into rows of codes the view words
+// (`skillsStudio.publish.*`); a message the service wrote (a reason it blocks) is kept as data next to its code.
+// Nothing is confirmed by default. No DOM and no imports.
+
+export const BLOCK_CODES = Object.freeze(['no_root', 'shared_root_off', 'root_read_only', 'root_unusable', 'lint_errors', 'scan_blocked', 'review_required', 'approval_stale', 'destination_unreadable']);
+// panel-reload: SynaBun's own Codex / OpenCode panel lists the skill now (Codex: a forced reload of its skill list on
+// skills:changed; OpenCode: its serve reads the folders again on every listing); a session open in a terminal needs a
+// new one. new-session stays for a server from before this.
+// terminal-only: a Claude Code folder OpenCode reads only outside SynaBun (its own serves start with
+// OPENCODE_DISABLE_CLAUDE_CODE=1): install for OpenCode for SynaBun's panel and an OpenCode Assistant.
+export const REFRESH_KINDS = Object.freeze(['automatic', 'reload-skills', 'new-session', 'panel-reload', 'terminal-only']);
+// Why a runtime could not be asked on Verify (lib/skills/runtime-checks.js probe, deploy.js verify): each has its words.
+export const PROBE_CODES = Object.freeze(['not-installed', 'not-running', 'no-answer', 'no-list', 'terminal-only']);
+export const ELIGIBILITY_STATES = Object.freeze(['enabled', 'disabled', 'unknown']);
+export const ELIGIBILITY_REASONS = Object.freeze(['codex-config', 'claude-override', 'claude-deny', 'opencode-permission', 'unreadable', 'invalid-json']);
+export const RESULT_STATES = Object.freeze(['committed', 'skipped', 'needs-confirmation', 'failed']);
+
+const list = (v) => (Array.isArray(v) ? v : []);
+
+// ── What Publish holds ──
+// A workspace's Publish state: the targets ticked (null until the first drawing picks them), the projects shown,
+// the plan with exactly what it was asked for (`planRevision`, `planTargets`), what the owner confirmed of it, the
+// last install's outcome, the verifies, and whether a request is on its way (`busy`: the targets and the version
+// are locked meanwhile).
+
+/**
+ * Publish as it starts: nothing ticked yet (the first drawing picks the defaults), every project in one scope, no
+ * plan and none on its way, nothing confirmed, Advanced and Export folded.
+ */
+export function newPublishState() {
+  return { checked: null, projects: [], scope: 'user', plan: null, planTargets: null, planRevision: null, planning: null, planError: null, planTimer: 0, confirmed: { replace: new Set(), scan: new Set() }, results: null, verify: {}, busy: false, config: null, advanced: false, exportOpen: false };
+}
+
+/** Forget a plan and what was confirmed of it: a plan is installed only for what it was asked for. */
+export function clearPlan(pub) {
+  if (!pub) return;
+  pub.plan = null;
+  pub.planTargets = null;
+  pub.planRevision = null;
+  pub.planError = null;
+  pub.confirmed = { replace: new Set(), scan: new Set() };
+}
+
+/**
+ * Publish shows another version (its dropdown, Versions' "Publish this"): the plan made for the one before goes,
+ * and so does the review it was installing when that review is of another version.
+ * @param {object} ws a workspace @param {string|null} revisionId @param {{ reviews?: object[] }} [o] the reviews read
+ */
+export function choosePublishRevision(ws, revisionId, { reviews = [] } = {}) {
+  if (ws.publishReviewId) {
+    const review = list(reviews).find((r) => r?.reviewId === ws.publishReviewId);
+    if (review?.submittedRevisionId !== revisionId) ws.publishReviewId = null;
+  }
+  ws.publishRevisionId = revisionId || null;
+  if (ws.pub) { clearPlan(ws.pub); ws.pub.results = null; }
+}
+
+/**
+ * One row per target of a plan.
+ * @returns {{ planDigest: string|null, revisionId: string|null, name: string, rows: object[] }}
+ */
+export function planModel(plan) {
+  const rows = list(plan?.targets).map((t) => {
+    const replace = list(t.needs).find((n) => n.code === 'confirm_replace') || null;
+    const scanAck = list(t.needs).find((n) => n.code === 'acknowledge_scan') || null;
+    const blocked = list(t.blocked).map((b) => ({ code: BLOCK_CODES.includes(b.code) ? b.code : 'other', message: String(b.message ?? '') }));
+    return {
+      targetKey: t.targetKey,
+      runtime: t.runtime, scope: t.scope || 'user', accountId: t.accountId || 'default', projectPath: t.projectPath || null,
+      destination: t.destination || null,
+      affectedRuntimes: list(t.affectedRuntimes),
+      status: blocked.length ? 'blocked' : (list(t.needs).length ? 'needs' : 'ready'),
+      blocked,
+      state: t.destinationState?.state || null,
+      installedBySynabun: !!t.destinationState?.installedBySynabun,
+      replace: replace ? { currentDigest: replace.currentDigest ?? null, state: t.destinationState?.state || null, message: String(replace.message ?? '') } : null,
+      scanAck: scanAck ? { digest: scanAck.digest, findings: list(t.scan?.findings).slice(0, 12) } : null,
+      transforms: list(t.export?.transforms).map((tr) => ({ op: tr.op, key: tr.key || null, file: tr.file || null, reason: String(tr.reason ?? '') })),
+      overlap: list(t.overlap).map((o) => ({ path: o.path, runtimes: list(o.runtimes), name: typeof o.name === 'string' ? o.name : (t.name || plan?.name || ''), why: String(o.why ?? '') })),
+      name: typeof t.name === 'string' ? t.name : (plan?.name || ''),
+      lint: { errors: Number(t.lint?.errors) || 0, warnings: Number(t.lint?.warnings) || 0, diagnostics: list(t.lint?.diagnostics).slice(0, 50) },
+      scan: { status: t.scan?.status || null, gate: t.scan?.gate || null, counts: t.scan?.counts || {}, trusted: !!t.scan?.trustedBundled, disclosure: t.scan?.disclosure || '' },
+      refresh: list(t.refresh).map((r) => ({ runtime: r.runtime, kind: REFRESH_KINDS.includes(r.kind) ? r.kind : 'unknown', message: String(r.message ?? '') })),
+      // Whether each runtime's own settings let the skill through (a server from before this says nothing: unknown).
+      eligibility: Object.fromEntries(Object.entries(t.eligibility && typeof t.eligibility === 'object' ? t.eligibility : {}).map(([runtime, e]) => [runtime, {
+        state: ELIGIBILITY_STATES.includes(e?.state) ? e.state : 'unknown',
+        reason: e?.reason && typeof e.reason === 'object' ? { kind: ELIGIBILITY_REASONS.includes(e.reason.kind) ? e.reason.kind : 'other', file: typeof e.reason.file === 'string' ? e.reason.file : null, pattern: typeof e.reason.pattern === 'string' ? e.reason.pattern : null, rule: typeof e.reason.rule === 'string' ? e.reason.rule : null, key: typeof e.reason.key === 'string' ? e.reason.key : null } : null,
+      }])),
+    };
+  });
+  return { planDigest: plan?.planDigest || null, revisionId: plan?.revisionId || null, name: plan?.name || '', rows };
+}
+
+/**
+ * The decisions an install sends: for each target exactly what the owner confirmed (the digest of what is there
+ * now, the digest whose scan findings were read).
+ * @param {object} model planModel()
+ * @param {{ replace?: Iterable<string>, scan?: Iterable<string> }} confirmed target keys
+ */
+export function decisionsOf(model, { replace = [], scan = [] } = {}) {
+  const r = new Set(replace); const s = new Set(scan);
+  const out = {};
+  for (const row of model.rows) {
+    const d = {};
+    if (row.replace && r.has(row.targetKey)) d.expectedDestinationDigest = row.replace.currentDigest;
+    if (row.scanAck && s.has(row.targetKey)) d.acknowledgedDigest = row.scanAck.digest;
+    if (Object.keys(d).length) out[row.targetKey] = d;
+  }
+  return out;
+}
+
+/** The targets an install with these confirmations would write (not blocked, and everything asked confirmed). */
+export function installableRows(model, { replace = [], scan = [] } = {}) {
+  const r = new Set(replace); const s = new Set(scan);
+  return model.rows.filter((row) => row.status !== 'blocked' && (!row.replace || r.has(row.targetKey)) && (!row.scanAck || s.has(row.targetKey)));
+}
+
+/** The outcome per target of an install (200 or 207), never one word for all. */
+export function resultModel(result) {
+  return list(result?.results).map((r) => ({
+    targetKey: r.targetKey,
+    status: RESULT_STATES.includes(r.status) ? r.status : 'failed',
+    unchanged: !!r.unchanged,
+    installationId: r.installationId || null,
+    backupId: r.backupId || null,
+    reasons: list(r.reasons).map((x) => ({ code: x.code || 'other', message: String(x.message ?? '') })),
+    error: r.error ? String(r.error) : null, ...(r.code ? { code: r.code } : {}),
+    refresh: list(r.refresh).map((x) => ({ runtime: x.runtime, kind: REFRESH_KINDS.includes(x.kind) ? x.kind : 'unknown', message: String(x.message ?? '') })),
+  }));
+}
+
+/** What a verify found, fact by fact; nothing is claimed that the service did not establish ("loaded" never is). */
+export function verifyFacts(installation) {
+  const s = installation?.state || {};
+  const written = s.writtenCheck || (s.written === true ? 'verified' : s.written === false ? 'changed' : 'unknown');
+  const discovered = s.discovered && typeof s.discovered === 'object'
+    ? Object.entries(s.discovered).map(([runtime, v]) => ({ runtime, discovered: v?.discovered ?? (typeof v === 'boolean' ? v : null), error: v?.error || null, code: PROBE_CODES.includes(v?.code) ? v.code : null }))
+    : [];
+  return {
+    written,
+    discoverable: s.discoverable === true ? 'yes' : s.discoverable === false ? 'no' : 'unknown',
+    eligibility: ['enabled', 'disabled'].includes(s.eligibility) ? s.eligibility : 'unknown',
+    discovered,
+    checks: list(s.checks).map((c) => ({ runtime: c.runtime || null, ok: !!c.ok, message: String(c.message ?? '') })),
+    checkedAt: s.checkedAt || null,
+  };
+}
+
+/** Whether an error of a rollback / uninstall asks the owner to confirm the folder as it is now. */
+export const needsConfirmation = (err) => err?.status === 409 && (err.code === 'rollback_conflict' || err.code === 'uninstall_conflict') && typeof err.body?.currentDigest === 'string';