qlogicagent 2.13.3 → 2.13.5

package/dist/orchestration/workflow/trigger-validation.js

@@ -0,0 +1,241 @@
+/**
+ * Trigger validation — deterministic, fail-loud gate for workflow trigger configs (plan D7/D15).
+ *
+ * Triggers are the unattended entry points to a workflow (schedule/im-message/webhook/manual). A
+ * malformed trigger (an unparseable cron, a non-path webhook, an uncompilable IM match regex) must
+ * be rejected at the SINGLE mutation channel (`applyPatch` set_trigger), not silently persisted to
+ * fail later inside the gateway trigger layer where it is unreachable to fix. This keeps §1.5
+ * fail-loud and satisfies D15 ("schedule 须有效 cron / webhook 鉴权+限流" preconditions).
+ *
+ * Pure functions, no I/O, no side effects — the gateway still owns actual registration/auth/rate
+ * limiting; this only guarantees the stored config is structurally valid and runnable.
+ */
+/** Returns a list of human-readable errors; empty ⇒ the trigger is valid. */
+export function validateTrigger(trigger) {
+    switch (trigger.type) {
+        case "manual":
+            return [];
+        case "schedule":
+            return validateCron(trigger.cron);
+        case "im-message":
+            return validateImMessage(trigger.channel, trigger.match);
+        case "webhook":
+            return validateWebhookPath(trigger.path);
+        case "intent":
+            return validateIntent(trigger.phrases, trigger.aliases, trigger.surfaces);
+        case "form":
+            return validateForm(trigger.fields);
+        default: {
+            // Exhaustiveness guard: an unknown trigger type must blow up, not pass silently.
+            const _never = trigger;
+            return [`unknown trigger type: ${JSON.stringify(_never)}`];
+        }
+    }
+}
+// ── intent (口令/意图触发, spec D22) ─────────────────────────
+const INTENT_SURFACES = new Set(["welcome", "chat"]);
+function validateIntent(phrases, aliases, surfaces) {
+    const errors = [];
+    if (!Array.isArray(phrases) || phrases.length === 0) {
+        errors.push("intent.phrases must be a non-empty array of trigger phrases");
+    }
+    else {
+        for (const p of phrases) {
+            if (typeof p !== "string" || p.trim() === "")
+                errors.push(`intent.phrases entries must be non-empty strings, got ${JSON.stringify(p)}`);
+        }
+    }
+    if (aliases !== undefined) {
+        if (!Array.isArray(aliases))
+            errors.push("intent.aliases must be an array when present");
+        else
+            for (const a of aliases) {
+                if (typeof a !== "string" || a.trim() === "")
+                    errors.push(`intent.aliases entries must be non-empty strings, got ${JSON.stringify(a)}`);
+            }
+    }
+    if (surfaces !== undefined) {
+        if (!Array.isArray(surfaces) || surfaces.length === 0)
+            errors.push("intent.surfaces must be a non-empty array when present");
+        else
+            for (const s of surfaces) {
+                if (typeof s !== "string" || !INTENT_SURFACES.has(s))
+                    errors.push(`intent.surfaces entries must be "welcome"|"chat", got ${JSON.stringify(s)}`);
+            }
+    }
+    return errors;
+}
+// ── form (D34 表单触发) ──────────────────────────────────────
+const FORM_FIELD_TYPES = new Set(["text", "number", "select"]);
+function validateForm(fields) {
+    const errors = [];
+    if (!Array.isArray(fields) || fields.length === 0) {
+        return ["form.fields must be a non-empty array"];
+    }
+    const seen = new Set();
+    for (const f of fields) {
+        if (typeof f?.key !== "string" || !/^[\w-]+$/.test(f.key)) {
+            errors.push(`form field key must be a [\\w-]+ string, got ${JSON.stringify(f?.key)}`);
+            continue;
+        }
+        if (seen.has(f.key))
+            errors.push(`duplicate form field key "${f.key}"`);
+        seen.add(f.key);
+        if (f.type !== undefined && (typeof f.type !== "string" || !FORM_FIELD_TYPES.has(f.type))) {
+            errors.push(`form field "${f.key}": type must be text|number|select`);
+        }
+        if (f.type === "select" && (!Array.isArray(f.options) || f.options.length === 0)) {
+            errors.push(`form field "${f.key}": select requires non-empty options`);
+        }
+    }
+    return errors;
+}
+// ── schedule (cron) ──────────────────────────────────────────
+const MONTH_NAMES = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
+const DOW_NAMES = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
+/**
+ * Validate a 5-field (min hour dom month dow) or 6-field (sec + the same) cron expression.
+ * Each field accepts a star, a star-step (every-N), a single value, a range, a stepped range, and
+ * comma-lists of those. Month and day-of-week additionally accept their 3-letter names.
+ * Day-of-week allows 0 and 7 for Sunday.
+ */
+export function validateCron(cron) {
+    if (typeof cron !== "string" || cron.trim() === "") {
+        return ["schedule.cron must be a non-empty string"];
+    }
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5 && parts.length !== 6) {
+        return [`schedule.cron must have 5 or 6 fields, got ${parts.length}: "${cron}"`];
+    }
+    const withSeconds = parts.length === 6;
+    const fields = withSeconds
+        ? [
+            { label: "second", min: 0, max: 59 },
+            { label: "minute", min: 0, max: 59 },
+            { label: "hour", min: 0, max: 23 },
+            { label: "day-of-month", min: 1, max: 31 },
+            { label: "month", min: 1, max: 12, names: MONTH_NAMES },
+            { label: "day-of-week", min: 0, max: 7, names: DOW_NAMES },
+        ]
+        : [
+            { label: "minute", min: 0, max: 59 },
+            { label: "hour", min: 0, max: 23 },
+            { label: "day-of-month", min: 1, max: 31 },
+            { label: "month", min: 1, max: 12, names: MONTH_NAMES },
+            { label: "day-of-week", min: 0, max: 7, names: DOW_NAMES },
+        ];
+    const errors = [];
+    for (let i = 0; i < fields.length; i++) {
+        const err = validateCronField(parts[i], fields[i]);
+        if (err)
+            errors.push(`schedule.cron ${err}`);
+    }
+    return errors;
+}
+function validateCronField(raw, field) {
+    // A field is a comma-list of segments; every segment must be valid.
+    for (const segment of raw.split(",")) {
+        const err = validateCronSegment(segment, field);
+        if (err)
+            return err;
+    }
+    return undefined;
+}
+function validateCronSegment(segment, field) {
+    if (segment === "")
+        return `${field.label} has an empty list element`;
+    // Split off an optional step "/n".
+    let body = segment;
+    let step;
+    const slash = segment.indexOf("/");
+    if (slash !== -1) {
+        body = segment.slice(0, slash);
+        step = segment.slice(slash + 1);
+        if (!/^\d+$/.test(step) || Number(step) <= 0) {
+            return `${field.label} has an invalid step "/${step}"`;
+        }
+    }
+    if (body === "*")
+        return undefined; // bare star or star-step
+    // Range "a-b" or single "a".
+    const dash = body.indexOf("-");
+    if (dash !== -1) {
+        const lo = resolveCronValue(body.slice(0, dash), field);
+        const hi = resolveCronValue(body.slice(dash + 1), field);
+        if (lo === undefined || hi === undefined) {
+            return `${field.label} has an invalid range "${body}"`;
+        }
+        if (lo > hi)
+            return `${field.label} range "${body}" is descending`;
+        return undefined;
+    }
+    // A bare step without a base (step with empty body) is only valid as a star-step, handled above.
+    if (body === "" && step !== undefined) {
+        return `${field.label} step "${segment}" needs a base ("*" or a range)`;
+    }
+    const value = resolveCronValue(body, field);
+    if (value === undefined)
+        return `${field.label} value "${body}" is out of range ${field.min}-${field.max}`;
+    return undefined;
+}
+/** Resolve a numeric-or-named cron token to its numeric value, or undefined if invalid/out of range. */
+function resolveCronValue(token, field) {
+    let n;
+    if (/^\d+$/.test(token)) {
+        n = Number(token);
+    }
+    else if (field.names) {
+        const idx = field.names.indexOf(token.toUpperCase());
+        if (idx === -1)
+            return undefined;
+        // Month names map to 1-12; day-of-week names map to 0-6.
+        n = field.label === "month" ? idx + 1 : idx;
+    }
+    else {
+        return undefined;
+    }
+    if (n < field.min || n > field.max)
+        return undefined;
+    return n;
+}
+// ── im-message ───────────────────────────────────────────────
+function validateImMessage(channel, match) {
+    const errors = [];
+    if (typeof channel !== "string" || channel.trim() === "") {
+        errors.push("im-message.channel must be a non-empty string");
+    }
+    if (match !== undefined) {
+        if (typeof match !== "string") {
+            errors.push("im-message.match must be a string regex");
+        }
+        else {
+            try {
+                new RegExp(match);
+            }
+            catch (e) {
+                errors.push(`im-message.match is not a valid regex: ${e.message}`);
+            }
+        }
+    }
+    return errors;
+}
+// ── webhook ──────────────────────────────────────────────────
+function validateWebhookPath(path) {
+    if (typeof path !== "string" || path === "") {
+        return ["webhook.path must be a non-empty string"];
+    }
+    if (!path.startsWith("/")) {
+        return [`webhook.path must start with "/": "${path}"`];
+    }
+    if (/\s/.test(path)) {
+        return [`webhook.path must not contain whitespace: "${path}"`];
+    }
+    if (path.includes("..")) {
+        return [`webhook.path must not contain "..": "${path}"`];
+    }
+    // URL path-safe characters only (no query string, no fragment).
+    if (!/^\/[A-Za-z0-9\-._~/]*$/.test(path)) {
+        return [`webhook.path contains illegal characters: "${path}"`];
+    }
+    return [];
+}

