@taskforcehq/taskforce 0.3.168

package/dist/server/runtimeMode.d.ts

@@ -0,0 +1,4 @@
+export type RuntimeMode = 'local' | 'cloud';
+export type DatabaseProvider = 'sqlite' | 'postgres';
+export declare function resolveRuntimeModeFromEnv(env?: NodeJS.ProcessEnv, fallbackProvider?: 'sqlite' | 'postgres'): RuntimeMode;
+export declare function assertCloudDatabaseProvider(runtimeMode: RuntimeMode, provider: DatabaseProvider, env?: NodeJS.ProcessEnv): void;

package/dist/server/runtimeMode.js

@@ -0,0 +1,25 @@
+function normalizeMode(raw) {
+    const normalized = String(raw || '').trim().toLowerCase();
+    if (normalized === 'local')
+        return 'local';
+    if (normalized === 'cloud')
+        return 'cloud';
+    return null;
+}
+export function resolveRuntimeModeFromEnv(env = process.env, fallbackProvider) {
+    const explicit = normalizeMode(env.TASKFORCE_RUNTIME_MODE);
+    if (explicit)
+        return explicit;
+    // Hosted deployments commonly use postgres and may omit an explicit runtime env.
+    // Keep provider-based fallback for compatibility, while still allowing explicit
+    // TASKFORCE_RUNTIME_MODE=local to force local behavior.
+    if (fallbackProvider === 'postgres')
+        return 'cloud';
+    return 'local';
+}
+export function assertCloudDatabaseProvider(runtimeMode, provider, env = process.env) {
+    const allowSqliteInCloud = String(env.TASKFORCE_ALLOW_SQLITE_IN_CLOUD || '').trim().toLowerCase() === 'true';
+    if (runtimeMode === 'cloud' && provider !== 'postgres' && !allowSqliteInCloud) {
+        throw new Error('[Taskforce] Cloud runtime requires Postgres. Set TASKFORCE_DB_PROVIDER=postgres and TASKFORCE_DATABASE_URL, or set TASKFORCE_ALLOW_SQLITE_IN_CLOUD=true only for temporary/non-production use.');
+    }
+}

package/dist/server/runtimeMode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/runtimeMode.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { assertCloudDatabaseProvider, resolveRuntimeModeFromEnv } from './runtimeMode';
+describe('server/runtimeMode', () => {
+    it('defaults to local when unset and sqlite fallback', () => {
+        expect(resolveRuntimeModeFromEnv({}, 'sqlite')).toBe('local');
+    });
+    it('falls back to cloud when postgres provider is set', () => {
+        expect(resolveRuntimeModeFromEnv({ TASKFORCE_DB_PROVIDER: 'postgres' }, 'postgres')).toBe('cloud');
+    });
+    it('honors explicit TASKFORCE_RUNTIME_MODE override', () => {
+        expect(resolveRuntimeModeFromEnv({ TASKFORCE_RUNTIME_MODE: 'local', TASKFORCE_DB_PROVIDER: 'postgres' })).toBe('local');
+        expect(resolveRuntimeModeFromEnv({ TASKFORCE_RUNTIME_MODE: 'cloud', TASKFORCE_DB_PROVIDER: 'sqlite' })).toBe('cloud');
+    });
+    it('keeps explicit local override even when postgres fallback is provided', () => {
+        expect(resolveRuntimeModeFromEnv({ TASKFORCE_RUNTIME_MODE: 'local', TASKFORCE_DB_PROVIDER: 'postgres' }, 'postgres')).toBe('local');
+    });
+    it('rejects sqlite provider in cloud runtime by default', () => {
+        expect(() => assertCloudDatabaseProvider('cloud', 'sqlite', {})).toThrow(/Cloud runtime requires Postgres/i);
+    });
+    it('allows sqlite provider in cloud runtime only with explicit override', () => {
+        expect(() => assertCloudDatabaseProvider('cloud', 'sqlite', { TASKFORCE_ALLOW_SQLITE_IN_CLOUD: 'true' })).not.toThrow();
+    });
+    it('allows postgres provider in cloud runtime', () => {
+        expect(() => assertCloudDatabaseProvider('cloud', 'postgres', {})).not.toThrow();
+    });
+});

