@revenexx/studio-integrations 0.1.4 → 0.2.0

package/dist/runtime/composables/useCanvasShortcuts.d.ts

@@ -0,0 +1,37 @@
+/**
+ * useCanvasShortcuts — document-level keyboard shortcuts for the workflow
+ * canvas, with editing-context scoping.
+ *
+ * Modeled on n8n's useKeybindings (editor-ui/src/app/composables/useKeybindings.ts)
+ * but dependency-free (no @vueuse) and with the platform-neutral `mod` token.
+ *
+ * Map keys:
+ *   - tokens joined by '+': modifiers `mod` (⌘ on mac, Ctrl elsewhere), `shift`,
+ *     `alt`, plus one key: a single character ('a', '1', '+'), or a named key
+ *     ('enter', 'escape', 'tab', 'space', 'f2', 'delete', 'backspace',
+ *     'arrowup', ...). Case-insensitive.
+ *   - alternatives via '|': 'f2|space' fires on either.
+ *
+ * Handlers are a function or `{ disabled: () => boolean, run: fn }` — a disabled
+ * handler lets the event fall through untouched (no preventDefault), so e.g.
+ * Enter still types a newline when nothing is selected.
+ *
+ * Scoping — a keydown is IGNORED entirely when:
+ *   1. `options.disabled` is truthy (the editor passes "config lightbox open").
+ *   2. The event target (or activeElement fallback) is INPUT / TEXTAREA / SELECT,
+ *      is contenteditable, or sits inside a [contenteditable] ancestor.
+ *   3. The target or an ancestor carries `data-canvas-shortcuts-ignore`.
+ *   4. `event.defaultPrevented` — someone upstream already claimed the key.
+ *
+ * On a match: preventDefault() + stopPropagation(), then run. Non-matching
+ * combos are never touched, so browser shortcuts keep working.
+ */
+import type { MaybeRefOrGetter } from 'vue';
+export type ShortcutHandler = ((event: KeyboardEvent) => void) | {
+    disabled: () => boolean;
+    run: (event: KeyboardEvent) => void;
+};
+export type ShortcutMap = Record<string, ShortcutHandler>;
+export declare function useCanvasShortcuts(keymap: MaybeRefOrGetter<ShortcutMap>, options?: {
+    disabled?: MaybeRefOrGetter<boolean>;
+}): void;

package/dist/runtime/composables/useCanvasShortcuts.js

@@ -0,0 +1,62 @@
+import { computed, onBeforeUnmount, onMounted, toValue } from "vue";
+const IS_MAC = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.platform ?? "");
+function canonical(parts) {
+  return parts.map((p) => p.toLowerCase()).sort((a, b) => a.localeCompare(b)).join("+");
+}
+function normalizeShortcut(shortcut) {
+  if (shortcut.length === 1) return shortcut.toLowerCase();
+  return canonical(shortcut.split("+"));
+}
+function codeToKey(code) {
+  if (code.startsWith("Key")) return code.slice(3).toLowerCase();
+  if (code.startsWith("Digit")) return code.slice(5);
+  return code.toLowerCase();
+}
+function eventShortcuts(event) {
+  const mods = [];
+  if (event.shiftKey) mods.push("shift");
+  if (event.altKey) mods.push("alt");
+  if (IS_MAC ? event.metaKey : event.ctrlKey) mods.push("mod");
+  const key = event.key === " " ? "space" : event.key.toLowerCase();
+  const code = codeToKey(event.code ?? "");
+  return {
+    byKey: canonical([...mods, key]),
+    byCode: canonical([...mods, code])
+  };
+}
+function isEditingContext(event) {
+  const el = event.target instanceof Element ? event.target : document.activeElement;
+  if (!el) return false;
+  const tag = el.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  if (el.isContentEditable) return true;
+  if (el.closest('[contenteditable=""],[contenteditable="true"]')) return true;
+  if (el.closest("[data-canvas-shortcuts-ignore]")) return true;
+  return false;
+}
+export function useCanvasShortcuts(keymap, options) {
+  const normalized = computed(() => {
+    const out = {};
+    for (const [combo, handler] of Object.entries(toValue(keymap))) {
+      for (const alt of combo.split("|")) {
+        out[normalizeShortcut(alt.trim())] = handler;
+      }
+    }
+    return out;
+  });
+  function onKeyDown(event) {
+    if (toValue(options?.disabled)) return;
+    if (event.defaultPrevented) return;
+    if (isEditingContext(event)) return;
+    const { byKey, byCode } = eventShortcuts(event);
+    const handler = normalized.value[byKey] ?? normalized.value[byCode];
+    if (!handler) return;
+    const run = typeof handler === "function" ? handler : handler.disabled() ? void 0 : handler.run;
+    if (!run) return;
+    event.preventDefault();
+    event.stopPropagation();
+    run(event);
+  }
+  onMounted(() => document.addEventListener("keydown", onKeyDown));
+  onBeforeUnmount(() => document.removeEventListener("keydown", onKeyDown));
+}

