@sendinel/mcp-server 1.0.4 → 1.0.6

package/build/audit.d.ts

@@ -18,4 +18,5 @@ export declare function logAudit(opts: {
     resourceType: string;
     resourceId?: string;
     details?: Record<string, unknown>;
+    channel?: string;
 }): Promise<void>;

package/build/audit.js

@@ -1,4 +1,4 @@
-import { db } from './db.js';
+import { db, requestContext } from './db.js';
 import { getProjectId } from './project.js';
 /**
  * Log a consent record for GDPR compliance.
@@ -24,15 +24,21 @@ export async function logConsent(opts) {
  */
 export async function logAudit(opts) {
     const projectId = getProjectId();
+    const context = requestContext();
     await db()
         .from('audit_log')
         .insert({
         project_id: projectId,
-        actor_type: 'mcp',
+        actor_type: context?.actorType ?? 'mcp',
+        actor_id: context?.actorId ?? null,
         action: opts.action,
         resource_type: opts.resourceType,
         resource_id: opts.resourceId ?? null,
-        details: opts.details ?? {},
+        details: {
+            ...(opts.details ?? {}),
+            ...(context?.workspaceId ? { workspace_id: context.workspaceId } : {}),
+        },
+        channel: opts.channel ?? context?.channel ?? 'mcp',
     })
         .then(() => { }, () => { }); // fire-and-forget
 }

package/build/auth.d.ts

@@ -1,10 +1,20 @@
 export type ProjectPlan = 'free' | 'byod' | 'managed' | 'agency-plus' | 'enterprise';
+export type ApprovalMode = 'standard' | 'autonomous';
 export interface ApiKeyInfo {
     projectId: string;
     scopes: string[];
     toolGroups: string[];
     approvalMode: string;
+    authMethod?: 'api_key' | 'scoped_jwt';
+    actsAsUserId?: string | null;
+    workspaceId?: string | null;
+}
+export declare class McpAuthenticationError extends Error {
+    readonly status: 401 | 403 | 503;
+    readonly code: string;
+    constructor(message: string, status: 401 | 403 | 503, code: string);
 }
 export declare function resolveToolGroupsForPlan(plan: string | null | undefined, requested: string[] | null | undefined): string[];
 export declare function serviceKeyInfo(projectId: string): Promise<ApiKeyInfo>;
 export declare function validateKey(key: string): Promise<ApiKeyInfo | null>;
+export declare function authenticateBearer(token: string, overrideProjectId?: string): Promise<ApiKeyInfo | null>;

package/build/auth.js

@@ -1,10 +1,17 @@
 import { adminDb } from './db.js';
 import { ALL_TOOL_GROUPS } from './server.js';
+import { looksLikeScopedJwt, scopedJwtVerificationEnabled, verifyScopedToken, } from './scoped-token.js';
 const BYOD_DEFAULT_TOOL_GROUPS = ['contacts', 'templates', 'analytics'];