package/dist/server/securityHeaders.d.ts

@@ -0,0 +1,3 @@
+import type { ServerResponse } from 'http';
+import type { RuntimeMode } from './runtimeMode.js';
+export declare function applySecurityHeaders(res: ServerResponse, runtimeMode: RuntimeMode): void;

package/dist/server/securityHeaders.js

@@ -0,0 +1,25 @@
+export function applySecurityHeaders(res, runtimeMode) {
+    const cspDirectives = [
+        "default-src 'self'",
+        "base-uri 'self'",
+        "frame-ancestors 'none'",
+        "object-src 'none'",
+        "connect-src 'self' https://api.stripe.com",
+        "frame-src 'self' https://js.stripe.com https://hooks.stripe.com",
+        "script-src 'self' https://js.stripe.com",
+        "img-src 'self' data: blob:",
+        "style-src 'self' 'unsafe-inline'",
+        "font-src 'self' data:"
+    ];
+    res.setHeader('Content-Security-Policy', cspDirectives.join('; '));
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('X-Frame-Options', 'DENY');
+    res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+    res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=(), payment=()');
+    res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+    res.setHeader('Cross-Origin-Resource-Policy', 'same-origin');
+    // HSTS is safe only on HTTPS deployments; cloud mode is expected to be TLS-terminated.
+    if (runtimeMode === 'cloud') {
+        res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+    }
+}

package/dist/server/securityHeaders.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/securityHeaders.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { applySecurityHeaders } from './securityHeaders';
+function mockRes() {
+    const store = {};
+    return {
+        setHeader: (name, value) => {
+            store[name] = value;
+            return undefined;
+        },
+        getHeader: (name) => store[name]
+    };
+}
+describe('server security headers', () => {
+    it('applies baseline security headers in local mode', () => {
+        const res = mockRes();
+        applySecurityHeaders(res, 'local');
+        expect(res.getHeader('X-Content-Type-Options')).toBe('nosniff');
+        expect(res.getHeader('Content-Security-Policy')).toContain("connect-src 'self' https://api.stripe.com");
+        expect(res.getHeader('Content-Security-Policy')).toContain("frame-src 'self' https://js.stripe.com https://hooks.stripe.com");
+        expect(res.getHeader('X-Frame-Options')).toBe('DENY');
+        expect(res.getHeader('Referrer-Policy')).toBe('strict-origin-when-cross-origin');
+        expect(res.getHeader('Permissions-Policy')).toBe('camera=(), microphone=(), geolocation=(), payment=()');
+        expect(res.getHeader('Cross-Origin-Opener-Policy')).toBe('same-origin');
+        expect(res.getHeader('Cross-Origin-Resource-Policy')).toBe('same-origin');
+        expect(res.getHeader('Strict-Transport-Security')).toBeUndefined();
+    });
+    it('adds HSTS in cloud mode', () => {
+        const res = mockRes();
+        applySecurityHeaders(res, 'cloud');
+        expect(res.getHeader('Strict-Transport-Security')).toBe('max-age=31536000; includeSubDomains');
+    });
+});

package/dist/server/smtpTransport.d.ts

@@ -0,0 +1,21 @@
+export interface SmtpTransport {
+    sendMail(input: {
+        from: string;
+        to: string;
+        replyTo?: string;
+        subject: string;
+        text: string;
+        html?: string;
+    }): Promise<{
+        messageId?: string;
+    }>;
+}
+export declare function createSmtpTransport(config: {
+    host: string;
+    port: number;
+    secure: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+}): Promise<SmtpTransport>;

package/dist/server/smtpTransport.js

@@ -0,0 +1,11 @@
+export async function createSmtpTransport(config) {
+    try {
+        const dynamicImport = new Function('modulePath', 'return import(modulePath);');
+        const mod = await dynamicImport('nodemailer');
+        const nodemailer = mod.default || mod;
+        return nodemailer.createTransport(config);
+    }
+    catch {
+        throw new Error('Nodemailer dependency is missing. Install nodemailer to use google-workspace provider.');
+    }
+}