package/dist/runtime/composables/useIntegrationsDeadLetters.d.ts

@@ -0,0 +1,22 @@
+import type { DeadLetterRow } from '../types/integrations.js';
+/** A dead letter enriched with its workflow's name (global "Missed runs" view). */
+export interface GlobalDeadLetterRow extends DeadLetterRow {
+    workflowName: string;
+}
+export declare function useIntegrationsDeadLetters(): {
+    list: (workflowId: number | string, opts?: {
+        page?: number;
+        perPage?: number;
+    }) => Promise<{
+        items: DeadLetterRow[];
+        total: number;
+        page: number;
+        lastPage: number;
+    }>;
+    replay: (id: number | string) => Promise<unknown>;
+    discard: (id: number | string) => Promise<unknown>;
+    loadGlobal: (force?: boolean) => Promise<GlobalDeadLetterRow[]>;
+    globalItems: any;
+    globalLoading: any;
+    pendingCount: import("vue").ComputedRef<any>;
+};

package/dist/runtime/composables/useIntegrationsDeadLetters.js

@@ -0,0 +1,50 @@
+import { computed } from "vue";
+import { useIntegrationsApi } from "./integrationsApi.js";
+export function useIntegrationsDeadLetters() {
+  const api = useIntegrationsApi();
+  async function list(workflowId, opts = {}) {
+    const page = opts.page ?? 1;
+    const perPage = opts.perPage ?? 25;
+    const res = await api.get(
+      `/workflows/${workflowId}/dead-letters?page=${page}&per_page=${perPage}`
+    );
+    return {
+      items: res?.data ?? [],
+      total: res?.meta?.total ?? (res?.data?.length ?? 0),
+      page: res?.meta?.current_page ?? page,
+      lastPage: res?.meta?.last_page ?? 1
+    };
+  }
+  const replay = (id) => api.post(`/dead-letters/${id}/replay`, {});
+  const discard = (id) => api.post(`/dead-letters/${id}/discard`, {});
+  const { workflows, load: loadWorkflows } = useIntegrationsWorkflows();
+  const globalItems = useState("integrations.deadletters.global", () => []);
+  const globalLoading = useState("integrations.deadletters.global.loading", () => false);
+  const globalLoaded = useState("integrations.deadletters.global.loaded", () => false);
+  const pendingCount = computed(() => globalItems.value.filter((i) => i.status === "pending").length);
+  async function loadGlobal(force = false) {
+    if (globalLoading.value) return globalItems.value;
+    if (globalLoaded.value && !force) return globalItems.value;
+    globalLoading.value = true;
+    try {
+      await loadWorkflows();
+      const MAX_PAGES = 20;
+      const per = await Promise.allSettled(workflows.value.map(async (wf) => {
+        const out = [];
+        let page = 1;
+        while (page <= MAX_PAGES) {
+          const res = await list(wf.id, { page, perPage: 100 });
+          out.push(...res.items.map((i) => ({ ...i, workflowName: wf.name })));
+          if (page >= res.lastPage) break;
+          page++;
+        }
+        return out;
+      }));
+      globalItems.value = per.flatMap((p) => p.status === "fulfilled" ? p.value : []).sort((a, b) => new Date(b.created_at ?? 0).getTime() - new Date(a.created_at ?? 0).getTime());
+      globalLoaded.value = true;
+    } finally {
+      globalLoading.value = false;
+    }
+  }
+  return { list, replay, discard, loadGlobal, globalItems, globalLoading, pendingCount };
+}

