@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/services/autoSaveService.d.ts

@@ -23,6 +23,12 @@ interface AutoSaveOptions {
      * Optional callback for successful saves
      */
     onSuccess?: () => void;
+    /**
+     * Dirty-state probe for the owning FlowDrop instance, e.g.
+     * `() => fd.workflow.isDirty`. Defaults to the page-default
+     * instance's dirty state when omitted.
+     */
+    isDirty?: () => boolean;
 }
 /**
  * Initialize auto-save functionality based on user settings
@@ -68,6 +74,7 @@ export declare class AutoSaveManager {
     private onSave;
     private onError?;
     private onSuccess?;
+    private isDirtyProbe;
     /**
      * Create a new AutoSaveManager
      *

package/dist/services/autoSaveService.js

@@ -7,7 +7,7 @@
  * @module services/autoSaveService
  */
 import { getBehaviorSettings, onSettingsChange } from '../stores/settingsStore.svelte.js';
-import { isDirty } from '../stores/workflowStore.svelte.js';
+import { getDefaultInstance } from '../stores/instanceContainer.svelte.js';
 import { logger } from '../utils/logger.js';
 /**
  * Initialize auto-save functionality based on user settings
@@ -40,7 +40,7 @@ import { logger } from '../utils/logger.js';
  * ```
  */
 export function initAutoSave(options) {
-    const { onSave, onError, onSuccess } = options;
+    const { onSave, onError, onSuccess, isDirty: isDirtyProbe = () => getDefaultInstance().workflow.isDirty } = options;
     const state = {
         intervalId: null,
         isSaving: false,
@@ -52,7 +52,7 @@ export function initAutoSave(options) {
      */
     async function performAutoSave() {
         // Skip if already saving or not dirty
-        if (state.isSaving || !isDirty()) {
+        if (state.isSaving || !isDirtyProbe()) {
             return;
         }
         state.isSaving = true;
@@ -127,6 +127,7 @@ export class AutoSaveManager {
     onSave;
     onError;
     onSuccess;
+    isDirtyProbe;
     /**
      * Create a new AutoSaveManager
      *
@@ -136,6 +137,7 @@ export class AutoSaveManager {
         this.onSave = options.onSave;
         this.onError = options.onError;
         this.onSuccess = options.onSuccess;
+        this.isDirtyProbe = options.isDirty ?? (() => getDefaultInstance().workflow.isDirty);
     }
     /**
      * Start the auto-save manager
@@ -207,7 +209,7 @@ export class AutoSaveManager {
      * Perform the save operation
      */
     async performSave() {
-        if (this.isSaving || !isDirty()) {
+        if (this.isSaving || !this.isDirtyProbe()) {
             return;
         }
         this.isSaving = true;

package/dist/services/categoriesApi.js

@@ -2,7 +2,8 @@
  * Categories API Service
  * Handles fetching category definitions from the backend
  */
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 import { DEFAULT_CATEGORIES } from '../config/defaultCategories.js';
 import { logger } from '../utils/logger.js';
 /**
@@ -11,11 +12,7 @@ import { logger } from '../utils/logger.js';
 export async function fetchCategories(endpointConfig, authProvider) {
     try {
         const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.categories);
-        const configHeaders = getEndpointHeaders(endpointConfig, 'categories');
-        const authHeaders = authProvider ? await authProvider.getAuthHeaders() : {};
-        const response = await fetch(url, {
-            headers: { ...configHeaders, ...authHeaders }
-        });
+        const response = await authenticatedFetch(url, {}, { config: endpointConfig, endpointKey: 'categories', authProvider });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }

package/dist/services/chatService.d.ts

@@ -7,6 +7,8 @@
  * @module services/chatService
  */
 import type { ChatRequest, ChatResponse, ChatHistoryMessage } from '../types/chat.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+import type { AuthProvider } from '../types/auth.js';
 /**
  * Chat Service class
  *
@@ -23,7 +25,9 @@ export declare class ChatService {
      */
     static getInstance(): ChatService;
     /**
-     * Get the endpoint configuration
+     * Validate and return the caller-supplied endpoint configuration.
+     *
+     * Callers thread the config from `getInstance().api.config`.
      *
      * @throws Error if endpoint configuration is not set
      * @returns The endpoint configuration
@@ -32,6 +36,7 @@ export declare class ChatService {
     /**
      * Generic API request helper
      *
+     * @param config - The endpoint configuration
      * @param url - The URL to fetch
      * @param options - Fetch options
      * @returns The parsed JSON response
@@ -44,20 +49,20 @@ export declare class ChatService {
      * @param request - The chat request payload
      * @returns The chat response from the LLM
      */
-    sendMessage(workflowId: string, request: ChatRequest): Promise<ChatResponse>;
+    sendMessage(endpointConfig: EndpointConfig | null, workflowId: string, request: ChatRequest, authProvider?: AuthProvider): Promise<ChatResponse>;
     /**
      * Get conversation history for a workflow
      *
      * @param workflowId - The workflow ID
      * @returns Array of chat history messages
      */
-    getHistory(workflowId: string): Promise<ChatHistoryMessage[]>;
+    getHistory(endpointConfig: EndpointConfig | null, workflowId: string, authProvider?: AuthProvider): Promise<ChatHistoryMessage[]>;
     /**
      * Clear conversation history for a workflow
      *
      * @param workflowId - The workflow ID
      */
-    clearHistory(workflowId: string): Promise<void>;
+    clearHistory(endpointConfig: EndpointConfig | null, workflowId: string, authProvider?: AuthProvider): Promise<void>;
 }
 /**
  * Pre-instantiated ChatService singleton

package/dist/services/chatService.js

@@ -6,8 +6,8 @@
  *
  * @module services/chatService
  */
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
-import { getEndpointConfig } from './api.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 import { logger } from '../utils/logger.js';
 /**
  * Chat Service class
@@ -30,34 +30,32 @@ export class ChatService {
         return ChatService.instance;
     }
     /**
-     * Get the endpoint configuration
+     * Validate and return the caller-supplied endpoint configuration.
+     *
+     * Callers thread the config from `getInstance().api.config`.
      *
      * @throws Error if endpoint configuration is not set
      * @returns The endpoint configuration
      */
-    getConfig() {
-        const config = getEndpointConfig();
+    getConfig(config) {
         if (!config) {
-            throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
+            throw new Error('Endpoint configuration not set. Configure the instance via fd.api.configure().');
         }
         return config;
     }
     /**
      * Generic API request helper
      *
+     * @param config - The endpoint configuration
      * @param url - The URL to fetch
      * @param options - Fetch options
      * @returns The parsed JSON response
      */
-    async request(url, options = {}) {
-        const config = this.getConfig();
-        const headers = getEndpointHeaders(config, 'chat');
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                ...headers,
-                ...options.headers
-            }
+    async request(config, url, options = {}, authProvider) {
+        const response = await authenticatedFetch(url, options, {
+            config,
+            endpointKey: 'chat',
+            authProvider
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
@@ -83,16 +81,16 @@ export class ChatService {
      * @param request - The chat request payload
      * @returns The chat response from the LLM
      */
-    async sendMessage(workflowId, request) {
-        const config = this.getConfig();
+    async sendMessage(endpointConfig, workflowId, request, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.chat.sendMessage, {
             id: workflowId
         });
         logger.debug('[ChatService] Sending message to', url);
-        return this.request(url, {
+        return this.request(config, url, {
             method: 'POST',
             body: JSON.stringify(request)
-        });
+        }, authProvider);
     }
     /**
      * Get conversation history for a workflow
@@ -100,29 +98,26 @@ export class ChatService {
      * @param workflowId - The workflow ID
      * @returns Array of chat history messages
      */
-    async getHistory(workflowId) {
-        const config = this.getConfig();
+    async getHistory(endpointConfig, workflowId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.chat.getHistory, {
             id: workflowId
         });
         logger.debug('[ChatService] Getting history from', url);
-        return this.request(url);
+        return this.request(config, url, {}, authProvider);
     }
     /**
      * Clear conversation history for a workflow
      *
      * @param workflowId - The workflow ID
      */
-    async clearHistory(workflowId) {
-        const config = this.getConfig();
+    async clearHistory(endpointConfig, workflowId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.chat.clearHistory, {
             id: workflowId
         });
         logger.debug('[ChatService] Clearing history at', url);
-        await fetch(url, {
-            method: 'DELETE',
-            headers: getEndpointHeaders(config, 'chat')
-        });
+        await authenticatedFetch(url, { method: 'DELETE' }, { config, endpointKey: 'chat', authProvider });
     }
 }
 /**

package/dist/services/draftStorage.d.ts

@@ -1,12 +1,82 @@
 /**
  * Draft Storage Service for FlowDrop
  *
- * Handles saving and loading workflow drafts to/from localStorage.
+ * Handles saving and loading workflow drafts to/from browser storage
+ * (localStorage by default, configurable via {@link setDraftStorage}).
  * Provides interval-based auto-save functionality.
  *
  * @module services/draftStorage
  */
 import type { Workflow } from '../types/index.js';
+/**
+ * Minimal storage adapter used for draft persistence.
+ *
+ * Implement this to back drafts with anything other than the built-in
+ * `localStorage` / `sessionStorage` options — e.g. an in-memory store, a
+ * key-prefixed wrapper, or a synchronous write-through cache.
+ *
+ * Note the interface is deliberately **synchronous**. Async backends
+ * (IndexedDB, network storage, WebCrypto-encrypted stores) cannot implement
+ * it directly — put a synchronous in-memory cache in front and flush to the
+ * async backend out of band. An `async` method assigned here will type-check
+ * (a Promise is assignable to `void`) but its errors are silently swallowed.
+ */
+export interface DraftStorageAdapter {
+    /** Read a value, or null when absent */
+    getItem(key: string): string | null;
+    /** Write a value */
+    setItem(key: string, value: string): void;
+    /** Remove a value */
+    removeItem(key: string): void;
+    /** List all keys currently held by the adapter */
+    keys(): string[];
+}
+/**
+ * Built-in storage backends
+ * - 'local': localStorage — drafts persist on the device even after the tab
+ *   or browser is closed, until saved or cleared
+ * - 'session': sessionStorage — drafts are scoped to the tab and removed
+ *   when it closes (they do not survive crash-and-reopen)
+ */
+export type DraftStorageType = 'local' | 'session';
+/** Accepted values for the `draftStorage` mount option */
+export type DraftStorageOption = DraftStorageType | DraftStorageAdapter;
+/**
+ * Resolve a {@link DraftStorageOption} to a concrete adapter.
+ *
+ * `'local'` / `'session'` map to the built-in Web Storage adapters, a custom
+ * adapter is returned as-is, and `undefined` resolves to the current
+ * module-level default (see {@link setDraftStorage}).
+ */
+export declare function resolveDraftStorage(option?: DraftStorageOption): DraftStorageAdapter;
+/**
+ * Configure the module-level default for where workflow drafts are persisted.
+ *
+ * - `'local'` (default): `localStorage` — drafts survive reloads and browser
+ *   restarts, and remain stored on the device even after the tab is closed,
+ *   until saved or cleared.
+ * - `'session'`: `sessionStorage` — drafts are scoped to the current tab and
+ *   removed when it closes. Note this also means drafts do not survive a
+ *   crash-and-reopen.
+ * - A custom {@link DraftStorageAdapter} for anything else.
+ *
+ * This sets the default used by the standalone helpers and by managers
+ * constructed without an explicit `storage` option. Mounted apps capture
+ * their own adapter at mount time, so calling this does not retarget
+ * already-running instances. With multiple mounts the most recent mount's
+ * backend wins *for the standalone helpers only*.
+ *
+ * Security note: neither built-in backend protects against same-origin
+ * script access (XSS) — both are readable by any script on the page. If
+ * workflows may contain secrets in node configs, disable drafts via
+ * `features.autoSaveDraft: false` or keep them off-disk with a custom
+ * in-memory adapter.
+ */
+export declare function setDraftStorage(option: DraftStorageOption): void;
+/**
+ * Get the current module-level default draft storage adapter
+ */
+export declare function getDraftStorage(): DraftStorageAdapter;
 /**
  * Draft metadata stored alongside the workflow
  */
@@ -19,7 +89,7 @@ interface DraftMetadata {
     workflowName?: string;
 }
 /**
- * Complete draft data stored in localStorage
+ * Complete draft data stored in draft storage
  */
 interface StoredDraft {
     /** The workflow data */
@@ -27,6 +97,14 @@ interface StoredDraft {
     /** Draft metadata */
     metadata: DraftMetadata;
 }
+/**
+ * Storage prefix of the page-default instance (`flowdrop:draft:default`).
+ *
+ * Every instance — including the default — uses an id-scoped prefix since
+ * v2.0. Standalone helper callers that don't pass a prefix get this one, so
+ * they keep addressing the default editor's drafts.
+ */
+export declare const DEFAULT_INSTANCE_DRAFT_PREFIX = "flowdrop:draft:default";
 /**
  * Generate a storage key for a workflow
  *
@@ -35,48 +113,70 @@ interface StoredDraft {
  *
  * @param workflowId - The workflow ID (optional)
  * @param customKey - Custom storage key provided by enterprise (optional)
+ * @param prefix - Key namespace; pass a FlowDrop instance's `storagePrefix`
+ *   to scope drafts per instance. Defaults to the page-default instance's
+ *   prefix.
  * @returns The storage key to use
  */
-export declare function getDraftStorageKey(workflowId?: string, customKey?: string): string;
+export declare function getDraftStorageKey(workflowId?: string, customKey?: string, prefix?: string): string;
+/**
+ * One-time migration of a 1.x draft key to its 2.0 scoped equivalent.
+ *
+ * In 1.x the page-default instance stored drafts under the bare
+ * `flowdrop:draft:<workflowId>` key; since 2.0 it uses
+ * `flowdrop:draft:default:<workflowId>`. When the scoped key is empty and the
+ * legacy key holds a draft, the draft is moved (copied, then the legacy key
+ * removed) so users upgrading mid-edit don't lose work.
+ *
+ * @param legacyKey - The 1.x bare-prefix key
+ * @param scopedKey - The 2.0 instance-scoped key
+ * @param storage - Adapter to migrate within (defaults to the module-level default)
+ */
+export declare function migrateLegacyDraftKey(legacyKey: string, scopedKey: string, storage?: DraftStorageAdapter): void;
 /**
- * Save a workflow draft to localStorage
+ * Save a workflow draft to draft storage
  *
  * @param workflow - The workflow to save
  * @param storageKey - The storage key to use
+ * @param storage - Adapter to write to (defaults to the module-level default)
  * @returns true if saved successfully, false otherwise
  */
-export declare function saveDraft(workflow: Workflow, storageKey: string): boolean;
+export declare function saveDraft(workflow: Workflow, storageKey: string, storage?: DraftStorageAdapter): boolean;
 /**
- * Load a workflow draft from localStorage
+ * Load a workflow draft from draft storage
  *
  * @param storageKey - The storage key to load from
+ * @param storage - Adapter to read from (defaults to the module-level default)
  * @returns The stored draft, or null if not found
  */
-export declare function loadDraft(storageKey: string): StoredDraft | null;
+export declare function loadDraft(storageKey: string, storage?: DraftStorageAdapter): StoredDraft | null;
 /**
- * Delete a workflow draft from localStorage
+ * Delete a workflow draft from draft storage
  *
  * @param storageKey - The storage key to delete
+ * @param storage - Adapter to delete from (defaults to the module-level default)
  */
-export declare function deleteDraft(storageKey: string): void;
+export declare function deleteDraft(storageKey: string, storage?: DraftStorageAdapter): void;
 /**
  * Check if a draft exists for a given storage key
  *
  * @param storageKey - The storage key to check
+ * @param storage - Adapter to check (defaults to the module-level default)
  * @returns true if a draft exists
  */
-export declare function hasDraft(storageKey: string): boolean;
+export declare function hasDraft(storageKey: string, storage?: DraftStorageAdapter): boolean;
 /**
  * Get draft metadata without loading the full workflow
  *
  * Useful for displaying draft information without parsing the entire workflow.
  *
  * @param storageKey - The storage key to check
+ * @param storage - Adapter to read from (defaults to the module-level default)
  * @returns Draft metadata, or null if not found
  */
-export declare function getDraftMetadata(storageKey: string): DraftMetadata | null;
+export declare function getDraftMetadata(storageKey: string, storage?: DraftStorageAdapter): DraftMetadata | null;
 /**
- * Clear all FlowDrop drafts from localStorage
+ * Clear all FlowDrop drafts from draft storage
  *
  * Removes every key beginning with `flowdrop:draft:`. Intended to be called
  * from a host application's logout handler so workflow drafts do not persist
@@ -85,9 +185,10 @@ export declare function getDraftMetadata(storageKey: string): DraftMetadata | nu
  * @param extraKeys - Additional explicit keys to remove. Pass any custom
  *   `draftStorageKey` values configured at mount time so they are cleared
  *   alongside the default-prefixed keys.
+ * @param storage - Adapter to clear (defaults to the module-level default)
  * @returns The number of entries removed.
  */
-export declare function clearAllDrafts(extraKeys?: readonly string[]): number;
+export declare function clearAllDrafts(extraKeys?: readonly string[], storage?: DraftStorageAdapter): number;
 /**
  * Draft auto-save manager
  *
@@ -107,6 +208,17 @@ export declare class DraftAutoSaveManager {
     private getWorkflow;
     /** Function to check if workflow is dirty */
     private isDirty;
+    /**
+     * Runtime gate for draft persistence (e.g. a user-facing opt-out setting).
+     * Checked on every save, so it can change after construction.
+     */
+    private isPersistenceAllowed;
+    /**
+     * Storage adapter this instance writes to.
+     * Captured at construction, so a later `setDraftStorage()` call (e.g. from
+     * another FlowDrop mount on the same page) cannot retarget this manager.
+     */
+    private storage;
     /** Last saved workflow hash (for change detection) */
     private lastSavedHash;
     /**
@@ -120,6 +232,10 @@ export declare class DraftAutoSaveManager {
         enabled: boolean;
         getWorkflow: () => Workflow | null;
         isDirty: () => boolean;
+        /** Optional runtime gate — return false to suppress draft writes (default: always allowed) */
+        isPersistenceAllowed?: () => boolean;
+        /** Storage backend for this instance (default: the module-level default at construction time) */
+        storage?: DraftStorageOption;
     });
     /**
      * Start auto-save interval