package/dist/orchestration/workflow/workflow-audit-store.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Workflow audit log (IT-12, spec D38): WHO did WHAT to WHICH workflow WHEN —
+ * configuration/lifecycle changes only. Runs are deliberately NOT duplicated here:
+ * WorkflowRunHistoryStore is already the complete run audit (trigger/timing/status/per-node);
+ * a timeline UI merges both sources.
+ *
+ * Storage: append-only JSONL at `<project>/.qlogicagent/workflows/audit.jsonl` (project-level
+ * single file — the natural unit for a cross-workflow timeline). Entries are never rewritten.
+ */
+export interface WorkflowAuditEntry {
+    ts: string;
+    /** Owning user id (resolveActiveOwnerUserId) at the time of the action. */
+    actor: string;
+    /** e.g. created / updated / patched / activated / deactivated / published / archived /
+     *  reverted / deleted / imported / duplicated / permissionGranted / publishedToHub */
+    action: string;
+    workflowId: string;
+    detail?: Record<string, unknown>;
+}
+export declare class WorkflowAuditStore {
+    private readonly file;
+    /** `rootDir` = the project's workflows dir (same root the WorkflowStore uses). */
+    constructor(rootDir: string);
+    /**
+     * Append one entry. Failures are LOUD on stderr but never break the business write that
+     * triggered them (an audit-log disk error must not corrupt a successful state change).
+     */
+    append(entry: WorkflowAuditEntry): void;
+    /** Newest-first entries, optionally filtered to one workflow. Malformed lines are skipped loud. */
+    list(workflowId?: string, limit?: number): WorkflowAuditEntry[];
+}

