@crowbartools/firebot-types 5.67.0-alpha24 → 5.67.0-alpha26

package/backend/database/turso-connection-registry.d.ts

@@ -0,0 +1,28 @@
+import { type Database } from "@tursodatabase/database";
+/**
+ *  Registry for Turso databases
+ *
+ * Each named database lives in its own file under the
+ * profile's databases/ dir (ie databases/quotes.db)
+ */
+declare class TursoConnectionRegistry {
+    private logger;
+    private connections;
+    constructor();
+    private getDatabasePath;
+    /**
+     * Returns a cached connection for the named database,
+     * creating the db file if it doesn't exist
+     */
+    getConnection(name: string): Promise<Database>;
+    private open;
+    /**
+     * Attaches another registered database to the given connection so queries
+     * can join across files, ie:
+     * "SELECT ... FROM quotes q JOIN viewers.viewers v ON ..."
+     */
+    attach(db: Database, name: string, alias: string): Promise<void>;
+    private closeAll;
+}
+declare const registry: TursoConnectionRegistry;
+export { registry as TursoConnectionRegistry };

package/backend/plugins/executors/plugin-executor.interface.d.ts

@@ -10,6 +10,7 @@ export interface PluginRegistrations {
     eventSourceIds?: string[];
     filterIds?: string[];
     systemCommandIds?: string[];
+    conditionIds?: string[];
     restrictionIds?: string[];
     integrationIds?: string[];
     gameIds?: string[];

package/backend/plugins/plugin-api/internal/message-broker.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from "winston";
+import type { ScopedIpc } from "../../../../types/plugin-api";
+export interface MessagingScope {
+    ipc: ScopedIpc;
+    dispose: () => void;
+}
+declare class PluginMessageBroker {
+    private readonly bus;
+    private readonly pendingRequests;
+    constructor();
+    /**
+     * Deep-clone a payload to:
+     * - Isolate senders/receivers from shared mutable references
+     * - Reject non-serializable payloads (ie functions)
+     */
+    private enforceSerialization;
+    createScope(pluginId: string, logger: Logger): MessagingScope;
+}
+export declare const pluginMessageBroker: PluginMessageBroker;
+export {};

package/backend/plugins/plugin-api/namespaces/messaging.d.ts

@@ -0,0 +1,2 @@
+import type { ScopedIpc } from "../../../../types/plugin-api";
+export declare const createMessagingApi: import("../internal/define-namespace").PluginApiNamespaceFactory<ScopedIpc>;

package/backend/quotes/quote-manager.d.ts

@@ -18,7 +18,13 @@ declare class QuoteManager {
     }>;
     constructor();
     private regExpEscape;
+    private buildSearchPattern;
+    private rowToQuote;
     loadQuoteDatabase(): Promise<void>;
+    private createSchema;
+    private migrateFromNeDb;
+    private insertQuoteRow;
+    private getQuoteCount;
     getCurrentQuoteId(): Promise<number>;
     getNextQuoteId(): Promise<number>;
     setQuoteIdIncrementer(number: number): Promise<number>;
@@ -27,13 +33,13 @@ declare class QuoteManager {
     updateQuote(quote: Quote, dontSendUiUpdateEvent?: boolean): Promise<Quote>;
     removeQuote(quoteId: number, dontSendUiUpdateEvent?: boolean): Promise<void>;
     getQuote(quoteId: number): Promise<Quote>;
+    private getRandomQuoteWhere;
     getRandomQuoteByDate(dateConfig: DateConfig): Promise<Quote>;
     getRandomQuoteByAuthor(author: string): Promise<Quote>;
     getRandomQuoteByGame(gameSearch: string): Promise<Quote>;
     getRandomQuoteContainingText(text: string): Promise<Quote>;
     getRandomQuote(): Promise<Quote>;
     getAllQuotes(): Promise<Quote[]>;
-    private updateQuoteId;
     recalculateQuoteIds(): Promise<void>;
     exportQuotesToFile(filepath: string): Promise<boolean>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowbartools/firebot-types",
-  "version": "5.67.0-alpha24",
+  "version": "5.67.0-alpha26",
   "description": "Type definitions and plugin API for Firebot plugins.",
   "main": "index.js",
   "types": "index.d.ts",

package/types/conditions.d.ts

@@ -0,0 +1,36 @@
+import type EventEmitter from "events";
+import { Trigger, TriggersObject, TriggerType } from "./triggers";
+type PresetValue = {
+    value: string;
+    display: string;
+};
+type ConditionValueType = "text" | "number" | "preset" | "none";
+export type ConditionSettings<ComparisonTypes extends string, LeftSideValueType extends ConditionValueType, RightSideValueType extends ConditionValueType> = {
+    type: string;
+    comparisonType: ComparisonTypes;
+    leftSideValue: LeftSideValueType extends "number" ? number : LeftSideValueType extends "none" ? undefined : string;
+    rightSideValue: RightSideValueType extends "number" ? number : string;
+};
+export type ConditionType<ComparisonTypes extends string, LeftSideValueType extends ConditionValueType, RightSideValueType extends ConditionValueType> = {
+    id: string;
+    name: string;
+    description: string;
+    comparisonTypes: ComparisonTypes[];
+    rightSideValueType: RightSideValueType;
+    leftSideValueType?: LeftSideValueType;
+    triggers?: TriggerType[] | TriggersObject;
+    leftSideTextPlaceholder?: string;
+    rightSideTextPlaceholder?: string;
+    getRightSidePresetValues?: (...args: unknown[]) => PresetValue[];
+    getLeftSidePresetValues?: (...args: unknown[]) => PresetValue[];
+    getRightSideValueDisplay?(condition: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, ...args: unknown[]): string;
+    getLeftSideValueDisplay?(condition: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, ...args: unknown[]): string;
+    valueIsStillValid?(condition: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, ...args: unknown[]): boolean;
+    predicate(conditionSettings: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, trigger: Trigger): boolean | Promise<boolean>;
+};
+export type ConditionManager = EventEmitter & {
+    registerConditionType(conditionType: ConditionType<any, any, any>): void;
+    getConditionTypeById(conditionTypeId: string): ConditionType<any, any, any>;
+    getAllConditionTypes(): ConditionType<any, any, any>[];
+};
+export {};

package/types/index.d.ts

@@ -3,6 +3,7 @@ export * from "./auth";
 export * from "./channel-rewards";
 export * from "./chat";
 export * from "./commands";
+export * from "./conditions";
 export * from "./control-deck";
 export * from "./counters";
 export * from "./currency";

package/types/plugin-api.d.ts

@@ -106,6 +106,37 @@ export interface PluginFrontendCommunicatorApi {
      */
     fireEventAsync<ReturnPayload = void, ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): Promise<ReturnPayload>;
 }
+export interface PluginMessageEvent<TPayload = unknown> {
+    /** The pluginId of the plugin that sent the message. */
+    sender: string;
+    /** The provided payload. */
+    payload: TPayload;
+}
+/**
+ * Plugin-to-plugin messaging. Supports both fire-and-forget (`emit`/`on`/`off`)
+ * and request/response (`invoke`/`handle`) messaging over a shared event bus,
+ * based on Electron's IPC
+ */
+export interface ScopedIpc {
+    /** Broadcast a message on a channel. */
+    emit(channel: string, data: unknown): void;
+    /**
+     * Listen for messages on a channel.
+     * Returns an `unsubscribe` function.
+     */
+    on<TPayload = unknown>(channel: string, callback: (event: PluginMessageEvent<TPayload>) => void): () => void;
+    /** Remove a previously registered `on` listener. */
+    off(channel: string, callback: (...args: never[]) => void): void;
+    /**
+     * Send a request on a channel and await a response. Rejects if
+     * no handler responds within a 10s timeout or if the handler throws.
+     */
+    invoke<TRequestPayload = unknown, TResponseData = unknown>(channel: string, data?: TRequestPayload): Promise<TResponseData>;
+    /**
+     * Register the handler for a request channel.
+     */
+    handle<TRequestPayload = unknown, TResponseData = unknown>(channel: string, handlerFn: (payload: TRequestPayload, sender: string) => Promise<TResponseData> | TResponseData): void;
+}
 export interface PluginSettingsApi {
     /**
      * Get a Firebot setting value or its default
@@ -165,6 +196,8 @@ export interface FirebotPluginApi {
     parameters: PluginParametersApi;
     /** Two-way messaging between the plugin and the frontend. */
     frontendCommunicator: PluginFrontendCommunicatorApi;
+    /** Plugin-to-plugin messaging */
+    messaging: ScopedIpc;
     /** Notifications owned by this plugin. */
     notifications: PluginNotificationsApi;
     /** Access to installed plugins. */

package/types/plugins.d.ts

@@ -13,6 +13,7 @@ import type { OverlayWidgetType } from "./overlay-widgets";
 import type { PluginHttpRouteDefinition } from "./http-server";
 import type { CustomWebSocketHandler } from "./websocket";
 import type { PluginWebhooks } from "./webhooks";
+import { ConditionType } from "./conditions";
 type NoResult = Awaitable<void>;
 type GenericParameters = Record<string, unknown>;
 export type ManagedPluginManifest = {
@@ -43,17 +44,7 @@ export type ManagedPluginWithManifest = ManagedPlugin & {
     manifest: ManagedPluginManifest;
 };
 export type ManagedPluginUpdateRequest = {
-    author: string;
-    name: string;
-    version: string;
-    firebotVersion: ManifestFirebotVersion;
-};
-export type ManagedPluginBatchUpdateRequest = {
-    plugins: Array<{
-        author: string;
-        name: string;
-        version: string;
-    }>;
+    plugins: Array<ManagedPlugin>;
     firebotVersion: ManifestFirebotVersion;
 };
 export type InstalledPluginConfig<Params extends GenericParameters = GenericParameters> = {
@@ -154,6 +145,7 @@ export interface Plugin<Params extends FirebotParams = FirebotParams> extends Pl
         integrations?: DynamicArray<Integration<any>>;
         filters?: DynamicArray<EventFilter>;
         restrictions?: DynamicArray<RestrictionType<any>>;
+        conditions?: DynamicArray<ConditionType<any, any, any>>;
         systemCommands?: DynamicArray<SystemCommand<any>>;
         games?: DynamicArray<FirebotGame>;
         frontendListeners?: DynamicArray<FrontendListener>;