package/dist/server/start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/start.js

@@ -0,0 +1,17 @@
+import { createStandaloneServer } from './index.js';
+const parsedPort = Number.parseInt(String(process.env.PORT || '8080'), 10);
+const port = Number.isFinite(parsedPort) && parsedPort > 0 ? parsedPort : 8080;
+const projectRoot = process.cwd();
+try {
+    const server = createStandaloneServer({
+        projectRoot,
+        port
+    });
+    server.listen(port, () => {
+        console.log(`[Taskforce] Server started on port ${port}`);
+    });
+}
+catch (error) {
+    console.error(`[Taskforce] Failed to start standalone server: ${error?.message || error}`);
+    process.exit(1);
+}

package/dist/services/formatTransformers.d.ts

@@ -0,0 +1,29 @@
+export interface WorkflowMetadata {
+    name: string;
+    description: string;
+    [key: string]: any;
+}
+export declare const formatTransformers: {
+    /**
+     * Transforms content to TOML format (Gemini CLI style)
+     * Structure:
+     * description = "..."
+     * prompt = """..."""
+     */
+    toToml(content: string, metadata: WorkflowMetadata): string;
+    /**
+     * Transforms content to Markdown format with frontmatter
+     * Structure:
+     * ---
+     * name: ...
+     * description: ...
+     * ---
+     * # Content
+     */
+    toMarkdown(content: string, metadata: WorkflowMetadata): string;
+    /**
+     * Transforms content to Cursor MDC format (.mdc)
+     * Structure: Markdown with YAML frontmatter + specific fields
+     */
+    toMdc(content: string, metadata: WorkflowMetadata): string;
+};

package/dist/services/formatTransformers.js

@@ -0,0 +1,56 @@
+import TOML from '@iarna/toml';
+export const formatTransformers = {
+    /**
+     * Transforms content to TOML format (Gemini CLI style)
+     * Structure:
+     * description = "..."
+     * prompt = """..."""
+     */
+    toToml(content, metadata) {
+        const { name, ...rest } = metadata;
+        // Ensure prompt is set
+        const data = {
+            ...rest,
+            prompt: content
+        };
+        return TOML.stringify(data);
+    },
+    /**
+     * Transforms content to Markdown format with frontmatter
+     * Structure:
+     * ---
+     * name: ...
+     * description: ...
+     * ---
+     * # Content
+     */
+    toMarkdown(content, metadata) {
+        const frontmatter = Object.entries(metadata)
+            .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+            .join('\n');
+        return `---\n${frontmatter}\n---\n\n${content}`;
+    },
+    /**
+     * Transforms content to Cursor MDC format (.mdc)
+     * Structure: Markdown with YAML frontmatter + specific fields
+     */
+    toMdc(content, metadata) {
+        const { name, description, ...rest } = metadata;
+        // Ensure description is present
+        const mdcMetadata = {
+            description: description || `Workflow: ${name}`,
+            globs: rest.globs || [],
+            alwaysApply: rest.alwaysApply !== undefined ? rest.alwaysApply : false,
+            ...rest
+        };
+        const frontmatter = Object.entries(mdcMetadata)
+            .map(([key, value]) => {
+            if (Array.isArray(value)) {
+                return `${key}: [${value.map(v => JSON.stringify(v)).join(', ')}]`;
+            }
+            return `${key}: ${JSON.stringify(value)}`;
+        })
+            .join('\n');
+        return `---\n${frontmatter}\n---\n\n${content}`;
+    }
+};

package/dist/services/templateEngine.d.ts