package/dist/orchestration/workflow/workflow-audit-store.js

@@ -0,0 +1,55 @@
+/**
+ * Workflow audit log (IT-12, spec D38): WHO did WHAT to WHICH workflow WHEN —
+ * configuration/lifecycle changes only. Runs are deliberately NOT duplicated here:
+ * WorkflowRunHistoryStore is already the complete run audit (trigger/timing/status/per-node);
+ * a timeline UI merges both sources.
+ *
+ * Storage: append-only JSONL at `<project>/.qlogicagent/workflows/audit.jsonl` (project-level
+ * single file — the natural unit for a cross-workflow timeline). Entries are never rewritten.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export class WorkflowAuditStore {
+    file;
+    /** `rootDir` = the project's workflows dir (same root the WorkflowStore uses). */
+    constructor(rootDir) {
+        this.file = path.join(rootDir, "audit.jsonl");
+    }
+    /**
+     * Append one entry. Failures are LOUD on stderr but never break the business write that
+     * triggered them (an audit-log disk error must not corrupt a successful state change).
+     */
+    append(entry) {
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            fs.appendFileSync(this.file, `${JSON.stringify(entry)}\n`, "utf8");
+        }
+        catch (err) {
+            process.stderr.write(`[workflow:audit] WRITE FAILED (${err instanceof Error ? err.message : String(err)}) — entry: ${JSON.stringify(entry)}\n`);
+        }
+    }
+    /** Newest-first entries, optionally filtered to one workflow. Malformed lines are skipped loud. */
+    list(workflowId, limit = 100) {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.file, "utf8");
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const e = JSON.parse(line);
+                if (!workflowId || e.workflowId === workflowId)
+                    out.push(e);
+            }
+            catch {
+                process.stderr.write(`[workflow:audit] skipping malformed line: ${line.slice(0, 120)}\n`);
+            }
+        }
+        return out.reverse().slice(0, limit);
+    }
+}

