synabun 2.0.9 → 2.1.0

package/neural-interface/lib/sqlite-integrity-worker.js

@@ -0,0 +1,22 @@
+// SQLite's PRAGMA integrity_check on each database copy of an upgrade snapshot, off the snapshot's main thread
+// (backup-service.js checkSqliteIntegrity): the archive is written and read back meanwhile. workerData: { paths };
+// posts [{ path, ok, lines, ms }] once, in the same order. A file that cannot be opened is not ok.
+import { parentPort, workerData } from 'node:worker_threads';
+import { DatabaseSync } from 'node:sqlite';
+
+const results = [];
+for (const path of workerData?.paths || []) {
+  const started = Date.now();
+  let db = null;
+  try {
+    db = new DatabaseSync(path, { readOnly: true });
+    // The check `synabun restore-backup` runs (scripts/restore-data-home-from-backup.mjs); 20 findings are plenty to say why.
+    const lines = db.prepare('PRAGMA integrity_check(20)').all().map(row => String(Object.values(row)[0]));
+    results.push({ path, ok: lines.length === 1 && lines[0] === 'ok', lines: lines.slice(0, 20), ms: Date.now() - started });
+  } catch (error) {
+    results.push({ path, ok: false, lines: [String(error?.message || error)], ms: Date.now() - started });
+  } finally {
+    try { db?.close(); } catch { /* already closed */ }
+  }
+}
+parentPort.postMessage(results);

package/neural-interface/lib/style-guide/api.js

@@ -47,6 +47,7 @@ import { EXPORT_FORMATS, StyleGuideError, renderFormat } from './store.js';
 import { estimateTokens, styleGuideSummaryForClass } from './summary.js';
 import { resolvedTokens } from './tokens.js';
 import { safeLogoFile } from './security.js';
+import { setUntrustedFileHeaders } from '../untrusted-file-headers.js';
 
 const LOGO_TYPES = Object.freeze({ 'image/png': '.png', 'image/svg+xml': '.svg', 'image/jpeg': '.jpg', 'image/webp': '.webp' });
 const SAVE_SOURCE_RE = /^(ui|import:[a-z-]{1,24}|preset:[a-z0-9-]{1,40})$/;
@@ -367,9 +368,9 @@ export function registerStyleGuideRoutes(app, { store, fetchImpl = null, log = (
     if (!full.startsWith(store.assetsDir + sep)) return res.status(403).json({ ok: false, error: 'Forbidden' });
     if (!existsSync(full)) return res.status(404).json({ ok: false, error: 'Not found' });
     store.assertPath(store.assetsDir, full);
-    // An uploaded SVG is served as a file to look at, never as a page that can run script on this origin.
-    res.set('Content-Security-Policy', "default-src 'none'; style-src 'unsafe-inline'; sandbox");
-    res.set('X-Content-Type-Options', 'nosniff');
+    // An uploaded SVG is served as a file to look at, never as a page that can run script on this origin
+    // (and opened by its address, a download).
+    setUntrustedFileHeaders(res, file);
     res.sendFile(full);
   }));
 }

package/neural-interface/lib/tool-lists.js