@@ -0,0 +1,46 @@
+import { Environment } from '../types.js';
+export interface WorkflowTemplate {
+    name: string;
+    description: string;
+    type: 'workflow' | 'command';
+    metadata?: Record<string, any>;
+    content: {
+        default: string;
+        [envId: string]: string;
+    };
+    variables?: string[];
+}
+export interface EnvironmentConfig {
+    id: string;
+    name: string;
+    icon?: string;
+    workflows: {
+        directory: string;
+        format: 'toml' | 'markdown' | 'mdc';
+        filenamePattern: string;
+        overrides?: Record<string, string | {
+            filename: string;
+            strategy?: 'overwrite' | 'inject' | 'append';
+        }>;
+    };
+    mcp?: {
+        prefix: string;
+    };
+}
+export declare class TemplateEngine {
+    private templatesDir;
+    private sanitizeMcpIdentifier;
+    constructor(templatesDir?: string);
+    getTemplatePath(name: string): string;
+    listTemplates(): string[];
+    getEnvironmentPath(envId: string): string;
+    listEnvironments(): Environment[];
+    loadTemplate(name: string): WorkflowTemplate;
+    loadEnvironment(envId: string): EnvironmentConfig;
+    processTemplate(templateName: string, envId: string, variables?: Record<string, string>): {
+        filename: string;
+        content: string;
+        strategy: 'overwrite' | 'inject' | 'append';
+    };
+    private substituteVariables;
+}

package/dist/services/templateEngine.js

@@ -0,0 +1,148 @@
+import yaml from 'js-yaml';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { formatTransformers } from './formatTransformers.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export class TemplateEngine {
+    templatesDir;
+    sanitizeMcpIdentifier(value) {
+        const normalized = String(value || '')
+            .replace(/[^a-zA-Z0-9_-]+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^[-_]+|[-_]+$/g, '');
+        return normalized || 'taskforce';
+    }
+    constructor(templatesDir) {
+        if (templatesDir) {
+            this.templatesDir = templatesDir;
+        }
+        else {
+            // Locate templates directory relative to this service file
+            // Works for both src/ (dev) and dist/ (prod) structure
+            // src/services/templateEngine.ts -> src/resources/templates
+            this.templatesDir = path.resolve(__dirname, '../resources/templates');
+        }
+    }
+    getTemplatePath(name) {
+        return path.join(this.templatesDir, 'workflows', `${name}.yaml`);
+    }
+    listTemplates() {
+        const workflowsDir = path.join(this.templatesDir, 'workflows');
+        if (!existsSync(workflowsDir))
+            return [];
+        return readdirSync(workflowsDir)
+            .filter(file => file.endsWith('.yaml'))
+            .map(file => file.replace('.yaml', ''));
+    }
+    getEnvironmentPath(envId) {
+        return path.join(this.templatesDir, 'environments', `${envId}.yaml`);
+    }
+    listEnvironments() {
+        const envDir = path.join(this.templatesDir, 'environments');
+        if (!existsSync(envDir))
+            return [];
+        const envs = readdirSync(envDir)
+            .filter(file => file.endsWith('.yaml'))
+            .map(file => {
+            const envId = file.replace('.yaml', '');
+            try {
+                const config = this.loadEnvironment(envId);
+                return {
+                    id: config.id,
+                    name: config.name,
+                    icon: config.icon,
+                    directory: config.workflows.directory
+                };
+            }
+            catch (e) {
+                console.error(`Failed to load environment config ${file}:`, e);
+                return null;
+            }
+        });
+        return envs.filter((env) => env !== null);
+    }
+    loadTemplate(name) {
+        const filePath = this.getTemplatePath(name);
+        if (!existsSync(filePath)) {
+            throw new Error(`Template not found: ${name}`);
+        }
+        return yaml.load(readFileSync(filePath, 'utf-8'));
+    }
+    loadEnvironment(envId) {
+        const filePath = this.getEnvironmentPath(envId);
+        if (!existsSync(filePath)) {
+            throw new Error(`Environment not found: ${envId}`);
+        }
+        return yaml.load(readFileSync(filePath, 'utf-8'));
+    }
+    processTemplate(templateName, envId, variables = {}) {
+        const template = this.loadTemplate(templateName);
+        const envConfig = this.loadEnvironment(envId);
+        // 1. Select Content (Env-specific or Default)
+        let rawContent = template.content[envId] || template.content.default;
+        // 2. Substitute Variables
+        // Add default variables from environment config
+        const effectiveVars = { ...variables };
+        if (envConfig.mcp?.prefix) {
+            const projectName = this.sanitizeMcpIdentifier(variables['projectName'] || 'taskforce');
+            const dynamicPrefix = envConfig.mcp.prefix.replace('{projectName}', projectName);
+            effectiveVars['MCP_PREFIX'] = dynamicPrefix;
+        }
+        const processedContent = this.substituteVariables(rawContent, effectiveVars);
+        // 3. Transform Format
+        let finalContent = processedContent;
+        const metadata = {
+            name: template.name,
+            description: template.description,
+            ...(template.metadata || {})
+        };
+        if (envConfig.workflows.format === 'toml') {
+            finalContent = formatTransformers.toToml(processedContent, metadata);
+        }
+        else if (envConfig.workflows.format === 'markdown') {
+            finalContent = formatTransformers.toMarkdown(processedContent, metadata);
+        }
+        else if (envConfig.workflows.format === 'mdc') {
+            finalContent = formatTransformers.toMdc(processedContent, metadata);
+        }
+        // 4. Generate Filename
+        const extMap = {
+            'toml': 'toml',
+            'markdown': 'md',
+            'mdc': 'mdc'
+        };
+        const ext = extMap[envConfig.workflows.format] || 'txt';
+        let filenamePattern = envConfig.workflows.filenamePattern;
+        let strategy = 'overwrite';
+        // Check for overrides
+        if (envConfig.workflows.overrides && envConfig.workflows.overrides[template.name]) {
+            const override = envConfig.workflows.overrides[template.name];
+            if (typeof override === 'string') {
+                filenamePattern = override;
+            }
+            else {
+                filenamePattern = override.filename;
+                if (override.strategy) {
+                    strategy = override.strategy;
+                }
+            }
+        }
+        const filename = filenamePattern
+            .replace('{name}', template.name)
+            .replace('{ext}', ext);
+        return {
+            filename,
+            content: finalContent,
+            strategy
+        };
+    }
+    substituteVariables(content, vars) {
+        let result = content;
+        for (const [key, value] of Object.entries(vars)) {
+            const regex = new RegExp(`{{${key}}}`, 'g');
+            result = result.replace(regex, value);
+        }
+        return result;
+    }
+}

