@sendinel/mcp-server 1.0.214 → 1.0.216

package/README.md

@@ -18,7 +18,7 @@ preserves REST outcomes, and redacts failures. See the
 [event-triggered campaign guide](../../docs/event-triggered-campaigns.md) for
 inputs, idempotency, subscription requirements, and conditional step examples.
 
-Sendinel currently exposes 35 tool groups and 352 tools (gateway mode exposes 4 meta-tools, sharing how_to with full mode). These counts are checked against the tool registry in CI, so this table matches what ships.
+Sendinel currently exposes 35 tool groups and 356 tools (gateway mode exposes 4 meta-tools, sharing how_to with full mode). These counts are checked against the tool registry in CI, so this table matches what ships.
 
 | Group | Count | Purpose |
 |-------|-------|---------|
@@ -35,19 +35,19 @@ Sendinel currently exposes 35 tool groups and 352 tools (gateway mode exposes 4
 | `compound` | 4 | Higher-level campaign/template/site setup and delivery diagnosis workflows |
 | `connector` | 6 | BYOD connector status, table discovery, schema/view setup, mapping, resync |
 | `contacts` | 40 | Subscriber CRUD, saved views, tags, email log, suppression, merge, timeline |
-| `content` | 14 | Content blocks, gated asset links, blog ingest and auto-publish, sources |
+| `content` | 15 | Content blocks, gated asset links, blog ingest and auto-publish, sources |
 | `data` | 19 | Platform connectors, imports, API keys, migration jobs, notifications, tenant export |
 | `data-proposals` | 3 | Data-derived campaign proposal generation, listing, approval |
 | `delivery-ops` | 25 | Domains, DNSBL, deliverability diagnostics, queue, DLQ, exports, blackout dates, abuse overrides |
 | `drafts` | 6 | Draft create/approve/reject and draft-to-campaign promotion |
-| `forms` | 3 | Form creation, listing, stats |
+| `forms` | 5 | Form creation, listing, stats |
 | `gdpr` | 4 | Contact data deletion and GDPR log |
 | `landing-pages` | 5 | Landing page CRUD |
 | `lists` | 7 | Static contact lists and membership management |
 | `newsletters` | 12 | Newsletter publications, issues, subscribers, scheduling, sending, stats |
 | `org` | 24 | Team members, plan usage/limits, audit log, model registry, white-label, support tickets, outbound digest, provider switching |
 | `segments` | 6 | Audience builder: create, edit, natural-language generation, preview |
-| `short-links` | 3 | Short links, click stats, QR codes |
+| `short-links` | 4 | Short links, click stats, QR codes |
 | `signatures` | 7 | Sending signature blocks |
 | `sites` | 7 | Site, sender, and brand voice management |
 | `skills` | 3 | Operator skills catalog |

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

@@ -1,4 +1,5 @@
 import type { DecisionEvidence } from './approval-elicitation-evidence.js';
+import { type AutoApproveUnavailableReason } from './sandbox-approvals.js';
 export { isApprovalGatedAction } from './approval-actions.js';
 /**
  * Action approval tiers:
@@ -45,6 +46,7 @@ export declare function approvalExcerpt(html: unknown, max?: number): string;
 export declare function buildApprovalSummary(action: string, params: Record<string, unknown>, display?: ApprovalDisplay): string;
 export interface ApprovalResult {
     requires_approval: true;
+    auto_approve_unavailable_reason?: AutoApproveUnavailableReason;
     approval_id: string;
     tier: ApprovalTier;
     action: string;

package/build/lib/action-approvals.js

@@ -1,5 +1,5 @@
 import { effectiveApproval, auditApprovalLevel } from './approval-classes.js';
-import { sandboxApprovalEligible, trySandboxApproval } from './sandbox-approvals.js';
+import { sandboxApprovalEligible, trySandboxApprovalWithReason } from './sandbox-approvals.js';
 import { humanApprovalEligible } from './approval-human-eligibility.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { z } from 'zod';
@@ -392,7 +392,8 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         throw new Error(`Failed to create approval request: ${error.message}`);
     let projectName;
     let sandboxDisplayRead = false;
-    const sandboxApproved = !(effective.applied && (effective.level === 'ask_every_time' || (effective.class === 'F' && !action.startsWith('delete_')))) && await trySandboxApproval(data.id, getProjectId(), action, approvalPayloadHash(action, frozenParams), name => { projectName = name; sandboxDisplayRead = true; }, frozenParams);
+    const sandboxPolicyBlocked = effective.applied && (effective.level === 'ask_every_time' || (effective.class === 'F' && !action.startsWith('delete_')));
+    const sandboxAttempt = sandboxPolicyBlocked ? { approved: false, reason: 'approval_policy' } : await trySandboxApprovalWithReason(data.id, getProjectId(), action, approvalPayloadHash(action, frozenParams), name => { projectName = name; sandboxDisplayRead = true; }, frozenParams);
     if (isTesterRequest(action))
         await logTesterRequestAudit('tester_request', action, data.id, null);
     fireWebhookEvent('approval.requested', {
@@ -414,16 +415,18 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         catch { /* Missing display data omits the project line. */ }
     const approveUrl = approvalPageUrl(data.id);
     const previewText = buildApprovalPreview({ action, params: frozenParams, summary: detailSummary, projectName, ...(display && 'recipient_count' in display ? { recipientCount: display.recipient_count } : {}) }).plain_summary;