@@ -0,0 +1,124 @@
+// Neural Interface's storage boundary. Catalog and resolution belong to mcp-server.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { parseToolList, resolveToolList, serializeToolList } from '../../mcp-server/dist/services/tool-list.js';
+
+export function requireToolList(result) {
+  if (!result.ok) throw Object.assign(new Error(result.message), result, { status: 400 });
+  return result;
+}
+
+// Run 1 treats a blank environment variable/header as absent. The accepted always-on id
+// carries an explicit empty selection across those transports without falling back to all.
+export function runtimeToolsValue(items) {
+  return serializeToolList(items) || 'memory';
+}
+
+/** null is inherited; [] is an explicit selection of always-on tools only. */
+export function storedToolList(record, { customPresets = null } = {}) {
+  if (!record || typeof record !== 'object') return null;
+  if (record.tools !== undefined && record.tools !== null) {
+    if (!Array.isArray(record.tools)) throw Object.assign(new Error('tools must be an array'), { code: 'TOOLS_INVALID', status: 400 });
+    return requireToolList(resolveToolList(requireToolList(parseToolList(record.tools)).items, { source: 'runtime' })).items;
+  }
+  const legacy = record.mcpProfile;
+  if (legacy === undefined || legacy === null || legacy === '') return null;
+  if (typeof legacy !== 'string') throw Object.assign(new Error('mcpProfile must be a string'), { code: 'TOOLS_INVALID', status: 400 });
+  if (!legacy.trim()) return null;
+  const parsed = requireToolList(parseToolList(legacy, { legacy: true, customPresets }));
+  return requireToolList(resolveToolList([...parsed.items, 'mcp:*'], { source: 'runtime' })).items;
+}
+
+/** Disk records written before external scoping inherited their provider's servers, even with an empty group list. */
+export function readStoredToolListRecord(record, options) {
+  const tools = storedToolList(record, options);
+  const migrated = tools !== null && record.externalMcpVersion !== 2 && !tools.some(item => item.startsWith('mcp:'))
+    ? [...tools, 'mcp:*'] : tools;
+  return toolListRecord({ ...record, ...(migrated === null ? {} : { tools: migrated }) }, options);
+}
+
+export function automationPlatform(schedule, group, template) {
+  for (const record of [template, schedule, group]) if (record?.platform) return record.platform;
+  for (const record of [schedule, group, template]) {
+    if (typeof record?.mcpProfile !== 'string') continue;
+    const parsed = parseToolList(record.mcpProfile, { legacy: true });
+    if (parsed.ok && parsed.platform) return parsed.platform;
+  }
+  const id = String(schedule?.templateId || template?.id || schedule?.id || '');
+  if (/^(cpfb_|fbdeals_)/.test(id)) return 'facebook';
+  if (/^cp_/.test(id)) return 'twitter';
+  return null;
+}
+
+/** A copy for persistence: never rewrite a source record just because it was read. */
+export function toolListRecord(record, options) {
+  const next = { ...record, externalMcpVersion: 2 };
+  const tools = storedToolList(record, options);
+  const platform = automationPlatform(record);
+  if (tools === null) delete next.tools;
+  else next.tools = tools;
+  if (platform) next.platform = platform;
+  delete next.mcpProfile;
+  return next;
+}
+
+/** An unrelated edit must not persist a read-time external-scope migration. */
+export function toolListRecordForUpdate(record, previous, options) {
+  const next = toolListRecord(record, options);
+  if (!previous || previous.mcpProfile != null) return next;
+  const before = storedToolList(readStoredToolListRecord(previous, options), options);
+  if (serializeToolList(next.tools ?? []) !== serializeToolList(before ?? [])
+      || (next.tools == null) !== (before == null)) return next;
+  // Keep the exact stored representation, including absent/null, legacy [] and version metadata.
+  for (const key of ['tools', 'externalMcpVersion']) {
+    delete next[key];
+    if (Object.hasOwn(previous, key)) next[key] = Array.isArray(previous[key]) ? [...previous[key]] : previous[key];
+  }
+  return next;
+}
+
+/** Apply an array patch while preserving stored legacy platform hints. */
+export function applyStoredToolList(record, patch, options) {
+  if (patch.tools === undefined) return record;
+  const source = { ...record, ...patch, platform: patch.platform || automationPlatform(record) };
+  delete source.mcpProfile;
+  const next = toolListRecord(source, options);
+  delete record.mcpProfile;
+  delete record.tools;
+  if (next.tools !== undefined) record.tools = next.tools;
+  if (next.platform) record.platform = next.platform;
+  return record;
+}
+
+export function resolveStoredTools(record, context = {}, options) {
+  const stored = storedToolList(record, options);
+  return requireToolList(resolveToolList(stored ?? undefined, { source: 'launch', usesBrowser: record?.usesBrowser, taskClass: record?.taskClass, ...context }));
+}
+
+export function readDefaultTools(dataHome, options) {
+  const path = resolve(dataHome, 'data', 'default-tools.json');
+  if (existsSync(path)) {
+    const record = JSON.parse(readFileSync(path, 'utf8'));
+    if (!Array.isArray(record.tools)) throw Object.assign(new Error('Default tools must be an array'), { code: 'TOOLS_INVALID', status: 400 });
+    return storedToolList(readStoredToolListRecord(record, options), options);
+  }
+  for (const dir of ['mcp-data', 'data']) {
+    const legacyPath = resolve(dataHome, dir, 'active-profile.json');
+    if (!existsSync(legacyPath)) continue;
+    const record = JSON.parse(readFileSync(legacyPath, 'utf8'));
+    const tools = storedToolList({ mcpProfile: record.profile }, options);
+    if (tools !== null) return tools;
+  }
+  return ['all', 'mcp:*'];
+}
+
+export function writeDefaultTools(dataHome, tools) {
+  const items = storedToolList({ tools });
+  if (items === null) throw Object.assign(new Error('tools must be an array'), { code: 'TOOLS_INVALID', status: 400 });
+  const path = resolve(dataHome, 'data', 'default-tools.json');
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ tools: items, externalMcpVersion: 2, updatedAt: new Date().toISOString() }, null, 2) + '\n', { mode: 0o600 });
+  renameSync(tmp, path);
+  return items;
+}