package/dist/shared/runtimeContract.d.ts

@@ -0,0 +1,12 @@
+export type RuntimeMode = 'local' | 'cloud';
+export type AuthSource = 'cloud' | 'local';
+export type WorkspaceMode = 'single-local' | 'multi-cloud';
+export interface RuntimeModeContract {
+    runtimeMode: RuntimeMode;
+    authSource: AuthSource;
+    workspaceMode: WorkspaceMode;
+    workspaceSwitchingEnabled: boolean;
+}
+export declare function normalizeRuntimeMode(mode: unknown): RuntimeMode;
+export declare function resolveRuntimeModeContract(mode: unknown): RuntimeModeContract;
+export declare function isWorkspaceSwitchingEnabledForRuntime(mode: unknown): boolean;

package/dist/shared/runtimeContract.js

@@ -0,0 +1,23 @@
+const RUNTIME_MODE_CONTRACTS = {
+    local: {
+        runtimeMode: 'local',
+        authSource: 'cloud',
+        workspaceMode: 'single-local',
+        workspaceSwitchingEnabled: false
+    },
+    cloud: {
+        runtimeMode: 'cloud',
+        authSource: 'cloud',
+        workspaceMode: 'multi-cloud',
+        workspaceSwitchingEnabled: true
+    }
+};
+export function normalizeRuntimeMode(mode) {
+    return String(mode || '').trim().toLowerCase() === 'cloud' ? 'cloud' : 'local';
+}
+export function resolveRuntimeModeContract(mode) {
+    return RUNTIME_MODE_CONTRACTS[normalizeRuntimeMode(mode)];
+}
+export function isWorkspaceSwitchingEnabledForRuntime(mode) {
+    return resolveRuntimeModeContract(mode).workspaceSwitchingEnabled;
+}