package/dist/runtime/composables/useIntegrationsNodes.d.ts

@@ -1,6 +1,10 @@
+import { findManifest } from '../data/integrationNodeCatalog.js';
+import { resolveLocalized } from '../utils/localize.js';
 export declare function useIntegrationsNodes(): {
     loading: any;
     error: any;
     loaded: any;
     load: (force?: boolean) => Promise<void>;
+    findManifest: typeof findManifest;
+    resolveLocalized: typeof resolveLocalized;
 };

package/dist/runtime/composables/useIntegrationsNodes.js

@@ -1,4 +1,5 @@
-import { applyNodeCatalog } from "../data/integrationNodeCatalog.js";
+import { applyNodeCatalog, findManifest } from "../data/integrationNodeCatalog.js";
+import { resolveLocalized } from "../utils/localize.js";
 import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
 export function useIntegrationsNodes() {
   const loading = useState("integrations.nodes.loading", () => false);
@@ -17,7 +18,9 @@ export function useIntegrationsNodes() {
         ...n.manifest,
         slug: n.manifest.slug ?? n.slug,
         version: n.manifest.version ?? n.version,
-        name: n.manifest.name ?? n.name
+        name: n.manifest.name ?? n.name,
+        // Keep the source package — the palette groups app nodes by it.
+        __package: n.package ? { name: n.package.name, label: n.package.label ?? null } : void 0
       }));
       applyNodeCatalog(manifests);
       loaded.value = true;
@@ -28,5 +31,5 @@ export function useIntegrationsNodes() {
       loading.value = false;
     }
   }
-  return { loading, error, loaded, load };
+  return { loading, error, loaded, load, findManifest, resolveLocalized };
 }

package/dist/runtime/composables/useIntegrationsRevisions.d.ts

@@ -0,0 +1,40 @@
+import type { WorkflowBlob } from '../types/integrations.js';
+/**
+ * Workflow revision history (PO — `workflow_histories`): every blob-changing
+ * save snapshots the previous revision. These endpoints expose that history
+ * and restore an archived revision as a brand-new one.
+ *
+ *   GET  /workflows/{id}/revisions            → metadata list (paginated, newest first)
+ *   GET  /workflows/{id}/revisions/{rev}      → full snapshot incl. blob + triggers
+ *   POST /workflows/{id}/revisions/{rev}/restore
+ */
+export interface WorkflowRevisionMeta {
+    id: number;
+    revision: number;
+    name: string;
+    description: string | null;
+    active: boolean;
+    blob_definition_version: string;
+    created_at: string | null;
+    updated_at: string | null;
+    archived_at: string | null;
+}
+export interface WorkflowRevisionDetail extends WorkflowRevisionMeta {
+    /** Cockpit-shaped blob: triggers merged in, like useIntegrationsWorkflows.toCockpit. */
+    blob: WorkflowBlob;
+}
+export declare function useIntegrationsRevisions(): {
+    loading: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<string | null, string | null>;
+    list: (workflowId: number, page?: number, perPage?: number) => Promise<{
+        revisions: WorkflowRevisionMeta[];
+        meta: {
+            current_page: number;
+            per_page: number;
+            total: number;
+            last_page: number;
+        };
+    }>;
+    get: (workflowId: number, revision: number) => Promise<WorkflowRevisionDetail>;
+    restore: (workflowId: number, revision: number) => Promise<void>;
+};

