@ixo/editor 5.37.1 → 5.39.0

package/dist/{chunk-OOPKMGYW.mjs → chunk-YWZJYSOP.js}

@@ -116,7 +116,12 @@ var CAN_TO_TYPE = {
   "pod/governance-config": "qi/pod.governance-config",
   "pod/member-multi-select": "qi/pod.member-multi-select",
   "pod/list-domain-flows": "qi/pod.list-domain-flows",
-  // Calendar integration
+  // Delegated integrations (author connects once, runners execute on their behalf)
+  "gmail.email/send": "qi/gmail.email.send",
+  "outlook.email/send": "qi/outlook.email.send",
+  "slack.message/send": "qi/slack.message.send",
+  "googlecalendar.event/create": "qi/googlecalendar.event.create",
+  // Calendar integration (self-connected)
   "calendar.event/create": "qi/calendar.event.create",
   "calendar.event/update": "qi/calendar.event.update",
   "calendar.event/list": "qi/calendar.event.list",
@@ -238,7 +243,8 @@ function buildServicesFromHandlers(handlers) {
     integrations: handlers?.integrations?.executeTool ? {
       executeTool: async (args) => handlers.integrations.executeTool(args),
       fetchCurrentState: handlers.integrations.fetchCurrentState ? async (args) => handlers.integrations.fetchCurrentState(args) : void 0,
-      getEntityDid: handlers?.getEntityDid ? () => handlers.getEntityDid() : void 0
+      getEntityDid: handlers?.getEntityDid ? () => handlers.getEntityDid() : void 0,
+      executeBinding: handlers.integrations.executeBinding ? async (args) => handlers.integrations.executeBinding(args) : void 0
     } : void 0,
     oracle: handlers?.generateWallet ? {
       generateWallet: async () => handlers.generateWallet(),
@@ -1157,6 +1163,10 @@ function registerFormSubmitAction(type, can) {
     sideEffect: true,
     defaultRequiresConfirmation: false,
     requiredCapability: "flow/execute",
+    // Additive: makes the form an event SOURCE so downstream blocks can
+    // auto-trigger on submission (e.g. form → send email). Nothing existing
+    // consumes this; it only enables new event wiring.
+    eligibleForEventTrigger: true,
     inputSchema: {
       type: "object",
       required: [],
@@ -1168,6 +1178,15 @@ function registerFormSubmitAction(type, can) {
       { path: "form.answers", displayName: "Form Answers JSON", type: "string", description: "JSON stringified form answers, matching form block runtime output." },
       { path: "answers", displayName: "Form Answers", type: "object", description: "Parsed form answers object for convenience." }
     ],
+    events: [
+      {
+        name: "form.submitted",
+        displayName: "Form submitted",
+        description: "Fires when the human submits the form. Payload carries the parsed answers.",
+        payloadSchema: [{ path: "answers", displayName: "Form Answers", type: "object" }],
+        pendingDisplayFields: ["answers"]
+      }
+    ],
     run: async (inputs) => {
       const answers = normalizeAnswers(inputs.answers ?? inputs.form?.answers);
       const answersJson = JSON.stringify(answers);
@@ -1177,7 +1196,8 @@ function registerFormSubmitAction(type, can) {
             answers: answersJson
           },
           answers
-        }
+        },
+        events: [{ name: "form.submitted", payload: { answers } }]
       };
     }
   });