package/neural-interface/lib/untrusted-file-headers.js

@@ -0,0 +1,27 @@
+// The headers of a file a user uploaded or an agent made, served back to the page: a pasted or generated image, a
+// category logo, a custom file icon, a Skills Studio icon, a Style Guide logo, an Assistant run's media. An <img> or
+// <video> in the app shows it as before (it ignores all three); opened by its address it runs nothing. An SVG is a
+// document that can carry script, so it also comes as a download there. tests/untrusted-file-headers.test.mjs.
+import { basename } from 'node:path';
+
+/** No script, no request, no plugin, no form; a unique origin (sandbox). Inline styles stay, so an SVG still draws. */
+export const UNTRUSTED_FILE_CSP = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
+
+/** Is this file an SVG, by its name or by the type it is sent as? */
+export function isSvgFile(name, type = '') {
+  return /\.svg$/i.test(String(name || '')) || /^image\/svg\+xml\b/i.test(String(type || ''));
+}
+
+/**
+ * Set the three headers on `res` (an Express response) for the file `name` (a path or a file name) sent as `type`.
+ * Call it before the body goes out; it does not touch Content-Type.
+ */
+export function setUntrustedFileHeaders(res, name, type = '') {
+  res.setHeader('Content-Security-Policy', UNTRUSTED_FILE_CSP);
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  if (isSvgFile(name, type)) {
+    const file = basename(String(name || '')) || 'image.svg';
+    const ascii = file.replace(/[^\x20-\x7e]|["\\]/g, '_');
+    res.setHeader('Content-Disposition', ascii === file ? `attachment; filename="${file}"` : `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(file)}`);
+  }
+}

package/neural-interface/lib/whatsapp/bridge.js

@@ -57,6 +57,7 @@
 // composition are injected (Packages A and C); nothing here knows a phone number.
 
 import { assistantEventKey } from '../../public/shared/assistant/asst-state.js';
+import { stripFollowups } from '../../public/shared/assistant/asst-followups.js';
 import { brainCapsLevel, defaultRemotePolicyRegistry, effectiveLevel, remoteBrainNotice } from '../remote-policy.js';
 import { brainSignature, resolveBrainChoice } from './brain.js';
 import { answerCard, cardFromPacket, failClosedResponse, isBareAnswer, randomTag, renderCard } from './cards.js';
@@ -646,12 +647,14 @@ export function createWhatsAppBridge({
   function finalText(turn) {
     const segments = turn.segments.filter(Boolean);
     const result = typeof turn.resultText === 'string' ? turn.resultText.trim() : '';
-    const final = result || segments[segments.length - 1] || '';
+    const raw = result || segments[segments.length - 1] || '';
+    // A follow-ups block is the panel's buttons: a phone gets the words around it.
+    const final = stripFollowups(raw).trim();
     if (!final) return '';
     if (final.length < 200) {
-      const earlier = segments.filter((segment) => segment !== final && segment.length >= 280);
+      const earlier = segments.filter((segment) => segment !== raw && segment !== final && segment.length >= 280);
       const lead = earlier[earlier.length - 1];
-      if (lead && !turn.narrated?.has(lead)) return `${lead}\n\n${final}`;
+      if (lead && !turn.narrated?.has(lead)) return `${stripFollowups(lead).trim()}\n\n${final}`;
     }
     return final;
   }