package/dist/runtime/composables/useIntegrationsRevisions.js

@@ -0,0 +1,51 @@
+import { ref } from "vue";
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+export function useIntegrationsRevisions() {
+  const api = useIntegrationsApi();
+  const loading = ref(false);
+  const error = ref(null);
+  function captureError(e, fallback) {
+    if (e instanceof IntegrationsApiError) return e.message;
+    return e?.message ?? fallback;
+  }
+  async function list(workflowId, page = 1, perPage = 25) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await api.get(`/workflows/${workflowId}/revisions?page=${page}&per_page=${perPage}`);
+      return { revisions: res.data ?? [], meta: res.meta };
+    } catch (e) {
+      error.value = captureError(e, "Could not load the revision history.");
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function get(workflowId, revision) {
+    const res = await api.get(`/workflows/${workflowId}/revisions/${revision}`);
+    const apiBlob = res.blob ?? {};
+    const triggers = (res.triggers ?? []).map((t) => ({
+      id: t.handle ?? String(t.id ?? ""),
+      type: t.type,
+      name: typeof t.name === "string" ? t.name : t.name ?? void 0,
+      active: t.active,
+      config: t.config ?? {}
+    }));
+    return {
+      ...res,
+      blob: {
+        nodeManifestVersion: apiBlob.nodeManifestVersion ?? "v0-draft",
+        name: apiBlob.name ?? res.name,
+        nodes: apiBlob.nodes ?? [],
+        edges: apiBlob.edges ?? [],
+        triggerPositions: apiBlob.triggerPositions ?? {},
+        stickies: apiBlob.stickies ?? [],
+        triggers
+      }
+    };
+  }
+  async function restore(workflowId, revision) {
+    await api.post(`/workflows/${workflowId}/revisions/${revision}/restore`, {});
+  }
+  return { loading, error, list, get, restore };
+}

package/dist/runtime/composables/useIntegrationsRuns.d.ts