@@ -4483,7 +4503,7 @@ registerAction({
     if (!ctx.services.matrix?.storeCredential) {
       throw new Error("Matrix credential storage service not configured");
     }
-    const { computeJsonCID } = await import("./cid-6O646X2I.mjs");
+    const { computeJsonCID } = await import("./cid-HDAVQ43S.js");
     const cid = await computeJsonCID(parsedCredential);
     const result = await ctx.services.matrix.storeCredential({
       roomId: roomId || "",
@@ -6292,6 +6312,379 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/_shared/delegatedTool.ts
+function parseBoundConnection(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const c = raw;
+  if (typeof c.bindingId !== "string" || !c.bindingId) return null;
+  if (typeof c.connectedAccountId !== "string") return null;
+  if (typeof c.toolkit !== "string") return null;
+  return {
+    bindingId: c.bindingId,
+    connectedAccountId: c.connectedAccountId,
+    toolkit: c.toolkit,
+    label: typeof c.label === "string" ? c.label : null
+  };
+}
+function parseDelegatedToolInputs(raw) {
+  let parsed = {};
+  try {
+    parsed = typeof raw === "string" ? JSON.parse(raw || "{}") : raw || {};
+  } catch {
+    parsed = {};
+  }
+  return { ...parsed, connection: parseBoundConnection(parsed.connection) };
+}
+function serializeDelegatedToolInputs(inputs) {
+  return JSON.stringify(inputs);
+}
+function fieldValues(inputs) {
+  const out = {};
+  for (const [k, v] of Object.entries(inputs)) {
+    if (k === "connection") continue;
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+function missingRequired(schema, values) {
+  return (schema.parameters.required || []).filter((name) => !(values[name] ?? "").trim());
+}
+function coerceToolArgs(schema, values) {
+  const out = {};
+  for (const [name, prop] of Object.entries(schema.parameters.properties || {})) {
+    const raw = values[name];
+    if (typeof raw !== "string" || raw.trim() === "") continue;
+    const type = prop.type;
+    if (type === "boolean") {
+      out[name] = raw === "true";
+    } else if (type === "array") {
+      out[name] = raw.split(/[\n,]+/).map((s) => s.trim()).filter(Boolean);
+    } else if (type === "number" || type === "integer") {
+      const n = Number(raw);
+      if (!Number.isNaN(n)) out[name] = n;
+    } else {
+      out[name] = raw;
+    }
+  }
+  return out;
+}
+async function executeDelegatedTool(ctx, opts) {
+  const svc = ctx.services.integrations;
+  if (!svc?.executeBinding) {
+    throw new Error(`${opts.toolkitLabel} integration is not configured.`);
+  }
+  const bindingId = opts.connection?.bindingId;
+  if (!bindingId) {
+    throw new Error(`No ${opts.toolkitLabel} account is bound. The template author must connect and bind ${opts.toolkitLabel}.`);
+  }
+  const missing = missingRequired(opts.schema, opts.values);
+  if (missing.length > 0) {
+    throw new Error(`Missing required field${missing.length === 1 ? "" : "s"}: ${missing.join(", ")}`);
+  }
+  const args = coerceToolArgs(opts.schema, opts.values);
+  const result = await svc.executeBinding({ bindingId, toolSlug: opts.toolSlug, arguments: args });
+  if (!result.successful) {
+    if (result.code === "AUTH_EXPIRED") {
+      throw new Error(`The template author's ${opts.toolkitLabel} access expired \u2014 they need to reconnect it in the template.`);
+    }
+    if (result.code === "UPSTREAM_4XX" && /not found|removed/i.test(result.error || "")) {
+      throw new Error(`This ${opts.toolkitLabel} integration was removed by the template author.`);
+    }
+    throw new Error(result.error || `${opts.toolkitLabel} action failed.`);
+  }
+  return result.data ?? {};
+}
+
+// src/core/lib/actionRegistry/actions/gmail/emailSend.types.ts
+var GMAIL_SEND_SLUG = "GMAIL_SEND_EMAIL";
+var GMAIL_SENT_EVENT = "email.sent";
+var GMAIL_SEND_SCHEMA = {
+  slug: GMAIL_SEND_SLUG,
+  name: "Send Email",
+  description: "Send an email from the template author's Gmail account.",
+  parameters: {
+    type: "object",
+    required: ["recipient_email", "body"],
+    properties: {
+      recipient_email: { type: "string", title: "To", description: "Recipient's email address." },
+      subject: { type: "string", title: "Subject" },
+      body: { type: "string", title: "Body", description: 'Email body. Plain text unless "HTML body" is set.' },
+      cc: { type: "array", title: "Cc", description: "Comma-separated email addresses." },
+      bcc: { type: "array", title: "Bcc", description: "Comma-separated email addresses." },
+      is_html: { type: "boolean", title: "HTML body", description: "Render the body as HTML." }
+    }
+  }
+};
+var GMAIL_SEND_OUTPUT_SCHEMA = [
+  { path: "messageId", displayName: "Message ID", type: "string", description: "Gmail id of the sent message" },
+  { path: "threadId", displayName: "Thread ID", type: "string" },
+  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" }
+];
+
+// src/core/lib/actionRegistry/actions/gmail/emailSend.ts
+registerAction({
+  type: "qi/gmail.email.send",
+  can: "gmail.email/send",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  // Can be wired to another block's event (e.g. form submitted → send email).
+  eligibleForEventTrigger: true,
+  outputSchema: GMAIL_SEND_OUTPUT_SCHEMA,
+  events: [
+    {
+      name: GMAIL_SENT_EVENT,
+      displayName: "Email sent",
+      description: "Fired after the email is sent from the author\u2019s Gmail.",
+      payloadSchema: [
+        { path: "messageId", displayName: "Message ID", type: "string" },
+        { path: "recipient_email", displayName: "To", type: "string" }
+      ],
+      pendingDisplayFields: ["messageId"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const parsed = parseDelegatedToolInputs(inputs);
+    const values = fieldValues(parsed);
+    const data = await executeDelegatedTool(ctx, {
+      connection: parsed.connection,
+      schema: GMAIL_SEND_SCHEMA,
+      toolSlug: GMAIL_SEND_SLUG,
+      values,
+      toolkitLabel: "Gmail"
+    });
+    const envelope = data.response_data ?? data;
+    const messageId = String(envelope.id ?? envelope.messageId ?? "");
+    const threadId = String(envelope.threadId ?? "");
+    return {
+      output: {
+        messageId,
+        threadId,
+        sentAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      events: messageId ? [{ name: GMAIL_SENT_EVENT, payload: { messageId, recipient_email: values.recipient_email ?? "" } }] : void 0
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/outlook/emailSend.types.ts
+var OUTLOOK_SEND_SLUG = "OUTLOOK_OUTLOOK_SEND_EMAIL";
+var OUTLOOK_SENT_EVENT = "email.sent";
+var OUTLOOK_SEND_SCHEMA = {
+  slug: OUTLOOK_SEND_SLUG,
+  name: "Send Email",
+  description: "Send an email from the template author's Outlook account.",
+  parameters: {
+    type: "object",
+    required: ["subject", "body", "to_email"],
+    properties: {
+      to_email: { type: "string", title: "To", description: "Recipient's email address." },
+      to_name: { type: "string", title: "To name", description: "Optional display name for the recipient." },
+      subject: { type: "string", title: "Subject" },
+      body: { type: "string", title: "Body", description: 'Email body. Plain text unless "HTML body" is set.' },
+      cc_emails: { type: "array", title: "Cc", description: "Comma-separated email addresses." },
+      bcc_emails: { type: "array", title: "Bcc", description: "Comma-separated email addresses." },
+      is_html: { type: "boolean", title: "HTML body", description: "Render the body as HTML." }
+    }
+  }
+};
+var OUTLOOK_SEND_OUTPUT_SCHEMA = [
+  { path: "messageId", displayName: "Message ID", type: "string" },
+  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" }
+];
+
+// src/core/lib/actionRegistry/actions/outlook/emailSend.ts
+registerAction({
+  type: "qi/outlook.email.send",
+  can: "outlook.email/send",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  // Can be wired to another block's event (e.g. form submitted → send email).
+  eligibleForEventTrigger: true,
+  outputSchema: OUTLOOK_SEND_OUTPUT_SCHEMA,
+  events: [
+    {
+      name: OUTLOOK_SENT_EVENT,
+      displayName: "Email sent",
+      description: "Fired after the email is sent from the author\u2019s Outlook.",
+      payloadSchema: [
+        { path: "messageId", displayName: "Message ID", type: "string" },
+        { path: "to_email", displayName: "To", type: "string" }
+      ],
+      pendingDisplayFields: ["messageId"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const parsed = parseDelegatedToolInputs(inputs);
+    const values = fieldValues(parsed);
+    const data = await executeDelegatedTool(ctx, {
+      connection: parsed.connection,
+      schema: OUTLOOK_SEND_SCHEMA,
+      toolSlug: OUTLOOK_SEND_SLUG,
+      values,
+      toolkitLabel: "Outlook"
+    });
+    const envelope = data.response_data ?? data;
+    const messageId = String(envelope.id ?? envelope.messageId ?? "");
+    return {
+      output: {
+        messageId,
+        sentAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      // Outlook often returns no id, so emit unconditionally.
+      events: [{ name: OUTLOOK_SENT_EVENT, payload: { messageId, to_email: values.to_email ?? "" } }]
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/slack/messageSend.types.ts
+var SLACK_SEND_SLUG = "SLACK_CHAT_POST_MESSAGE";
+var SLACK_SENT_EVENT = "message.sent";
+var SLACK_SEND_SCHEMA = {
+  slug: SLACK_SEND_SLUG,
+  name: "Post Message",
+  description: "Post a message to a Slack channel from the template author's Slack account.",
+  parameters: {
+    type: "object",
+    required: ["channel"],
+    properties: {
+      channel: { type: "string", title: "Channel", description: "Channel ID or name, e.g. #general or C0123456." },
+      markdown_text: {
+        type: "string",
+        title: "Message",
+        description: "Message text in Slack markdown. Preferred over the deprecated plain text field."
+      },
+      thread_ts: { type: "string", title: "Thread", description: "Optional parent message timestamp to reply within a thread." }
+    }
+  }
+};
+var SLACK_SEND_OUTPUT_SCHEMA = [
+  { path: "messageTs", displayName: "Message ts", type: "string" },
+  { path: "channel", displayName: "Channel", type: "string" },
+  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" }
+];
+
+// src/core/lib/actionRegistry/actions/slack/messageSend.ts
+registerAction({
+  type: "qi/slack.message.send",
+  can: "slack.message/send",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  // Can be wired to another block's event (e.g. form submitted → post message).
+  eligibleForEventTrigger: true,
+  outputSchema: SLACK_SEND_OUTPUT_SCHEMA,
+  events: [
+    {
+      name: SLACK_SENT_EVENT,
+      displayName: "Message posted",
+      description: "Fired after the message is posted to Slack.",
+      payloadSchema: [
+        { path: "messageTs", displayName: "Message ts", type: "string" },
+        { path: "channel", displayName: "Channel", type: "string" }
+      ],
+      pendingDisplayFields: ["messageTs"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const parsed = parseDelegatedToolInputs(inputs);
+    const values = fieldValues(parsed);
+    const data = await executeDelegatedTool(ctx, {
+      connection: parsed.connection,
+      schema: SLACK_SEND_SCHEMA,
+      toolSlug: SLACK_SEND_SLUG,
+      values,
+      toolkitLabel: "Slack"
+    });
+    const envelope = data.response_data ?? data;
+    const messageTs = String(envelope.ts ?? "");
+    const channel = String(envelope.channel ?? values.channel ?? "");
+    return {
+      output: {
+        messageTs,
+        channel,
+        sentAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      events: messageTs ? [{ name: SLACK_SENT_EVENT, payload: { messageTs, channel } }] : void 0
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/googlecalendar/eventCreate.types.ts
+var GOOGLECALENDAR_CREATE_SLUG = "GOOGLECALENDAR_CREATE_EVENT";
+var GOOGLECALENDAR_CREATED_EVENT = "event.created";
+var GOOGLECALENDAR_CREATE_SCHEMA = {
+  slug: GOOGLECALENDAR_CREATE_SLUG,
+  name: "Create Event",
+  description: "Create an event on the template author's Google Calendar.",
+  parameters: {
+    type: "object",
+    required: ["start_datetime"],
+    properties: {
+      start_datetime: { type: "string", title: "Start time", description: "ISO 8601, e.g. 2026-05-12T09:00:00." },
+      summary: { type: "string", title: "Title" },
+      description: { type: "string", title: "Description" },
+      location: { type: "string", title: "Location" },
+      timezone: { type: "string", title: "Timezone", description: "IANA name, e.g. Europe/London." },
+      attendees: { type: "array", title: "Attendees", description: "Comma-separated email addresses." },
+      calendar_id: { type: "string", title: "Calendar", description: "Use 'primary' for the author's main calendar." },
+      event_duration_minutes: { type: "number", title: "Duration (minutes)", description: "Defaults to the calendar default if blank." }
+    }
+  }
+};
+var GOOGLECALENDAR_CREATE_OUTPUT_SCHEMA = [
+  { path: "eventId", displayName: "Event ID", type: "string" },
+  { path: "htmlLink", displayName: "Event link", type: "string" },
+  { path: "summary", displayName: "Summary", type: "string" },
+  { path: "startIso", displayName: "Start", type: "string" }
+];
+
+// src/core/lib/actionRegistry/actions/googlecalendar/eventCreate.ts
+registerAction({
+  type: "qi/googlecalendar.event.create",
+  can: "googlecalendar.event/create",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  outputSchema: GOOGLECALENDAR_CREATE_OUTPUT_SCHEMA,
+  events: [
+    {
+      name: GOOGLECALENDAR_CREATED_EVENT,
+      displayName: "Calendar event created",
+      description: "Fired after the event is created on the author\u2019s calendar.",
+      payloadSchema: [
+        { path: "eventId", displayName: "Event ID", type: "string" },
+        { path: "htmlLink", displayName: "Event link", type: "string" },
+        { path: "summary", displayName: "Summary", type: "string" }
+      ],
+      pendingDisplayFields: ["summary", "eventId"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const parsed = parseDelegatedToolInputs(inputs);
+    const values = fieldValues(parsed);
+    const data = await executeDelegatedTool(ctx, {
+      connection: parsed.connection,
+      schema: GOOGLECALENDAR_CREATE_SCHEMA,
+      toolSlug: GOOGLECALENDAR_CREATE_SLUG,
+      values,
+      toolkitLabel: "Google Calendar"
+    });
+    const envelope = data.response_data ?? data;
+    const eventId = String(envelope.id ?? "");
+    const htmlLink = String(envelope.htmlLink ?? "");
+    const summary = String(envelope.summary ?? values.summary ?? "");
+    const start = envelope.start;
+    const startIso = String(start?.dateTime ?? start?.date ?? values.start_datetime ?? "");
+    return {
+      output: { eventId, htmlLink, summary, startIso },
+      events: eventId ? [{ name: GOOGLECALENDAR_CREATED_EVENT, payload: { eventId, htmlLink, summary } }] : void 0
+    };
+  }
+});
+
 // src/core/lib/actionRegistry/actions/calendar/eventCreate.types.ts
 var EMPTY = {
   connection: null,
@@ -10725,6 +11118,9 @@ function compileBaseUcanFlow(plan, registry) {
     if (cap.condition) {
       props.conditions = compileCondition(cap.condition, blockIndex);
     }
+    if (cap.trigger) {
+      props.trigger = compileTrigger(cap.trigger, blockIndex);
+    }
     props.triggerMode = cap.trigger?.type || "manual";
     blocks.push({
       id: blockId,
@@ -10795,6 +11191,18 @@ function compileCondition(condition, blockIndex) {
   };
   return JSON.stringify(conditionConfig);
 }
+function compileTrigger(trigger, blockIndex) {
+  if (trigger.type === "block.event" && trigger.sourceBlockId) {
+    return JSON.stringify({ ...trigger, sourceBlockId: blockIndex[trigger.sourceBlockId.trim()] });
+  }
+  if (trigger.type === "block.event.all" && trigger.sources) {
+    return JSON.stringify({
+      ...trigger,
+      sources: trigger.sources.map((src) => ({ ...src, sourceBlockId: blockIndex[src.sourceBlockId.trim()] }))
+    });
+  }
+  return JSON.stringify(trigger);
+}
 function collectOutputRefs(value) {
   const refs = [];
   walk(value);
@@ -11150,9 +11558,13 @@ function mergeCompiledFlows(existing, incoming, strategy) {
 
 // src/core/lib/flowCompiler/decompile.ts
 function decompileToBaseUcanFlow(compiled) {
+  const nodeIdByBlockId = {};
+  for (const [nodeId, blockId] of Object.entries(compiled.blockIndex)) {
+    nodeIdByBlockId[blockId] = nodeId;
+  }
   const capabilities = compiled.order.map((nodeId) => {
     const node = compiled.nodes[nodeId];
-    return nodeToCapability(node);
+    return nodeToCapability(node, nodeIdByBlockId);
   });
   return {
     kind: "qi.flow.base-ucan",
@@ -11167,7 +11579,7 @@ function decompileToBaseUcanFlow(compiled) {
     capabilities
   };
 }
-function nodeToCapability(node) {
+function nodeToCapability(node, nodeIdByBlockId) {
   const cap = {
     id: node.id,
     can: node.can,
@@ -11202,7 +11614,7 @@ function nodeToCapability(node) {
     try {
       const trigger = JSON.parse(node.props.trigger);
       if (trigger && typeof trigger === "object" && typeof trigger.type === "string") {
-        cap.trigger = trigger;
+        cap.trigger = triggerToNodeIds(trigger, nodeIdByBlockId);
       }
     } catch {
     }
@@ -11218,6 +11630,18 @@ function nodeToCapability(node) {
   }
   return cap;
 }
+function triggerToNodeIds(trigger, nodeIdByBlockId) {
+  if (trigger.type === "block.event" && trigger.sourceBlockId) {
+    return { ...trigger, sourceBlockId: nodeIdByBlockId[trigger.sourceBlockId] ?? trigger.sourceBlockId };
+  }
+  if (trigger.type === "block.event.all" && trigger.sources) {
+    return {
+      ...trigger,
+      sources: trigger.sources.map((src) => ({ ...src, sourceBlockId: nodeIdByBlockId[src.sourceBlockId] ?? src.sourceBlockId }))
+    };
+  }
+  return trigger;
+}
 
 // src/core/lib/flowCompiler/setup.ts
 import * as Y7 from "yjs";
@@ -12851,6 +13275,14 @@ export {
   didToMatrixUserId,
   findOrCreateDMRoom,
   sendDirectMessage,
+  parseDelegatedToolInputs,
+  serializeDelegatedToolInputs,
+  fieldValues,
+  missingRequired,
+  GMAIL_SEND_SCHEMA,
+  OUTLOOK_SEND_SCHEMA,
+  SLACK_SEND_SCHEMA,
+  GOOGLECALENDAR_CREATE_SCHEMA,
   parseCalendarEventCreateInputs,
   serializeCalendarEventCreateInputs,
   parseAttendeesField,
@@ -12942,4 +13374,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-OOPKMGYW.mjs.map
+//# sourceMappingURL=chunk-YWZJYSOP.js.map