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

package/integrations/definitions/schema/records.md

@@ -1,105 +0,0 @@
-# Integrations published as definitions: database records (v0.1)
-
-Three layers, stored separately. Worked examples for Phone ↔ HubSpot are in `examples/records/`.
-
-| Layer | What it holds | Table | Changes when |
-|---|---|---|---|
-| Definition | What the integration can do | `IntegrationDefinitionVersion` (new) | A version is published (then never again) |
-| Installation | What one customer turned on and chose | `Integration.config` (existing column, new shape) | The customer configures, or an upgrade moves the pin |
-| State | What has happened | `IntegrationMapping` (existing), `WorkflowRun` (new) | Every event |
-
-## IntegrationDefinitionVersion (new)
-
-One row per published version. `document` is the definition verbatim; `checksum` is sha256 of its canonical JSON
-(sorted keys), so the same content always has the same checksum and an installation can prove what it runs.
-
-```prisma
-model IntegrationDefinitionVersion {
-  id            String   @id @default(cuid())
-  definitionId  String                       // "phone-hubspot"
-  version       String                       // "1.4.0" (semver)
-  schemaVersion String                       // "0.1"
-  status        DefinitionStatus @default(DRAFT)
-  checksum      String                       // "sha256:..." of canonical(document)
-  document      Json                         // the definition, immutable once PUBLISHED
-  changeLevel   String?                      // patch | minor | major, computed by versioning.diff at publish
-  previousVersion String?
-  notes         String?
-  createdBy     String?
-  createdAt     DateTime @default(now())
-  publishedAt   DateTime?
-
-  @@unique([definitionId, version])
-  @@index([definitionId, status])
-}
-
-enum DefinitionStatus { DRAFT PUBLISHED DEPRECATED RETIRED }
-```
-
-Rules: a `DRAFT` may be edited; publishing runs `validate` (must be valid) and `checkBump` against the latest
-published version (the declared bump must cover the computed change level), then freezes the row. `DEPRECATED`
-versions keep running for installations pinned to them but cannot be newly installed. A version is `RETIRED` only
-when no installation pins it and no queued message references it.
-
-## Integration.config (existing column)
-
-```jsonc
-{
-  "definition": { "id": "phone-hubspot", "version": "1.4.0", "checksum": "sha256:…" },   // the pin
-  "settings":  { "fromNumber": "+15125550100" },                                       // integration-level settings
-  "syncs":     { "contacts": { "enabled": true, "mapping": [ /* optional full override */ ] } },
-  "workflows": { "missed-call-task": { "enabled": true, "settings": { "owner": "81273645" } } },
-  "ui":        { "phone-card": { "enabled": true } },
-  "runtime":   { "installed": { "hook": { "id": "WHk2c9", "url": "…", "events": [ … ] } } }  // runtime-owned: onInstall results by step id
-}
-```
-
-An absent `enabled` means "use the definition's default". The existing `Integration.version` column mirrors
-`config.definition.version` so it can be queried and indexed.
-
-## IntegrationMapping (existing) — three kinds of row
-
-| `sourceId` | `mapping` | Written by |
-|---|---|---|
-| `link:<sync>:<moduleKey>:<id>` | `{ "<moduleKey>": id, …, linkedAt }` | `links.upsert` (both sides get a row) |
-| `idx:<sync>:<identityKey>:<normalised value>` | same as link | `links.upsert` with `keys` (email lowercased, phone E.164) |
-| `evt:<definition>:<workflow>:<providerEventId>` | `{ at }` | `runWorkflow`, insert-only (`createMapping`) so a redelivery is a no-op |
-
-No new table: these are the rows hand-written integrations already keep, under a fixed naming scheme.
-
-## WorkflowRun (new)
-
-One row per workflow execution. Carries the definition version it ran on, so a run is always explainable against the
-exact document, even after an upgrade.
-
-```prisma
-model WorkflowRun {
-  id                String   @id @default(cuid())
-  integrationId     String
-  definitionId      String
-  definitionVersion String
-  workflowId        String
-  triggerType       String                     // webhook | schedule | userAction | syncRecord
-  eventId           String?                    // provider event id (dedupe key)
-  status            String                     // completed | stopped | filtered | duplicate | failed | waiting
-  reason            String?                    // why it stopped
-  error             String?
-  attempt           Int      @default(1)
-  trace             Json                       // [{ id, use, status, ms, error? }] — no payload bodies
-  runKey            String?                    // the runtime's run id: how routes and resume jobs address a run
-  waitingFor        Json?                      // a paused run: { stepId, kind: delay|approval, until, prompt?, approvers?, onTimeout? }
-  resumeAt          DateTime?
-  startedAt         DateTime
-  endedAt           DateTime?
-
-  @@index([integrationId, workflowId, startedAt])
-  @@index([integrationId, status])
-}
-```
-
-A paused run (a `delay` or `approval` step) is one row from its first step to its last: it is updated when it
-resumes. Its checkpoint (the step index and the earlier steps' results) is not on the row; it is an
-`IntegrationMapping` row `wait:<runKey>`, encrypted at rest like every mapping, deleted when the run ends.
-
-Retention: keep `failed` runs 30 days and the rest 7 by default. `trace` holds step ids, timings and error messages,
-never request or response bodies (those can hold customer data; the existing logging rules apply).

package/integrations/definitions/schema-check.js

@@ -1,58 +0,0 @@
-/**
- * Two layers of validation, run together everywhere (the CLI, the tests, anything that publishes):
- *   1. JSON Schema (schema/*.schema.json) — the published shape. Needs ajv, which the monorepo installs for
- *      @friggframework/schemas; core's runtime stays dependency-free, so ajv is loaded only here.
- *   2. References (validate.js / manifests.js) — what a schema cannot see: steps name declared capabilities,
- *      $.steps.x is an earlier step, view paths exist, option inputs are declared, and so on.
- * A document is valid only when both pass.
- */
-const fs = require('fs');
-const path = require('path');
-const { validate } = require('./validate');
-const { validateManifest } = require('./manifests');
-
-const SCHEMA_DIR = path.join(__dirname, 'schema');
-let compiled;
-
-function loadAjv() {
-    try { return require('ajv/dist/2020'); } catch {
-        const e = new Error('ajv is not installed. Run npm install at the monorepo root (@friggframework/schemas depends on ajv@8).');
-        e.code = 'NO_AJV';
-        throw e;
-    }
-}
-
-function schemas() {
-    if (compiled) return compiled;
-    const Ajv = loadAjv();
-    const ajv = new Ajv({ allErrors: true, strict: false });
-    const read = (f) => JSON.parse(fs.readFileSync(path.join(SCHEMA_DIR, f), 'utf8'));
-    compiled = {
-        definition: ajv.compile(read('integration-definition.v0.1.schema.json')),
-        manifest: ajv.compile(read('capability-manifest.v0.1.schema.json')),
-        installation: ajv.compile(read('installation.v0.1.schema.json')),
-    };
-    return compiled;
-}
-
-const schemaErrors = (check, doc) => (check(doc) ? [] : check.errors.map((e) => ({ layer: 'schema', path: e.instancePath.replace(/^\//, '').replace(/\//g, '.') || '(root)', message: e.message + (e.params?.allowedValues ? ` (${e.params.allowedValues.join(', ')})` : e.params?.additionalProperty ? ` ("${e.params.additionalProperty}")` : '') })));
-
-/** @returns {{ valid: boolean, errors: Array<{layer,path,message}>, warnings: Array<{layer,path,message}> }} */
-function checkManifest(manifest) {
-    const errors = [...schemaErrors(schemas().manifest, manifest), ...validateManifest(manifest).errors.map((e) => ({ layer: 'references', ...e }))];
-    return { valid: errors.length === 0, errors, warnings: [] };
-}
-
-/** A definition against the manifests of the modules it uses. Both layers run even when the first fails. */
-function checkDefinition(def, manifests) {
-    const v = validate(def, manifests);
-    const errors = [...schemaErrors(schemas().definition, def), ...v.errors.map((e) => ({ layer: 'references', ...e }))];
-    return { valid: errors.length === 0, errors, warnings: v.warnings.map((w) => ({ layer: 'references', ...w })) };
-}
-
-function checkInstallation(config) {
-    const errors = schemaErrors(schemas().installation, config);
-    return { valid: errors.length === 0, errors, warnings: [] };
-}
-
-module.exports = { checkDefinition, checkManifest, checkInstallation, loadAjv };

package/integrations/definitions/scripts/check-manifests.js

@@ -1,220 +0,0 @@
-#!/usr/bin/env node
-/**
- * Check capability manifests against the real API modules they describe (ADR-063 phase 4: real manifests).
- *
- *   node scripts/check-manifests.js <modules-dir> [<modules-dir> ...]
- *   node scripts/check-manifests.js --manifests capabilities/ --json ~/api-module-library/packages
- *   node scripts/check-manifests.js --stub-missing --strict ~/api-module-library/packages
- *
- * For every manifest it finds the module (a directory named <module> or api-module-<module>, or whose package.json
- * name ends in that, up to three levels under each given directory; the first one that loads wins), loads its Api
- * class and checks, with no network and no instance, on the prototype:
- *   - every capability's `method` exists (a capability marked `status: "unimplemented"` must NOT have it: the
- *     manifest would be stale);
- *   - the arguments fit the method's declared parameters: `args` no longer than the parameter list, and a
- *     capability with no `args` (called with one object) is not a method that needs two or more positional ones;
- *   - `webhook.verify` names a method that exists.
- *
- * Exit codes: 0 every method found (unimplemented capabilities and modules with no source are reported, not failed,
- * unless --strict) · 1 a mismatch · 2 could not run (bad arguments, no manifests).
- *
- *   --manifests <dir>   manifests to check (default: ../capabilities)
- *   --json              machine-readable result on stdout
- *   --strict            unimplemented capabilities, unloadable modules and modules not found fail too
- *   --stub-missing      load modules whose own dependencies are not installed (jsforce, stripe, @linear/sdk ...) by
- *                       standing in for the missing packages; enough to read the Api's methods, never to call them
- */
-const fs = require('fs');
-const path = require('path');
-const Module = require('module');
-
-const FOUND = 'ok';
-
-/** Parameters of a function as written: [{ name, optional }]. Reads the source, so it is a heuristic for the arity check. */
-function parametersOf(fn) {
-    const src = Function.prototype.toString.call(fn);
-    const bare = /^(?:async\s+)?([\w$]+)\s*=>/.exec(src);
-    if (bare) return [{ text: bare[1], optional: false }];
-    const open = src.indexOf('(');
-    if (open < 0) return [];
-    let depth = 0, i = open, cur = '';
-    const parts = [];
-    for (; i < src.length; i++) {
-        const c = src[i];
-        if ('([{'.includes(c)) { depth++; if (depth === 1) continue; }
-        if (')]}'.includes(c)) { depth--; if (depth === 0) break; }
-        if (c === ',' && depth === 1) { parts.push(cur); cur = ''; } else cur += c;
-    }
-    if (cur.trim()) parts.push(cur);
-    return parts.map((p) => p.replace(/\/\*[\s\S]*?\*\//g, '').trim()).filter(Boolean).map((p) => ({ text: p.replace(/\s+/g, ' '), optional: /^\.\.\./.test(p) || p.includes('=') || /^[\w$]+\s*\?/.test(p) }));
-}
-
-function methodOf(Api, name) {
-    for (let p = Api && Api.prototype; p && p !== Object.prototype; p = Object.getPrototypeOf(p)) {
-        const d = Object.getOwnPropertyDescriptor(p, name);
-        if (d) return typeof d.value === 'function' ? d.value : null;
-    }
-    return null;
-}
-
-const signatureOf = (fn) => `(${parametersOf(fn).map((p) => p.text).join(', ')})`;
-
-const looksLikeModule = (dir) => ['package.json', 'index.js', 'api.js'].some((f) => fs.existsSync(path.join(dir, f)));
-
-/** Directories that could be the module: name match, up to `depth` levels below root. */
-function candidates(root, moduleName, depth = 3) {
-    const found = [];
-    const isMatch = (dir) => {
-        const base = path.basename(dir);
-        if (base === moduleName || base === `api-module-${moduleName}`) return true;
-        try { return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).name?.endsWith(`api-module-${moduleName}`); } catch { return false; }
-    };
-    const walk = (dir, level) => {
-        if (level > depth) return;
-        let entries;
-        try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
-        for (const e of entries) {
-            if (!e.isDirectory() || e.name === 'node_modules' || e.name.startsWith('.')) continue;
-            const full = path.join(dir, e.name);
-            if (isMatch(full) && looksLikeModule(full)) found.push(full);
-            else walk(full, level + 1);
-        }
-    };
-    if (isMatch(root) && looksLikeModule(root)) found.push(root);
-    walk(root, 1);
-    return found;
-}
-
-/** Stand-ins for dependencies that are not installed, so an Api's methods can be read. Restored by the caller. */
-function stubMissingDependencies() {
-    const original = Module._load;
-    const stub = () => new Proxy(function stubbed() {}, { get: (t, k) => (k === '__esModule' ? false : k === 'prototype' ? t.prototype : t[k] || (t[k] = stub())), construct: () => ({}), apply: () => stub() });
-    Module._load = function load(request, ...rest) {
-        try { return original.call(this, request, ...rest); } catch (e) {
-            if (e && e.code === 'MODULE_NOT_FOUND' && !request.startsWith('.') && !path.isAbsolute(request)) return stub();
-            throw e;
-        }
-    };
-    return () => { Module._load = original; };
-}
-
-function loadApi(dir) {
-    const attempts = [dir, path.join(dir, 'api.js'), path.join(dir, 'src', 'api.js'), path.join(dir, 'dist', 'api.js')];
-    let firstError;
-    for (const target of attempts) {
-        try {
-            const mod = require(target);
-            const Api = mod.Api || mod.API || mod.Definition?.API || (typeof mod === 'function' ? mod : null);
-            if (typeof Api === 'function' && Api.prototype) return { Api, from: path.relative(dir, require.resolve(target)) || '.' };
-            firstError = firstError || new Error('exports no Api class');
-        } catch (e) { firstError = firstError || e; } // the first failure is the module's own; later ones are only missing fallbacks
-    }
-    return { error: (firstError?.message || 'cannot load').split('\n')[0] };
-}
-
-/**
- * @param {Record<string, object>} manifests  module -> manifest
- * @param {string[]} roots                    directories to look for the modules in
- * @returns {Array<{module, package?, source?, state, message?, rows: Array<{capability, method, state, signature?, args?, note?}>}>}
- */
-function checkManifests(manifests, roots, { stubMissing = false } = {}) {
-    const restore = stubMissing ? stubMissingDependencies() : null;
-    try {
-        return Object.values(manifests).map((m) => {
-            const result = { module: m.module, package: m.package, state: FOUND, rows: [] };
-            const dirs = roots.flatMap((r) => candidates(path.resolve(r), m.module));
-            if (!dirs.length) return { ...result, state: 'no-module', message: `No directory named ${m.module} or api-module-${m.module} under ${roots.join(', ')}` };
-            let loaded, failures = [];
-            for (const dir of dirs) {
-                const l = loadApi(dir);
-                if (l.Api) { loaded = { ...l, dir }; break; }
-                failures.push(`${dir}: ${l.error}`);
-            }
-            if (!loaded) return { ...result, state: 'unloadable', message: failures.join('; ') };
-            result.source = loaded.dir;
-            const { Api } = loaded;
-            for (const [name, c] of Object.entries(m.capabilities || {})) {
-                const fn = methodOf(Api, c.method);
-                const row = { capability: name, method: c.method };
-                if (c.status === 'unimplemented') {
-                    row.state = fn ? 'stale-unimplemented' : 'unimplemented';
-                    row.note = fn ? `Marked unimplemented, but ${c.method}${signatureOf(fn)} exists: ${c.note || 'no note says why it cannot be used'}` : c.note;
-                    if (fn) row.signature = signatureOf(fn);
-                } else if (!fn) {
-                    row.state = 'missing';
-                } else {
-                    row.signature = signatureOf(fn);
-                    const params = parametersOf(fn);
-                    const required = params.filter((p) => !p.optional).length;
-                    if (c.args) {
-                        row.args = c.args.map((a) => (typeof a === 'string' ? a : `=${JSON.stringify(a.value)}`)).join(', ');
-                        row.state = c.args.length > params.length && !params.some((p) => p.text.startsWith('...')) ? 'arity' : 'ok';
-                        if (row.state === 'arity') row.note = `Passes ${c.args.length} arguments; ${c.method} declares ${params.length}`;
-                    } else {
-                        row.state = required > 1 ? 'arity' : 'ok';
-                        if (row.state === 'arity') row.note = `Called with one object; ${c.method} needs ${required} positional arguments (add args)`;
-                    }
-                    if (c.note) row.note = [row.note, c.note].filter(Boolean).join('. ');
-                }
-                result.rows.push(row);
-            }
-            if (m.webhook?.verify) {
-                const fn = methodOf(Api, m.webhook.verify);
-                const marked = m.webhook.status === 'unimplemented';
-                result.rows.push({ capability: 'webhook.verify', method: m.webhook.verify, state: fn ? (marked ? 'stale-unimplemented' : 'ok') : marked ? 'unimplemented' : 'missing', ...(fn ? { signature: signatureOf(fn) } : {}), ...(m.webhook.note ? { note: m.webhook.note } : {}) });
-            }
-            return result;
-        });
-    } finally { if (restore) restore(); }
-}
-
-// stale-unimplemented is soft: the method exists but the note may say why it cannot be used as the capability is shaped.
-const BAD = new Set(['missing', 'arity']);
-const SOFT = new Set(['unimplemented', 'stale-unimplemented', 'unloadable', 'no-module']);
-
-function summarise(results) {
-    const counts = {};
-    for (const r of results) {
-        counts[r.state] = (counts[r.state] || 0) + (r.state === FOUND ? 0 : 1);
-        for (const row of r.rows) counts[row.state] = (counts[row.state] || 0) + 1;
-    }
-    const mismatches = results.flatMap((r) => r.rows.filter((x) => BAD.has(x.state)));
-    const soft = results.filter((r) => SOFT.has(r.state)).length + results.flatMap((r) => r.rows).filter((x) => SOFT.has(x.state)).length;
-    return { counts, mismatches: mismatches.length, soft };
-}
-
-function main(argv) {
-    const args = [...argv];
-    const flag = (n) => { const i = args.indexOf(n); if (i < 0) return false; args.splice(i, 1); return true; };
-    const option = (n) => { const i = args.indexOf(n); if (i < 0) return null; const v = args[i + 1]; args.splice(i, 2); return v; };
-    const strict = flag('--strict'), asJson = flag('--json'), stubMissing = flag('--stub-missing');
-    const manifestDir = option('--manifests') || path.join(__dirname, '..', 'capabilities');
-    const unknown = args.find((a) => a.startsWith('--'));
-    if (unknown) { console.error(`Unknown option ${unknown}`); return 2; }
-    if (!args.length) { console.error('Usage: check-manifests.js [--manifests dir] [--json] [--strict] [--stub-missing] <modules-dir> [...]'); return 2; }
-    for (const r of args) if (!fs.existsSync(r)) { console.error(`No such directory: ${r}`); return 2; }
-    if (!fs.existsSync(manifestDir)) { console.error(`No such directory: ${manifestDir}`); return 2; }
-    const manifests = {};
-    for (const f of fs.readdirSync(manifestDir).filter((x) => x.endsWith('.capabilities.json'))) {
-        try { const m = JSON.parse(fs.readFileSync(path.join(manifestDir, f), 'utf8')); manifests[m.module] = m; } catch (e) { console.error(`${f}: not valid JSON (${e.message})`); return 2; }
-    }
-    if (!Object.keys(manifests).length) { console.error(`No *.capabilities.json in ${manifestDir}`); return 2; }
-
-    const results = checkManifests(manifests, args, { stubMissing });
-    const sum = summarise(results);
-    const failed = sum.mismatches > 0 || (strict && sum.soft > 0);
-    if (asJson) process.stdout.write(`${JSON.stringify({ valid: !failed, strict, summary: sum, results }, null, 2)}\n`);
-    else {
-        for (const r of results) {
-            if (r.state !== FOUND) { console.log(`${strict ? 'FAIL' : 'skip'} ${r.module.padEnd(12)} ${r.state}: ${r.message}`); continue; }
-            const bad = r.rows.filter((x) => BAD.has(x.state)).length;
-            console.log(`${bad ? 'FAIL' : 'ok  '} ${r.module.padEnd(12)} ${r.rows.filter((x) => x.state === 'ok').length}/${r.rows.length} ok  (${path.relative(process.cwd(), r.source) || '.'})`);
-            for (const x of r.rows.filter((y) => y.state !== 'ok')) console.log(`       ${x.state.padEnd(20)} ${x.capability} -> ${x.method}${x.note ? `  ${x.note}` : ''}`);
-        }
-        console.log(`\n${results.length} manifests: ${sum.mismatches} mismatches, ${sum.soft} unverifiable or unimplemented${strict ? ' (strict)' : ''}`);
-    }
-    return failed ? 1 : 0;
-}
-
-if (require.main === module) process.exit(main(process.argv.slice(2)));
-module.exports = { checkManifests, summarise, parametersOf, methodOf, candidates };

package/integrations/definitions/scripts/validate.js

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-/**
- * Validate integration definitions and capability manifests: JSON Schema, then references.
- *
- *   node scripts/validate.js                       every bundled manifest and example
- *   node scripts/validate.js my.definition.json    one or more definitions (files or directories)
- *   node scripts/validate.js --manifests dir/ ...  check against manifests in another directory
- *   node scripts/validate.js --strict ...          warnings fail too
- *   node scripts/validate.js --json ...            machine-readable result on stdout
- *
- * Exit codes: 0 valid · 1 invalid · 2 could not run (bad arguments, unreadable file, ajv missing).
- * Manifests are always checked first, because a definition is only as trustworthy as the manifests it is checked
- * against: an invalid manifest fails the run even if every definition passes.
- */
-const fs = require('fs');
-const path = require('path');
-
-const root = path.join(__dirname, '..');
-const args = process.argv.slice(2);
-const flag = (name) => { const i = args.indexOf(name); if (i < 0) return false; args.splice(i, 1); return true; };
-const option = (name) => { const i = args.indexOf(name); if (i < 0) return null; const v = args[i + 1]; args.splice(i, 2); return v; };
-
-const strict = flag('--strict');
-const asJson = flag('--json');
-const manifestDir = option('--manifests') || path.join(root, 'capabilities');
-const unknown = args.find((a) => a.startsWith('--'));
-if (unknown) { console.error(`Unknown option ${unknown}`); process.exit(2); }
-
-const jsonFiles = (p) => {
-    if (!fs.existsSync(p)) { console.error(`No such file or directory: ${p}`); process.exit(2); }
-    return fs.statSync(p).isDirectory() ? fs.readdirSync(p).filter((f) => f.endsWith('.json')).map((f) => path.join(p, f)) : [p];
-};
-const readJson = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch (e) { console.error(`${f}: not valid JSON (${e.message})`); process.exit(2); } };
-
-let check;
-try { check = require('../schema-check'); check.loadAjv(); } catch (e) { console.error(e.message); process.exit(2); }
-
-const manifestFiles = jsonFiles(manifestDir).filter((f) => f.endsWith('.capabilities.json'));
-const definitionFiles = (args.length ? args : [path.join(root, 'examples')]).flatMap(jsonFiles).filter((f) => !f.endsWith('.capabilities.json') && !f.includes(`${path.sep}records${path.sep}`));
-
-const manifests = {};
-const results = [];
-for (const f of manifestFiles) {
-    const m = readJson(f);
-    manifests[m.module] = m;
-    results.push({ kind: 'manifest', file: path.relative(process.cwd(), f), name: m.module, ...check.checkManifest(m) });
-}
-for (const f of definitionFiles) {
-    const def = readJson(f);
-    results.push({ kind: 'definition', file: path.relative(process.cwd(), f), name: `${def.id}@${def.version}`, ...check.checkDefinition(def, manifests) });
-}
-
-const failed = results.filter((r) => !r.valid || (strict && r.warnings.length));
-if (asJson) {
-    process.stdout.write(JSON.stringify({ valid: failed.length === 0, strict, results }, null, 2) + '\n');
-} else {
-    for (const r of results) {
-        const bad = !r.valid || (strict && r.warnings.length);
-        console.log(`${bad ? 'FAIL' : 'ok  '} ${r.kind.padEnd(10)} ${r.name}${r.warnings.length ? `  (${r.warnings.length} warning${r.warnings.length > 1 ? 's' : ''})` : ''}`);
-        for (const e of r.errors) console.log(`       error   [${e.layer}] ${e.path}: ${e.message}`);
-        for (const w of r.warnings) console.log(`       warning [${w.layer}] ${w.path}: ${w.message}`);
-    }
-    const n = (k) => results.filter((r) => r.kind === k).length;
-    console.log(`\n${n('manifest')} manifests, ${n('definition')} definitions: ${failed.length ? `${failed.length} failed` : 'all valid'}${strict ? ' (strict)' : ''}`);
-}
-process.exit(failed.length ? 1 : 0);

package/integrations/definitions/steps.js

@@ -1,123 +0,0 @@
-/**
- * The v0.1 step catalogue. A step is { id?, use, with?, when?, onError? }.
- *
- * `use` is either a built-in below or "<moduleKey>.<object>.<verb>": a capability the module's manifest declares
- * (e.g. "hubspot.task.create" -> HubSpot Api.createTask). Nothing else can run: there is no http, eval or script step.
- * The only way to run custom code is `code`, which calls a named, versioned function registered with the runtime.
- */
-const { applyMapping, deepMerge } = require('./transforms');
-const { resolve } = require('./expressions');
-
-const BUILTINS = {
-    'links.find': {
-        summary: 'Find records already linked, by a sync or a link set (definition.links). By one side\'s id, or by an identity key it indexes (email, phone).',
-        args: { link: 'link set id (or sync: sync id)', from: 'module key, with id', id: 'that module\'s record id', key: '{ <identity field>: value }' },
-        run: (a, { ports }) => ports.links.find(a),
-    },
-    'links.upsert': {
-        summary: 'Record that records on two sides are the same thing, and index their identity keys.',
-        args: { link: 'link set id (or sync: sync id)', ids: '{ <module key>: id }', keys: '{ <identity field>: value }' },
-        run: (a, { ports }) => ports.links.upsert(a),
-    },
-    map: {
-        summary: 'Apply a field mapping: a sync\'s mapping (with the installation\'s overrides) or an inline one.',
-        args: { sync: 'sync id', mapping: 'inline rows', record: 'the source record' },
-        run: (a, { def, installation }) => {
-            let rows = a.mapping;
-            if (!rows && a.sync) {
-                const sync = (def.syncs || []).find((s) => s.id === a.sync);
-                if (!sync) throw new Error(`map: unknown sync "${a.sync}"`);
-                rows = installation?.syncs?.[a.sync]?.mapping || sync.mapping;
-            }
-            return applyMapping(rows, a.record || {});
-        },
-    },
-    template: {
-        summary: 'Render a named template (definition.templates) or inline text.',
-        args: { id: 'template id', text: 'inline template' },
-        run: (a, { def, ctx }) => {
-            const src = a.id ? def.templates?.[a.id] : a.text;
-            if (src == null) throw new Error(`template: unknown template "${a.id}"`);
-            return resolve(src, ctx);
-        },
-    },
-    merge: {
-        summary: 'Deep-merge objects into one; later objects win, lists are replaced.',
-        args: { objects: '[object, ...]' },
-        run: (a) => deepMerge(...(Array.isArray(a.objects) ? a.objects : [])),
-    },
-    set: {
-        summary: 'Store values in $.vars for later steps.',
-        args: { '<name>': 'value' },
-        run: (a, { ctx }) => { Object.assign(ctx.vars, a); return a; },
-    },
-    stop: {
-        summary: 'End the run early (a normal outcome, not an error). Usually guarded by `when`.',
-        args: { reason: 'string' },
-        run: (a) => ({ stop: true, reason: a.reason || 'stopped' }),
-    },
-    foreach: {
-        summary: 'Run nested steps once per item ($.item). Bounded by max (default 100, hard cap 1000). With `collect`, the step\'s result is the list of that value per item; `where` skips items.',
-        args: { over: 'array', max: 'number', where: 'condition on $.item', collect: 'value per item (may use $.item and this iteration\'s $.steps)', do: 'steps (optional when collect is set)' },
-        nested: true,
-    },
-    branch: {
-        summary: 'Run the first case whose `when` holds, else the `else` steps.',
-        args: { cases: '[{ when, do }]', else: 'steps' },
-        nested: true,
-    },
-    delay: {
-        summary: 'Pause the run, then carry on after a duration or at a time. Only at the top level of a workflow. $.steps.<id> is { resumedAt, until }.',
-        args: { for: 'duration (15m, 2h, 3d; at most 365d)', until: 'ISO time (in the past: no pause)' },
-        run: (a, { now }) => {
-            const { parseEvery } = require('../../infrastructure/scheduler/recurrence');
-            const base = now ? new Date(now) : new Date();
-            let until = null;
-            if (a.for !== undefined) {
-                const minutes = parseEvery(a.for);
-                if (minutes === null || minutes > 365 * 1440) throw new Error(`delay: "${a.for}" is not a duration up to 365d`);
-                until = new Date(base.getTime() + minutes * 60000);
-            } else if (a.until !== undefined) {
-                until = new Date(a.until);
-                if (Number.isNaN(until.getTime())) throw new Error(`delay: "${a.until}" is not a time`);
-            } else throw new Error('delay: give for or until');
-            if (until <= base) return { resumedAt: base.toISOString(), until: until.toISOString(), waited: false };
-            return { wait: { kind: 'delay', until: until.toISOString() } };
-        },
-    },
-    approval: {
-        summary: 'Pause the run until someone approves or rejects it (POST /api/integrations/:id/runs/:runId/decision), or the timeout passes. Only at the top level of a workflow. $.steps.<id> is { decision: approved|rejected, by, note, at }.',
-        args: { prompt: 'what is being approved', approvers: 'user ids allowed to decide (default: the installation\'s owner)', timeout: 'duration (default 7d)', onTimeout: 'reject (default) | approve | stop' },
-        run: (a, { now }) => {
-            const { parseEvery } = require('../../infrastructure/scheduler/recurrence');
-            const minutes = parseEvery(a.timeout ?? '7d');
-            if (minutes === null || minutes > 365 * 1440) throw new Error(`approval: timeout "${a.timeout}" is not a duration up to 365d`);
-            const onTimeout = a.onTimeout ?? 'reject';
-            if (!['reject', 'approve', 'stop'].includes(onTimeout)) throw new Error('approval: onTimeout is reject, approve or stop');
-            const base = now ? new Date(now) : new Date();
-            return { wait: { kind: 'approval', prompt: String(a.prompt ?? ''), approvers: Array.isArray(a.approvers) ? a.approvers.map(String) : null, until: new Date(base.getTime() + minutes * 60000).toISOString(), onTimeout } };
-        },
-    },
-    code: {
-        summary: 'Call a registered code step: a named, versioned function shipped in reviewed code ("pkg#fn@1.2.0").',
-        args: { ref: 'string', with: 'object' },
-        run: (a, { ports }) => {
-            if (!ports.runCode) throw new Error('code: this runtime has no code steps registered');
-            return ports.runCode(a.ref, a.with || {});
-        },
-    },
-};
-
-const FOREACH_HARD_CAP = 1000;
-/** Steps that pause a run. They may appear only at the top level of a workflow's steps. */
-const PAUSING = new Set(['delay', 'approval']);
-
-function isBuiltin(use) { return Object.prototype.hasOwnProperty.call(BUILTINS, use); }
-
-/** "hubspot.task.create" -> { module: 'hubspot', capability: 'task.create' } */
-function splitCapability(use) {
-    const i = use.indexOf('.');
-    return i < 0 ? null : { module: use.slice(0, i), capability: use.slice(i + 1) };
-}
-
-module.exports = { BUILTINS, FOREACH_HARD_CAP, PAUSING, isBuiltin, splitCapability };