-    if (sandboxApproved) {
+    if (sandboxAttempt.approved) {
         return { requires_approval: true, approval_id: data.id, tier, action, summary, expires_at: expiresAt,
             approve_via: 'sandbox', decided_via: 'sandbox', decided_by: null, approve_url: approveUrl, preview_text: previewText, decision_status: 'approved',
             message: approvalNext(action, { approve_via: 'sandbox', decision_status: 'approved' }) };
     }
+    const autoApproveUnavailableReason = sandboxAttempt.reason;
     const chatGuidance = tier === 'gated' && await humanApprovalEligible(action, getProjectId(), actor, true)
         ? `\nAsk the user in plain chat: "${previewText.split('\n')[0].trim()}". Only after they say yes, call confirm_approval with approval_id, action, echo (the first line of preview_text) and user_reply (their exact words), then ${approvalRetryInstruction(action)}`
         : '';
     const result = await elicitApproval({
         requires_approval: true,
+        auto_approve_unavailable_reason: autoApproveUnavailableReason,
         ...(effective.channelRule === 'human_only' ? {} : await offerApprovalApp({ id: data.id, action, params: frozenParams, summary, tier, expires_at: expiresAt,
             payload_hash: approvalPayloadHash(action, frozenParams) })),
         approval_id: data.id,

package/build/lib/approval-actions.js

@@ -1,4 +1,9 @@
 export const GATED_ACTIONS = new Set([
+    // #4392: edits and reversible archive/disable transitions affect public visitors.
+    'update_form',
+    'archive_form',
+    'update_short_link',
+    'update_asset_link',
     'set_link_domain', // domain routing and optional customer DNS writes, one approval
     'recheck_domain_dns', // live provider verification may request an EE certificate
     'draft_agent_reply',

package/build/lib/how-to-recipes.js

@@ -8,6 +8,18 @@ const projectRule = 'On hosted /mcp, pass project_id on each call. It is require
 const previewRule = 'preview_email uses the real send renderer with sample contact data. send_test_email with dry_run:true uses the real renderer without sending or needing approval, including in standard mode. Stdio requires SENDINEL_API_KEY.';
 const sender = { n: 1, tool: 'get_sites', args_example: {}, note: 'Choose the intended sender from the returned array; do not assume the first sender is correct. Replace example content and addresses with the user’s own choices.' };
 export const HOW_TO_RECIPES = [
+    {
+        id: 'clean-up-test-objects', title: 'Clean up sandbox test contacts and objects',
+        when_to_use: 'Remove throwaway contacts or objects created by this credential after a sandbox test.',
+        synonyms: TOOL_ALIASES.delete_subscriber_data,
+        requires: { scopes: ['admin'], tester_ok: false },
+        steps: [
+            { n: 1, tool: 'delete_subscriber_data', args_example: { contact_id: '11111111-1111-4111-8111-111111111111', reason: 'admin' }, approval, note: 'Replace contact_id with the saved ID of a test contact you created. This is irreversible GDPR erasure, including related data. In a sandbox project, same-credential provenance permits automatic approval; inspect decision_status and auto_approve_unavailable_reason. If pending, show approve_url and wait for human approval.' },
+            { n: 2, tool: 'delete_subscriber_data', args_example: { approval_id: from(1, 'approval_id') }, approval, note: 'Only after decision_status is approved, re-call with ONLY approval_id to execute. Repeat for each intended test contact.' },
+        ],
+        gotchas: [projectRule, 'is_test:true is only a contact classification, never delete authority. Non-sandbox projects keep human approval. Unknown or foreign provenance stays gated. Campaign cleanup uses delete_campaign with campaign_id; every cascading step must also belong to this credential. Templates and segments use delete_template with id and delete_segment with segment_id, with the same approval_id flow.'],
+        done_when: 'Each intended cleanup execution succeeds; automatic approval alone has not deleted anything.',
+    },
     {
         id: 'brand-kit-signature', title: 'Preview and save a brand-kit email signature',
         when_to_use: 'Set up or edit a signature footer for future AI-generated drafts using stored brand details.',

package/build/lib/mcp-created-items.d.ts

@@ -25,4 +25,7 @@ export declare function withCreatedItems<T extends {
     error: any;
 }>(entityType: CreatedItemType, query: PromiseLike<T>): Promise<T>;
 /** Unknown actions/targets and partial reads fail closed, including defensive bulk inputs. */
+export type DeleteOwnershipUnavailableReason = 'not_created_by_this_credential' | 'unknown_provenance';
+export declare function deleteOwnershipUnavailableReason(projectId: string, action: string, params: Record<string, unknown>, creatorKey: string | null): Promise<DeleteOwnershipUnavailableReason | null>;
+/** Preserve the boolean authority API; diagnostics never supply another approval path. */
 export declare function ownsDeleteTargets(projectId: string, action: string, params: Record<string, unknown>, creatorKey: string | null): Promise<boolean>;

package/build/lib/mcp-created-items.js

@@ -54,11 +54,10 @@ export async function withCreatedItems(entityType, query) {
     return result;
 }
 const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** Unknown actions/targets and partial reads fail closed, including defensive bulk inputs. */
-export async function ownsDeleteTargets(projectId, action, params, creatorKey) {
+export async function deleteOwnershipUnavailableReason(projectId, action, params, creatorKey) {
     const target = DELETE_ITEM_TARGETS[action];
     if (!creatorKey || !target)
-        return false;
+        return 'unknown_provenance';
     const [entityType, single, bulk] = target;
     const source = adminDb().schema('email');
     let ids = [];
@@ -66,36 +65,46 @@ export async function ownsDeleteTargets(projectId, action, params, creatorKey) {
         ids.push(params[single]);
     if (params[bulk] !== undefined) {
         if (!Array.isArray(params[bulk]) || !params[bulk].length)
-            return false;
+            return 'unknown_provenance';
         ids.push(...params[bulk]);
     }
     // GDPR snapshots carry both ID and email. Verify the address names that same target.
     if (action === 'delete_subscriber_data' && params.email !== undefined) {
         if (typeof params.email !== 'string' || !params.email.trim())
-            return false;
+            return 'unknown_provenance';
         const { data, error } = await source.from('subscribers').select('id').eq('project_id', projectId)
             .eq('email', params.email.trim().toLowerCase()).maybeSingle();
         if (error || !data || (ids.length && (ids.length !== 1 || ids[0] !== data.id)))
-            return false;
+            return 'unknown_provenance';
         ids.push(data.id);
     }
     if (!ids.length || ids.some(id => typeof id !== 'string' || !uuid.test(id)))
-        return false;
+        return 'unknown_provenance';
     ids = [...new Set(ids)];
     const owns = async (type, targets) => {
-        const { data, error } = await source.from('mcp_created_items').select('entity_id')
-            .eq('project_id', projectId).eq('entity_type', type).eq('creator_key', creatorKey).in('entity_id', targets);
-        return !error && Array.isArray(data) && targets.every(id => data.some(row => row.entity_id === id));
+        const { data, error } = await source.from('mcp_created_items').select('entity_id, creator_key')
+            .eq('project_id', projectId).eq('entity_type', type).in('entity_id', targets);
+        if (error || !Array.isArray(data))
+            return 'unknown_provenance';
+        if (targets.some(id => !data.some(row => row.entity_id === id && typeof row.creator_key === 'string')))
+            return 'unknown_provenance';
+        return targets.every(id => data.some(row => row.entity_id === id && row.creator_key === creatorKey))
+            ? null : 'not_created_by_this_credential';
     };
-    if (!await owns(entityType, ids))
-        return false;
+    const reason = await owns(entityType, ids);
+    if (reason)
+        return reason;
     // Deleting a campaign also deletes its steps; another client may have added one.
     if (action === 'delete_campaign') {
         const { data, error } = await source.from('campaign_steps').select('id').in('campaign_id', ids);
         if (error || !Array.isArray(data))
-            return false;
-        if (data.length && !await owns('campaign_steps', data.map(row => row.id)))
-            return false;
+            return 'unknown_provenance';
+        if (data.length)
+            return await owns('campaign_steps', data.map(row => row.id));
     }
-    return true;
+    return null;
+}
+/** Preserve the boolean authority API; diagnostics never supply another approval path. */
+export async function ownsDeleteTargets(projectId, action, params, creatorKey) {
+    return await deleteOwnershipUnavailableReason(projectId, action, params, creatorKey) === null;
 }

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

@@ -26,6 +26,14 @@ export declare const SANDBOX_ADMIN_SCOPE: {
     readonly set_team_member_role: 'org';
     readonly tenant_export_full: 'project';
 };
+export type AutoApproveUnavailableReason = 'not_sandbox' | 'not_created_by_this_credential' | 'unknown_provenance' | 'action_not_eligible' | 'org_not_all_sandbox' | 'approval_policy' | 'auto_approval_failed';
 /** Never consult token claims, BYOD clients or cached display data for this authority. */
+export declare function sandboxAutoApproveUnavailableReason(projectId: string, action: string, onProjectRead?: (name: string | undefined) => void, params?: Record<string, unknown>): Promise<AutoApproveUnavailableReason | null>;
+/** Existing callers keep their boolean contract and the same fail-closed conditions. */
 export declare function sandboxApprovalEligible(projectId: string, action: string, onProjectRead?: (name: string | undefined) => void, params?: Record<string, unknown>): Promise<boolean>;
+/** Capture the refusal from the same attempt, without a second mutable authority read. */
+export declare function trySandboxApprovalWithReason(id: string, projectId: string, action: string, payloadHash: string, onProjectRead?: (name: string | undefined) => void, params?: Record<string, unknown>): Promise<{
+    approved: boolean;
+    reason?: AutoApproveUnavailableReason;
+}>;
 export declare function trySandboxApproval(id: string, projectId: string, action: string, payloadHash: string, onProjectRead?: (name: string | undefined) => void, params?: Record<string, unknown>): Promise<boolean>;

package/build/lib/sandbox-approvals.js

@@ -1,5 +1,5 @@
 import { adminDb } from '../db.js';
-import { DELETE_ITEM_TARGETS, ownsDeleteTargets, requestingCreatorKey } from './mcp-created-items.js';
+import { DELETE_ITEM_TARGETS, deleteOwnershipUnavailableReason, requestingCreatorKey } from './mcp-created-items.js';
 import { approvalClass } from '@sendinel/domain';
 import { PROTECTED_ACTIONS } from './approval-actions.js';
 import { isHumanRequestableAdminTool } from './admin-tools.js';
@@ -16,48 +16,63 @@ export const SANDBOX_ADMIN_SCOPE = {
     tenant_export_full: 'project',
 };
 /** Never consult token claims, BYOD clients or cached display data for this authority. */
-export async function sandboxApprovalEligible(projectId, action, onProjectRead, params = {}) {
+export async function sandboxAutoApproveUnavailableReason(projectId, action, onProjectRead, params = {}) {
     const deletion = approvalClass(action) === 'D' || action.startsWith('delete_');
     // No exception for shared org credentials, unknown delete actions or other protected effects.
-    if (deletion && (!(action in DELETE_ITEM_TARGETS) || !requestingCreatorKey()))
-        return false;
+    if (deletion && !(action in DELETE_ITEM_TARGETS))
+        return 'action_not_eligible';
+    if (deletion && !requestingCreatorKey())
+        return 'unknown_provenance';
     if (action === 'delete_provider_credential' || (!deletion && PROTECTED_ACTIONS.has(action)))
-        return false;
+        return 'action_not_eligible';
     try {
         const source = adminDb().schema('email');
         const { data, error } = await source.from('projects').select('id, org_id, sandbox_mode, name')
             .eq('id', projectId).maybeSingle();
         onProjectRead?.(!error && typeof data?.name === 'string' ? data.name : undefined);
-        if (error || data?.id !== projectId || data.sandbox_mode !== true)
-            return false;
+        if (error || data?.id !== projectId)
+            return 'unknown_provenance';
+        if (data.sandbox_mode !== true)
+            return 'not_sandbox';
         if (deletion)
-            return await ownsDeleteTargets(projectId, action, params, requestingCreatorKey());
+            return await deleteOwnershipUnavailableReason(projectId, action, params, requestingCreatorKey());
         if (!isHumanRequestableAdminTool(action))
-            return true;
+            return null;
         const scope = SANDBOX_ADMIN_SCOPE[action];
         if (scope === 'project')
-            return true;
+            return null;
         if (scope !== 'org' || typeof data.org_id !== 'string')
-            return false;
+            return 'action_not_eligible';
         const others = await source.from('projects').select('id').eq('org_id', data.org_id)
             .eq('sandbox_mode', false).limit(1);
-        return !others.error && Array.isArray(others.data) && others.data.length === 0;
+        if (others.error || !Array.isArray(others.data))
+            return 'unknown_provenance';
+        return others.data.length === 0 ? null : 'org_not_all_sandbox';
     }
     catch {
-        return false;
+        return 'unknown_provenance';
     }
 }
-export async function trySandboxApproval(id, projectId, action, payloadHash, onProjectRead, params = {}) {
-    if (!await sandboxApprovalEligible(projectId, action, onProjectRead, params))
-        return false;
+/** Existing callers keep their boolean contract and the same fail-closed conditions. */
+export async function sandboxApprovalEligible(projectId, action, onProjectRead, params = {}) {
+    return await sandboxAutoApproveUnavailableReason(projectId, action, onProjectRead, params) === null;
+}
+/** Capture the refusal from the same attempt, without a second mutable authority read. */
+export async function trySandboxApprovalWithReason(id, projectId, action, payloadHash, onProjectRead, params = {}) {
+    const reason = await sandboxAutoApproveUnavailableReason(projectId, action, onProjectRead, params);
+    if (reason)
+        return { approved: false, reason };
     try {
         // The RPC performs one conditional UPDATE + audit INSERT in one transaction.
         const { data, error } = await adminDb().schema('email').rpc('approve_sandbox_action', {
             p_approval_id: id, p_project_id: projectId, p_action: action, p_payload_hash: payloadHash,
         });
-        return !error && data === true;
-    }
-    catch {
-        return false;
+        if (!error && data === true)
+            return { approved: true };
     }
+    catch { /* An RPC failure never grants authority. */ }
+    return { approved: false, reason: 'auto_approval_failed' };
+}
+export async function trySandboxApproval(id, projectId, action, payloadHash, onProjectRead, params = {}) {
+    return (await trySandboxApprovalWithReason(id, projectId, action, payloadHash, onProjectRead, params)).approved;
 }

package/build/lib/survey-link-resolver.js

@@ -14,6 +14,7 @@ export async function resolveSurveyShortLink(sb, projectId, surveyId) {
         .from('short_links')
         .select('id, slug, project_id')
         .eq('id', survey.short_link_id)
+        .is('disabled_at', null)
         .eq('project_id', projectId)
         .maybeSingle();
     return link?.slug ? `${appBaseUrl()}/s/${link.slug}` : null;

package/build/server.js

@@ -120,7 +120,7 @@ const WRITE_TOOLS = new Set([
     'trigger_automation', 'enroll_automation', 'create_escalation_ladder', 'enroll_in_escalation_ladder',
     'update_scoring_rules', 'register_domain', 'publish_dmarc_record',
     'update_warmup_schedule', 'pause_warmup', 'resume_warmup',
-    'create_form', 'invite_team_member',
+    'create_form', 'update_form', 'archive_form', 'invite_team_member',
     'remove_team_member', 'set_team_member_role', 'set_member_project_access',
     'set_active_project',
     'resend_invitation', 'revoke_invitation',
@@ -129,7 +129,7 @@ const WRITE_TOOLS = new Set([
     'create_api_key', 'revoke_api_key', 'mark_notifications_read',
     'migrate_campaigns_from', 'start_platform_migration',
     'create_content_block', 'delete_content_block', 'trigger_content_pipeline',
-    'create_asset_link',
+    'create_asset_link', 'update_asset_link',
     'set_white_label_settings', 'add_white_label_domain',
     'create_blog_post',
     'generate_blog_post_image',
@@ -141,7 +141,7 @@ const WRITE_TOOLS = new Set([
     'create_custom_webhook', 'rotate_custom_webhook_secret',
     'update_brand_voice', 'promote_draft_to_campaign',
     'propose_campaign_from_data', 'approve_data_proposal',
-    'create_survey', 'update_survey', 'create_short_link', 'generate_qr_code',
+    'create_survey', 'update_survey', 'create_short_link', 'update_short_link', 'generate_qr_code',
     'create_signature', 'update_signature',
     'mark_ai_work_item_seen', 'snooze_ai_work_item', 'dismiss_ai_work_item',
     'submit_ai_context_event',

package/build/tools/contacts.js

@@ -1315,6 +1315,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             company_name: z.string().optional(),
             company_domain: z.string().optional(),
             tags: z.array(z.string()).optional().describe('Initial tags for new subscribers; existing contacts keep their stored tags.'),
+            is_test: z.boolean().optional().describe('Mark a NEW contact as a test contact: excluded from headline counts and default audiences. Ignored for existing contacts.'),
             source: z.enum(['signup', 'import', 'form', 'manual']).optional().default('manual'),
             utm_source: z.string().optional(),
             utm_medium: z.string().optional(),
@@ -1322,7 +1323,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             utm_content: z.string().optional(),
             utm_term: z.string().optional(),
         },
-    }, async ({ email, site_id, first_name, last_name, company_id, company_name, company_domain, tags, source, utm_source, utm_medium, utm_campaign, utm_content, utm_term }) => {
+    }, async ({ email, site_id, first_name, last_name, company_id, company_name, company_domain, tags, is_test, source, utm_source, utm_medium, utm_campaign, utm_content, utm_term }) => {
         try {
             const normalizedTags = normalizeTagInput(tags ?? []);
             const warnings = tagInputWarnings(normalizedTags);
@@ -1370,6 +1371,8 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             let contact;
             if (!existingContact) {
                 const row = { project_id: projectId, email, first_name, last_name, company_id: resolvedCompanyId, source, source_site: site_id };
+                if (is_test === true)
+                    row.is_test = true;
                 if (tags !== undefined)
                     row.tags = normalizedTags.tags;
                 if (customProperties)
@@ -1447,11 +1450,11 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             if (needsConfirm) {
                 // Create opt-in token (confirmation email must be sent externally in MCP context)
                 await db().from('opt_in_tokens').insert({ contact_id: contact.id, site_id });
-                await writeBackMcpContact(projectId, contact, { email, first_name: contact.first_name ?? null, last_name: contact.last_name ?? null, ...(!existing && tags !== undefined ? { tags: normalizedTags.tags } : {}) });
+                await writeBackMcpContact(projectId, contact, { email, first_name: contact.first_name ?? null, last_name: contact.last_name ?? null, ...(!existing && tags !== undefined ? { tags: normalizedTags.tags } : {}), ...(!existing && is_test === true ? { is_test: contact.is_test } : {}) });
                 logConsent({ contactId: contact.id, siteId: site_id, action: 'grant', consentType: 'email_marketing', source: 'mcp_pending_double_opt_in' });
                 return { content: [{ type: 'text', text: JSON.stringify({ ...contact, ...tagWarnings, existing, confirmation: 'pending', message: 'Double opt-in required. Confirmation token created.', ...existingMessage }, null, 2) }] };
             }
-            await writeBackMcpContact(projectId, contact, { email, first_name: contact.first_name ?? null, last_name: contact.last_name ?? null, ...(!existing && tags !== undefined ? { tags: normalizedTags.tags } : {}) });
+            await writeBackMcpContact(projectId, contact, { email, first_name: contact.first_name ?? null, last_name: contact.last_name ?? null, ...(!existing && tags !== undefined ? { tags: normalizedTags.tags } : {}), ...(!existing && is_test === true ? { is_test: contact.is_test } : {}) });
             logConsent({ contactId: contact.id, siteId: site_id, action: 'grant', consentType: 'email_marketing', source: 'mcp_add_subscriber' });
             if (!existing)
                 logAudit({ action: 'contact.created', resourceType: 'contact', resourceId: contact.id, details: { email, source } });

package/build/tools/content.js

@@ -143,6 +143,48 @@ export function registerContentTools(server) {
         const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? 'https://sendinel.ai';
         return j({ asset_link: { ...data, url: `${appUrl.replace(/\/$/, '')}/a/${data.slug}` } });
     });
+    server.registerTool('update_asset_link', {
+        title: 'Update Asset Link',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Update a project asset link or reversibly archive/restore it. Keeps its slug and view history. Requires approval in standard mode.',
+        inputSchema: {
+            asset_link_id: z.string().uuid(),
+            title: z.string().min(1).max(255).optional(),
+            asset_url: z.string().url().max(2000).optional(),
+            gate_headline: z.string().max(255).optional(),
+            gate_body: z.string().max(1000).optional(),
+            source_attribution: z.string().max(500).optional(),
+            status: z.enum(['draft', 'active', 'archived']).optional(),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, withApproval('update_asset_link', async ({ asset_link_id, title, asset_url, gate_headline, gate_body, source_attribution, status }) => {
+        for (const [field, value] of Object.entries({ title, source_attribution, gate_headline, gate_body })) {
+            const error = refuseActiveTextFields(field, value);
+            if (error)
+                return j({ error, code: 'validation_failed' });
+        }
+        if (asset_url !== undefined) {
+            try {
+                assertHttpUrl(asset_url);
+            }
+            catch {
+                return j({ error: 'asset_url must use http or https', code: 'validation_failed' });
+            }
+        }
+        const patch = Object.fromEntries(Object.entries({ title, asset_url, gate_headline, gate_body, source_attribution, status })
+            .filter(([, value]) => value !== undefined));
+        if (!Object.keys(patch).length)
+            return j({ error: 'Provide at least one asset link field to update', code: 'validation_failed' });
+        const { data, error } = await db().from('asset_links').update({ ...patch, updated_at: new Date().toISOString() })
+            .eq('id', asset_link_id).eq('project_id', getProjectId()).select().maybeSingle();
+        if (error)
+            return j(dbToolError(error));
+        if (!data)
+            return j({ error: 'Asset link not found', code: 'NOT_FOUND' });
+        await logAudit({ action: 'asset_link.updated', resourceType: 'asset_link', resourceId: asset_link_id, details: patch });
+        const appUrl = (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+        return j({ asset_link: { ...data, url: `${appUrl}/a/${data.slug}` } });
+    }));
     server.registerTool('list_asset_links', {
         title: 'List Asset Links',
         annotations: {

package/build/tools/forms.js

@@ -2,8 +2,29 @@ import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { assertHttpUrl } from '../lib/url-validation.js';
+import { withApproval } from '../lib/action-approvals.js';
+import { logAudit } from '../audit.js';
 import { dbToolError } from '../lib/db-error.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+function validateFields(fields) {
+    if (!fields.length)
+        return 'fields must contain at least one field';
+    const names = new Set();
+    for (const field of fields) {
+        if (typeof field.name !== 'string' || !/^[a-z][a-z0-9_]{0,49}$/.test(field.name) ||
+            typeof field.type !== 'string' || !['email', 'text', 'textarea', 'select', 'checkbox', 'number', 'tel', 'url', 'date'].includes(field.type)) {
+            return 'Each field needs a name (lowercase snake_case) and a supported type';
+        }
+        if (names.has(field.name))
+            return `Duplicate field name: ${field.name}`;
+        names.add(field.name);
+    }
+    // The public handler always reads fields.email to identify the subscriber.
+    if (!fields.some(field => field.name === 'email' && field.type === 'email')) {
+        return 'fields must include an email field named email';
+    }
+    return null;
+}
 export function registerFormTools(server) {
     server.registerTool('list_forms', {
         title: 'List Forms',
@@ -70,22 +91,9 @@ export function registerFormTools(server) {
             form_type: z.enum(['signup', 'management']).optional(),
         },
     }, async ({ site_id, name, fields, redirect_url, double_opt_in, form_type }) => {
-        if (!fields.length)
-            return j({ error: 'fields must contain at least one field', code: 'validation_failed' });
-        const names = new Set();
-        for (const field of fields) {
-            if (typeof field.name !== 'string' || !/^[a-z][a-z0-9_]{0,49}$/.test(field.name) ||
-                typeof field.type !== 'string' || !['email', 'text', 'textarea', 'select', 'checkbox', 'number', 'tel', 'url', 'date'].includes(field.type)) {
-                return j({ error: 'Each field needs a name (lowercase snake_case) and a supported type', code: 'validation_failed' });
-            }
-            if (names.has(field.name))
-                return j({ error: `Duplicate field name: ${field.name}`, code: 'validation_failed' });
-            names.add(field.name);
-        }
-        // The public handler always reads fields.email to identify the subscriber.
-        if (!fields.some(field => field.name === 'email' && field.type === 'email')) {
-            return j({ error: 'fields must include an email field named email', code: 'validation_failed' });
-        }
+        const fieldsError = validateFields(fields);
+        if (fieldsError)
+            return j({ error: fieldsError, code: 'validation_failed' });
         if (redirect_url !== undefined) {
             try {
                 assertHttpUrl(redirect_url);
@@ -105,4 +113,87 @@ export function registerFormTools(server) {
             return j({ ...dbToolError(error), code: 'INTERNAL_ERROR' });
         return j({ form: data });
     });
+    server.registerTool('update_form', {
+        title: 'Update Form',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Update a project form without changing its slug or submissions. Settings edits preserve other settings. Requires approval in standard mode.',
+        inputSchema: {
+            form_id: z.string().uuid(),
+            name: z.string().min(1).optional(),
+            fields: z.array(z.record(z.string(), z.unknown())).optional(),
+            redirect_url: z.string().url().optional(),
+            double_opt_in: z.boolean().optional(),
+            status: z.enum(['active', 'archived']).optional(),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, withApproval('update_form', async ({ form_id, name, fields, redirect_url, double_opt_in, status }) => {
+        if (fields !== undefined) {
+            const error = validateFields(fields);
+            if (error)
+                return j({ error, code: 'validation_failed' });
+        }
+        if (redirect_url !== undefined) {
+            try {
+                assertHttpUrl(redirect_url);
+            }
+            catch {
+                return j({ error: 'redirect_url must use http or https', code: 'validation_failed' });
+            }
+        }
+        const projectId = getProjectId();
+        const { data: form, error: readError } = await db().from('signup_forms').select('id, settings')
+            .eq('id', form_id).eq('project_id', projectId).maybeSingle();
+        if (readError)
+            return j(dbToolError(readError));
+        if (!form)
+            return j({ error: 'Form not found', code: 'NOT_FOUND' });
+        const patch = {};
+        if (name !== undefined)
+            patch.name = name;
+        if (fields !== undefined)
+            patch.fields = fields;
+        if (status !== undefined)
+            patch.status = status;
+        const settingsChanged = redirect_url !== undefined || double_opt_in !== undefined;
+        if (settingsChanged) {
+            patch.settings = { ...form.settings,
+                ...(redirect_url !== undefined ? { redirect_url } : {}),
+                ...(double_opt_in !== undefined ? { double_opt_in } : {}),
+            };
+        }
+        if (!Object.keys(patch).length)
+            return j({ error: 'Provide at least one form field to update', code: 'validation_failed' });
+        patch.updated_at = new Date().toISOString();
+        let query = db().from('signup_forms').update(patch).eq('id', form_id).eq('project_id', projectId);
+        // Do not overwrite a concurrent settings edit with the earlier JSON snapshot.
+        if (settingsChanged)
+            query = query.eq('settings', JSON.stringify(form.settings));
+        const { data, error } = await query.select().maybeSingle();
+        if (error)
+            return j(dbToolError(error));
+        if (!data)
+            return j({ error: 'Form changed; read it again before retrying', code: 'conflict' });
+        await logAudit({ action: 'form.updated', resourceType: 'form', resourceId: form_id, details: patch });
+        return j({ form: data });
+    }));
+    server.registerTool('archive_form', {
+        title: 'Archive Form',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Reversibly archive a project form, or restore it with archived=false. Keeps submissions. Requires approval in standard mode.',
+        inputSchema: {
+            form_id: z.string().uuid(),
+            archived: z.boolean().optional().default(true),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, withApproval('archive_form', async ({ form_id, archived = true }) => {
+        const status = archived ? 'archived' : 'active';
+        const { data, error } = await db().from('signup_forms').update({ status, updated_at: new Date().toISOString() })
+            .eq('id', form_id).eq('project_id', getProjectId()).select().maybeSingle();
+        if (error)
+            return j(dbToolError(error));
+        if (!data)
+            return j({ error: 'Form not found', code: 'NOT_FOUND' });
+        await logAudit({ action: 'form.updated', resourceType: 'form', resourceId: form_id, details: { status } });
+        return j({ form: data });
+    }));
 }

package/build/tools/gdpr.js

@@ -87,7 +87,7 @@ export function registerGdprTools(server) {
             idempotentHint: false,
             openWorldHint: false,
         },
-        description: 'GDPR Article 17: Permanently delete a subscriber and all their data. Anonymizes email_log, hashes suppressions, cascades to subscriptions/enrollments/tokens. This action is IRREVERSIBLE. Requires human approval via dashboard.',
+        description: 'GDPR Article 17: Permanently delete a subscriber and all their data. Anonymizes email_log, hashes suppressions, cascades to subscriptions/enrollments/tokens. This action is IRREVERSIBLE. Also use for test contact cleanup (reason: admin). In a sandbox project, contacts created by the same credential are erased without a human click via the approval_id retry flow. Other cases require human approval via dashboard.',
         inputSchema: {
             contact_id: z.string().uuid().describe('UUID of the subscriber to delete'),
             reason: z.enum(['gdpr_request', 'user_request', 'admin']).optional().default('gdpr_request'),

package/build/tools/short-links.js

@@ -3,6 +3,8 @@ import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { assertHttpUrl, RESERVED_LINK_SLUGS } from '../lib/url-validation.js';
+import { withApproval } from '../lib/action-approvals.js';
+import { logAudit } from '../audit.js';
 import { dbToolError } from '../lib/db-error.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
@@ -85,6 +87,42 @@ export function registerShortLinkTools(server) {
             return j({ ...dbToolError(error), code: 'INTERNAL_ERROR' });
         return j({ short_link: data, short_url: `${appBaseUrl()}/s/${data.slug}` });
     });
+    server.registerTool('update_short_link', {
+        title: 'Update Short Link',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Update a project short link or reversibly disable/re-enable it. Keeps click history. Requires approval in standard mode.',
+        inputSchema: {
+            short_link_id: z.string().uuid(),
+            destination_url: z.string().url().optional(),
+            disabled: z.boolean().optional(),
+            reason: z.string().optional(),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, withApproval('update_short_link', async ({ short_link_id, destination_url, disabled, reason }) => {
+        const patch = {};
+        if (destination_url !== undefined) {
+            try {
+                patch.destination_url = assertHttpUrl(destination_url);
+            }
+            catch {
+                return j({ error: 'destination_url must use http or https', code: 'validation_failed' });
+            }
+        }
+        if (disabled !== undefined) {
+            patch.disabled_at = disabled ? new Date().toISOString() : null;
+            patch.disabled_reason = disabled ? reason ?? null : null;
+        }
+        if (!Object.keys(patch).length)
+            return j({ error: 'Provide destination_url or disabled', code: 'validation_failed' });
+        const { data, error } = await db().from('short_links').update(patch)
+            .eq('id', short_link_id).eq('project_id', getProjectId()).select().maybeSingle();
+        if (error)
+            return j(dbToolError(error));
+        if (!data)
+            return j({ error: 'Short link not found', code: 'NOT_FOUND' });
+        await logAudit({ action: 'short_link.updated', resourceType: 'short_link', resourceId: short_link_id, details: patch });
+        return j({ short_link: data, short_url: `${appBaseUrl()}/s/${data.slug}` });
+    }));
     server.registerTool('get_short_link_stats', {
         title: 'Get Short Link Stats',
         annotations: {
@@ -99,7 +137,7 @@ export function registerShortLinkTools(server) {
         const projectId = getProjectId();
         const { data: link, error: linkError } = await db()
             .from('short_links')
-            .select('id, slug, destination_url, click_count, last_clicked_at, created_at')
+            .select('id, slug, destination_url, click_count, last_clicked_at, created_at, disabled_at, disabled_reason')
             .eq('id', short_link_id)
             .eq('project_id', projectId)
             .maybeSingle();

package/build/tools/tool-search.js

@@ -12,6 +12,7 @@ export const STOPWORDS = new Set([
  * Only tools that exist in the registry belong here.
  */
 export const TOOL_ALIASES = {
+    delete_subscriber_data: ['delete contact', 'delete contacts', 'remove subscriber', 'remove subscribers', 'clean up test contacts', 'clean up test objects', 'sandbox cleanup'],
     list_custom_fields: ['custom fields', 'field definitions', 'contact schema', 'unused fields'],
     update_site: ['footer', 'email footer', 'unsubscribe text', 'unsubscribe link', 'site footer', 'unsubscribe settings'],
     set_campaign_trigger: ['trigger', 'event', 'fires on', 'fires-on', 'dunning', 'set campaign trigger event name', 'invoice payment failed', 'payment failed', 'trial ending', 'event trigger', 'billing'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.214",
+  "version": "1.0.216",
   "description": "AI-controlled email operations control plane for campaigns, contacts, segments, analytics, and multi-provider sending via MCP.",
   "mcpName": "ai.sendinel/mcp-server",
   "type": "module",