@friggframework/core 2.0.0--canary.703.12b980b.0 → 2.0.0--canary.707.df80bfd.0

package/integrations/definitions/interpreter.js

@@ -1,104 +0,0 @@
-/**
- * Runs a list of steps against a context. Pure apart from the ports it is given:
- *   ports.call(moduleKey, capability, args)   a module capability (the runtime maps it to Api.<method>)
- *   ports.links.find / ports.links.upsert       the link + identity store (IntegrationMapping rows)
- *   ports.runCode(ref, args)                    registered code steps (optional)
- *
- * Every step leaves a trace entry: { id, use, status, ms, error? }. A step's result is stored at $.steps.<id>.
- * onError per step: 'fail' (default: throw, so the queue retries the whole run), 'continue' (result null), 'stop'.
- *
- * A pausing step (delay, approval) ends the run for now with status 'waiting': the caller saves a checkpoint (the
- * step's index, $.steps and $.vars) and later calls execute again with startAt = index + 1 and the wait step's
- * result in ctx.steps. Pausing steps run only at the top level, so an index is the whole position.
- */
-const { resolve, evaluate } = require('./expressions');
-const { BUILTINS, FOREACH_HARD_CAP, PAUSING, isBuiltin, splitCapability } = require('./steps');
-
-class StopRun extends Error { constructor(reason) { super(reason); this.name = 'StopRun'; this.reason = reason; } }
-class WaitRun extends Error { constructor(index, id, wait) { super(`waiting at ${id}`); this.name = 'WaitRun'; Object.assign(this, { index, id, wait }); } }
-
-async function runSteps(steps, env, path = 'steps', startAt = 0) {
-    const { ctx, trace } = env;
-    for (let i = startAt; i < (steps || []).length; i++) {
-        const step = steps[i];
-        const id = step.id || `${step.use}#${i}`;
-        const at = `${path}[${i}]`;
-        if (step.when && !evaluate(step.when, ctx)) { trace.push({ id, use: step.use, at, status: 'skipped' }); continue; }
-        const t0 = Date.now();
-        try {
-            let out;
-            if (step.use === 'foreach') {
-                const all = resolve(step.with?.over, ctx) ?? [];
-                if (!Array.isArray(all)) throw new Error('foreach: `over` is not an array');
-                const max = Math.min(step.with?.max || 100, FOREACH_HARD_CAP);
-                const saved = { item: ctx.item, index: ctx.index };
-                // `where` is checked per item, before the cap, so max bounds the work actually done.
-                const items = [];
-                for (const [n, item] of all.entries()) {
-                    ctx.item = item; ctx.index = n;
-                    if (!step.with?.where || evaluate(step.with.where, ctx)) items.push(item);
-                }
-                Object.assign(ctx, saved);
-                const collect = step.with && 'collect' in step.with;
-                out = [];
-                for (const [n, item] of items.slice(0, max).entries()) {
-                    ctx.item = item; ctx.index = n;
-                    await runSteps(step.do || [], env, `${at}.do#${n}`);
-                    out.push(collect
-                        ? resolve(step.with.collect, ctx)
-                        : Object.fromEntries((step.do || []).filter((s) => s.id).map((s) => [s.id, ctx.steps[s.id]])));
-                    Object.assign(ctx, saved);
-                }
-                if (items.length > max) trace.push({ id, use: 'foreach', at, status: 'truncated', note: `${items.length - max} items over max ${max}` });
-            } else if (step.use === 'branch') {
-                const hit = (step.cases || []).find((c) => evaluate(c.when, ctx));
-                await runSteps(hit ? hit.do : step.else || [], env, `${at}.${hit ? 'case' : 'else'}`);
-                out = { matched: hit ? hit.when : null };
-            } else if (isBuiltin(step.use)) {
-                if (PAUSING.has(step.use) && path !== 'steps') throw new Error(`${step.use} can only be a top-level workflow step`);
-                out = await BUILTINS[step.use].run(resolve(step.with || {}, ctx), { ...env, now: ctx.now });
-                if (out && out.wait) {
-                    if (!env.canWait) throw new Error(`${step.use} can only be a top-level workflow step`);
-                    trace.push({ id, use: step.use, at, status: 'waiting', ms: Date.now() - t0, until: out.wait.until });
-                    throw new WaitRun(i, id, out.wait);
-                }
-                if (out && out.stop) { ctx.steps[id] = out; trace.push({ id, use: step.use, at, status: 'stopped', ms: Date.now() - t0, reason: out.reason }); throw new StopRun(out.reason); }
-            } else {
-                const cap = splitCapability(step.use);
-                if (!cap) throw new Error(`Unknown step "${step.use}"`);
-                out = await env.ports.call(cap.module, cap.capability, resolve(step.with || {}, ctx));
-            }
-            ctx.steps[id] = out === undefined ? null : out;
-            trace.push({ id, use: step.use, at, status: 'ok', ms: Date.now() - t0 });
-        } catch (e) {
-            if (e instanceof StopRun || e instanceof WaitRun) throw e;
-            const policy = step.onError || 'fail';
-            trace.push({ id, use: step.use, at, status: 'error', ms: Date.now() - t0, error: String(e && e.message || e), policy });
-            if (policy === 'continue') { ctx.steps[id] = null; continue; }
-            if (policy === 'stop') throw new StopRun(`step ${id} failed`);
-            throw e;
-        }
-    }
-}
-
-/**
- * Run steps and report the outcome instead of throwing for a normal stop or pause.
- * @param {object} p
- * @param {boolean} [p.canWait]  a workflow run (pausing steps allowed); queries and lifecycle steps cannot pause
- * @param {number} [p.startAt]   resume: the index of the first step to run (ctx.steps/ctx.vars carry the earlier ones)
- * @returns {Promise<{status:'completed'|'stopped'|'waiting', reason?, steps, vars, trace, wait?: {index, id, ...}}>}
- */
-async function execute(steps, { def, installation, ctx, ports, canWait = false, startAt = 0 }) {
-    const env = { def, installation, ports, canWait, trace: [], ctx: { steps: {}, vars: {}, ...ctx } };
-    try {
-        await runSteps(steps, env, 'steps', startAt);
-        return { status: 'completed', steps: env.ctx.steps, vars: env.ctx.vars, trace: env.trace };
-    } catch (e) {
-        if (e instanceof StopRun) return { status: 'stopped', reason: e.reason, steps: env.ctx.steps, vars: env.ctx.vars, trace: env.trace };
-        if (e instanceof WaitRun) return { status: 'waiting', wait: { index: e.index, id: e.id, ...e.wait }, steps: env.ctx.steps, vars: env.ctx.vars, trace: env.trace };
-        e.trace = env.trace;
-        throw e;
-    }
-}
-
-module.exports = { execute, runSteps, StopRun, WaitRun };