package/dist/orchestration/workflow/workflow-bundle.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Portable workflow bundle (spec D23) — THE single serialization format shared by
+ * export / import / save-as(duplicate) / Hub publish / Hub apply. Two invariants:
+ *
+ * 1. SANITIZED: credentials never leave the machine inside a bundle. Any params key that
+ *    looks credential-shaped has its VALUE stripped and is recorded as a CredentialRequirement
+ *    the importer must re-bind. Unknown-but-suspicious shapes fail toward stripping (§1.5:
+ *    never silently carry a secret out).
+ * 2. SELF-DESCRIBING: `requires` lists the capabilities (tool/agent/mcp/channel/skill) the
+ *    graph references, so an importer (or the Hub apply checklist) can verify bindings
+ *    BEFORE activating instead of failing mid-run.
+ */
+import type { WorkflowDef } from "./node-schema.js";
+import type { TriggerDef } from "./workflow-trigger.js";
+import type { ConcurrencyPolicy, WorkflowRecord } from "./workflow-store.js";
+export declare const WORKFLOW_BUNDLE_SCHEMA_VERSION = 2;
+export interface CapabilityRequirement {
+    category: "agent" | "tool" | "skill" | "mcp" | "memory" | "channel";
+    kind: string;
+    /** Concrete capability reference (tool name / agent id / "server.tool" / channel name). */
+    ref: string;
+    /** Human-readable label shown in the apply/bind checklist. */
+    label: string;
+    nodeIds: string[];
+}
+export interface CredentialRequirement {
+    /** Best-effort type hint; v1 marks all stripped values "custom" (vault types land in IT-7). */
+    type: "apiKey" | "bearer" | "basic" | "oauth2" | "custom";
+    /** Where the value was stripped from, e.g. `节点「发飞书」 params.headers.Authorization`. */
+    label: string;
+    nodeIds: string[];
+}
+export interface WorkflowBundle {
+    schemaVersion: typeof WORKFLOW_BUNDLE_SCHEMA_VERSION;
+    name: string;
+    description?: string;
+    def: WorkflowDef;
+    trigger?: TriggerDef;
+    concurrency?: ConcurrencyPolicy;
+    requires: CapabilityRequirement[];
+    credentialsRequired: CredentialRequirement[];
+    meta?: {
+        author?: string;
+        tags?: string[];
+        category?: string;
+        version?: string;
+        source?: "native" | "n8n";
+    };
+}
+/** Placeholder left where a credential value was stripped (visibly broken > silently leaked). */
+export declare const STRIPPED_CREDENTIAL_PLACEHOLDER = "__CREDENTIAL_REQUIRED__";
+/** Derive the capability requirements a graph references (host-backed kinds only). */
+export declare function deriveRequirements(def: WorkflowDef): CapabilityRequirement[];
+/** Serialize a stored record into a sanitized, self-describing portable bundle. */
+export declare function toWorkflowBundle(record: WorkflowRecord): WorkflowBundle;
+export interface ParsedBundle {
+    name: string;
+    def: WorkflowDef;
+    trigger?: TriggerDef;
+    concurrency?: ConcurrencyPolicy;
+    requires: CapabilityRequirement[];
+    credentialsRequired: CredentialRequirement[];
+}
+/** Parse + validate an incoming bundle payload. fail-loud on malformed shapes (§1.5). */
+export declare function fromWorkflowBundle(payload: unknown): ParsedBundle;