@@ -1,4 +1,4 @@
-import type { RunStatus, WorkflowRun } from '../types/integrations.js';
+import type { RunStatus, RunStepRow, WorkflowRun } from '../types/integrations.js';
 export declare function useIntegrationsRuns(): {
     runs: any;
     loading: any;
@@ -8,17 +8,37 @@ export declare function useIntegrationsRuns(): {
     failedCount: import("vue").ComputedRef<any>;
     runningCount: import("vue").ComputedRef<any>;
     load: (force?: boolean) => Promise<WorkflowRun[]>;
+    loadForWorkflow: (workflowId: number, workflowName: string, opts?: {
+        reconcile?: boolean;
+        page?: number;
+        perPage?: number;
+    }) => Promise<{
+        runs: WorkflowRun[];
+        total: number;
+        page: number;
+        lastPage: number;
+    }>;
     list: (filter?: {
         workflowId?: number;
         status?: RunStatus;
     }) => WorkflowRun[];
     get: (id: string) => WorkflowRun | null;
+    fetchRun: (workflowId: number | string, runId: number | string, workflowName: string) => Promise<WorkflowRun>;
     trigger: (workflowId: number | string, payload?: Record<string, unknown>, mode?: "sync" | "async") => Promise<unknown>;
+    cancelRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
+    terminateRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
+    retryRun: (workflowId: number | string, runId: number | string) => Promise<unknown>;
+    resumeRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
     getRun: (workflowId: number | string, runId: number | string) => Promise<unknown>;
     getDetails: (workflowId: number | string, runId: number | string) => Promise<{
         source: string;
         data: Record<string, unknown>;
     }>;
+    getSteps: (workflowId: number | string, runId: number | string, includePayloads?: boolean) => Promise<{
+        source: string;
+        run: Record<string, unknown>;
+        steps: RunStepRow[];
+    }>;
     getHistory: (workflowId: number | string, runId: number | string, params?: {
         page_token?: string;
         page_size?: number;

package/dist/runtime/composables/useIntegrationsRuns.js

@@ -8,14 +8,18 @@ function mapStatus(status) {
       return "queued";
     case "terminated":
       return "failed";
+    case "timed_out":
+      return "failed";
     case "running":
       return "running";
     case "failed":
       return "failed";
     case "cancelled":
       return "cancelled";
+    // An unknown/unexpected status must never surface as a stuck `running` —
+    // fail closed so a run the backend can't classify is visibly terminal.
     default:
-      return "running";
+      return "failed";
   }
 }
 export function useIntegrationsRuns() {
@@ -23,19 +27,25 @@ export function useIntegrationsRuns() {
   const loading = useState("integrations.runs.loading", () => false);
   const error = useState("integrations.runs.error", () => null);
   const loaded = useState("integrations.runs.loaded", () => false);
+  const reconciling = useState("integrations.runs.reconciling", () => false);
+  const SYNC_LIMIT = 5;
   const api = useIntegrationsApi();
   const { workflows, load: loadWorkflows } = useIntegrationsWorkflows();
   function mapRun(r, workflowName) {
+    const startedMs = r.started_at ? new Date(r.started_at).getTime() : null;
+    const finishedMs = r.completed_at ? new Date(r.completed_at).getTime() : null;
     return {
       id: String(r.id),
       workflowId: r.workflow_id,
       workflowName,
       status: mapStatus(r.status),
+      temporalRunId: r.temporal_run_id ?? null,
       triggerId: "",
       triggerType: "manual",
       startedAt: r.started_at ?? "",
       finishedAt: r.completed_at ?? null,
-      durationMs: null,
+      // Derived from the timestamps — the list payload carries no duration.
+      durationMs: startedMs != null && finishedMs != null && finishedMs >= startedMs ? finishedMs - startedMs : null,
       steps: []
     };
   }
@@ -46,13 +56,41 @@ export function useIntegrationsRuns() {
     error.value = null;
     try {
       await loadWorkflows();
+      const MAX_PAGES = 100;
       const perWorkflow = await Promise.allSettled(
         workflows.value.map(async (wf) => {
-          const res = await api.get(`/workflows/${wf.id}/runs`);
-          return (res?.data ?? []).map((r) => mapRun(r, wf.name));
+          const out = [];
+          let page = 1;
+          while (page <= MAX_PAGES) {
+            const res = await api.get(
+              `/workflows/${wf.id}/runs?page=${page}&per_page=100`
+            );
+            out.push(...(res?.data ?? []).map((r) => mapRun(r, wf.name)));
+            const last = res?.meta?.last_page ?? 1;
+            if (page >= last) break;
+            page++;
+          }
+          return out;
         })
       );
       runs.value = perWorkflow.flatMap((p) => p.status === "fulfilled" ? p.value : []).sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+      if (!reconciling.value) {
+        reconciling.value = true;
+        try {
+          const active = runs.value.filter((r) => r.status === "running" || r.status === "queued").sort((a, b) => Number(b.id) - Number(a.id)).slice(0, SYNC_LIMIT);
+          await Promise.allSettled(active.map(async (r) => {
+            try {
+              const raw = await api.get(`/workflows/${r.workflowId}/runs/${r.id}`);
+              const apiRun = raw?.data ?? raw;
+              const fresh = mapRun(apiRun, r.workflowName);
+              runs.value = runs.value.map((x) => x.id === fresh.id ? fresh : x);
+            } catch {
+            }
+          }));
+        } finally {
+          reconciling.value = false;
+        }
+      }
       loaded.value = true;
     } catch (e) {
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load runs.";
@@ -61,6 +99,32 @@ export function useIntegrationsRuns() {
     }
     return runs.value;
   }
+  async function loadForWorkflow(workflowId, workflowName, opts = {}) {
+    const page = opts.page ?? 1;
+    const perPage = opts.perPage ?? 25;
+    const res = await api.get(
+      `/workflows/${workflowId}/runs?page=${page}&per_page=${perPage}`
+    );
+    let list2 = (res?.data ?? []).map((r) => mapRun(r, workflowName)).sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+    if (opts.reconcile) {
+      const active = list2.filter((r) => r.status === "running" || r.status === "queued").sort((a, b) => Number(b.id) - Number(a.id)).slice(0, SYNC_LIMIT);
+      await Promise.allSettled(active.map(async (r) => {
+        try {
+          const raw = await api.get(`/workflows/${workflowId}/runs/${r.id}`);
+          const apiRun = raw?.data ?? raw;
+          const fresh = mapRun(apiRun, workflowName);
+          list2 = list2.map((x) => x.id === fresh.id ? fresh : x);
+        } catch {
+        }
+      }));
+    }
+    return {
+      runs: list2,
+      total: res?.meta?.total ?? list2.length,
+      page: res?.meta?.current_page ?? page,
+      lastPage: res?.meta?.last_page ?? 1
+    };
+  }
   function list(filter) {
     let result = [...runs.value];
     if (filter?.workflowId !== void 0) result = result.filter((r) => r.workflowId === filter.workflowId);
@@ -76,8 +140,25 @@ export function useIntegrationsRuns() {
     const res = await api.post(`/workflows/${workflowId}/runs`, body);
     return res?.data ?? res;
   }
+  async function runAction(workflowId, runId, action, reason) {
+    const body = reason ? { reason } : {};
+    const res = await api.post(`/workflows/${workflowId}/runs/${runId}/${action}`, body);
+    return res?.data ?? res;
+  }
+  const cancelRun = (workflowId, runId, reason) => runAction(workflowId, runId, "cancel", reason);
+  const terminateRun = (workflowId, runId, reason) => runAction(workflowId, runId, "terminate", reason);
+  const retryRun = (workflowId, runId) => runAction(workflowId, runId, "retry");
+  const resumeRun = (workflowId, runId, reason) => runAction(workflowId, runId, "resume", reason);
   const getRun = (workflowId, runId) => api.get(`/workflows/${workflowId}/runs/${runId}`);
+  async function fetchRun(workflowId, runId, workflowName) {
+    const raw = await getRun(workflowId, runId);
+    const apiRun = raw?.data ?? raw;
+    return mapRun(apiRun, workflowName);
+  }
   const getDetails = (workflowId, runId) => api.get(`/workflows/${workflowId}/runs/${runId}/details`);
+  const getSteps = (workflowId, runId, includePayloads = false) => api.get(
+    `/workflows/${workflowId}/runs/${runId}/steps${includePayloads ? "?include_payloads=1" : ""}`
+  );
   const getHistory = (workflowId, runId, params = {}) => {
     const qs = new URLSearchParams();
     if (params.page_token) qs.set("page_token", params.page_token);
@@ -98,11 +179,18 @@ export function useIntegrationsRuns() {
     failedCount,
     runningCount,
     load,
+    loadForWorkflow,
     list,
     get,
+    fetchRun,
     trigger,
+    cancelRun,
+    terminateRun,
+    retryRun,
+    resumeRun,
     getRun,
     getDetails,
+    getSteps,
     getHistory,
     getStackTrace
   };

package/dist/runtime/composables/useIntegrationsTemplates.d.ts

@@ -10,6 +10,7 @@ export declare function useIntegrationsTemplates(): {
     list: () => WorkflowTemplate[];
     get: (slug: string) => WorkflowTemplate | null;
     fetchDetail: (slug: string) => Promise<WorkflowTemplate | null>;
+    ensureDetails: (slugs: string[], concurrency?: number) => Promise<void>;
     requirements: (slug: string) => Promise<TemplateRequirements | null>;
     instantiate: (slug: string, opts?: {
         name?: string;

package/dist/runtime/composables/useIntegrationsTemplates.js

@@ -3,6 +3,14 @@ import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
 import { resolveLocalized } from "../utils/localize.js";
 const BLOB_VERSION = "v0-draft";
 const INDUSTRY_VALUES = ["mechanical-engineering", "chemicals", "wholesale", "manufacturing", "retail", "any"];
+function plainExcerpt(md) {
+  for (const raw of md.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    return line.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
+  }
+  return "";
+}
 function publisherFor(slug, vendors) {
   const ns = slug.includes(":") ? slug.split(":")[0] : vendors[0] ?? "revenexx";
   const kind = ns === "revenexx" ? "revenexx" : "partner";
@@ -15,10 +23,16 @@ function emptyBlob(name) {
   return { nodeManifestVersion: BLOB_VERSION, name, nodes: [], edges: [], triggerPositions: {}, triggers: [] };
 }
 function mapListItem(api) {
+  const short = resolveLocalized(api.shortDescription ?? "");
+  const md = resolveLocalized(api.description ?? "");
   return {
     slug: api.slug,
     name: resolveLocalized(api.name),
-    description: resolveLocalized(api.description || api.shortDescription || ""),
+    description: short || plainExcerpt(md),
+    descriptionMd: md,
+    triggerTypes: api.triggerTypes ?? [],
+    images: api.images ?? [],
+    package: api.package ? { name: api.package.name, label: api.package.label ?? null } : null,
     category: api.category ?? "sync",
     industries: mapIndustries(api.industries),
     vendors: api.vendors ?? [],
@@ -48,13 +62,17 @@ function applyDetail(base, api) {
     name: def.name ?? base.name,
     nodes,
     edges: def.edges ?? [],
-    triggerPositions: {},
+    triggerPositions: def.triggerPositions ?? {},
+    variables: def.variables,
     triggers
   };
+  const md = resolveLocalized(api.description ?? "") || base.descriptionMd;
   return {
     ...base,
-    description: resolveLocalized(api.description || api.shortDescription || "") || base.description,
+    description: base.description || plainExcerpt(md),
+    descriptionMd: md,
     blob,
+    detailLoaded: true,
     nodeCount: nodes.length,
     outline: nodes.map((n) => n.nodeSlug ?? n.id).filter(Boolean)
   };
@@ -107,6 +125,16 @@ export function useIntegrationsTemplates() {
       return base;
     }
   }
+  async function ensureDetails(slugs, concurrency = 4) {
+    const queue = slugs.filter((slug) => get(slug)?.fromApi && !get(slug)?.detailLoaded);
+    const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+      while (queue.length) {
+        const slug = queue.shift();
+        if (slug) await fetchDetail(slug);
+      }
+    });
+    await Promise.all(workers);
+  }
   async function requirements(slug) {
     try {
       const raw = unwrap(await api.get(`/templates/${slug}/requirements`));
@@ -137,5 +165,5 @@ export function useIntegrationsTemplates() {
   }
   const total = computed(() => templates.value.length);
   const popular = computed(() => [...templates.value].sort((a, b) => b.installs - a.installs).slice(0, 4));
-  return { templates, loaded, loading, error, total, popular, load, list, get, fetchDetail, requirements, instantiate, install };
+  return { templates, loaded, loading, error, total, popular, load, list, get, fetchDetail, ensureDetails, requirements, instantiate, install };
 }

package/dist/runtime/composables/useIntegrationsWorkflows.d.ts

@@ -23,6 +23,7 @@ export declare function useIntegrationsWorkflows(): {
         active: boolean;
         executionMode?: WorkflowExecutionMode;
     }) => Promise<Workflow>;
+    duplicate: (id: number, name?: string) => Promise<Workflow>;
     remove: (id: number) => Promise<void>;
     toggleActive: (id: number) => Promise<Workflow | null>;
 };