package/integrations/definitions/manifests.js

@@ -1,177 +0,0 @@
-/**
- * Validate a capability manifest (v0.1): the module author's promise of what a definition may call. Definitions are
- * validated against manifests, so a broken manifest would let a broken definition through; this checks the manifest
- * itself.
- *
- * @param {object} m  capabilities/<module>.capabilities.json
- * @returns {{ valid: boolean, errors: Array<{path:string,message:string}> }}
- */
-const { templateTags, parseCondition, FILTERS } = require('./expressions');
-const { eventsIn } = require('./webhooks');
-
-const PATH_RE = /^\$\.[A-Za-z_][\w-]*(\.[\w-]+|\[\d+\])*$/;
-const KINDS = new Set(['read', 'search', 'write', 'delete', 'subscribe']); // schema/capability-manifest.v0.1.schema.json
-const READS = new Set(['read', 'search']);
-
-function validateManifest(m) {
-    const errors = [];
-    const err = (path, message) => errors.push({ path, message });
-    if (!m || typeof m !== 'object') return { valid: false, errors: [{ path: '', message: 'Manifest must be an object' }] };
-    if (!/^[a-z][a-z0-9-]*$/.test(m.module || '')) err('module', 'Lowercase module name');
-    if (!m.label) err('label', 'Required');
-
-    const objects = m.objects || {};
-    for (const [o, def] of Object.entries(objects)) {
-        const names = new Set();
-        (def.fields || []).forEach((f, i) => {
-            if (!f?.name) err(`objects.${o}.fields[${i}]`, 'Field needs a name');
-            else if (names.has(f.name)) err(`objects.${o}.fields[${i}]`, `Duplicate field "${f.name}"`);
-            else names.add(f.name);
-            // An enum lists its values, or names one of this module's option lists when they differ per account
-            // (HubSpot deal stages are per portal).
-            if (f?.type === 'enum' && !Array.isArray(f.values) && !(typeof f.values === 'string' && m.options?.[f.values])) err(`objects.${o}.fields[${i}]`, 'An enum lists its values, or names an option list of this module');
-        });
-    }
-
-    const caps = m.capabilities || {};
-    for (const [name, c] of Object.entries(caps)) {
-        const p = `capabilities.${name}`;
-        if (!/^[A-Za-z][\w]*\.[A-Za-z][\w]*$/.test(name)) err(p, 'Capability names are "<object>.<verb>"');
-        if (!KINDS.has(c?.kind)) err(`${p}.kind`, [...KINDS].join(', '));
-        if (!/^[A-Za-z_$][\w$]*$/.test(c?.method || '')) err(`${p}.method`, 'Name of a method on the module\'s Api class');
-        for (const [arg, spec] of Object.entries(c?.input || {})) if (!spec?.type) err(`${p}.input.${arg}`, 'Input needs a type');
-        if (c?.status !== undefined && c.status !== 'unimplemented') err(`${p}.status`, 'Only "unimplemented" (the module\'s Api has no such method)');
-        if (c?.args !== undefined) {
-            if (!Array.isArray(c.args)) err(`${p}.args`, 'An ordered list: input names, "$rest", or { value }');
-            else {
-                const named = new Set();
-                c.args.forEach((a, i) => {
-                    if (typeof a === 'string' && a !== '$rest') {
-                        if (!(a in (c.input || {}))) err(`${p}.args[${i}]`, `"${a}" is not an input of this capability`);
-                        else if (named.has(a)) err(`${p}.args[${i}]`, `"${a}" is passed twice`);
-                        named.add(a);
-                    } else if (a === '$rest') { if (c.args.indexOf('$rest') !== i) err(`${p}.args[${i}]`, '"$rest" appears once'); }
-                    else if (!(a && typeof a === 'object' && 'value' in a)) err(`${p}.args[${i}]`, 'An input name, "$rest" or { value }');
-                });
-                // An input that is never passed would be accepted and silently dropped.
-                if (!c.args.includes('$rest')) for (const k of Object.keys(c.input || {})) if (!named.has(k)) err(`${p}.args`, `Input "${k}" is declared but never passed to ${c.method}; list it in args or use "$rest"`);
-            }
-        }
-    }
-
-    // How a sync reads and writes an object (sync-engine.js). Each operation names a capability of the right kind on
-    // that object; list says how pages work; a write may wrap the mapped record in one argument (body).
-    const OPS = { list: READS, get: READS, search: new Set(['search']), create: new Set(['write']), update: new Set(['write']) };
-    const ARG_RE = /^[A-Za-z_][\w]*$/;
-    for (const [o, def] of Object.entries(objects)) {
-        const sy = def.sync;
-        if (!sy) continue;
-        const p = `objects.${o}.sync`;
-        for (const [op, kinds] of Object.entries(OPS)) {
-            const spec = sy[op];
-            if (spec === undefined) continue;
-            const c = caps[spec?.capability];
-            if (!c) { err(`${p}.${op}.capability`, `"${spec?.capability}" is not a capability of this module`); continue; }
-            if (spec.capability.split('.')[0] !== o) err(`${p}.${op}.capability`, `${spec.capability} belongs to another object`);
-            if (!kinds.has(c.kind)) err(`${p}.${op}.capability`, `${op} needs a ${[...kinds].join(' or ')} capability; ${spec.capability} is ${c.kind}`);
-            for (const argKey of ['id', 'body', 'cursor', 'limit', 'since']) {
-                const arg = spec[argKey];
-                if (arg === undefined) continue;
-                if (!ARG_RE.test(arg)) err(`${p}.${op}.${argKey}`, 'The name of one argument');
-                else if (!(arg in (c.input || {}))) err(`${p}.${op}.${argKey}`, `${spec.capability} takes no argument "${arg}"`);
-            }
-        }
-        if (sy.get && !sy.get.id) err(`${p}.get.id`, 'Which argument carries the record id');
-        if (sy.update && !sy.update.id) err(`${p}.update.id`, 'Which argument carries the record id');
-        if (sy.list) {
-            const mode = sy.list.paging || 'cursor';
-            if (!['cursor', 'offset', 'page'].includes(mode)) err(`${p}.list.paging`, 'cursor (the next cursor is in the response), offset or page');
-            if (mode === 'cursor' && sy.list.cursor && !sy.list.next) err(`${p}.list.next`, 'Where the response puts the next cursor');
-            if (mode !== 'cursor' && !sy.list.limit) err(`${p}.list.limit`, `${mode} paging needs the page size argument`);
-        }
-        for (const k of ['id', 'updatedAt']) if (sy[k] !== undefined && typeof sy[k] !== 'string') err(`${p}.${k}`, 'A path in the record');
-    }
-
-    for (const [topic, e] of Object.entries(m.events || {})) {
-        const p = `events.${topic}`;
-        if (e.object && !objects[e.object]) err(`${p}.object`, `"${e.object}" is not an object of this module`);
-        if (e.recordId !== undefined && !objects[e.object]?.sync?.get) err(`${p}.recordId`, 'An event that carries only an id needs its object\'s sync.get to fetch the record');
-        if (e.payload && (e.delivery || 'webhook') === 'webhook' && m.webhook) {
-            // The example is a real delivery (body, plus headers when the topic is in one): it must route to this event
-            // through the same code a live webhook goes through, and its record path must find something.
-            const found = eventsIn(m, { body: e.payload, headers: e.headers }).find((x) => x.topic === topic);
-            if (!found) err(`${p}.payload`, `The example delivery does not route to "${topic}" (check webhook.topic and this event's match)`);
-            else if (e.record && found.record === undefined) err(`${p}.record`, `"${e.record}" finds nothing in the example event`);
-        } else if (e.record && e.payload) {
-            let cur = e.payload;
-            for (const seg of e.record.split(/\.|(?=\[)/)) { const i = /^\[(\d+)\]$/.exec(seg); cur = cur == null ? undefined : i ? cur[Number(i[1])] : cur[seg]; }
-            if (cur === undefined) err(`${p}.record`, `"${e.record}" is not a path in the example payload`);
-        }
-    }
-
-    // An option list: a read capability, its inputs, and how each item becomes { label, value } (one reference, or
-    // a template). A string that mixes "$.x" into text renders the path literally, so it is refused.
-    const checkItemExpr = (v, p) => {
-        if (typeof v !== 'string') { err(p, 'A reference ($.item.id) or a template ({{item.name}})'); return; }
-        if (!PATH_RE.test(v) && v.includes('$.')) err(p, `"${v}" mixes a $. reference into text, which renders literally; use {{item.x}} for every part`);
-        for (const t of templateTags(v)) {
-            if (t.path.split(/\.|\[/)[0] !== 'item') err(p, `{{${t.path}}} — an option label can only read item`);
-            for (const f of t.filters) if (!FILTERS[f.name]) err(p, `Unknown template filter "${f.name}"`);
-        }
-        if (PATH_RE.test(v) && !v.startsWith('$.item')) err(p, 'An option value can only read $.item');
-    };
-    for (const [name, o] of Object.entries(m.options || {})) {
-        const p = `options.${name}`;
-        const c = caps[o?.capability];
-        if (!c) err(`${p}.capability`, `"${o?.capability}" is not a capability of this module`);
-        else if (!READS.has(c.kind)) err(`${p}.capability`, `An option list reads; ${o.capability} is a ${c.kind} capability`);
-        checkItemExpr(o?.label, `${p}.label`);
-        checkItemExpr(o?.value, `${p}.value`);
-        for (const [input, spec] of Object.entries(o?.inputs || {})) {
-            if (c && !(input in (c.input || {}))) err(`${p}.inputs.${input}`, `${o.capability} takes no argument "${input}"`);
-            if (!spec?.type) err(`${p}.inputs.${input}`, 'Input needs a type');
-        }
-        if (c) for (const [arg, spec] of Object.entries(c.input || {})) if (spec.required && !(arg in (o.inputs || {}))) err(`${p}.inputs`, `${o.capability} requires "${arg}", so the option list must declare it as an input`);
-    }
-
-    // Webhook delivery: how a POST from this provider becomes module events (webhooks.js). Templates may read body,
-    // headers (lower-case), query, item (one event of a batch) and parent (the outer item of a two-level batch).
-    const w = m.webhook;
-    const webhookEvents = Object.entries(m.events || {}).filter(([, e]) => (e.delivery || 'webhook') === 'webhook');
-    if (webhookEvents.length && !w) err('webhook', 'This module has webhook events, so it needs a webhook block saying where the topic is');
-    if (w) {
-        if (!['installation', 'app'].includes(w.scope)) err('webhook.scope', 'installation (a URL per installation) or app (one URL for every account)');
-        const tpl = (v, p, roots = ['body', 'headers', 'query', 'item', 'parent']) => {
-            for (const t of (Array.isArray(v) ? v : [v])) {
-                if (typeof t !== 'string') { err(p, 'A template string, or a list of them'); continue; }
-                for (const tag of templateTags(t)) {
-                    if (!roots.includes(tag.path.split(/\.|\[/)[0])) err(p, `{{${tag.path}}}: a webhook template can read ${roots.join(', ')}`);
-                    for (const f of tag.filters) if (!FILTERS[f.name]) err(p, `Unknown template filter "${f.name}"`);
-                }
-            }
-        };
-        if (!w.topic) err('webhook.topic', 'Required: where the provider puts the event type');
-        else tpl(w.topic, 'webhook.topic');
-        if (w.eventId) tpl(w.eventId, 'webhook.eventId'); else err('webhook.eventId', 'Required: the id that makes a redelivery a no-op');
-        if (w.scope === 'app' && !w.account) err('webhook.account', 'An app-level webhook needs account: which connected account an event is about');
-        if (w.account) tpl(w.account, 'webhook.account');
-        const batch = w.batch == null ? [] : Array.isArray(w.batch) ? w.batch : [w.batch];
-        if (batch.length > 2 || batch.some((b) => typeof b !== 'string')) err('webhook.batch', 'A path to the array of events, or [outer, inner] for two levels');
-        if (w.status !== undefined && w.status !== 'unimplemented') err('webhook.status', 'Only "unimplemented" (the module\'s Api has no verify method)');
-        if (w.verify != null && !/^[A-Za-z_$][\w$]*$/.test(w.verify)) err('webhook.verify', 'Name of an Api method that checks the signature');
-        if (w.handshake) {
-            try { parseCondition(w.handshake.when); } catch (e) { err('webhook.handshake.when', e.message); }
-            if (w.handshake.status != null && !Number.isInteger(w.handshake.status)) err('webhook.handshake.status', 'An HTTP status code');
-        }
-        if (w.unwrap != null && typeof w.unwrap !== 'string') err('webhook.unwrap', 'The name of a form field holding the JSON body');
-    }
-    for (const [topic, e] of webhookEvents) {
-        if (e.match != null && typeof e.match !== 'string') err(`events.${topic}.match`, 'The provider\'s topic string for this event');
-        if (e.when) { try { parseCondition(e.when); } catch (x) { err(`events.${topic}.when`, x.message); } }
-    }
-
-    for (const pl of m.ui?.placements || []) if (typeof pl !== 'string') err('ui.placements', 'Placements are strings');
-    return { valid: errors.length === 0, errors };
-}
-
-module.exports = { validateManifest };

package/integrations/definitions/renderers/common.js

@@ -1,67 +0,0 @@
-/**
- * What every renderer shares: coercion of view props (they come from record data, so any type can arrive), the one
- * URL rule, truncation that never leaves half an entity behind, and the button <-> Slack round trip.
- */
-
-/** A view prop as text. Objects are JSON, null/undefined are empty: a renderer never prints "[object Object]" or "undefined". */
-function str(v) {
-    if (v == null) return '';
-    if (typeof v === 'string') return v;
-    if (typeof v === 'object') { try { return JSON.stringify(v); } catch (_) { return ''; } }
-    return String(v);
-}
-
-/**
- * Only http(s) links leave a preview or a card. Record data decides these URLs ("{{data.proposal.recording}}"), and a
- * `javascript:` or `data:` URL in a vendor field must not become a clickable thing in someone's HubSpot or Slack.
- * @returns {string|null}
- */
-function safeUrl(u) {
-    const s = str(u).trim();
-    if (!/^https?:\/\/[^\s<>"']+$/i.test(s)) return null;
-    try { new URL(s); } catch (_) { return null; }
-    return s;
-}
-
-/**
- * Cut to at most `max` characters, ending in the marker. Never leaves a dangling half of a Slack entity ("&am"), which
- * would render as literal junk instead of the character it stood for.
- */
-function truncate(s, max, marker = '…') {
-    s = String(s);
-    if (s.length <= max) return s;
-    let cut = s.slice(0, Math.max(0, max - marker.length));
-    cut = cut.replace(/&(?:[a-z]{1,4}|#\d{0,6}|#x[0-9a-f]{0,5})?$/i, '');
-    return cut + marker;
-}
-
-/** Badge tone (`neutral`, or a Jira statusCategory key like `done`) -> one of four. Unknown is neutral, never an error. */
-function toneOf(tone) {
-    const t = str(tone).toLowerCase();
-    if (['positive', 'success', 'good', 'done', 'green', 'complete', 'completed'].includes(t)) return 'positive';
-    if (['warning', 'caution', 'indeterminate', 'yellow', 'in_progress', 'pending'].includes(t)) return 'warning';
-    if (['critical', 'danger', 'error', 'bad', 'red', 'failed'].includes(t)) return 'critical';
-    return 'neutral';
-}
-
-const ACTION_VALUE_MAX = 2000; // Slack's cap on a button's value
-
-/**
- * A userAction button's identity as a Slack button value: which installation, which workflow, which surface it was on.
- * `needsInput` marks a button whose workflow asks for values first (a Slack button cannot, so the handler opens a form).
- */
-function encodeAction({ integrationId, workflow, surface, needsInput }) {
-    const value = JSON.stringify({ ...(integrationId ? { integrationId: String(integrationId) } : {}), workflow, surface, ...(needsInput ? { needsInput: true } : {}) });
-    return value.length <= ACTION_VALUE_MAX ? value : null;
-}
-
-/** The inverse, for the handler that receives a click. null for anything that is not one of ours. */
-function decodeAction(value) {
-    let v;
-    try { v = JSON.parse(value); } catch (_) { return null; }
-    if (!v || typeof v !== 'object' || typeof v.workflow !== 'string' || !v.workflow || typeof v.surface !== 'string') return null;
-    if (v.integrationId !== undefined && typeof v.integrationId !== 'string') return null;
-    return { ...(v.integrationId ? { integrationId: v.integrationId } : {}), workflow: v.workflow, surface: v.surface, ...(v.needsInput ? { needsInput: true } : {}) };
-}
-
-module.exports = { str, safeUrl, truncate, toneOf, encodeAction, decodeAction, ACTION_VALUE_MAX };

package/integrations/definitions/renderers/html.js

@@ -1,129 +0,0 @@
-/**
- * Safe, self-contained HTML for a preview pane. Every piece of data goes through `esc`, links are http(s) only, styles
- * are inline attributes and there is no script, no `<style>`, no event handler and no external resource, so a pane can
- * show a vendor's record next to the definition's chrome without that record being able to do anything.
- */
-const { str, safeUrl, toneOf } = require('./common');
-
-const esc = (v) => str(v).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
-const FONT = "font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Helvetica,Arial,sans-serif";
-
-/** How each host frames what it shows. `generic` is for hosts with no look of their own (a phone app, Zendesk, Shopify…). */
-const HOSTS = {
-    hubspot: { label: 'HubSpot card', frame: `${FONT};background:#fff;border:1px solid #cbd6e2;border-radius:3px;max-width:420px;color:#33475b;font-size:14px;box-shadow:0 1px 2px rgba(0,0,0,.08)`, head: 'background:#f5f8fa;border-bottom:1px solid #cbd6e2;padding:8px 14px;font-size:12px;color:#516f90;font-weight:600', body: 'padding:14px', accent: '#ff7a59' },
-    slack: { label: 'Slack message', frame: `${FONT};background:#fff;border:1px solid #e0e0e0;border-radius:8px;max-width:560px;color:#1d1c1d;font-size:15px`, head: 'padding:8px 14px 0;font-size:13px;color:#616061', body: 'padding:6px 14px 12px', accent: '#4a154b' },
-    generic: { label: 'Preview', frame: `${FONT};background:#fff;border:1px solid #d9dde3;border-radius:6px;max-width:480px;color:#1f2937;font-size:14px`, head: 'background:#f3f4f6;border-bottom:1px solid #d9dde3;padding:8px 14px;font-size:12px;color:#6b7280;font-weight:600', body: 'padding:14px', accent: '#2563eb' },
-};
-const hostOf = (h) => HOSTS[h] || HOSTS.generic;
-const TONE = { positive: 'background:#e6f4ea;color:#1e6b34', warning: 'background:#fff4d6;color:#8a5a00', critical: 'background:#fde8e6;color:#a4261b', neutral: 'background:#eceff3;color:#44505f' };
-
-/** The view tree as HTML, without the host frame. */
-function viewToHtmlBody(view, host = 'generic') {
-    const H = hostOf(host);
-    const go = (v) => {
-        if (!v || typeof v !== 'object') return '';
-        const p = v.props || {};
-        const kids = () => (v.children || []).map(go).join('');
-        switch (v.component) {
-            case 'Stack': return `<div style="display:flex;flex-direction:column;gap:10px">${kids()}</div>`;
-            case 'Heading': return `<h3 style="margin:0;font-size:16px;font-weight:700">${esc(p.text)}</h3>`;
-            case 'Text': return `<p style="margin:0;line-height:1.4">${esc(p.text)}</p>`;
-            case 'KeyValue': return `<dl style="margin:0;display:grid;grid-template-columns:max-content 1fr;gap:4px 14px">${(Array.isArray(p.items) ? p.items : []).map((it) => `<dt style="color:#6b7280">${esc(it?.label)}</dt><dd style="margin:0">${esc(it?.value) || '—'}</dd>`).join('')}</dl>`;
-            case 'List': return `<ul style="margin:0;padding-left:18px">${(Array.isArray(p.items) ? p.items : []).map((it) => `<li>${esc(it?.title)}${it?.meta ? ` <span style="color:#6b7280;font-size:12px">${esc(it.meta)}</span>` : ''}</li>`).join('')}</ul>`;
-            case 'Table': return `<table style="border-collapse:collapse;width:100%"><thead><tr>${(Array.isArray(p.columns) ? p.columns : []).map((c) => `<th style="text-align:left;border-bottom:1px solid #d9dde3;padding:4px 8px;font-size:12px;color:#6b7280">${esc(c)}</th>`).join('')}</tr></thead><tbody>${(Array.isArray(p.rows) ? p.rows : []).map((r) => `<tr>${(Array.isArray(r) ? r : []).map((c) => `<td style="border-bottom:1px solid #eef0f3;padding:4px 8px">${esc(c)}</td>`).join('')}</tr>`).join('')}</tbody></table>`;
-            case 'Badge': return `<span style="display:inline-block;align-self:flex-start;padding:2px 8px;border-radius:10px;font-size:12px;font-weight:600;${TONE[toneOf(p.tone)]}">${esc(p.text)}</span>`;
-            case 'Empty': return `<p style="margin:0;color:#6b7280;font-style:italic">${esc(p.text)}</p>`;
-            case 'Divider': return '<hr style="border:0;border-top:1px solid #e5e7eb;margin:2px 0">';
-            case 'Button': return buttonHtml({ label: p.label, action: p.action, primary: p.style === 'primary', accent: H.accent });
-            default: return kids();
-        }
-    };
-    return go(view);
-}
-
-/** A button in a preview does nothing (no script), but says what it would do: a link for open_url, a `data-` marker for a workflow. */
-function buttonHtml({ label, action, primary, accent }) {
-    const style = `display:inline-block;align-self:flex-start;padding:6px 14px;border-radius:4px;font-size:14px;font-weight:600;text-decoration:none;cursor:default;${primary ? `background:${accent};color:#fff;border:1px solid ${accent}` : `background:#fff;color:${accent};border:1px solid ${accent}`}`;
-    if (action?.type === 'open_url') {
-        const url = safeUrl(action.url);
-        if (url) return `<a href="${esc(url)}" target="_blank" rel="noopener noreferrer" style="${style}">${esc(label || 'Open')}</a>`;
-    }
-    const wf = action?.type === 'userAction' ? ` data-workflow="${esc(action.workflow)}" title="${esc(`Runs the "${action.workflow}" workflow`)}"` : '';
-    return `<button type="button"${wf} style="${style}">${esc(label || 'Open')}</button>`;
-}
-
-/** The framed preview: a head line saying what this is and where it appears, then the body. */
-function frame(host, title, bodyHtml) {
-    const H = hostOf(host);
-    return `<div data-preview-host="${esc(host in HOSTS ? host : 'generic')}" style="${H.frame}"><div style="${H.head}">${esc(title || H.label)}</div><div style="${H.body}">${bodyHtml}</div></div>`;
-}
-
-/**
- * @param {object|null} view
- * @param {{ host?: string, title?: string }} [opts]
- */
-function viewToHtml(view, { host = 'generic', title } = {}) {
-    const body = view ? viewToHtmlBody(view, host) : `<p style="margin:0;color:#6b7280;font-style:italic">Nothing to show for this record.</p>`;
-    return frame(host, title, body);
-}
-
-// ---- Slack: mrkdwn and Block Kit as HTML, so a posted message previews as it will look, not as a data dump ----
-
-/** Slack mrkdwn (already Slack-encoded: `&amp;`, `<url|label>`) to HTML. Only `* _ ~ \`` and links are interpreted. */
-function mrkdwnToHtml(text) {
-    const parts = str(text).split(/(<[^<>\n]*>)/);
-    const out = parts.map((seg) => {
-        const tok = /^<([^<>\n]*)>$/.exec(seg);
-        if (tok) {
-            // the target is Slack-encoded like the rest (`&amp;` in a query string): decode it once, then esc() it as an attribute
-            const [rawTarget, label] = tok[1].split('|');
-            const target = rawTarget.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
-            if (/^https?:\/\//i.test(target)) { const url = safeUrl(target); return url ? `<a href="${esc(url)}" target="_blank" rel="noopener noreferrer" style="color:#1264a3">${esc(label || target)}</a>` : esc(label || ''); }
-            if (target.startsWith('!')) return `<span style="background:#fff3cd">@${esc(label || target.slice(1).split('^')[0])}</span>`;
-            if (target.startsWith('@')) return `<span style="background:#e8f5fa;color:#1264a3">@${esc(label || target.slice(1))}</span>`;
-            if (target.startsWith('#')) return `<span style="color:#1264a3">#${esc(label || target.slice(1))}</span>`;
-            return esc(label || '');
-        }
-        // decode Slack's three entities once, then escape for HTML, then emphasis on the escaped text
-        const raw = seg.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
-        return esc(raw)
-            .replace(/`([^`\n]+)`/g, '<code style="background:#f4f4f4;border:1px solid #e0e0e0;border-radius:3px;padding:0 3px">$1</code>')
-            .replace(/(^|[\s(])\*([^*\n]+)\*(?=$|[\s).,!?:;])/g, '$1<strong>$2</strong>')
-            .replace(/(^|[\s(])_([^_\n]+)_(?=$|[\s).,!?:;])/g, '$1<em>$2</em>')
-            .replace(/(^|[\s(])~([^~\n]+)~(?=$|[\s).,!?:;])/g, '$1<del>$2</del>');
-    }).join('');
-    return out.replace(/\n/g, '<br>');
-}
-
-const textOf = (t) => (t && t.type === 'mrkdwn' ? mrkdwnToHtml(t.text) : esc(t?.text));
-
-function slackBlocksToHtml(blocks) {
-    return (Array.isArray(blocks) ? blocks : []).map((b) => {
-        switch (b?.type) {
-            case 'header': return `<div style="font-size:18px;font-weight:700;margin:6px 0">${esc(b.text?.text)}</div>`;
-            case 'section': return `<div style="margin:4px 0">${b.text ? `<div>${textOf(b.text)}</div>` : ''}${Array.isArray(b.fields) ? `<div style="display:grid;grid-template-columns:1fr 1fr;gap:6px 14px;margin-top:4px">${b.fields.map((f) => `<div>${textOf(f)}</div>`).join('')}</div>` : ''}</div>`;
-            case 'context': return `<div style="color:#616061;font-size:12px;margin:4px 0">${(b.elements || []).map(textOf).join(' ')}</div>`;
-            case 'divider': return '<hr style="border:0;border-top:1px solid #e0e0e0;margin:8px 0">';
-            case 'actions': return `<div style="display:flex;flex-wrap:wrap;gap:8px;margin:6px 0">${(b.elements || []).map((e) => (e.url
-                ? buttonHtml({ label: e.text?.text, action: { type: 'open_url', url: e.url }, accent: '#1264a3' })
-                : buttonHtml({ label: e.text?.text, action: { type: 'userAction', workflow: safeWorkflow(e.value) }, primary: e.style === 'primary', accent: e.style === 'primary' ? '#007a5a' : '#1264a3' }))).join('')}</div>`;
-            default: return `<div style="color:#616061;font-size:12px">(${esc(b?.type || 'unknown')} block)</div>`;
-        }
-    }).join('');
-}
-function safeWorkflow(value) { try { const w = JSON.parse(value)?.workflow; return typeof w === 'string' ? w : ''; } catch (_) { return ''; } }
-
-/** A Slack message as the channel will show it: who posts it, where, then the blocks (or the text). */
-function slackMessageToHtml({ channel, text, blocks, appName = 'Your integration' }) {
-    const to = channel ? esc(channel) : '<em>(channel not chosen yet)</em>';
-    const body = Array.isArray(blocks) && blocks.length ? slackBlocksToHtml(blocks) : `<div>${mrkdwnToHtml(text)}</div>`;
-    return `<div data-preview-host="slack" style="${HOSTS.slack.frame}"><div style="${HOSTS.slack.head}"><strong style="color:#1d1c1d">${esc(appName)}</strong> <span style="background:#e8e8e8;border-radius:3px;padding:0 4px;font-size:11px">APP</span> to ${to}</div><div style="${HOSTS.slack.body}">${body}</div></div>`;
-}
-
-/** Any other outbound call: what it is and what it carries. The values are escaped, and objects are shown as JSON. */
-function callToHtml({ module, capability, args }) {
-    const rows = Object.entries(args || {}).map(([k, v]) => `<dt style="color:#6b7280">${esc(k)}</dt><dd style="margin:0;white-space:pre-wrap;word-break:break-word">${esc(typeof v === 'string' ? v : JSON.stringify(v, null, 2))}</dd>`).join('');
-    return frame('generic', `Would call ${module} · ${capability}`, `<dl style="margin:0;display:grid;grid-template-columns:max-content 1fr;gap:4px 14px">${rows}</dl>`);
-}
-
-module.exports = { viewToHtml, viewToHtmlBody, slackBlocksToHtml, slackMessageToHtml, mrkdwnToHtml, callToHtml, esc, HOSTS };

package/integrations/definitions/renderers/hubspot.js

@@ -1,59 +0,0 @@
-/**
- * Resolved view tree -> a JSON description of HubSpot UI-extension components. Names and prop values were checked
- * against @hubspot/ui-extensions 0.17.1 (its shared.synced/types/components/*.d.ts). Data, not React: a thin card
- * deployed once maps `{ type, props, children }` onto `React.createElement(components[type], props, ...children)`, so a
- * changed card is a publish, not a card deploy.
- *
- * A node is `{ type, props?, children?, action? }`; a child is a string (text) or a node. Strings are text, never markup.
- * `props` holds only real component props, passed straight through. `action` is OURS, not a HubSpot prop: the card must
- * not spread it onto the component, but turn it into `onClick={() => runServerless(...)}` that posts it to the actions
- * endpoint (a userAction button), because a UI extension cannot call out except through a serverless function.
- * An `open_url` button needs no action: it is the real `href` prop, which the host opens in a new tab.
- */
-const { str, safeUrl, toneOf } = require('./common');
-
-/** The component names this emits, so the card can fail closed on one it does not know. */
-const HUBSPOT_COMPONENTS = ['Flex', 'Heading', 'Text', 'List', 'Tag', 'Button', 'EmptyState', 'DescriptionList', 'DescriptionListItem', 'Divider', 'Table', 'TableHead', 'TableBody', 'TableRow', 'TableHeader', 'TableCell'];
-const TAG_VARIANT = { positive: 'success', warning: 'warning', critical: 'error', neutral: 'default' };
-
-const node = (type, props, children, action) => ({ type, ...(props && Object.keys(props).length ? { props } : {}), ...(action ? { action } : {}), ...(children && children.length ? { children } : {}) });
-
-/**
- * @param {object|null} view
- * @param {{ integrationId?: string, surface?: string }} [opts]  carried on a button's `action`, so the card can post it back
- * @returns {object|null}
- */
-function viewToHubSpot(view, { integrationId, surface } = {}) {
-    const go = (v) => {
-        if (!v || typeof v !== 'object') return null;
-        const p = v.props || {};
-        const kids = () => (v.children || []).map(go).filter(Boolean);
-        switch (v.component) {
-            case 'Stack': return node('Flex', { direction: 'column', gap: 'sm' }, kids());
-            case 'Heading': return node('Heading', {}, [str(p.text)]);
-            case 'Text': return node('Text', {}, [str(p.text)]);
-            case 'KeyValue': return node('DescriptionList', { direction: 'row' }, (Array.isArray(p.items) ? p.items : []).map((it) => node('DescriptionListItem', { label: str(it?.label) }, [node('Text', {}, [str(it?.value) || '—'])])));
-            case 'List': return node('List', { variant: 'unordered' }, (Array.isArray(p.items) ? p.items : []).map((it) => node('Flex', { direction: 'column', gap: 'flush' }, [node('Text', { format: { fontWeight: 'demibold' } }, [str(it?.title)]), ...(it?.meta ? [node('Text', { variant: 'microcopy' }, [str(it.meta)])] : [])])));
-            case 'Table': return node('Table', {}, [
-                node('TableHead', {}, [node('TableRow', {}, (Array.isArray(p.columns) ? p.columns : []).map((c) => node('TableHeader', {}, [str(c)])))]),
-                node('TableBody', {}, (Array.isArray(p.rows) ? p.rows : []).map((r) => node('TableRow', {}, (Array.isArray(r) ? r : []).map((c) => node('TableCell', {}, [str(c)]))))),
-            ]);
-            case 'Badge': return node('Tag', { variant: TAG_VARIANT[toneOf(p.tone)] }, [str(p.text)]);
-            case 'Empty': return node('EmptyState', { layout: 'vertical' }, [node('Text', {}, [str(p.text)])]);
-            case 'Divider': return node('Divider', { distance: 'sm' });
-            case 'Button': {
-                const a = p.action;
-                const variant = p.style === 'primary' ? 'primary' : p.style === 'danger' ? 'destructive' : 'secondary';
-                let action;
-                if (a?.type === 'userAction' && typeof a.workflow === 'string') action = { type: 'userAction', workflow: a.workflow, surface, ...(integrationId ? { integrationId: String(integrationId) } : {}), ...(a.input ? { input: a.input } : {}) };
-                const href = a?.type === 'open_url' ? safeUrl(a.url) : null;
-                // A button with no usable action still renders (disabled), so the card matches the definition.
-                return node('Button', { variant, ...(href ? { href } : action ? {} : { disabled: true }) }, [str(p.label) || 'Open'], action);
-            }
-            default: return kids().length === 1 ? kids()[0] : node('Flex', { direction: 'column', gap: 'sm' }, kids());
-        }
-    };
-    return go(view);
-}
-
-module.exports = { viewToHubSpot, HUBSPOT_COMPONENTS };