package/dist/orchestration/workflow/workflow-bundle.js

@@ -0,0 +1,168 @@
+/**
+ * Portable workflow bundle (spec D23) — THE single serialization format shared by
+ * export / import / save-as(duplicate) / Hub publish / Hub apply. Two invariants:
+ *
+ * 1. SANITIZED: credentials never leave the machine inside a bundle. Any params key that
+ *    looks credential-shaped has its VALUE stripped and is recorded as a CredentialRequirement
+ *    the importer must re-bind. Unknown-but-suspicious shapes fail toward stripping (§1.5:
+ *    never silently carry a secret out).
+ * 2. SELF-DESCRIBING: `requires` lists the capabilities (tool/agent/mcp/channel/skill) the
+ *    graph references, so an importer (or the Hub apply checklist) can verify bindings
+ *    BEFORE activating instead of failing mid-run.
+ */
+export const WORKFLOW_BUNDLE_SCHEMA_VERSION = 2;
+/** Keys whose values must never travel inside a bundle (case-insensitive substring match). */
+const CREDENTIAL_KEY_PATTERN = /token|secret|authorization|api[-_]?key|apikey|password|credential|cookie|passphrase|private[-_]?key/i;
+/** Placeholder left where a credential value was stripped (visibly broken > silently leaked). */
+export const STRIPPED_CREDENTIAL_PLACEHOLDER = "__CREDENTIAL_REQUIRED__";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Deep-copy `value`, stripping credential-shaped entries. Returns the sanitized copy and
+ * appends a CredentialRequirement per stripped key.
+ */
+function sanitizeValue(value, pathLabel, nodeId, nodeLabel, found) {
+    if (Array.isArray(value)) {
+        return value.map((item, i) => sanitizeValue(item, `${pathLabel}[${i}]`, nodeId, nodeLabel, found));
+    }
+    if (!isPlainObject(value))
+        return value;
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+        if (CREDENTIAL_KEY_PATTERN.test(key) && inner !== undefined && inner !== null && inner !== "") {
+            found.push({
+                type: "custom",
+                label: `${nodeLabel} ${pathLabel}.${key}`,
+                nodeIds: [nodeId],
+            });
+            out[key] = STRIPPED_CREDENTIAL_PLACEHOLDER;
+            continue;
+        }
+        out[key] = sanitizeValue(inner, `${pathLabel}.${key}`, nodeId, nodeLabel, found);
+    }
+    return out;
+}
+function mergeCredentialRequirements(reqs) {
+    const byLabel = new Map();
+    for (const req of reqs) {
+        const existing = byLabel.get(req.label);
+        if (existing) {
+            for (const id of req.nodeIds)
+                if (!existing.nodeIds.includes(id))
+                    existing.nodeIds.push(id);
+        }
+        else {
+            byLabel.set(req.label, { ...req, nodeIds: [...req.nodeIds] });
+        }
+    }
+    return [...byLabel.values()];
+}
+function nodeLabel(node) {
+    return `节点「${node.name ?? node.id}」`;
+}
+/** Derive the capability requirements a graph references (host-backed kinds only). */
+export function deriveRequirements(def) {
+    const byKey = new Map();
+    const add = (req, nodeId) => {
+        const key = `${req.category}:${req.ref}`;
+        const existing = byKey.get(key);
+        if (existing) {
+            if (!existing.nodeIds.includes(nodeId))
+                existing.nodeIds.push(nodeId);
+        }
+        else {
+            byKey.set(key, { ...req, nodeIds: [nodeId] });
+        }
+    };
+    for (const node of def.nodes) {
+        const p = (node.params ?? {});
+        switch (node.kind) {
+            case "agent": {
+                const agentId = typeof p.agentId === "string" && p.agentId && p.agentId !== "self" ? p.agentId : "qlogicagent";
+                add({ category: "agent", kind: "agent", ref: agentId, label: `Agent: ${agentId}` }, node.id);
+                break;
+            }
+            case "tool": {
+                const tool = typeof p.tool === "string" ? p.tool : "";
+                if (tool)
+                    add({ category: "tool", kind: "tool", ref: tool, label: `工具: ${tool}` }, node.id);
+                break;
+            }
+            case "skill": {
+                const skill = typeof p.skill === "string" ? p.skill : "";
+                if (skill)
+                    add({ category: "skill", kind: "skill", ref: skill, label: `技能: ${skill}` }, node.id);
+                break;
+            }
+            case "mcp": {
+                const server = typeof p.server === "string" ? p.server : "";
+                const tool = typeof p.tool === "string" ? p.tool : "";
+                if (server)
+                    add({ category: "mcp", kind: "mcp", ref: tool ? `${server}.${tool}` : server, label: `MCP: ${server}${tool ? ` / ${tool}` : ""}` }, node.id);
+                break;
+            }
+            case "channel": {
+                const channel = typeof p.channel === "string" ? p.channel : "";
+                if (channel)
+                    add({ category: "channel", kind: "channel", ref: channel, label: `渠道: ${channel}` }, node.id);
+                break;
+            }
+            case "memory": {
+                add({ category: "memory", kind: "memory", ref: "memory", label: "记忆读写" }, node.id);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return [...byKey.values()];
+}
+/** Serialize a stored record into a sanitized, self-describing portable bundle. */
+export function toWorkflowBundle(record) {
+    const credentials = [];
+    const nodes = record.def.nodes.map((node) => ({
+        ...node,
+        ...(node.params !== undefined
+            ? { params: sanitizeValue(node.params, "params", node.id, nodeLabel(node), credentials) }
+            : {}),
+    }));
+    const def = { ...record.def, nodes };
+    return {
+        schemaVersion: WORKFLOW_BUNDLE_SCHEMA_VERSION,
+        name: record.name,
+        def,
+        ...(record.trigger ? { trigger: record.trigger } : {}),
+        concurrency: record.concurrency,
+        requires: deriveRequirements(def),
+        credentialsRequired: mergeCredentialRequirements(credentials),
+        meta: { source: "native" },
+    };
+}
+/** Parse + validate an incoming bundle payload. fail-loud on malformed shapes (§1.5). */
+export function fromWorkflowBundle(payload) {
+    const raw = typeof payload === "string" ? JSON.parse(payload) : payload;
+    if (!isPlainObject(raw))
+        throw new Error("workflow bundle: payload must be an object");
+    if (raw.schemaVersion !== WORKFLOW_BUNDLE_SCHEMA_VERSION) {
+        throw new Error(`workflow bundle: unsupported schemaVersion ${String(raw.schemaVersion)} (expected ${WORKFLOW_BUNDLE_SCHEMA_VERSION})`);
+    }
+    if (typeof raw.name !== "string" || !raw.name)
+        throw new Error("workflow bundle: `name` is required");
+    const def = raw.def;
+    if (!isPlainObject(def) || !Array.isArray(def.nodes) || !Array.isArray(def.edges)) {
+        throw new Error("workflow bundle: `def.nodes` and `def.edges` are required arrays");
+    }
+    const concurrency = raw.concurrency;
+    if (concurrency !== undefined && concurrency !== "queue" && concurrency !== "skip" && concurrency !== "parallel") {
+        throw new Error(`workflow bundle: invalid concurrency "${String(concurrency)}"`);
+    }
+    return {
+        name: raw.name,
+        def: def,
+        trigger: isPlainObject(raw.trigger) ? raw.trigger : undefined,
+        concurrency: concurrency,
+        requires: Array.isArray(raw.requires) ? raw.requires : [],
+        credentialsRequired: Array.isArray(raw.credentialsRequired) ? raw.credentialsRequired : [],
+    };
+}