qlogicagent 2.13.5 → 2.13.6

package/dist/orchestration/workflow/host-executors.js

@@ -1,207 +0,0 @@
-/**
- * Host-backed NodeExecutors (M3 bridge contract; plan D12/D13, spec §B).
- *
- * The engine is a pure executor: kinds that need real-world capabilities (agent / tool / http /
- * mcp / channel) are fulfilled by an injected `ExecutorHost`. In production the openclaw gateway
- * (or the qlogicagent CLI host) provides a real host; the engine never imports those subsystems.
- *
- * These executors are REAL (not mocks): they read the node's resolved params + inputs and delegate
- * to the host. fail-loud — invoking a host-backed kind with no host throws (no silent fallback).
- */
-import { isUnattendedTrigger } from "./node-schema.js";
-function requireHost(host, kind) {
-    if (!host) {
-        throw new Error(`Node kind "${kind}" requires a host (ExecutorHost) but none was injected. ` +
-            `Provide one via WorkflowRuntimeOptions.host.`);
-    }
-    return host;
-}
-function str(params, key, kind) {
-    const v = params[key];
-    if (typeof v !== "string" || v.length === 0) {
-        throw new Error(`Node kind "${kind}" requires string param "${key}"`);
-    }
-    return v;
-}
-function obj(params, key) {
-    const v = params[key];
-    if (v === undefined || v === null)
-        return {};
-    if (typeof v !== "object" || Array.isArray(v)) {
-        throw new Error(`Param "${key}" must be an object`);
-    }
-    return v;
-}
-/** `agent`: run an agent turn via the host. params: { agentId?, prompt }. */
-const agentExec = async (inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "agent");
-    const items = await host.runAgent({
-        agentId: typeof params.agentId === "string" ? params.agentId : undefined,
-        prompt: str(params, "prompt", "agent"),
-        input: inputs.default ?? [],
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/** `tool`: invoke a qlogicagent tool via the host. params: { tool, args? }. */
-const toolExec = async (inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "tool");
-    const items = await host.invokeTool({
-        tool: str(params, "tool", "tool"),
-        args: obj(params, "args"),
-        // IT-7b: unattended runs get a fine-grained operation audit host-side (kind-level
-        // grants don't excuse destructive/cross-workspace specifics).
-        unattended: isUnattendedTrigger(ctx.triggerKind ?? "manual"),
-        input: inputs.default ?? [],
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/** `http`: perform an HTTP request via the host. params: { method?, url, headers?, body?, credentialId? }. */
-const httpExec = async (_inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "http");
-    const method = typeof params.method === "string" ? params.method : "GET";
-    const items = await host.httpRequest({
-        method,
-        url: str(params, "url", "http"),
-        headers: params.headers,
-        body: params.body,
-        credentialId: typeof params.credentialId === "string" && params.credentialId ? params.credentialId : undefined,
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/** `mcp`: invoke an MCP server tool via the host. params: { server, tool, args? }. */
-const mcpExec = async (_inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "mcp");
-    const items = await host.invokeMcp({
-        server: str(params, "server", "mcp"),
-        tool: str(params, "tool", "mcp"),
-        args: obj(params, "args"),
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/** `channel`: send out through a channel via the host (openclaw channel layer). */
-const channelExec = async (inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "channel");
-    const items = await host.sendChannel({
-        channel: str(params, "channel", "channel"),
-        target: typeof params.target === "string" ? params.target : undefined,
-        payload: params.payload ?? inputs.default?.[0]?.json ?? {},
-        input: inputs.default ?? [],
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/**
- * `skill`: run an installed skill (spec D25). params: { skill, args? }.
- * Single-track: delegates to the existing skill meta-tool via the SAME invokeTool host
- * callback (action:"invoke") — no parallel skill-execution plumbing.
- */
-const skillExec = async (inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "skill");
-    const args = params.args;
-    const items = await host.invokeTool({
-        tool: "skill",
-        args: {
-            action: "invoke",
-            name: str(params, "skill", "skill"),
-            ...(args !== undefined && args !== null && args !== "" ? { args } : {}),
-        },
-        input: inputs.default ?? [],
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/**
- * `memory`: project-scoped memdir read/write/search (spec D25).
- * params: { op: "read"|"write"|"search", key?, value?, query?, scope? }.
- * scope defaults to the owning project; "global" is rejected until the unattended
- * permission gate lands (IT-7) — fail-loud, not silently widened.
- */
-const memoryExec = async (inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "memory");
-    if (!host.memory) {
-        throw new Error(`Node kind "memory" requires an ExecutorHost with a memory backend`);
-    }
-    const op = str(params, "op", "memory");
-    if (op !== "read" && op !== "write" && op !== "search") {
-        throw new Error(`memory node: op must be "read"|"write"|"search", got "${op}"`);
-    }
-    if (params.scope === "global") {
-        throw new Error(`memory node: scope "global" 需经权限闸门(未开放);默认项目级请移除 scope`);
-    }
-    const items = await host.memory({
-        op,
-        key: typeof params.key === "string" && params.key ? params.key : undefined,
-        value: params.value !== undefined ? params.value : inputs.default?.[0]?.json,
-        query: typeof params.query === "string" ? params.query : undefined,
-        input: inputs.default ?? [],
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/**
- * `subworkflow` (D34): run another workflow as one step. params: { workflowId, projectId?, payload? }.
- * Cycle/depth guarding lives in the host (it owns the cross-root view).
- */
-const subworkflowExec = async (inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "subworkflow");
-    if (!host.runSubworkflow)
-        throw new Error(`Node kind "subworkflow" requires an ExecutorHost with runSubworkflow`);
-    const payload = params.payload && typeof params.payload === "object" && !Array.isArray(params.payload)
-        ? params.payload
-        : inputs.default?.[0]?.json;
-    const items = await host.runSubworkflow({
-        workflowId: str(params, "workflowId", "subworkflow"),
-        callerWorkflowId: ctx.workflowId,
-        projectId: typeof params.projectId === "string" && params.projectId ? params.projectId : undefined,
-        payload,
-        input: inputs.default ?? [],
-        signal: ctx.signal,
-    });
-    return { outputs: { default: items } };
-};
-/**
- * `approval` (D34 human-in-the-loop): notify the owner, AWAIT the decision, then either pass the
- * inputs through (approved) or fail the node (denied/timeout — D32 onError applies like any failure).
- */
-const approvalExec = async (inputs, params, ctx) => {
-    const host = requireHost(ctx.host, "approval");
-    if (!host.approval)
-        throw new Error(`Node kind "approval" requires an ExecutorHost with approval`);
-    const decision = await host.approval({
-        nodeId: ctx.nodeId,
-        workflowId: ctx.workflowId,
-        prompt: typeof params.prompt === "string" && params.prompt ? params.prompt : undefined,
-        timeoutMs: typeof params.timeoutMs === "number" && params.timeoutMs > 0 ? params.timeoutMs : undefined,
-        input: inputs.default ?? [],
-        signal: ctx.signal,
-    });
-    if (!decision.approved) {
-        throw new Error(`approval node "${ctx.nodeId}" denied${decision.note ? `: ${decision.note}` : ""} (${decision.decidedAt})`);
-    }
-    return {
-        outputs: {
-            default: [
-                ...(inputs.default ?? []),
-                { json: { approved: true, decidedAt: decision.decidedAt, ...(decision.note ? { note: decision.note } : {}) } },
-            ],
-        },
-    };
-};
-/** The host-backed kinds. Register these into a NodeRegistry to enable agent/tool/http/mcp/channel/skill/memory/subworkflow/approval. */
-export const hostExecutors = {
-    agent: agentExec,
-    tool: toolExec,
-    http: httpExec,
-    mcp: mcpExec,
-    channel: channelExec,
-    skill: skillExec,
-    memory: memoryExec,
-    subworkflow: subworkflowExec,
-    approval: approvalExec,
-};
-/** Host-backed kind names (used by callers to know which kinds need a host). */
-export const HOST_BACKED_KINDS = Object.keys(hostExecutors);

package/dist/orchestration/workflow/n8n-expression.d.ts

@@ -1,48 +0,0 @@
-/**
- * n8n expression → restricted-language converter (IT-11, spec D35).
- *
- * n8n expressions are arbitrary JS inside `={{ }}`; our language is a fixed grammar
- * (path access + literal + whitelist functions — see expression.ts, D6 hard line: NO eval).
- * So conversion is a CURATED rewrite of the safe overlap, gated by our own parser:
- * every rewritten body must pass `validateExpressionSyntax` or the whole parameter is
- * flagged "manual" — we never emit anything our language can't parse, and we never
- * approximate semantics silently.
- *
- * Convertible subset (n8n → ours):
- *   $json.path / $json["k"]                     → unchanged
- *   $node["X"].json.y                           → $node("X").output.default[0].json.y
- *   $('X').item.json.y / $('X').first().json.y  → $node("X").output.default[0].json.y
- *   $items("X")[i].json.y                       → $node("X").output.default[i].json.y
- *   $input.item.json / $input.first().json      → $json
- *   $now                                        → $now (note: n8n is Luxon, ours is Date)
- * Anything else ($today, $binary, $workflow, .method() calls, operators, …) → manual.
- */
-export type ExpressionConversion = {
-    ok: true;
-    converted: string;
-    notes: string[];
-} | {
-    ok: false;
-    reason: string;
-};
-/**
- * Convert one n8n parameter STRING. n8n marks expression strings with a leading `=`;
- * inside, `{{ }}` segments are evaluated and the rest is literal text. Strings without
- * the `=` prefix are plain literals (returned unchanged, not counted as conversions).
- */
-export declare function convertN8nExpression(raw: string): ExpressionConversion | null;
-export interface ParamConversionStats {
-    converted: number;
-    manual: Array<{
-        path: string;
-        raw: string;
-        reason: string;
-    }>;
-    notes: string[];
-}
-/**
- * Deep-walk a params object converting every n8n expression string in place (returns a new
- * object). Unconvertible expressions KEEP their raw n8n text (visible, greppable) and are
- * reported in `stats.manual` — explicit degradation, never silent loss.
- */
-export declare function convertN8nParams(params: Record<string, unknown>, stats: ParamConversionStats, basePath?: string): Record<string, unknown>;

package/dist/orchestration/workflow/n8n-expression.js

@@ -1,95 +0,0 @@
-/**
- * n8n expression → restricted-language converter (IT-11, spec D35).
- *
- * n8n expressions are arbitrary JS inside `={{ }}`; our language is a fixed grammar
- * (path access + literal + whitelist functions — see expression.ts, D6 hard line: NO eval).
- * So conversion is a CURATED rewrite of the safe overlap, gated by our own parser:
- * every rewritten body must pass `validateExpressionSyntax` or the whole parameter is
- * flagged "manual" — we never emit anything our language can't parse, and we never
- * approximate semantics silently.
- *
- * Convertible subset (n8n → ours):
- *   $json.path / $json["k"]                     → unchanged
- *   $node["X"].json.y                           → $node("X").output.default[0].json.y
- *   $('X').item.json.y / $('X').first().json.y  → $node("X").output.default[0].json.y
- *   $items("X")[i].json.y                       → $node("X").output.default[i].json.y
- *   $input.item.json / $input.first().json      → $json
- *   $now                                        → $now (note: n8n is Luxon, ours is Date)
- * Anything else ($today, $binary, $workflow, .method() calls, operators, …) → manual.
- */
-import { validateExpressionSyntax } from "./expression.js";
-/** Rewrite one expression BODY (text inside {{ }}) from n8n syntax to ours. */
-function rewriteBody(body) {
-    const notes = [];
-    let out = body;
-    // $node["X"].json…  →  $node("X").output.default[0].json…
-    out = out.replace(/\$node\[\s*(['"])([^'"\]]+)\1\s*\]\.json/g, '$node("$2").output.default[0].json');
-    // $('X').item.json / $('X').first().json / $("X").json  →  $node("X").output.default[0].json
-    out = out.replace(/\$\(\s*(['"])([^'")]+)\1\s*\)(?:\.item|\.first\(\))?\.json/g, '$node("$2").output.default[0].json');
-    // $items("X")[i].json  →  $node("X").output.default[i].json
-    out = out.replace(/\$items\(\s*(['"])([^'")]+)\1\s*\)\[(\d+)\]\.json/g, '$node("$2").output.default[$3].json');
-    // $input.item.json / $input.first().json  →  $json
-    out = out.replace(/\$input(?:\.item|\.first\(\))\.json/g, "$json");
-    if (/\$now\b/.test(out))
-        notes.push("$now:n8n 为 Luxon DateTime,此处为 Date(格式化函数用 date(...))");
-    return { body: out, notes };
-}
-/**
- * Convert one n8n parameter STRING. n8n marks expression strings with a leading `=`;
- * inside, `{{ }}` segments are evaluated and the rest is literal text. Strings without
- * the `=` prefix are plain literals (returned unchanged, not counted as conversions).
- */
-export function convertN8nExpression(raw) {
-    if (!raw.startsWith("="))
-        return null; // plain literal — nothing to convert
-    const text = raw.slice(1);
-    if (!text.includes("{{")) {
-        // `=` prefix without {{ }} is just a literal in n8n's UI semantics.
-        return { ok: true, converted: text, notes: [] };
-    }
-    const allNotes = [];
-    let failure = null;
-    const converted = text.replace(/\{\{([\s\S]*?)\}\}/g, (_m, inner) => {
-        if (failure)
-            return _m;
-        const { body, notes } = rewriteBody(inner.trim());
-        const syntaxError = validateExpressionSyntax(body);
-        if (syntaxError) {
-            failure = `表达式「{{ ${inner.trim()} }}」超出受限语言(${syntaxError})`;
-            return _m;
-        }
-        allNotes.push(...notes);
-        return `{{ ${body} }}`;
-    });
-    if (failure)
-        return { ok: false, reason: failure };
-    return { ok: true, converted, notes: allNotes };
-}
-/**
- * Deep-walk a params object converting every n8n expression string in place (returns a new
- * object). Unconvertible expressions KEEP their raw n8n text (visible, greppable) and are
- * reported in `stats.manual` — explicit degradation, never silent loss.
- */
-export function convertN8nParams(params, stats, basePath = "") {
-    const walk = (value, p) => {
-        if (typeof value === "string") {
-            const res = convertN8nExpression(value);
-            if (res === null)
-                return value;
-            if (res.ok) {
-                stats.converted++;
-                stats.notes.push(...res.notes);
-                return res.converted;
-            }
-            stats.manual.push({ path: p, raw: value, reason: res.reason });
-            return value;
-        }
-        if (Array.isArray(value))
-            return value.map((v, i) => walk(v, `${p}[${i}]`));
-        if (value && typeof value === "object") {
-            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(v, p ? `${p}.${k}` : k)]));
-        }
-        return value;
-    };
-    return walk(params, basePath);
-}

package/dist/orchestration/workflow/n8n-import.d.ts

@@ -1,68 +0,0 @@
-/**
- * n8n workflow JSON import — read-format-only translator (plan M5 §2.1: "导入 n8n workflow JSON
- * (读格式,不打包其代码)"), deepened for IT-11 (spec D35).
- *
- * Converts an n8n workflow export (its public JSON shape: `nodes` + `connections`) into our own
- * WorkflowDef. This reads n8n's data FORMAT only — it links/embeds NONE of n8n's runtime code, so
- * the SUL licensing concern (plan §2.1 / risk register) does not apply.
- *
- * Error model (IT-11): STRUCTURAL problems (malformed JSON, duplicate/missing node names, dangling
- * connections) stay fail-loud — the graph identity itself is broken, nothing useful survives.
- * SEMANTIC gaps (unmapped node type, inconvertible expression, Code-node JS) DEGRADE EXPLICITLY:
- * the node lands as kind "manual" (its executor throws at run time — never silently passes
- * through), the original n8n type/params are preserved for the human, and every degradation is
- * itemized in the returned ConversionReport. Nothing is silently dropped; no JS is ever executed
- * (D6 hard line — n8n Code nodes are flagged manual, not emulated).
- *
- * Credentials: n8n nodes carry `credentials: {type: {id,name}}` references. The secrets are NOT
- * in the export — we extract them as CredentialRequirement entries (mapped to vault types, D29)
- * so the import UI can walk the user through re-binding.
- */
-import type { WorkflowDef } from "./node-schema.js";
-export interface N8nNodeReport {
-    id: string;
-    n8nType: string;
-    /** converted=faithful; partial=landed but params need attention; manual=placeholder node; skipped=annotation dropped. */
-    outcome: "converted" | "partial" | "manual" | "skipped";
-    notes: string[];
-}
-export interface N8nCredentialRequirement {
-    nodeId: string;
-    n8nCredentialType: string;
-    /** n8n-side display name of the credential (helps the user recognize which secret to re-create). */
-    label?: string;
-    /** Suggested vault credential type (D29). */
-    suggestedVaultType: string;
-}
-export interface N8nConversionReport {
-    /** full=everything faithful; partial=some degradations; manual=at least one manual placeholder. */
-    status: "full" | "partial" | "manual";
-    nodes: N8nNodeReport[];
-    expressions: {
-        converted: number;
-        manual: Array<{
-            nodeId: string;
-            path: string;
-            raw: string;
-            reason: string;
-        }>;
-    };
-    credentials: N8nCredentialRequirement[];
-    notes: string[];
-}
-export interface N8nImportResult {
-    name: string;
-    def: WorkflowDef;
-    report: N8nConversionReport;
-}
-/** Thrown when an n8n workflow is STRUCTURALLY untranslatable. Carries every problem found. */
-export declare class N8nImportError extends Error {
-    readonly errors: string[];
-    constructor(errors: string[]);
-}
-/**
- * Convert an n8n workflow (a JSON string or already-parsed object) into a WorkflowDef + report.
- * The returned def is NOT yet graph-validated — pass it to `validateWorkflowDef` / a controller
- * write path, which is the single existing invariant gate.
- */
-export declare function convertN8nWorkflow(input: string | unknown, workflowId: string): N8nImportResult;