@com55/node-red-ai-access 0.0.0-stage → 0.1.1

package/dist/plugin.d.cts

@@ -0,0 +1,707 @@
+import { Express, Request, Response, NextFunction } from 'express';
+
+/**
+ * In-memory access-link store. Nothing is persisted — a process restart
+ * clears every link, so previously issued tokens become invalid.
+ */
+/** Surface a token is minted for. Missing/undefined on legacy records → get_link. */
+type AccessLinkKind$1 = 'get_link' | 'rest' | 'mcp';
+interface AccessLinkPublic {
+    id: string;
+    kind: AccessLinkKind$1;
+    label?: string;
+    createdAt: string;
+    expiresAt: string;
+    /** ISO time of last successful token validation; omitted until first use. */
+    lastUsedAt?: string;
+    createdBy?: string;
+}
+interface AccessLinkCreated extends AccessLinkPublic {
+    /** Raw token — available while the in-memory link is active. */
+    token: string;
+}
+interface AccessLinkRecord {
+    id: string;
+    tokenHash: string;
+    /** Raw token kept in memory so admins can re-copy the GET URL. */
+    token: string;
+    /**
+     * Token surface. Optional for in-memory migration of pre-kind records
+     * (treated as `get_link` by {@link resolveAccessLinkKind}).
+     */
+    kind?: AccessLinkKind$1;
+    label?: string;
+    createdAtMs: number;
+    expiresAtMs: number;
+    lastUsedAtMs?: number;
+    createdBy?: string;
+    revokedAtMs?: number;
+}
+interface CreateAccessLinkInput {
+    ttlSeconds?: number;
+    label?: string;
+    createdBy?: string;
+    /** Defaults to `get_link` when omitted. */
+    kind?: AccessLinkKind$1;
+}
+interface AccessLinkStoreOptions {
+    /** Defaults to 14400 (4h). */
+    defaultTtlSeconds?: number;
+    /** Defaults to 10. */
+    maxActiveLinks?: number;
+    /** Injectable clock for tests. */
+    now?: () => number;
+    /** Injectable id/token generators for tests. */
+    randomId?: () => string;
+    randomToken?: () => string;
+}
+/** Result of looking up a raw token in the in-memory store. */
+type AccessLinkValidateResult = {
+    status: 'active';
+    link: AccessLinkPublic;
+} | {
+    status: 'expired';
+    expiresAt: string;
+} | {
+    status: 'invalid';
+};
+declare class AccessLinkStore {
+    private readonly links;
+    private defaultTtlSeconds;
+    private maxActiveLinks;
+    private readonly now;
+    private readonly randomId;
+    private readonly randomToken;
+    constructor(options?: AccessLinkStoreOptions);
+    /** Hot-update defaults from AI Access settings (no restart). */
+    configureDefaults(options: {
+        defaultTtlSeconds?: number;
+        maxActiveLinks?: number;
+    }): void;
+    /** Active = not revoked and not past expiresAt. */
+    private isActive;
+    list(): AccessLinkPublic[];
+    create(input?: CreateAccessLinkInput): AccessLinkCreated;
+    /**
+     * Raw token for an active link (in-memory only). Used to rebuild the GET URL
+     * for admin "Copy link" — never logs the value.
+     */
+    peekToken(linkId: string): string | null;
+    revoke(linkId: string): AccessLinkPublic;
+    /**
+     * Look up a link by id even if revoked/expired (still in memory).
+     * Used to enrich older audit rows that omitted label/expiry.
+     */
+    getById(linkId: string): AccessLinkPublic | null;
+    /**
+     * Validate a raw bearer token with distinct expired vs unknown/revoked.
+     * After a process restart the store is empty, so expired tokens cannot be
+     * told apart from unknown ones (both → `invalid`).
+     */
+    validateResult(token: string): AccessLinkValidateResult;
+    /**
+     * Validate a raw bearer token. Returns the public link metadata when active;
+     * otherwise null (unknown / expired / revoked / pre-restart).
+     */
+    validate(token: string): AccessLinkPublic | null;
+    /** Test helper: number of records still held in memory (including revoked). */
+    size(): number;
+    /** Test helper: wipe everything (simulates a process restart). */
+    clear(): void;
+    /**
+     * Test helper: insert or mutate a raw record (e.g. legacy without `kind`).
+     * Not for production use.
+     */
+    upsertRecordForTest(record: AccessLinkRecord): void;
+}
+
+/**
+ * Flow adapter contracts for in-process RED.runtime and Admin API fallback.
+ */
+/** Admin API / runtime deployment types used when applying an update. */
+type DeploymentType = 'nodes' | 'flows' | 'full';
+/** One node (or tab) object from the flat Admin API v2 flows array. */
+type FlowNode = Record<string, unknown> & {
+    id: string;
+    type: string;
+    z?: string;
+};
+/**
+ * Nested tab shape used by GET /flow/:id and by updateFlow payloads.
+ * Child nodes live in `nodes` / `configs` (not in the flat array form).
+ */
+interface FlowTab {
+    id: string;
+    type?: string;
+    label?: string;
+    disabled?: boolean;
+    info?: string;
+    env?: unknown[];
+    nodes?: FlowNode[];
+    configs?: FlowNode[];
+    [key: string]: unknown;
+}
+interface FlowsSnapshot {
+    rev: string;
+    flows: FlowNode[];
+}
+interface FlowSnapshot {
+    rev: string;
+    flow: FlowTab;
+}
+interface UpdateFlowParams {
+    flowId: string;
+    /** Replacement tab content (label/disabled/info/env + nodes/configs). */
+    flow: Partial<FlowTab>;
+    /** Revision from a prior getFlows/getFlow — must match the live rev. */
+    expectedRev: string;
+    /** Defaults to `nodes` (modified-nodes deploy). */
+    deploymentType?: DeploymentType;
+}
+interface UpdateFlowResult {
+    flowId: string;
+    rev: string;
+}
+interface FlowAdapter {
+    readonly kind: 'red' | 'http';
+    getFlows(): Promise<FlowsSnapshot>;
+    getFlow(flowId: string): Promise<FlowSnapshot>;
+    updateFlow(params: UpdateFlowParams): Promise<UpdateFlowResult>;
+}
+
+/**
+ * On-disk layout under `<userDir>/.ai-access`.
+ */
+interface AiAccessPaths {
+    root: string;
+    proposals: string;
+    logs: string;
+    /** Persisted AI Access settings (`settings.json`). */
+    settings: string;
+}
+
+/**
+ * Append-only JSONL audit log under `.ai-access/logs/`.
+ */
+
+type AuditActor = {
+    kind: 'access-link';
+    linkId: string;
+    label?: string;
+} | {
+    kind: 'admin';
+    username?: string;
+} | {
+    kind: 'system';
+};
+interface AuditEntry {
+    id: string;
+    at: string;
+    action: string;
+    actor: AuditActor;
+    details?: Record<string, unknown>;
+}
+declare class AuditLog {
+    private readonly paths;
+    private readonly filePath;
+    private readonly now;
+    private readonly maxAppendBytes;
+    private seq;
+    constructor(paths: AiAccessPaths, options?: {
+        now?: () => number;
+        maxAppendBytes?: number;
+    });
+    append(action: string, actor: AuditActor, details?: Record<string, unknown>): AuditEntry;
+    list(limit?: number): AuditEntry[];
+}
+
+/**
+ * Proposal JSON store under `.ai-access/proposals/`.
+ */
+
+type ProposalStatus = 'pending' | 'approved' | 'rejected' | 'failed' | 'withdrawn' | 'expired' | 'superseded';
+type ProposalType = 'replace_flow';
+interface ProposalCreator {
+    kind: 'access-link';
+    linkId: string;
+    label?: string;
+}
+type ProposalDecisionBy = {
+    kind: 'admin';
+    username?: string;
+} | {
+    kind: 'access-link';
+    linkId: string;
+    label?: string;
+};
+interface ReplaceFlowPayload {
+    flowId: string;
+    flow: Partial<FlowTab>;
+}
+/** Soft validation notes stored with a proposal (scaffold gaps, not hard errors). */
+interface ProposalWarning {
+    code: string;
+    error: string;
+    nodeId?: string;
+    type?: string;
+    property?: string;
+    configType?: string;
+    candidates?: string[];
+}
+interface Proposal {
+    id: string;
+    type: ProposalType;
+    status: ProposalStatus;
+    expectedRev: string;
+    payload: ReplaceFlowPayload;
+    /**
+     * Flow tab snapshot at `expectedRev` when the proposal was submitted.
+     * Diffs compare `payload.flow` against this base (not the live flow).
+     * Optional on legacy proposals created before this field existed.
+     */
+    baseFlow?: Partial<FlowTab>;
+    /**
+     * Soft validation notes from submit (missing config, unwired nodes, …).
+     * Never blocks approve — AI may scaffold first; humans configure later.
+     */
+    warnings?: ProposalWarning[];
+    /**
+     * Short human title (≤80 chars). Set at submit (AI-supplied or auto-generated).
+     * Optional on legacy proposals; API responses always resolve a title.
+     */
+    title?: string;
+    createdBy: ProposalCreator;
+    createdAt: string;
+    updatedAt: string;
+    decidedBy?: ProposalDecisionBy;
+    reason?: string;
+    resultRev?: string;
+}
+interface CreateProposalInput {
+    type: ProposalType;
+    expectedRev: string;
+    payload: ReplaceFlowPayload;
+    /** Live flow tab at expectedRev (stored for stable diffs). */
+    baseFlow: Partial<FlowTab>;
+    createdBy: ProposalCreator;
+    /** Sanitized short title (≤80 chars). */
+    title: string;
+    /** Soft validation notes to persist with the proposal. */
+    warnings?: ProposalWarning[];
+}
+declare class ProposalStore {
+    private readonly paths;
+    private readonly inFlight;
+    private readonly now;
+    private readonly randomId;
+    private readonly maxProposalBytes;
+    constructor(paths: AiAccessPaths, options?: {
+        now?: () => number;
+        randomId?: () => string;
+        maxProposalBytes?: number;
+    });
+    private fileFor;
+    /** Rebuild a proposal record so only validated fields are written to disk. */
+    private toDiskRecord;
+    private writeAtomic;
+    create(input: CreateProposalInput): Proposal;
+    get(id: string): Proposal;
+    list(filter?: {
+        linkId?: string;
+        status?: ProposalStatus;
+        flowId?: string;
+    }): Proposal[];
+    /**
+     * Begin an approve attempt. Throws if another approve is in flight or status
+     * is not pending. Caller must call finishApprove / failApprove / releaseLock.
+     */
+    beginApprove(id: string): Proposal;
+    releaseLock(id: string): void;
+    markApproved(id: string, decidedBy: ProposalDecisionBy, resultRev: string): Proposal;
+    markRejected(id: string, decidedBy: ProposalDecisionBy | undefined, reason: string): Proposal;
+    markFailed(id: string, decidedBy: ProposalDecisionBy | undefined, reason: string): Proposal;
+    markWithdrawn(id: string, decidedBy: ProposalDecisionBy, reason: string): Proposal;
+    /**
+     * Auto-close a pending proposal that can no longer be approved
+     * (`expired` = live rev moved; `superseded` = another proposal was approved).
+     */
+    markClosed(id: string, status: 'expired' | 'superseded', reason: string, decidedBy?: ProposalDecisionBy): Proposal;
+}
+
+/**
+ * Persisted AI Access settings under `<userDir>/.ai-access/settings.json`.
+ *
+ * Precedence for effective values (highest wins):
+ * 1. Disk file keys present in `.ai-access/settings.json` (sidebar AI Access UI)
+ * 2. `settings.js` `aiAccess` block
+ * 3. Built-in defaults
+ *
+ * Changes via PUT /mcp/api/v1/settings update memory + disk immediately
+ * (no Node-RED restart).
+ */
+
+interface PersistedAiAccessSettings {
+    /** When false, AI features are off even if adminAuth is enabled. Default true. */
+    enabled?: boolean;
+    allowWithoutAdminAuth?: boolean;
+    defaultLinkTtlSeconds?: number;
+    defaultDeploymentType?: DeploymentType;
+    maxActiveLinks?: number;
+}
+interface EffectiveAiAccessSettings {
+    enabled: boolean;
+    allowWithoutAdminAuth: boolean;
+    defaultLinkTtlSeconds: number;
+    defaultDeploymentType: DeploymentType;
+    maxActiveLinks: number;
+}
+type SettingsSource = 'default' | 'settings.js' | 'disk';
+interface EffectiveAiAccessSettingsWithMeta extends EffectiveAiAccessSettings {
+    sources: Record<keyof EffectiveAiAccessSettings, SettingsSource>;
+}
+declare class SettingsStore {
+    private readonly paths;
+    private readonly filePath;
+    private disk;
+    private settingsJs;
+    private cached;
+    constructor(paths: AiAccessPaths, settingsJsAiAccess?: PersistedAiAccessSettings);
+    getEffective(): EffectiveAiAccessSettingsWithMeta;
+    getDisk(): PersistedAiAccessSettings;
+    /**
+     * Replace disk overrides with the given partial (omit a key to clear that
+     * disk override and fall back to settings.js / default).
+     */
+    update(partial: PersistedAiAccessSettings): EffectiveAiAccessSettingsWithMeta;
+    /** Merge into existing disk overrides (only provided keys change). */
+    patch(partial: PersistedAiAccessSettings): EffectiveAiAccessSettingsWithMeta;
+    private persist;
+}
+
+/**
+ * Installed palette node-type discovery + unknown-type validation.
+ *
+ * Read-only: lists types from Node-RED's node catalogue and parses HTML
+ * registerType defaults when available. Never installs packages.
+ */
+
+interface NodeSetInfo {
+    id: string;
+    module: string;
+    version?: string;
+    types: string[];
+    enabled?: boolean;
+    name?: string;
+}
+interface NodeTypesAdapter {
+    listNodeSets(): Promise<NodeSetInfo[]>;
+    getNodeConfigHtml?(setId: string, lang?: string): Promise<string | null>;
+}
+interface CatalogueModule {
+    id: string;
+    description?: string;
+    updated_at?: string;
+    version?: string;
+    keywords?: string[];
+    url?: string;
+    downloads?: number;
+}
+interface CatalogueJson {
+    modules?: CatalogueModule[];
+    [key: string]: unknown;
+}
+type CatalogueFetcher = (url: string, etag?: string) => Promise<{
+    status: number;
+    etag?: string;
+    body?: CatalogueJson | null;
+}>;
+
+/**
+ * Approve / reject proposals through the FlowAdapter with audit logging.
+ */
+
+declare class ProposalService {
+    private readonly proposals;
+    private readonly audit;
+    private readonly adapter;
+    private readonly getDeploymentType;
+    constructor(proposals: ProposalStore, audit: AuditLog, adapter: FlowAdapter, getDeploymentType: () => DeploymentType);
+    approve(id: string, decidedBy: ProposalDecisionBy, options?: {
+        deploymentType?: DeploymentType;
+    }): Promise<Proposal>;
+    reject(id: string, decidedBy: ProposalDecisionBy, reason: string): Proposal;
+}
+
+/**
+ * Minimal Node-RED runtime surface used by the AI Access plugin.
+ */
+
+/**
+ * Plugin settings read from settings.js (`aiAccess: { ... }`).
+ */
+interface AiAccessSettings {
+    /**
+     * Master switch. When false, AI features stay off even with adminAuth.
+     * Default: true. Editable from the editor sidebar AI Access tab.
+     */
+    enabled?: boolean;
+    /**
+     * When adminAuth is not configured, AI features stay off unless this is true
+     * (intended for local-only setups).
+     */
+    allowWithoutAdminAuth?: boolean;
+    /** Default access-link TTL in seconds (default: 14400 = 4h). */
+    defaultLinkTtlSeconds?: number;
+    /** Maximum concurrent active access links (default: 10). */
+    maxActiveLinks?: number;
+    /** Deployment type used when approving proposals (default: nodes). */
+    defaultDeploymentType?: 'nodes' | 'flows' | 'full';
+    /**
+     * Rate-limit window in milliseconds for `/mcp/api` and `/mcp/a`
+     * (default: 60000).
+     */
+    rateLimitWindowMs?: number;
+    /**
+     * Max requests per IP per window (default: 600 — generous for editor + AI
+     * polling).
+     */
+    rateLimitMaxPerIp?: number;
+    /**
+     * Max requests per access-link token per window (default: 300).
+     */
+    rateLimitMaxPerToken?: number;
+    /**
+     * Explicit public base URL (e.g. `https://nodered.example.com`) used for
+     * absolute URLs (access-link `url`, proposal `reviewUrl`, `accessLinksUrl`).
+     * Overrides `Host` / `X-Forwarded-*`. settings.js only.
+     */
+    publicBaseUrl?: string;
+    /**
+     * Browser origins allowed to call the AI-facing endpoints (`/mcp/a`,
+     * `/mcp/api`, `/mcp/rpc`) cross-origin, e.g. `['https://app.example.com']`.
+     * Default: none (no CORS headers). settings.js only.
+     */
+    corsAllowedOrigins?: string[];
+}
+type AiAccessPermission = 'read' | '*';
+interface AiAccessCapabilities {
+    view: boolean;
+    manageLinks: boolean;
+    approveProposals: boolean;
+}
+interface AiAccessStatusCallerAdmin {
+    kind: 'admin';
+    permission?: AiAccessPermission;
+}
+interface AiAccessStatusCallerBaseUrls {
+    /** REST API base (`{httpAdminRoot}/mcp/api/v1`). */
+    api: string;
+    /** MCP Streamable HTTP endpoint (`{httpAdminRoot}/mcp/rpc`). */
+    rpc: string;
+    /** OpenAPI YAML URL. */
+    openapi: string;
+    /** OpenAPI JSON URL (same spec as `openapi`). */
+    openapiJson: string;
+    /** Unauthenticated JSON discovery index. */
+    discovery: string;
+}
+interface AiAccessStatusCallerAccessLink {
+    kind: 'access-link';
+    linkId: string;
+    /** Token surface this Bearer was minted for (`get_link` | `rest` | `mcp`). */
+    tokenKind: AccessLinkKind;
+    label?: string;
+    /** ISO-8601 expiry of this access link. */
+    expiresAt?: string;
+    /** Whole minutes until `expiresAt` (0 when already past). */
+    /** Whole minutes left, rounded up (never 0 while the token is valid). */
+    minutesRemaining?: number;
+    /** Whole seconds left, rounded up. */
+    secondsRemaining?: number;
+    /**
+     * Capabilities granted to this access link (not admin scopes).
+     * Example: `status:read`, `flows:read`, `proposals:create`, `proposals:read-own`.
+     */
+    permissions?: string[];
+    /**
+     * Absolute admin paths this token can use.
+     * Surfaces the token cannot call are omitted (not merely marked).
+     */
+    baseUrls?: Partial<AiAccessStatusCallerBaseUrls>;
+}
+type AiAccessStatusCaller = AiAccessStatusCallerAdmin | AiAccessStatusCallerAccessLink;
+interface AiAccessStatus {
+    ok: boolean;
+    version: string;
+    adminAuthEnabled: boolean;
+    /** Effective master switch (settings.js / disk). */
+    aiAccessEnabled: boolean;
+    aiFeaturesEnabled: boolean;
+    allowWithoutAdminAuth: boolean;
+    /**
+     * Admin session permission (`read` / `*`), or `null` for access-link callers
+     * (AI tokens are not admin sessions — see `caller`).
+     */
+    permission: AiAccessPermission | null;
+    capabilities: AiAccessCapabilities;
+    storageDir?: string;
+    /** Effective default access-link TTL (seconds). */
+    defaultLinkTtlSeconds: number;
+    /** Effective max concurrent active access links. */
+    maxActiveLinks: number;
+    /** Deployment type used when approving proposals. */
+    defaultDeploymentType: 'nodes' | 'flows' | 'full';
+    /** Who is calling: admin session or access-link Bearer. */
+    caller?: AiAccessStatusCaller;
+}
+interface NodeRedPluginSettings {
+    userDir: string;
+    httpAdminRoot?: string;
+    adminAuth?: unknown;
+    aiAccess?: AiAccessSettings;
+}
+interface NodeRedAuthAPI {
+    needsPermission(permission: string): (req: Request, res: Response, next: NextFunction) => void;
+}
+interface NodeRedPluginAPI {
+    settings: NodeRedPluginSettings;
+    httpAdmin: Express;
+    auth: NodeRedAuthAPI;
+    plugins: {
+        registerPlugin: (id: string, definition?: Record<string, unknown>) => void;
+    };
+    log?: {
+        info?: (message: string) => void;
+        warn?: (message: string) => void;
+        error?: (message: string) => void;
+    };
+}
+type AccessLinkKind = 'get_link' | 'rest' | 'mcp';
+interface AccessLinkAuthInfo {
+    id: string;
+    kind: AccessLinkKind;
+    label?: string;
+    createdAt: string;
+    expiresAt: string;
+    createdBy?: string;
+}
+interface AuthenticatedRequest extends Request {
+    user?: {
+        username?: string;
+        permissions?: string | string[];
+    };
+    authInfo?: {
+        scope?: string | string[];
+    };
+    /** Set by the Bearer access-link middleware when a valid token is presented. */
+    accessLink?: AccessLinkAuthInfo;
+}
+
+/**
+ * Construct shared plugin services (stores, adapter, audit).
+ */
+
+interface PluginServices {
+    linkStore: AccessLinkStore;
+    proposalStore: ProposalStore;
+    auditLog: AuditLog;
+    flowAdapter: FlowAdapter;
+    nodeTypesAdapter: NodeTypesAdapter;
+    proposalService: ProposalService;
+    settingsStore: SettingsStore;
+    /** Optional catalogue fetcher override (unit tests). */
+    catalogueFetcher?: CatalogueFetcher;
+    catalogueUrl?: string;
+}
+interface CreatePluginServicesOptions {
+    flowAdapter?: FlowAdapter;
+    nodeTypesAdapter?: NodeTypesAdapter;
+    catalogueFetcher?: CatalogueFetcher;
+    catalogueUrl?: string;
+    linkStore?: AccessLinkStore;
+    settingsStore?: SettingsStore;
+    /** When false, do not bind the process-wide settings store (tests). Default true. */
+    bindSettings?: boolean;
+}
+declare function createPluginServices(RED: NodeRedPluginAPI, options?: CreatePluginServicesOptions): PluginServices;
+
+/**
+ * Bearer access-link middleware for AI-facing routes.
+ */
+
+declare const ACCESS_LINK_INVALID_MESSAGE = "Access link is invalid, revoked, or no longer available (it may have expired, or Node-RED may have restarted). Ask the user for a new access link.";
+declare const ACCESS_LINK_MISSING_MESSAGE = "Access link Bearer token is missing. Ask the user for a new access link and send Authorization: Bearer <token>.";
+/**
+ * Authenticate AI clients with an access-link Bearer token of the expected kind.
+ * Always rejects when AI features are disabled.
+ */
+declare function requireAccessLink(RED: NodeRedPluginAPI, store: AccessLinkStore, expectedKind: AccessLinkKind$1): (req: AuthenticatedRequest, res: Response, next: NextFunction) => void;
+
+/**
+ * On-disk layout for proposals and logs (under the Node-RED userDir).
+ */
+
+/**
+ * Hidden AI Access data directory: `<userDir>/.ai-access`.
+ * Contains `proposals/` JSON files and append-only `logs/`.
+ */
+declare function getStorageDir(settings: NodeRedPluginSettings): string;
+
+/**
+ * Resolve AI Access settings from settings.js + optional disk store.
+ */
+
+declare function bindSettingsStore(store: SettingsStore | null): void;
+declare function isAdminAuthEnabled(settings: NodeRedPluginSettings): boolean;
+/**
+ * Effective AI Access settings. When a {@link SettingsStore} is bound,
+ * disk overrides apply without restart; otherwise falls back to settings.js.
+ */
+declare function resolveAiAccessSettings(settings: NodeRedPluginSettings): EffectiveAiAccessSettings;
+/**
+ * AI features require `enabled` (default true) and either adminAuth or the
+ * local-only `allowWithoutAdminAuth` opt-in.
+ */
+declare function areAiFeaturesEnabled(settings: NodeRedPluginSettings): boolean;
+
+/** Max serialized proposal JSON size (pretty-printed). */
+declare const MAX_PROPOSAL_JSON_BYTES = 1500000;
+
+/**
+ * Editor sidebar AI Access tab — script + styles served from
+ * GET /mcp/editor/ai-access-sidebar.js (Cache-Control: no-store).
+ *
+ * Companion `ai-access.html` is a thin loader that injects this file with a
+ * cache-bust query so Node-RED's cached companion HTML no longer freezes UX.
+ */
+/** Derived from package.json via build-time `__AI_ACCESS_VERSION__` (not hand-typed). */
+declare const EDITOR_SIDEBAR_ASSET_VERSION: string;
+/** Full JS payload for GET /mcp/editor/ai-access-sidebar.js (injects CSS, then runs tab). */
+declare function renderEditorSidebarJs(): string;
+/**
+ * Thin companion HTML loader. Version is always {@link EDITOR_SIDEBAR_ASSET_VERSION}
+ * (from package.json) — never hand-typed in a second place.
+ */
+declare function renderEditorSidebarLoaderHtml(version?: string): string;
+
+/**
+ * Package version injected at build time (tsup / vitest `define`).
+ * Used for status payloads and editor-sidebar asset cache-busting.
+ */
+/** Resolved package version (`package.json` via build define). */
+declare function packageVersion(): string;
+
+/**
+ * Node-RED plugin entry for @com55/node-red-ai-access.
+ *
+ * Registers /mcp admin page, access links, proposals, flows, logs APIs,
+ * and the /mcp/rpc Streamable HTTP endpoint.
+ */
+
+declare function registerRoutes(RED: NodeRedPluginAPI, serviceOptions?: CreatePluginServicesOptions): void;
+/**
+ * Node-RED plugin factory. Loaded via `ai-access.cjs` → `dist/plugin.cjs`.
+ */
+declare function registerAiAccessPlugin(RED: NodeRedPluginAPI): void;
+
+export { ACCESS_LINK_INVALID_MESSAGE, ACCESS_LINK_MISSING_MESSAGE, type AccessLinkAuthInfo, AccessLinkStore, type AiAccessCapabilities, type AiAccessPermission, type AiAccessSettings, type AiAccessStatus, EDITOR_SIDEBAR_ASSET_VERSION, MAX_PROPOSAL_JSON_BYTES, type NodeRedPluginAPI, SettingsStore, areAiFeaturesEnabled, bindSettingsStore, createPluginServices, registerAiAccessPlugin as default, getStorageDir, isAdminAuthEnabled, packageVersion, registerRoutes, renderEditorSidebarJs, renderEditorSidebarLoaderHtml, requireAccessLink, resolveAiAccessSettings };