@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/server/aiProfileAvatarAssets.js

@@ -1,7 +1,17 @@
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
+import sharp from 'sharp';
 import { normalizeTaskDataRelativePath } from '../storage/objectStorageClient.js';
+import { isAiProfileAvatarGenerationEligible } from '../shared/aiProfileAvatarEligibility.js';
+import { buildAiProfileAvatarStorageKey, storageKeyBelongsToAiProfileAvatar, } from '../utils/aiProfileAvatarPaths.js';
+export { buildAiProfileAvatarStorageKey } from '../utils/aiProfileAvatarPaths.js';
+export class AiProfileAvatarStateConflictError extends Error {
+    constructor() {
+        super('AI profile avatar state changed before the generated avatar could be saved.');
+        this.name = 'AiProfileAvatarStateConflictError';
+    }
+}
 const SUPPORTED_IMAGE_MIME_TYPES = new Set([
     'image/gif',
     'image/jpeg',
@@ -9,20 +19,15 @@ const SUPPORTED_IMAGE_MIME_TYPES = new Set([
     'image/webp',
 ]);
 const AVATAR_MAX_BYTES = 5 * 1024 * 1024;
+const AVATAR_DISPLAY_MAX_DIMENSION = 256;
+const AVATAR_DISPLAY_WEBP_QUALITY = 82;
 function normalizeId(value) {
     return String(value || '').trim();
 }
-function sanitizeStorageSegment(value, fallback) {
-    const normalized = normalizeId(value)
-        .replace(/[^a-zA-Z0-9._-]/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return normalized || fallback;
-}
 function normalizeImageMimeType(value) {
     return normalizeId(value).toLowerCase();
 }
-function extensionForMimeType(mimeType) {
+function avatarFileExtensionForMimeType(mimeType) {
     if (mimeType === 'image/gif')
         return 'gif';
     if (mimeType === 'image/jpeg')
@@ -38,12 +43,6 @@ function stableAssetId(workspaceId, profileId, slot) {
         .slice(0, 32);
     return `asset-${digest}`;
 }
-export function buildAiProfileAvatarStorageKey(input) {
-    const workspaceId = sanitizeStorageSegment(input.workspaceId, 'default');
-    const profileId = sanitizeStorageSegment(input.profileId, 'ai-profile');
-    const ext = extensionForMimeType(input.mimeType);
-    return `workspaces/${workspaceId}/assets/images/ai-profiles/${profileId}/avatar/${input.slot}.${ext}`;
-}
 function contextUrlForStorageKey(storageKey) {
     return `/api/taskforce/context/${encodeURIComponent(storageKey)}`;
 }
@@ -75,10 +74,29 @@ function validatePayload(payload, label) {
     }
     return mimeType;
 }
-function storageKeyBelongsToAiProfileAvatar(workspaceId, profileId, storageKey) {
-    const workspaceIdSafe = sanitizeStorageSegment(workspaceId, 'default');
-    const profileIdSafe = sanitizeStorageSegment(profileId, 'ai-profile');
-    return storageKey.startsWith(`workspaces/${workspaceIdSafe}/assets/images/ai-profiles/${profileIdSafe}/avatar/`);
+async function optimizeDisplayAvatar(payload) {
+    try {
+        const buffer = await sharp(payload.buffer, { animated: true })
+            .rotate()
+            .resize({
+            width: AVATAR_DISPLAY_MAX_DIMENSION,
+            height: AVATAR_DISPLAY_MAX_DIMENSION,
+            fit: 'inside',
+            withoutEnlargement: true,
+        })
+            .webp({ quality: AVATAR_DISPLAY_WEBP_QUALITY })
+            .toBuffer();
+        const originalName = normalizeId(payload.originalName);
+        const nameBase = originalName.replace(/\.[^.]+$/, '') || 'avatar';
+        return {
+            buffer,
+            mimeType: 'image/webp',
+            originalName: `${nameBase}.webp`,
+        };
+    }
+    catch {
+        return payload;
+    }
 }
 async function writeAvatarObject(deps, storageKey, payload, provider) {
     if (provider === 'r2') {
@@ -116,18 +134,28 @@ async function deleteAvatarObject(deps, storageKey, provider) {
         fs.rmSync(destination, { force: true });
     }
 }
+function appendAvatarTelemetry(deps, event, payload) {
+    try {
+        deps.appendStorageTelemetry(event, payload);
+    }
+    catch {
+        // Telemetry must never change the outcome of an already committed avatar mutation.
+    }
+}
 function upsertAvatarAsset(input) {
     if (!input.deps.workspaceAssetStore) {
         throw new Error('Workspace asset storage is required for AI profile avatars.');
     }
     const contentSha256 = createHash('sha256').update(input.payload.buffer).digest('hex');
-    const existing = input.deps.workspaceAssetStore.getByStorageKey(input.storageKey, input.workspaceId);
+    const assetId = stableAssetId(input.workspaceId, input.profileId, input.slot);
+    const existing = input.deps.workspaceAssetStore.get(assetId, input.workspaceId)
+        || input.deps.workspaceAssetStore.getByStorageKey(input.storageKey, input.workspaceId);
     return input.deps.workspaceAssetStore.upsertAsset({
-        assetId: existing?.assetId || stableAssetId(input.workspaceId, input.profileId, input.slot),
+        assetId,
         workspaceId: input.workspaceId,
         kind: 'image',
         logicalName: `AI profile avatar ${input.slot}`,
-        originalFilename: normalizeId(input.payload.originalName) || `${input.slot}.${extensionForMimeType(input.payload.mimeType)}`,
+        originalFilename: normalizeId(input.payload.originalName) || `${input.slot}.${avatarFileExtensionForMimeType(input.payload.mimeType)}`,
         mimeType: input.payload.mimeType,
         storageProvider: input.provider,
         storageKey: input.storageKey,
@@ -178,7 +206,7 @@ async function cleanupAiProfileAvatarAssets(input) {
             }
         }
         catch {
-            input.deps.appendStorageTelemetry('ai_avatar.cleanup', {
+            appendAvatarTelemetry(input.deps, 'ai_avatar.cleanup', {
                 path: storageKey,
                 provider,
                 status: 'metadata-delete-failed',
@@ -186,14 +214,14 @@ async function cleanupAiProfileAvatarAssets(input) {
         }
         try {
             await deleteAvatarObject(input.deps, storageKey, provider);
-            input.deps.appendStorageTelemetry('ai_avatar.cleanup', {
+            appendAvatarTelemetry(input.deps, 'ai_avatar.cleanup', {
                 path: storageKey,
                 provider,
                 status: 'deleted',
             });
         }
         catch {
-            input.deps.appendStorageTelemetry('ai_avatar.cleanup', {
+            appendAvatarTelemetry(input.deps, 'ai_avatar.cleanup', {
                 path: storageKey,
                 provider,
                 status: 'object-delete-failed',
@@ -212,62 +240,118 @@ export async function saveAiProfileAvatarAssets(deps, input) {
         .find((profile) => profile.id === profileId);
     if (!existingProfile)
         throw new Error(`Profile ${profileId} not found.`);
-    const displayMimeType = validatePayload(input.display, 'Display avatar');
-    const sourcePayload = input.source || input.display;
-    const sourceMimeType = validatePayload(sourcePayload, 'Source avatar');
-    const displayPayload = { ...input.display, mimeType: displayMimeType };
-    const normalizedSourcePayload = { ...sourcePayload, mimeType: sourceMimeType };
+    validatePayload(input.display, 'Display avatar');
+    const preserveExistingSource = input.preserveExistingSource === true;
+    const preservedSourceStorageKey = preserveExistingSource
+        ? storageKeyFromContextUrl(existingProfile.avatarSourceUrl)
+        : null;
+    const preservedSourceAsset = preserveExistingSource && preservedSourceStorageKey && deps.workspaceAssetStore
+        ? (deps.workspaceAssetStore.get(stableAssetId(workspaceId, profileId, 'source'), workspaceId)
+            || deps.workspaceAssetStore.getByStorageKey(preservedSourceStorageKey, workspaceId))
+        : null;
+    if (preserveExistingSource && (!preservedSourceStorageKey
+        || !preservedSourceAsset
+        || preservedSourceAsset.storageKey !== preservedSourceStorageKey)) {
+        throw new Error('The existing source avatar is unavailable. Choose the original image again before applying changes.');
+    }
+    const sourcePayload = preserveExistingSource ? null : (input.source || input.display);
+    const sourceMimeType = sourcePayload ? validatePayload(sourcePayload, 'Source avatar') : null;
+    const displayPayload = await optimizeDisplayAvatar(input.display);
+    const displayMimeType = normalizeImageMimeType(displayPayload.mimeType);
+    const normalizedSourcePayload = sourcePayload && sourceMimeType
+        ? { ...sourcePayload, mimeType: sourceMimeType }
+        : null;
+    const generationId = randomUUID().replace(/-/g, '');
     const displayStorageKey = buildAiProfileAvatarStorageKey({
         workspaceId,
         profileId,
         slot: 'display',
         mimeType: displayMimeType,
+        generationId,
     });
-    const sourceStorageKey = buildAiProfileAvatarStorageKey({
+    const sourceStorageKey = preservedSourceStorageKey || buildAiProfileAvatarStorageKey({
         workspaceId,
         profileId,
         slot: 'source',
         mimeType: sourceMimeType,
+        generationId,
     });
     const objectStorageClient = deps.getObjectStorageClient();
     const provider = objectStorageClient ? 'r2' : 'local';
     const nowIso = new Date().toISOString();
-    await writeAvatarObject(deps, displayStorageKey, displayPayload, provider);
-    await writeAvatarObject(deps, sourceStorageKey, normalizedSourcePayload, provider);
-    const displayAsset = upsertAvatarAsset({
-        deps,
-        workspaceId,
-        profileId,
-        slot: 'display',
-        storageKey: displayStorageKey,
-        payload: displayPayload,
-        provider,
-        actorId: input.actorId,
-        nowIso,
-    });
-    const sourceAsset = upsertAvatarAsset({
-        deps,
-        workspaceId,
-        profileId,
-        slot: 'source',
-        storageKey: sourceStorageKey,
-        payload: normalizedSourcePayload,
-        provider,
-        actorId: input.actorId,
-        nowIso,
-    });
-    deps.core.notifyDocumentMetadataMutation(workspaceId, [displayStorageKey, sourceStorageKey], 'upsert');
-    deps.appendStorageTelemetry('ai_avatar.upload', {
-        path: displayStorageKey,
-        provider,
-        status: 'stored',
-    });
-    const profile = deps.core.updateAiProfileAvatar({
-        workspaceId,
-        profileId,
-        avatarUrl: contextUrlForStorageKey(displayStorageKey),
-        avatarSourceUrl: contextUrlForStorageKey(sourceStorageKey),
-    });
+    const stagedStorageKeys = [];
+    let displayAsset;
+    let sourceAsset;
+    let profile;
+    try {
+        await writeAvatarObject(deps, displayStorageKey, displayPayload, provider);
+        stagedStorageKeys.push(displayStorageKey);
+        if (normalizedSourcePayload) {
+            await writeAvatarObject(deps, sourceStorageKey, normalizedSourcePayload, provider);
+            stagedStorageKeys.push(sourceStorageKey);
+        }
+        const commit = deps.core.getDatabaseAdapter().transaction(() => {
+            const currentProfile = deps.core.listAiProfiles(workspaceId)
+                .find((candidate) => candidate.id === profileId);
+            const expected = input.expectedProfileState;
+            if (!currentProfile || (expected && (Number(currentProfile.avatarRevision || 0) !== expected.avatarRevision
+                || (currentProfile.avatarUrl || null) !== (expected.avatarUrl || null)
+                || (currentProfile.avatarSourceUrl || null) !== (expected.avatarSourceUrl || null)
+                || (expected.requireGenerationEligibility === true && !isAiProfileAvatarGenerationEligible(currentProfile))))) {
+                throw new AiProfileAvatarStateConflictError();
+            }
+            displayAsset = upsertAvatarAsset({
+                deps,
+                workspaceId,
+                profileId,
+                slot: 'display',
+                storageKey: displayStorageKey,
+                payload: displayPayload,
+                provider,
+                actorId: input.actorId,
+                nowIso,
+            });
+            sourceAsset = preservedSourceAsset || upsertAvatarAsset({
+                deps,
+                workspaceId,
+                profileId,
+                slot: 'source',
+                storageKey: sourceStorageKey,
+                payload: normalizedSourcePayload,
+                provider,
+                actorId: input.actorId,
+                nowIso,
+            });
+            profile = deps.core.updateAiProfileAvatar({
+                workspaceId,
+                profileId,
+                avatarUrl: contextUrlForStorageKey(displayStorageKey),
+                avatarSourceUrl: contextUrlForStorageKey(sourceStorageKey),
+            });
+        });
+        commit();
+    }
+    catch (error) {
+        for (const storageKey of stagedStorageKeys) {
+            if (provider === 'r2') {
+                await deps.getObjectStorageClient()?.deleteObject(storageKey).catch(() => false);
+            }
+            else {
+                const { basePath } = deps.core.getPaths();
+                const destination = deps.ensureWithinDir(path.join(basePath, storageKey), basePath);
+                if (destination && fs.existsSync(destination))
+                    fs.rmSync(destination, { force: true });
+            }
+        }
+        throw error;
+    }
+    try {
+        deps.core.notifyDocumentMetadataMutation(workspaceId, preserveExistingSource ? [displayStorageKey] : [displayStorageKey, sourceStorageKey], 'upsert');
+    }
+    catch {
+        // Realtime notification is best-effort after the database commit.
+    }
+    appendAvatarTelemetry(deps, 'ai_avatar.upload', { path: displayStorageKey, provider, status: 'stored' });
     await cleanupAiProfileAvatarAssets({
         deps,
         workspaceId,
@@ -278,11 +362,16 @@ export async function saveAiProfileAvatarAssets(deps, input) {
             storageKeyFromContextUrl(existingProfile.avatarSourceUrl),
         ],
         providerFallback: provider,
+    }).catch(() => {
+        appendAvatarTelemetry(deps, 'ai_avatar.cleanup', {
+            provider,
+            status: 'cleanup-failed-after-commit',
+        });
     });
     return {
-        profile,
-        displayAsset,
-        sourceAsset,
+        profile: profile,
+        displayAsset: displayAsset,
+        sourceAsset: sourceAsset,
         displayStorageKey,
         sourceStorageKey,
     };

package/dist/server/auth.js

@@ -1,5 +1,6 @@
 import { createHmac, timingSafeEqual } from 'crypto';
 import { getTaskforceCloudEnvironmentConfig, parseTaskforceCloudEnvironment } from '../config/cloudEnvironment.js';
+import { resolveDeploymentConfig } from '../config/deployment.js';
 function parseBoolean(raw, fallback) {
     if (raw === undefined)
         return fallback;
@@ -33,6 +34,18 @@ function inferCloudSessionCookieDomain(env) {
         return 'taskforcehq.ai';
     return undefined;
 }
+function inferLocalProxySessionCookieName(runtimeMode, env) {
+    if (runtimeMode !== 'local')
+        return 'taskforce_session';
+    const cloudEnvironment = resolveDeploymentConfig(env).cloudEnvironment;
+    if (cloudEnvironment === 'production')
+        return 'taskforce_session_prod';
+    if (cloudEnvironment === 'staging')
+        return 'taskforce_session_staging';
+    if (cloudEnvironment === 'performance')
+        return 'taskforce_session_performance';
+    return 'taskforce_session';
+}
 function normalizeSameSite(raw, fallback) {
     const value = String(raw || '').trim().toLowerCase();
     if (value === 'lax')
@@ -88,7 +101,8 @@ export function resolveAuthConfigFromEnv(runtimeMode, env = process.env) {
         .split(',')
         .map(v => v.trim())
         .filter(Boolean);
-    const sessionCookieName = (env.TASKFORCE_AUTH_SESSION_COOKIE || 'taskforce_session').trim();
+    const sessionCookieName = (env.TASKFORCE_AUTH_SESSION_COOKIE
+        || inferLocalProxySessionCookieName(runtimeMode, env)).trim();
     const sessionSecret = (env.TASKFORCE_AUTH_SESSION_SECRET || '').trim();
     const sessionTtlSeconds = parsePositiveInt(env.TASKFORCE_AUTH_SESSION_TTL_SECONDS, 60 * 60 * 24 * 30);
     const sessionCookieSameSite = normalizeSameSite(env.TASKFORCE_AUTH_SESSION_SAMESITE, runtimeMode === 'cloud' ? 'None' : 'Lax');

package/dist/server/cors.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'http';
-export declare function getAllowedOriginsFromEnv(envValue?: string): Set<string>;
+import type { RuntimeMode } from './runtimeMode.js';
+export declare function getAllowedOriginsFromEnv(envValue?: string, runtimeMode?: RuntimeMode): Set<string>;
 export declare function resolveAllowedOrigin(originHeader: unknown, allowedOrigins: Set<string>): string | null;
 export declare function applyCorsHeaders(req: IncomingMessage, res: ServerResponse, allowedOrigins: Set<string>): {
     allowed: boolean;

package/dist/server/cors.js

@@ -1,4 +1,4 @@
-const DEFAULT_ALLOWED_ORIGINS = [
+const DEFAULT_CLOUD_ALLOWED_ORIGINS = [
     'https://taskforcehq.ai',
     'https://www.taskforcehq.ai',
     'https://app.taskforcehq.ai',
@@ -8,8 +8,12 @@ const DEFAULT_ALLOWED_ORIGINS = [
     'https://staging-mcp.taskforcehq.ai',
     'https://performance-app.taskforcehq.ai',
     'https://performance-mcp.taskforcehq.ai',
-    // Allow local development and packaged desktop webviews out of the box.
+    // Local runtime performs cloud auth and workspace sync handshakes from loopback origins.
     '__loopback__',
+];
+const DEFAULT_LOCAL_ALLOWED_ORIGINS = [
+    ...DEFAULT_CLOUD_ALLOWED_ORIGINS,
+    // Allow packaged desktop webviews out of the box in local runtime.
     '__null__',
     'tauri://localhost',
     'capacitor://localhost',
@@ -18,12 +22,26 @@ const DEFAULT_ALLOWED_ORIGINS = [
 ];
 const CORS_ALLOW_METHODS = 'GET, POST, PUT, PATCH, DELETE, OPTIONS';
 const CORS_ALLOW_HEADERS = 'Content-Type';
-export function getAllowedOriginsFromEnv(envValue) {
-    const raw = typeof envValue === 'string' ? envValue.trim() : '';
-    const allowed = new Set(DEFAULT_ALLOWED_ORIGINS);
+function stripWrappingQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2) {
+        const first = trimmed[0];
+        const last = trimmed[trimmed.length - 1];
+        if ((first === '"' && last === '"') || (first === '\'' && last === '\'')) {
+            return trimmed.slice(1, -1).trim();
+        }
+    }
+    return trimmed;
+}
+export function getAllowedOriginsFromEnv(envValue, runtimeMode = 'local') {
+    const raw = typeof envValue === 'string' ? stripWrappingQuotes(envValue) : '';
+    const defaults = runtimeMode === 'cloud'
+        ? DEFAULT_CLOUD_ALLOWED_ORIGINS
+        : DEFAULT_LOCAL_ALLOWED_ORIGINS;
+    const allowed = new Set(defaults);
     if (!raw)
         return allowed;
-    for (const value of raw.split(',').map(v => v.trim()).filter(Boolean)) {
+    for (const value of raw.split(',').map(v => stripWrappingQuotes(v)).filter(Boolean)) {
         allowed.add(value);
     }
     return allowed;
@@ -41,12 +59,31 @@ export function resolveAllowedOrigin(originHeader, allowedOrigins) {
     for (const entry of allowedOrigins) {
         if (!entry.includes('*'))
             continue;
-        const prefix = entry.replace(/\*+$/g, '');
-        if (prefix && origin.startsWith(prefix))
+        if (matchesWildcardOrigin(origin, entry))
             return origin;
     }
     return null;
 }
+function matchesWildcardOrigin(origin, entry) {
+    const match = entry.match(/^(https?):\/\/\*\.([^/:]+)(?::(\d+))?$/i);
+    if (!match)
+        return false;
+    try {
+        const parsed = new URL(origin);
+        const protocol = String(match[1] || '').toLowerCase();
+        const suffix = String(match[2] || '').toLowerCase();
+        const port = String(match[3] || '').trim();
+        const hostname = parsed.hostname.toLowerCase();
+        if (parsed.protocol !== `${protocol}:`)
+            return false;
+        if (port && parsed.port !== port)
+            return false;
+        return hostname.endsWith(`.${suffix}`) && hostname !== suffix;
+    }
+    catch {
+        return false;
+    }
+}
 function isLoopbackOrigin(origin) {
     try {
         const parsed = new URL(origin);

package/dist/server/email.d.ts

@@ -1,9 +1,11 @@
-export type TaskforceEmailProvider = 'console' | 'resend' | 'google-workspace';
+export type TaskforceEmailProvider = 'console' | 'resend' | 'google-workspace' | 'mailpit';
 export interface TaskforceEmailConfig {
     provider: TaskforceEmailProvider;
     from: string;
     replyTo?: string;
     providerApiKey?: string;
+    smtpHost?: string;
+    smtpPort?: number;
 }
 export interface TaskforceEmailSettingsInput {
     provider?: string;

package/dist/server/email.js

@@ -12,22 +12,31 @@ export function resolveEmailConfig(env = process.env) {
         ? 'resend'
         : rawProvider === 'google-workspace'
             ? 'google-workspace'
-            : 'console';
+            : rawProvider === 'mailpit'
+                ? 'mailpit'
+                : 'console';
     const from = String(env.TASKFORCE_EMAIL_FROM || 'Taskforce <no-reply@taskforcehq.ai>').trim();
     const replyTo = String(env.TASKFORCE_EMAIL_REPLY_TO || '').trim() || undefined;
     const providerApiKey = String(env.TASKFORCE_EMAIL_PROVIDER_API_KEY
         || (provider === 'resend' ? env.TASKFORCE_EMAIL_RESEND_API_KEY : '')
         || (provider === 'google-workspace' ? env.TASKFORCE_EMAIL_GOOGLE_APP_PASSWORD : '')
         || '').trim() || undefined;
-    return { provider, from, replyTo, providerApiKey };
+    const rawSmtpPort = Number(env.TASKFORCE_EMAIL_SMTP_PORT || 1025);
+    const smtpPort = Number.isInteger(rawSmtpPort) && rawSmtpPort >= 1 && rawSmtpPort <= 65535
+        ? rawSmtpPort
+        : 1025;
+    const smtpHost = String(env.TASKFORCE_EMAIL_SMTP_HOST || '127.0.0.1').trim() || '127.0.0.1';
+    return { provider, from, replyTo, providerApiKey, smtpHost, smtpPort };
 }
 export function resolveEffectiveEmailConfig(env = process.env, settings) {
     const base = resolveEmailConfig(env);
-    const provider = settings?.provider === 'resend'
-        || settings?.provider === 'console'
-        || settings?.provider === 'google-workspace'
-        ? settings.provider
-        : base.provider;
+    const provider = base.provider === 'mailpit'
+        ? 'mailpit'
+        : settings?.provider === 'resend'
+            || settings?.provider === 'console'
+            || settings?.provider === 'google-workspace'
+            ? settings.provider
+            : base.provider;
     const from = typeof settings?.from === 'string' && settings.from.trim().length > 0
         ? settings.from.trim()
         : base.from;
@@ -41,7 +50,9 @@ export function resolveEffectiveEmailConfig(env = process.env, settings) {
         provider,
         from,
         replyTo,
-        providerApiKey
+        providerApiKey,
+        smtpHost: base.smtpHost,
+        smtpPort: base.smtpPort
     };
 }
 async function sendWithResend(input, config) {
@@ -123,6 +134,30 @@ async function sendWithGoogleWorkspace(input, config) {
         return { ok: false, provider: 'google-workspace', error: String(error?.message || 'Google Workspace SMTP request failed') };
     }
 }
+async function sendWithMailpit(input, config) {
+    try {
+        const transporter = await createSmtpTransport({
+            host: config.smtpHost || '127.0.0.1',
+            port: config.smtpPort || 1025,
+            secure: false,
+            connectionTimeout: 5_000,
+            greetingTimeout: 5_000,
+            socketTimeout: 10_000
+        });
+        const info = await transporter.sendMail({
+            from: config.from,
+            to: input.to,
+            replyTo: config.replyTo,
+            subject: input.subject,
+            text: input.text,
+            html: input.html || `<p>${input.text.replace(/\n/g, '<br/>')}</p>`
+        });
+        return { ok: true, provider: 'mailpit', messageId: String(info?.messageId || '') || undefined };
+    }
+    catch (error) {
+        return { ok: false, provider: 'mailpit', error: String(error?.message || 'Mailpit SMTP request failed') };
+    }
+}
 function sendToConsole(input) {
     console.info(`[Taskforce Email] to=${input.to} subject="${input.subject}"\n${input.text}`);
     return { ok: true, provider: 'console' };
@@ -134,5 +169,8 @@ export async function sendEmail(input, config) {
     if (config.provider === 'google-workspace') {
         return sendWithGoogleWorkspace(input, config);
     }
+    if (config.provider === 'mailpit') {
+        return sendWithMailpit(input, config);
+    }
     return sendToConsole(input);
 }

package/dist/server/index.d.ts

@@ -5,12 +5,34 @@
  * Serves pre-built static UI and provides API endpoints.
  */
 import * as http from 'http';
+import { WebSocketServer } from 'ws';
 import { TaskforceCore } from '../core/Taskforce.js';
 import type { RequestAccessContext } from './auth.js';
+import type { LocalSyncCoordinatorHost } from '../sync/coordinator/localSyncCoordinatorHost.js';
+import type { LocalSyncProcessLock } from '../sync/coordinator/localSyncProcessLock.js';
+import type { LocalDataOwnerPermit } from './localDataOwnerPermit.js';
 export interface StandaloneServerOptions {
     projectRoot: string;
     port: number;
+    localSyncProcessLock: LocalSyncProcessLock | undefined;
+    localDataOwnerPermit?: LocalDataOwnerPermit;
+    manageProcessSignals?: boolean;
+    afterShutdown?: () => Promise<void> | void;
+    localService?: {
+        generation: string;
+        protocolVersion: string;
+        appVersion: string;
+        ownerPid: number;
+        bootstrapCapability: string;
+        ownershipKey: string;
+    };
 }
+export interface TaskforceStandaloneServer extends http.Server {
+    shutdownTaskforce(): Promise<void>;
+    readonly localSyncCoordinatorHost: LocalSyncCoordinatorHost | null;
+}
+export declare function isLocalSyncCoordinatorOwnedPath(pathname: string): boolean;
+export declare function closeTaskforceTransports(server: http.Server, wss: WebSocketServer, graceMs?: number): Promise<void>;
 export type HttpServerTimeoutSettings = {
     keepAliveTimeoutMs: number;
     headersTimeoutMs: number;
@@ -31,6 +53,7 @@ interface AuthorizedRequestAccess extends RequestAccessContext {
 export declare function isWorkspaceAccessRecoveryRoute(pathname: string): boolean;
 export declare function resolveDisabledAccessError(access: Pick<AuthorizedRequestAccess, 'disabled' | 'accountDisabled' | 'workspaceDisabled'>, pathname: string): string | null;
 export declare function shouldProxyCloudPath(pathname: string): boolean;
+export declare function shouldProxyCloudRequest(url: Pick<URL, 'pathname' | 'searchParams'>, env?: NodeJS.ProcessEnv): boolean;
 export declare function resolveCloudProxyUpstreamBaseUrl(req: http.IncomingMessage, fallbackBaseUrl: string): string;
 export declare function resolveAuthorizedWorkspaceAccess(core: Pick<TaskforceCore, 'resolveUserAccess' | 'getSystemRole'>, access: AuthorizedRequestAccess, requestedWorkspaceId: string): AuthorizedRequestAccess;
 export declare function shouldApplyReadOnlyMutationGuard(methodRaw: string | undefined, pathname: string): boolean;
@@ -48,5 +71,5 @@ export declare function ensureBillingWebhookAuthExclusion(excludedPaths: string[
 export declare function ensurePublicPricingAuthExclusion(excludedPaths: string[]): string[];
 export declare function ensurePublicSiteConfigAuthExclusion(excludedPaths: string[]): string[];
 export declare function isBillingWebhookPath(pathname: string): boolean;
-export declare function createStandaloneServer(options: StandaloneServerOptions): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+export declare function createStandaloneServer(options: StandaloneServerOptions): TaskforceStandaloneServer;
 export {};