package/dist/shared/runtimeContract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/runtimeContract.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { isWorkspaceSwitchingEnabledForRuntime, normalizeRuntimeMode, resolveRuntimeModeContract } from './runtimeContract';
+describe('runtimeContract', () => {
+    it('resolves local runtime contract', () => {
+        const contract = resolveRuntimeModeContract('local');
+        expect(contract.runtimeMode).toBe('local');
+        expect(contract.authSource).toBe('cloud');
+        expect(contract.workspaceMode).toBe('single-local');
+        expect(contract.workspaceSwitchingEnabled).toBe(false);
+    });
+    it('resolves cloud runtime contract', () => {
+        const contract = resolveRuntimeModeContract('cloud');
+        expect(contract.runtimeMode).toBe('cloud');
+        expect(contract.authSource).toBe('cloud');
+        expect(contract.workspaceMode).toBe('multi-cloud');
+        expect(contract.workspaceSwitchingEnabled).toBe(true);
+    });
+    it('normalizes unknown modes to local', () => {
+        expect(normalizeRuntimeMode(undefined)).toBe('local');
+        expect(normalizeRuntimeMode('staging')).toBe('local');
+        expect(isWorkspaceSwitchingEnabledForRuntime('staging')).toBe(false);
+    });
+});

package/dist/soak/preflight.cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/soak/preflight.cli.js

@@ -0,0 +1,28 @@
+import { loadSyncEndurancePreflightConfig, validateSyncEndurancePreflight } from './preflight';
+function printList(title, values) {
+    if (values.length === 0)
+        return;
+    console.log(title);
+    for (const value of values)
+        console.log(`- ${value}`);
+}
+function main() {
+    const config = loadSyncEndurancePreflightConfig(process.env);
+    const result = validateSyncEndurancePreflight(config);
+    console.log('Sync Soak Preflight');
+    console.log(`Profile: ${config.profile}`);
+    console.log(`Duration (min): ${config.durationMin}`);
+    console.log(`Artifact dir: ${config.artifactDir}`);
+    console.log(`Local base URL: ${config.localBaseUrl || '(missing)'}`);
+    console.log(`Cloud base URL: ${config.cloudBaseUrl || '(missing)'}`);
+    console.log(`Local workspace ID: ${config.localWorkspaceId || '(missing)'}`);
+    console.log(`Cloud workspace ID: ${config.cloudWorkspaceId || '(missing)'}`);
+    printList('Warnings:', result.warnings);
+    printList('Errors:', result.errors);
+    if (!result.ok) {
+        process.exitCode = 1;
+        return;
+    }
+    console.log('Preflight passed.');
+}
+main();

package/dist/soak/preflight.d.ts

@@ -0,0 +1,26 @@
+export type SyncSoakProfile = 'smoke' | 'stress' | 'overnight';
+export interface SyncEndurancePreflightConfig {
+    localBaseUrl: string;
+    cloudBaseUrl: string;
+    workspaceId: string;
+    localWorkspaceId: string;
+    cloudWorkspaceId: string;
+    localEmail: string;
+    localPassword: string;
+    cloudEmail: string;
+    cloudPassword: string;
+    durationMin: number;
+    seed: string;
+    profile: SyncSoakProfile;
+    artifactDir: string;
+    enableSyncDebug: boolean;
+}
+export interface SyncEndurancePreflightResult {
+    ok: boolean;
+    config: SyncEndurancePreflightConfig;
+    errors: string[];
+    warnings: string[];
+}
+export declare function loadSyncEndurancePreflightConfig(env?: NodeJS.ProcessEnv): SyncEndurancePreflightConfig;
+export declare function validateSyncEndurancePreflight(config: SyncEndurancePreflightConfig): SyncEndurancePreflightResult;
+export declare function assertSyncEndurancePreflight(env?: NodeJS.ProcessEnv): SyncEndurancePreflightConfig;