-export function resolveToolGroupsForPlan(plan, requested) {
-    if (requested && requested.length > 0) {
-        return requested.filter((group) => ALL_TOOL_GROUPS.includes(group));
+export class McpAuthenticationError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
     }
+}
+function defaultToolGroupsForPlan(plan) {
     switch (plan) {
         case 'byod':
             return BYOD_DEFAULT_TOOL_GROUPS.slice();
@@ -17,14 +24,28 @@ export function resolveToolGroupsForPlan(plan, requested) {
             return [];
     }
 }
-async function getProjectPlan(projectId) {
+function planAllowsExplicitToolGroups(plan) {
+    return plan === 'byod' || plan === 'managed' || plan === 'agency-plus' || plan === 'enterprise';
+}
+export function resolveToolGroupsForPlan(plan, requested) {
+    if (requested && requested.length > 0) {
+        if (!planAllowsExplicitToolGroups(plan))
+            return defaultToolGroupsForPlan(plan);
+        return requested.filter((group) => ALL_TOOL_GROUPS.includes(group));
+    }
+    return defaultToolGroupsForPlan(plan);
+}
+async function getProjectAuthDefaults(projectId) {
     const { data } = await adminDb()
         .schema('email')
         .from('projects')
-        .select('plan')
+        .select('plan, approval_mode')
         .eq('id', projectId)
         .maybeSingle();
-    return data?.plan ?? 'free';
+    return {
+        plan: data?.plan ?? 'free',
+        approvalMode: data?.approval_mode ?? 'standard',
+    };
 }
 // First-party service auth for the MCP lane: the shared SYNCHRONEX_SERVICE_TOKEN
 // acts on an explicitly-named project (no per-project key lookup). Tool access is
@@ -32,12 +53,12 @@ async function getProjectPlan(projectId) {
 // the project is entitled to — never more. Mirrors authenticateV1's service path
 // on the dashboard side.
 export async function serviceKeyInfo(projectId) {
-    const plan = await getProjectPlan(projectId);
+    const { plan, approvalMode } = await getProjectAuthDefaults(projectId);
     return {
         projectId,
         scopes: ['admin'],
         toolGroups: resolveToolGroupsForPlan(plan, null),
-        approvalMode: 'standard',
+        approvalMode,
     };
 }
 export async function validateKey(key) {
@@ -47,7 +68,7 @@ export async function validateKey(key) {
     if (error || !data?.length)
         return null;
     const row = data[0];
-    const plan = await getProjectPlan(row.project_id);
+    const { plan } = await getProjectAuthDefaults(row.project_id);
     return {
         projectId: row.project_id,
         scopes: row.scopes,
@@ -55,3 +76,55 @@ export async function validateKey(key) {
         approvalMode: row.approval_mode ?? 'standard',
     };
 }
+export async function authenticateBearer(token, overrideProjectId) {
+    if (scopedJwtVerificationEnabled() && looksLikeScopedJwt(token)) {
+        let claims;
+        try {
+            claims = await verifyScopedToken(token);
+        }
+        catch {
+            throw new McpAuthenticationError('Invalid or expired token', 401, 'INVALID_SCOPED_TOKEN');
+        }
+        if (claims.scope === 'data'
+            && overrideProjectId
+            && overrideProjectId !== claims.projectId) {
+            throw new McpAuthenticationError('Project header conflicts with signed token', 403, 'PROJECT_SCOPE_MISMATCH');
+        }
+        const projectId = claims.scope === 'service:provision'
+            ? (overrideProjectId || claims.projectId)
+            : claims.projectId;
+        if (!projectId) {
+            throw new McpAuthenticationError('Token missing project scope', 403, 'INSUFFICIENT_SCOPE');
+        }
+        const info = await serviceKeyInfo(projectId);
+        const { error: auditError } = await adminDb()
+            .schema('email')
+            .from('audit_log')
+            .insert({
+            project_id: projectId,
+            actor_type: 'synchronex_scoped_jwt',
+            actor_id: claims.userId,
+            action: 'mcp.authenticate',
+            resource_type: 'mcp_transport',
+            details: {
+                workspace_id: claims.workspaceId,
+                token_scope: claims.scope,
+            },
+            channel: 'synchronex_scoped_jwt',
+        });
+        if (auditError) {
+            throw new McpAuthenticationError('Scoped request audit unavailable', 503, 'AUDIT_UNAVAILABLE');
+        }
+        return {
+            ...info,
+            authMethod: 'scoped_jwt',
+            actsAsUserId: claims.userId,
+            workspaceId: claims.workspaceId,
+        };
+    }
+    let info = await validateKey(token);
+    if (info && overrideProjectId && info.scopes?.includes('service:provision')) {
+        info = await serviceKeyInfo(overrideProjectId);
+    }
+    return info;
+}

package/build/db.d.ts

@@ -18,7 +18,13 @@ export declare function setProjectClient(client: any): void;
 export declare function runWithClient<T>(client: any, fn: () => Promise<T>, request?: {
     projectId?: string;
     approvalMode?: string;
+    channel?: string;
+    channelVerified?: boolean;
+    actorType?: string;
+    actorId?: string | null;
+    workspaceId?: string | null;
 }): Promise<T>;
+export declare function runWithToolContext<T>(toolGroup: string, toolName: string, fn: () => Promise<T> | T): Promise<T>;
 /**
  * Request-scoped identity set via runWithClient() (HTTP transport).
  * Undefined under stdio, where the process env is the single-project source of truth.
@@ -26,7 +32,13 @@ export declare function runWithClient<T>(client: any, fn: () => Promise<T>, requ
 export declare function requestContext(): {
     projectId?: string;
     approvalMode?: string;
+    channel?: string;
+    channelVerified?: boolean;
+    actorType?: string;
+    actorId?: string | null;
+    workspaceId?: string | null;
 } | undefined;
+export declare function projectClientForWriteback(): any | null;
 /**
  * Returns the project client appropriate for the current execution context:
  *   1. Per-request store (HTTP): set via runWithClient() — safe under concurrency.

package/build/db.js

@@ -48,13 +48,45 @@ export async function runWithClient(
 client, fn, request) {
     return _requestStore.run({ client, ...request }, fn);
 }
+export async function runWithToolContext(toolGroup, toolName, fn) {
+    const current = _requestStore.getStore();
+    if (!current)
+        return await _requestStore.run({ client: _processClient, toolGroup, toolName }, fn);
+    return await _requestStore.run({ ...current, toolGroup, toolName }, fn);
+}
 /**
  * Request-scoped identity set via runWithClient() (HTTP transport).
  * Undefined under stdio, where the process env is the single-project source of truth.
  */
 export function requestContext() {
     const ctx = _requestStore.getStore();
-    return ctx ? { projectId: ctx.projectId, approvalMode: ctx.approvalMode } : undefined;
+    return ctx
+        ? {
+            projectId: ctx.projectId,
+            approvalMode: ctx.approvalMode,
+            channel: ctx.channel,
+            channelVerified: ctx.channelVerified,
+            actorType: ctx.actorType,
+            actorId: ctx.actorId,
+            workspaceId: ctx.workspaceId,
+        }
+        : undefined;
+}
+// Explicit BYOD write-back accessor. Contact tools continue to use db() for
+// central reads/writes; this exposes the customer client only where a tool
+// deliberately mirrors a completed central mutation.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function projectClientForWriteback() {
+    const ctx = _requestStore.getStore();
+    return ctx?.client ?? _processClient ?? null;
+}
+const BYOD_TOOL_NAMES = new Set(['create_blog_post', 'list_blog_posts', 'list_blog_destinations']);
+function shouldUseProjectClient(ctx) {
+    if (!ctx?.client)
+        return false;
+    if (ctx.toolName && BYOD_TOOL_NAMES.has(ctx.toolName))
+        return true;
+    return false;
 }
 /**
  * Returns the project client appropriate for the current execution context:
@@ -66,5 +98,8 @@ export function requestContext() {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function db() {
-    return _requestStore.getStore()?.client ?? _processClient ?? adminDb();
+    const ctx = _requestStore.getStore();
+    if (shouldUseProjectClient(ctx))
+        return ctx?.client;
+    return adminDb();
 }

package/build/index.js

@@ -9,8 +9,8 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 import express from 'express';
 import { registerAllTools } from './server.js';
 import { runWithClient } from './db.js';
-import { initProjectClient, resolveProjectClient } from './byod-client.js';
-import { serviceKeyInfo, validateKey } from './auth.js';
+import { initProjectClient, resolveProjectClientStrict, TenantResolutionError } from './byod-client.js';
+import { authenticateBearer, McpAuthenticationError, validateKey } from './auth.js';
 const transport = process.env.MCP_TRANSPORT ?? 'stdio';
 async function runStdio() {
     const server = new McpServer({ name: 'sendinel', version: '0.1.0' });
@@ -51,18 +51,22 @@ async function runHttp() {
             return;
         }
         const key = authHeader.slice(7);
-        let info = await validateKey(key);
+        const overrideProjectId = req.headers['x-sendinel-project-id']?.trim();
+        let info;
+        try {
+            info = await authenticateBearer(key, overrideProjectId);
+        }
+        catch (error) {
+            if (error instanceof McpAuthenticationError) {
+                res.status(error.status).json({ error: error.message, code: error.code });
+                return;
+            }
+            throw error;
+        }
         if (!info) {
             res.status(401).json({ error: 'Invalid or revoked API key' });
             return;
         }
-        // First-party service key (service:provision scope) may target any project
-        // via X-Sendinel-Project-Id, so Synchronex drives the bundled MCP lane
-        // without storing a per-project key. Other keys ignore the header.
-        const overrideProjectId = req.headers['x-sendinel-project-id']?.trim();
-        if (overrideProjectId && info.scopes?.includes('service:provision')) {
-            info = await serviceKeyInfo(overrideProjectId);
-        }
         req._apiKeyInfo = info;
         next();
     });
@@ -72,7 +76,21 @@ async function runHttp() {
         // runWithClient() binds it — plus projectId/approvalMode — to this request's
         // AsyncLocalStorage context. Nothing request-scoped may be written to
         // process.env here: it is process-global and leaks across concurrent tenants.
-        const projectClient = await resolveProjectClient(info.projectId);
+        let projectClient;
+        try {
+            projectClient = await resolveProjectClientStrict(info.projectId);
+        }
+        catch (err) {
+            if (err instanceof TenantResolutionError) {
+                res.status(424).json({
+                    error: 'Project-level Supabase connector is not available',
+                    code: 'PROJECT_CONNECTOR_UNAVAILABLE',
+                    detail: err.message,
+                });
+                return;
+            }
+            throw err;
+        }
         await runWithClient(projectClient, async () => {
             const server = new McpServer({ name: 'sendinel', version: '0.1.0' });
             registerAllTools(server, {
@@ -82,7 +100,15 @@ async function runHttp() {
             const t = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
             await server.connect(t);
             await t.handleRequest(req, res, req.body);
-        }, { projectId: info.projectId, approvalMode: info.approvalMode });
+        }, {
+            projectId: info.projectId,
+            approvalMode: info.approvalMode,
+            channel: info.authMethod === 'scoped_jwt' ? 'synchronex_scoped_jwt' : 'mcp_api_key',
+            channelVerified: true,
+            actorType: info.authMethod === 'scoped_jwt' ? 'synchronex_scoped_jwt' : 'mcp',
+            actorId: info.actsAsUserId ?? null,
+            workspaceId: info.workspaceId ?? null,
+        });
     });
     app.get('/health', (_req, res) => res.json({ ok: true }));
     app.listen(port, () => {

package/build/lib/action-approvals.d.ts

@@ -1,5 +1,30 @@
 export type ApprovalTier = 'autonomous' | 'gated' | 'protected';
 export declare function getApprovalTier(action: string, params?: Record<string, unknown>): ApprovalTier;
+/**
+ * The surface that originated an MCP tool call. Used to decide which tiers of
+ * action a given request is even allowed to *request* approval for — separate
+ * from who ultimately *decides* the approval (see `decided_via` and the
+ * `protected_requires_authenticated_decision` DB constraint).
+ */
+export type ChannelKind = 'dashboard_session' | 'mcp_oauth_session' | 'mcp_api_key' | 'slack_command' | 'sms_inbound' | 'email_reply';
+export interface ChannelExecutionContext {
+    channel: ChannelKind;
+    /** Whether the originating request was cryptographically verified (e.g. Slack signature, OAuth token, API key). */
+    verified: boolean;
+}
+export interface ExecutionDecision {
+    allowed: boolean;
+    tier: ApprovalTier;
+    reason?: string;
+}
+/**
+ * Gate on WHICH CHANNEL may even request an action of a given tier — distinct
+ * from getApprovalTier(), which only decides the tier itself. Call this before
+ * requestApproval() at every gated/protected call site.
+ */
+export declare function assertChannelCanExecute(action: string, params: Record<string, unknown> | undefined, context: ChannelExecutionContext): ExecutionDecision;
+/** Convenience: pull channel/verified out of the request-scoped context, defaulting to today's only live caller (mcp_api_key). */
+export declare function currentChannelContext(): ChannelExecutionContext;
 /** Build a human-readable summary of the action for the approval screen */
 export declare function buildApprovalSummary(action: string, params: Record<string, unknown>): string;
 export interface ApprovalResult {
@@ -16,13 +41,15 @@ export interface ApprovalResult {
  * Request human approval for an action. Creates a pending approval token
  * and returns instructions for the agent to wait.
  */
-export declare function requestApproval(action: string, params: Record<string, unknown>, apiKeyId?: string): Promise<ApprovalResult>;
+export declare function requestApproval(action: string, params: Record<string, unknown>, apiKeyId?: string, channelContext?: ChannelExecutionContext): Promise<ApprovalResult>;
 /**
  * Check if an approval token has been approved.
  * Returns the approval if approved, null if still pending, throws if rejected/expired.
  */
 export declare function checkApproval(approvalId: string, options?: {
     consume?: boolean;
+    action?: string;
+    params?: Record<string, unknown>;
 }): Promise<{
     approved: boolean;
     status: string;

package/build/lib/action-approvals.js

@@ -10,11 +10,13 @@ import { fireWebhookEvent } from './webhook-events.js';
  */
 const GATED_ACTIONS = new Set([
     'launch_campaign', // sends real emails
+    'broadcast_to_segment', // creates + activates a real broadcast
     'create_campaign_with_content', // can activate + send in one call
     'enroll_segment', // bulk enrollment
     'import_subscribers', // bulk data ingestion
     'subscribe_webhook', // outbound data channel
     'send_transactional', // sends a real email
+    'update_campaign_status', // activation sends real emails (see special case below)
 ]);
 const PROTECTED_ACTIONS = new Set([
     'delete_subscriber_data', // GDPR delete — irreversible
@@ -42,14 +44,75 @@ export function getApprovalTier(action, params) {
         return 'autonomous';
     if (action === 'send_transactional' && params?.category === 'test')
         return 'autonomous';
+    // update_campaign_status only sends real emails when activating; draft/pause/
+    // archive transitions are safe. Keeping this out of GATED_ACTIONS' plain
+    // membership check would silently drop the gate for any caller that reaches
+    // this action via the generic tier lookup instead of the hand-rolled check
+    // in campaigns.ts — so the special case must live here, not just at the call site.
+    if (action === 'update_campaign_status' && params?.status !== 'active')
+        return 'autonomous';
     if (GATED_ACTIONS.has(action))
         return 'gated';
     return 'autonomous';
 }
+// Channels trusted to originate Tier 1 (gated) actions. Every channel here has
+// either an authenticated session/key or (for slack_command) a verified request
+// signature — see verifySlackSignature in packages/dashboard/lib/slack.ts.
+const TIER1_CHANNELS = new Set([
+    'dashboard_session',
+    'mcp_oauth_session',
+    'mcp_api_key',
+    'slack_command',
+]);
+// Channels trusted to originate Tier 2 (protected) actions. Inbound,
+// unattended channels (SMS, email replies, Slack slash commands) are excluded —
+// irreversible actions must originate from an authenticated session/key, even
+// though the final *decision* may still happen via dashboard or a verified
+// Slack interactive component.
+const TIER2_CHANNELS = new Set([
+    'dashboard_session',
+    'mcp_oauth_session',
+    'mcp_api_key',
+]);
+/**
+ * Gate on WHICH CHANNEL may even request an action of a given tier — distinct
+ * from getApprovalTier(), which only decides the tier itself. Call this before
+ * requestApproval() at every gated/protected call site.
+ */
+export function assertChannelCanExecute(action, params, context) {
+    const tier = getApprovalTier(action, params);
+    if (tier === 'autonomous')
+        return { allowed: true, tier };
+    if (!context.verified) {
+        return {
+            allowed: false,
+            tier,
+            reason: `This action requires human approval (tier: ${tier}), but the request came from an unverified "${context.channel}" channel. Verified channel required.`,
+        };
+    }
+    const allowedChannels = tier === 'protected' ? TIER2_CHANNELS : TIER1_CHANNELS;
+    if (!allowedChannels.has(context.channel)) {
+        return {
+            allowed: false,
+            tier,
+            reason: `Channel "${context.channel}" is not permitted to request ${tier}-tier actions.`,
+        };
+    }
+    return { allowed: true, tier };
+}
+/** Convenience: pull channel/verified out of the request-scoped context, defaulting to today's only live caller (mcp_api_key). */
+export function currentChannelContext() {
+    const ctx = requestContext();
+    return {
+        channel: ctx?.channel ?? 'mcp_api_key',
+        verified: ctx?.channelVerified ?? true,
+    };
+}
 /** Build a human-readable summary of the action for the approval screen */
 export function buildApprovalSummary(action, params) {
     const summaries = {
         launch_campaign: (p) => `Launch campaign "${p.name || p.campaign_name || 'unknown'}" — will send emails to real contacts`,
+        broadcast_to_segment: (p) => `Broadcast "${p.name || p.subject || 'untitled'}" to segment ${p.segment_id} — will send emails to real contacts`,
         create_campaign_with_content: (p) => `Create + activate campaign "${p.name}" with ${p.steps?.length ?? 0} email(s) and enroll contacts`,
         enroll_segment: (p) => `Enroll all contacts from site into campaign ${p.campaign_id}`,
         import_subscribers: (p) => `Import subscribers (up to ${p.contacts?.length ?? 'unknown'} records)`,
@@ -64,14 +127,30 @@ export function buildApprovalSummary(action, params) {
     const fn = summaries[action];
     return fn ? fn(params) : `Execute ${action} with provided parameters`;
 }
+function normalizeApprovalParams(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeApprovalParams);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, entryValue]) => entryValue !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entryValue]) => [key, normalizeApprovalParams(entryValue)]));
+    }
+    return value;
+}
+function approvalParamsEqual(expected, actual) {
+    return JSON.stringify(normalizeApprovalParams(expected)) === JSON.stringify(normalizeApprovalParams(actual));
+}
 /**
  * Request human approval for an action. Creates a pending approval token
  * and returns instructions for the agent to wait.
  */
-export async function requestApproval(action, params, apiKeyId) {
+export async function requestApproval(action, params, apiKeyId, channelContext) {
     const tier = getApprovalTier(action, params);
     const summary = buildApprovalSummary(action, params);
     const expiresAt = new Date(Date.now() + 30 * 60 * 1000).toISOString();
+    const { channel, verified } = channelContext ?? currentChannelContext();
     const { data, error } = await db()
         .from('action_approvals')
         .insert({
@@ -82,6 +161,8 @@ export async function requestApproval(action, params, apiKeyId) {
         params,
         summary,
         expires_at: expiresAt,
+        channel,
+        channel_verified: verified,
     })
         .select('id')
         .single();
@@ -111,12 +192,18 @@ export async function requestApproval(action, params, apiKeyId) {
 export async function checkApproval(approvalId, options = {}) {
     const { data, error } = await db()
         .from('action_approvals')
-        .select('status, decided_by, decided_via, expires_at, used_at')
+        .select('action, status, decided_by, decided_via, expires_at, used_at, params')
         .eq('id', approvalId)
         .eq('project_id', getProjectId())
         .maybeSingle();
     if (error || !data)
         return { approved: false, status: 'not_found' };
+    if (options.action && data.action !== options.action) {
+        return { approved: false, status: 'action_mismatch' };
+    }
+    if (options.params && !approvalParamsEqual(options.params, data.params)) {
+        return { approved: false, status: 'params_mismatch' };
+    }
     // Check expiry
     if (data.status === 'pending' && new Date(data.expires_at) < new Date()) {
         await db()

package/build/lib/brand-asset-persist.d.ts

@@ -0,0 +1,35 @@
+export declare const BRAND_ASSETS_BUCKET = "brand-assets";
+export declare const MAX_ASSET_BYTES: number;
+export type BrandAssetKind = 'logo' | 'image' | 'document' | 'font' | 'avatar' | 'video';
+export declare const BRAND_ASSET_KINDS: BrandAssetKind[];
+export declare function extOf(filename: string): string;
+export declare function resolveMime(filename: string, declared?: string | null): string;
+export declare function isValidKind(value: unknown): value is BrandAssetKind;
+export declare function inferKind(mime: string): BrandAssetKind;
+export declare function refineKindFromName(filename: string, mime: string): BrandAssetKind;
+export declare function resolveKind(inputKind: unknown, filename: string, mimeType: string): BrandAssetKind;
+export type PersistBrandAssetInput = {
+    sb: any;
+    orgId: string;
+    projectId: string;
+    bytes: Buffer;
+    filename: string;
+    mimeType?: string | null;
+    kind: BrandAssetKind;
+    source: 'uploaded' | 'imported';
+    collection?: string | null;
+    tags?: string[];
+    brandKitId?: string | null;
+};
+export type PersistBrandAssetResult = {
+    assetId: string;
+    skippedExisting: boolean;
+    storagePath: string;
+};
+/**
+ * Uploads bytes to Sendinel's own Supabase Storage + inserts/dedupes the row
+ * in email.brand_media_assets, using the MCP server's own adminDb() client —
+ * no round-trip through the dashboard's v1 API, no separate SENDINEL_API_KEY.
+ * Video (R2-backed in the dashboard) is not supported via this path.
+ */
+export declare function persistBrandAsset(input: PersistBrandAssetInput): Promise<PersistBrandAssetResult>;