@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/services/workflowSimulation.test.js

@@ -1,113 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-import yaml from 'js-yaml';
-const workflowsDir = path.resolve(process.cwd(), 'src/resources/templates/workflows');
-function loadWorkflow(name) {
-    const raw = fs.readFileSync(path.join(workflowsDir, `${name}.yaml`), 'utf8');
-    return yaml.load(raw);
-}
-function buildAliasMap(names) {
-    const map = new Map();
-    for (const name of names) {
-        const workflow = loadWorkflow(name);
-        for (const alias of workflow.dispatch?.aliases || []) {
-            map.set(alias, name);
-        }
-    }
-    return map;
-}
-function simulateDoDispatch(params) {
-    const doWorkflow = loadWorkflow('do');
-    const aliasMap = buildAliasMap(['do', 'execute', 'plan', 'evaluate', 'collaborate', 'review']);
-    const calls = [];
-    if (params.knownTaskId) {
-        calls.push({ tool: 'get_task' });
-    }
-    else {
-        calls.push({ tool: 'list_tasks' });
-        calls.push({ tool: 'get_task' });
-    }
-    const explicitRoute = aliasMap.get(params.command);
-    if (explicitRoute && explicitRoute !== 'do') {
-        return { routedTo: explicitRoute, calls };
-    }
-    const mapped = params.approach ? doWorkflow.dispatch?.approachMap?.[params.approach] : undefined;
-    return {
-        routedTo: mapped || doWorkflow.dispatch?.default || 'execute',
-        calls
-    };
-}
-function simulateExecuteFlow(params) {
-    const calls = [{ tool: 'update_task', args: { status: 'in-progress' } }];
-    const requested = params.explicitFinalStatus;
-    if (!requested) {
-        calls.push({ tool: 'add_comment', args: { kind: 'summary' } });
-        calls.push({ tool: 'update_task', args: { status: 'review' } });
-        return calls;
-    }
-    if ((requested === 'done' || requested === 'cancelled') && !params.explicitUserInstructionForDoneOrCancelled) {
-        throw new Error('Blocked unsafe status transition');
-    }
-    if (requested === 'task' || requested === 'on-hold') {
-        calls.push({ tool: 'add_comment', args: { kind: 'status-justification' } });
-    }
-    else {
-        calls.push({ tool: 'add_comment', args: { kind: 'summary' } });
-    }
-    calls.push({ tool: 'update_task', args: { status: requested } });
-    return calls;
-}
-function simulateOptionalArtifactSave(workflowName, approveSave) {
-    const workflow = loadWorkflow(workflowName);
-    const artifact = Object.values(workflow.artifacts || {})[0];
-    const calls = [{ tool: 'render_in_screen' }];
-    if (!artifact || artifact.required || artifact.savePolicy !== 'ask-before-save') {
-        return calls;
-    }
-    calls.push({ tool: 'prompt_save_artifact', args: { path: artifact.path } });
-    if (approveSave) {
-        calls.push({ tool: 'write_file', args: { path: artifact.path } });
-        calls.push({ tool: 'attach_context_file', args: { path: artifact.path } });
-    }
-    return calls;
-}
-describe('Workflow simulation', () => {
-    it('/do routes by approach to execute when approach is implement', () => {
-        const result = simulateDoDispatch({ command: '/do', approach: 'implement', knownTaskId: true });
-        expect(result.routedTo).toBe('execute');
-        expect(result.calls[0].tool).toBe('get_task');
-    });
-    it('/do defaults to execute when approach is missing', () => {
-        const result = simulateDoDispatch({ command: '/do', knownTaskId: true });
-        expect(result.routedTo).toBe('execute');
-    });
-    it('explicit slash command wins over approach routing', () => {
-        const result = simulateDoDispatch({ command: '/review', approach: 'implement', knownTaskId: true });
-        expect(result.routedTo).toBe('review');
-    });
-    it('unknown task id uses list before get', () => {
-        const result = simulateDoDispatch({ command: '/do', approach: 'plan', knownTaskId: false });
-        expect(result.calls.map((c) => c.tool)).toEqual(['list_tasks', 'get_task']);
-    });
-    it('execute flow defaults to in-progress then review', () => {
-        const calls = simulateExecuteFlow({});
-        expect(calls.map((c) => c.tool)).toEqual(['update_task', 'add_comment', 'update_task']);
-        expect(calls[0].args?.status).toBe('in-progress');
-        expect(calls[2].args?.status).toBe('review');
-    });
-    it('execute flow requires justification for task/on-hold final status', () => {
-        const calls = simulateExecuteFlow({ explicitFinalStatus: 'on-hold' });
-        expect(calls[1].args?.kind).toBe('status-justification');
-        expect(calls[2].args?.status).toBe('on-hold');
-    });
-    it('execute flow blocks done/cancelled without explicit user instruction', () => {
-        expect(() => simulateExecuteFlow({ explicitFinalStatus: 'done' })).toThrow('Blocked unsafe status transition');
-    });
-    it('optional artifact flow prompts first and only attaches on approval', () => {
-        const noSave = simulateOptionalArtifactSave('evaluate', false);
-        expect(noSave.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact']);
-        const saved = simulateOptionalArtifactSave('evaluate', true);
-        expect(saved.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact', 'write_file', 'attach_context_file']);
-    });
-});

package/dist/services/workflowV2Policy.test.d.ts

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

package/dist/services/workflowV2Policy.test.js

@@ -1,80 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-import yaml from 'js-yaml';
-const WORKFLOW_DIR = path.resolve(process.cwd(), 'src/resources/templates/workflows');
-const semverLike = (value) => /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value);
-describe('Workflow v2 policy', () => {
-    const files = fs.readdirSync(WORKFLOW_DIR).filter((f) => f.endsWith('.yaml'));
-    const docs = files.map((file) => {
-        const full = path.join(WORKFLOW_DIR, file);
-        const parsed = yaml.load(fs.readFileSync(full, 'utf8'));
-        return { file, parsed };
-    });
-    it('all workflows are v2 with required top-level policy blocks', () => {
-        for (const { file, parsed } of docs) {
-            expect(parsed.version, `${file} should be version 2`).toBe(2);
-            expect(parsed.type, `${file} should be workflow type`).toBe('workflow');
-            expect(parsed.dispatch, `${file} missing dispatch`).toBeTruthy();
-            expect(parsed.compat, `${file} missing compat`).toBeTruthy();
-            expect(parsed.toolPolicy, `${file} missing toolPolicy`).toBeTruthy();
-            expect(parsed.contextPolicy, `${file} missing contextPolicy`).toBeTruthy();
-            expect(parsed.content?.default, `${file} missing content.default`).toBeTruthy();
-        }
-    });
-    it('uses semver-like minTaskforceVersion', () => {
-        for (const { file, parsed } of docs) {
-            const version = parsed.compat?.minTaskforceVersion || '';
-            expect(semverLike(version), `${file} has invalid minTaskforceVersion: ${version}`).toBe(true);
-        }
-    });
-    it('splits required tools into critical and optional lists', () => {
-        for (const { file, parsed } of docs) {
-            const critical = parsed.compat?.requiredToolsCritical || [];
-            const optional = parsed.compat?.requiredToolsOptional || [];
-            expect(Array.isArray(critical), `${file} missing requiredToolsCritical`).toBe(true);
-            expect(Array.isArray(optional), `${file} missing requiredToolsOptional`).toBe(true);
-            expect(critical.length > 0, `${file} requiredToolsCritical should not be empty`).toBe(true);
-            expect(new Set(critical).size === critical.length, `${file} requiredToolsCritical has duplicates`).toBe(true);
-            expect(new Set(optional).size === optional.length, `${file} requiredToolsOptional has duplicates`).toBe(true);
-            for (const tool of critical) {
-                expect(optional.includes(tool), `${file} tool listed as both critical and optional: ${tool}`).toBe(false);
-            }
-        }
-    });
-    it('enforces requiredToolsPolicy and status safety defaults', () => {
-        for (const { file, parsed } of docs) {
-            expect(parsed.toolPolicy?.requiredToolsPolicy?.critical, `${file} critical policy`).toBe('strict-fail');
-            expect(parsed.toolPolicy?.requiredToolsPolicy?.nonCritical, `${file} nonCritical policy`).toBe('warn-and-fallback');
-            expect(parsed.toolPolicy?.statusTransitions?.allowedStatuses).toEqual(expect.arrayContaining(['task', 'on-hold', 'in-progress', 'review', 'done']));
-            expect(parsed.toolPolicy?.statusTransitions?.forbiddenStatuses).toEqual(expect.arrayContaining(['cancelled']));
-        }
-    });
-    it('uses explicit MCP unavailable action', () => {
-        for (const { file, parsed } of docs) {
-            expect(parsed.contextPolicy?.mcpUnavailableAction, `${file} missing mcpUnavailableAction`).toBeTruthy();
-        }
-    });
-    it('keeps artifact paths project-root-relative', () => {
-        for (const { file, parsed } of docs) {
-            const artifacts = parsed.artifacts || {};
-            for (const [artifactName, def] of Object.entries(artifacts)) {
-                expect(path.isAbsolute(def.path), `${file} ${artifactName} path must be relative`).toBe(false);
-                expect(def.path.includes('..'), `${file} ${artifactName} path must not escape project root`).toBe(false);
-            }
-        }
-    });
-    it('defines global approach routing in do workflow', () => {
-        const doDoc = docs.find((d) => d.parsed.name === 'do');
-        expect(doDoc, 'do workflow is missing').toBeTruthy();
-        expect(doDoc?.parsed.dispatch?.routeByApproach).toBe(true);
-        expect(doDoc?.parsed.dispatch?.approachMap).toEqual(expect.objectContaining({
-            evaluate: 'evaluate',
-            collaborate: 'collaborate',
-            plan: 'plan',
-            review: 'review',
-            implement: 'execute'
-        }));
-        expect(doDoc?.parsed.dispatch?.default).toBe('execute');
-    });
-});

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

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

package/dist/shared/customTaxonomyLibrary.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getBuiltInCustomTaxonomyLibraryPack, listBuiltInCustomTaxonomyLibraryPacks } from './customTaxonomyLibrary';
-describe('customTaxonomyLibrary', () => {
-    it('includes the expanded built-in custom taxonomy packs', () => {
-        const packs = listBuiltInCustomTaxonomyLibraryPacks();
-        expect(packs.map((pack) => pack.id)).toEqual(expect.arrayContaining([
-            'client-delivery',
-            'content-operations',
-            'product-delivery',
-            'content-production'
-        ]));
-    });
-    it('returns cloned pack definitions', () => {
-        const pack = getBuiltInCustomTaxonomyLibraryPack('product-delivery');
-        expect(pack?.label).toBe('Product Delivery');
-        pack?.taxonomies[0]?.options?.push({ value: 'test', label: 'Test' });
-        const freshPack = getBuiltInCustomTaxonomyLibraryPack('product-delivery');
-        expect(freshPack?.taxonomies[0]?.options).not.toEqual(expect.arrayContaining([expect.objectContaining({ value: 'test' })]));
-    });
-});

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

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

package/dist/shared/passwordPolicy.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getPasswordPolicyGuidance, MIN_PASSWORD_LENGTH, validatePasswordPolicy } from './passwordPolicy';
-describe('passwordPolicy', () => {
-    it('describes the active password policy guidance', () => {
-        expect(getPasswordPolicyGuidance()).toEqual([
-            `Use at least ${MIN_PASSWORD_LENGTH} characters.`,
-            'Avoid common passwords or obvious patterns.',
-            'Do not include your email or display name.'
-        ]);
-    });
-    it('rejects common passwords even when padded with punctuation', () => {
-        expect(validatePasswordPolicy('Password123!')).toEqual({
-            ok: false,
-            code: 'PASSWORD_TOO_COMMON',
-            message: 'Choose a less common password.'
-        });
-    });
-    it('rejects passwords containing personal information', () => {
-        expect(validatePasswordPolicy('RossBurkeSecure!2026', {
-            email: 'ross@example.com',
-            displayName: 'Ross Burke'
-        })).toEqual({
-            ok: false,
-            code: 'PASSWORD_CONTAINS_PERSONAL_INFO',
-            message: 'Password cannot contain your email or display name.'
-        });
-    });
-    it('accepts long passwords without common or personal tokens', () => {
-        expect(validatePasswordPolicy('MapleHarborOrbit!2026', {
-            email: 'ross@example.com',
-            displayName: 'Ross Burke'
-        })).toEqual({ ok: true });
-    });
-});

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

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

package/dist/shared/runtimeContract.test.js

@@ -1,23 +0,0 @@
-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/shared/taxonomyLibrary.test.d.ts

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

package/dist/shared/taxonomyLibrary.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getDefaultStarterTaxonomyLibraryPack, listBuiltInTaxonomyLibraryPacks } from './taxonomyLibrary.js';
-describe('taxonomyLibrary', () => {
-    it('includes General and Software Development starter packs', () => {
-        const packs = listBuiltInTaxonomyLibraryPacks();
-        expect(packs.map((pack) => pack.id)).toEqual(['general', 'software-development']);
-        expect(packs.find((pack) => pack.id === 'general')).toEqual(expect.objectContaining({
-            label: 'General'
-        }));
-        expect(packs.find((pack) => pack.id === 'software-development')).toEqual(expect.objectContaining({
-            label: 'Software Development'
-        }));
-    });
-    it('returns cloned pack payloads so callers cannot mutate the source definitions', () => {
-        const [firstCallPack] = listBuiltInTaxonomyLibraryPacks();
-        firstCallPack.categories[0].label = 'Changed';
-        const [secondCallPack] = listBuiltInTaxonomyLibraryPacks();
-        expect(secondCallPack.categories[0].label).toBe('General');
-    });
-    it('marks General as the default starter pack', () => {
-        const pack = getDefaultStarterTaxonomyLibraryPack();
-        expect(pack.id).toBe('general');
-        expect(pack.types.map((type) => type.value)).toEqual(['task', 'deliverable', 'issue', 'idea', 'review']);
-        expect(pack.priorities.map((priority) => priority.value)).toEqual([1, 2, 3]);
-    });
-});

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

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

package/dist/shared/taxonomyState.test.js

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { hasWorkspaceTaxonomyStatePayload, normalizeWorkspaceTaxonomyStatePayload } from './taxonomyState';
-describe('taxonomyState helpers', () => {
-    it('normalizes legacy string categories into category records', () => {
-        const normalized = normalizeWorkspaceTaxonomyStatePayload({
-            categories: ['General', { value: 'research', label: 'Research' }],
-            types: [{ value: 'task', label: 'Task' }],
-            priorities: [{ value: 2, label: 'Medium' }],
-            taxonomies: []
-        });
-        expect(normalized.categories).toEqual([
-            { value: 'general', label: 'General' },
-            { value: 'research', label: 'Research' }
-        ]);
-        expect(normalized.types).toEqual([{
-                value: 'task',
-                label: 'Task',
-                icon: 'CheckSquare',
-                color: 'blue-500',
-                aliases: undefined,
-                status: 'active'
-            }]);
-        expect(normalized.priorities).toEqual([{ value: 2, label: 'Medium' }]);
-        expect(normalized.taxonomies).toEqual([]);
-        expect(normalized.displayLabels).toEqual({});
-    });
-    it('fills missing arrays with empty collections', () => {
-        const normalized = normalizeWorkspaceTaxonomyStatePayload(undefined);
-        expect(normalized).toEqual({
-            categories: [],
-            types: [],
-            priorities: [],
-            taxonomies: [],
-            displayLabels: {}
-        });
-    });
-    it('sanitizes custom taxonomy aliases for taxonomies and options', () => {
-        const normalized = normalizeWorkspaceTaxonomyStatePayload({
-            taxonomies: [{
-                    id: 'review-status',
-                    label: 'Review Status',
-                    aliases: [' review route ', '', 'workflow'],
-                    widgetType: 'select',
-                    isSystem: false,
-                    multiSelect: false,
-                    options: [
-                        { value: 'legal-review', label: 'Legal Review', aliases: [' legal ', '', 'lawyer'], status: 'retired' }
-                    ]
-                }]
-        });
-        expect(normalized.taxonomies).toEqual([
-            expect.objectContaining({
-                id: 'review-status',
-                aliases: ['review route', 'workflow'],
-                options: [
-                    expect.objectContaining({
-                        value: 'legal-review',
-                        aliases: ['legal', 'lawyer'],
-                        status: 'retired'
-                    })
-                ]
-            })
-        ]);
-    });
-    it('detects unified taxonomy payloads', () => {
-        expect(hasWorkspaceTaxonomyStatePayload({ categories: [] })).toBe(true);
-        expect(hasWorkspaceTaxonomyStatePayload({ priorities: [] })).toBe(true);
-        expect(hasWorkspaceTaxonomyStatePayload({ foo: 'bar' })).toBe(false);
-        expect(hasWorkspaceTaxonomyStatePayload(null)).toBe(false);
-    });
-});

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

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

package/dist/soak/preflight.cli.js

@@ -1,28 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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;

package/dist/soak/preflight.js

@@ -1,113 +0,0 @@
-function asNonEmpty(value) {
-    return String(value || '').trim();
-}
-function parsePositiveInt(value, fallback) {
-    const parsed = Number.parseInt(String(value || '').trim(), 10);
-    if (!Number.isFinite(parsed) || parsed <= 0)
-        return fallback;
-    return parsed;
-}
-function parseBoolean(value, fallback = false) {
-    const normalized = String(value || '').trim().toLowerCase();
-    if (!normalized)
-        return fallback;
-    if (['1', 'true', 'yes', 'on'].includes(normalized))
-        return true;
-    if (['0', 'false', 'no', 'off'].includes(normalized))
-        return false;
-    return fallback;
-}
-function parseProfile(value) {
-    const normalized = String(value || '').trim().toLowerCase();
-    if (normalized === 'stress')
-        return 'stress';
-    if (normalized === 'overnight')
-        return 'overnight';
-    return 'smoke';
-}
-function isHttpUrl(value) {
-    try {
-        const url = new URL(value);
-        return url.protocol === 'http:' || url.protocol === 'https:';
-    }
-    catch {
-        return false;
-    }
-}
-function containsProdHint(value) {
-    return /\bprod(uction)?\b/i.test(value);
-}
-export function loadSyncEndurancePreflightConfig(env = process.env) {
-    const sharedWorkspaceId = asNonEmpty(env.SYNC_SOAK_WORKSPACE_ID);
-    const sharedEmail = asNonEmpty(env.SYNC_SOAK_EMAIL);
-    const sharedPassword = asNonEmpty(env.SYNC_SOAK_PASSWORD);
-    const workspaceId = sharedWorkspaceId;
-    const localWorkspaceId = workspaceId;
-    const cloudWorkspaceId = workspaceId;
-    const localEmail = sharedEmail;
-    const localPassword = sharedPassword;
-    const cloudEmail = sharedEmail;
-    const cloudPassword = sharedPassword;
-    return {
-        localBaseUrl: asNonEmpty(env.SYNC_SOAK_LOCAL_BASE_URL),
-        cloudBaseUrl: asNonEmpty(env.SYNC_SOAK_CLOUD_BASE_URL),
-        workspaceId,
-        localWorkspaceId,
-        cloudWorkspaceId,
-        localEmail,
-        localPassword,
-        cloudEmail,
-        cloudPassword,
-        durationMin: parsePositiveInt(env.SYNC_SOAK_DURATION_MIN, 60),
-        seed: asNonEmpty(env.SYNC_SOAK_SEED) || String(Date.now()),
-        profile: parseProfile(env.SYNC_SOAK_PROFILE),
-        artifactDir: asNonEmpty(env.SYNC_SOAK_ARTIFACT_DIR) || '.taskforce/soak-artifacts',
-        enableSyncDebug: parseBoolean(env.SYNC_SOAK_ENABLE_SYNC_DEBUG, false)
-    };
-}
-export function validateSyncEndurancePreflight(config) {
-    const errors = [];
-    const warnings = [];
-    if (!config.localBaseUrl)
-        errors.push('Missing SYNC_SOAK_LOCAL_BASE_URL.');
-    if (!config.cloudBaseUrl)
-        errors.push('Missing SYNC_SOAK_CLOUD_BASE_URL.');
-    if (config.localBaseUrl && !isHttpUrl(config.localBaseUrl)) {
-        errors.push('SYNC_SOAK_LOCAL_BASE_URL must be an absolute http(s) URL.');
-    }
-    if (config.cloudBaseUrl && !isHttpUrl(config.cloudBaseUrl)) {
-        errors.push('SYNC_SOAK_CLOUD_BASE_URL must be an absolute http(s) URL.');
-    }
-    if (!config.workspaceId)
-        errors.push('Missing SYNC_SOAK_WORKSPACE_ID.');
-    if (!config.localEmail)
-        errors.push('Missing SYNC_SOAK_EMAIL.');
-    if (!config.localPassword)
-        errors.push('Missing SYNC_SOAK_PASSWORD.');
-    if (!config.cloudEmail)
-        errors.push('Missing SYNC_SOAK_EMAIL.');
-    if (!config.cloudPassword)
-        errors.push('Missing SYNC_SOAK_PASSWORD.');
-    if (!config.artifactDir)
-        errors.push('Missing SYNC_SOAK_ARTIFACT_DIR.');
-    if (config.durationMin < 5)
-        errors.push('SYNC_SOAK_DURATION_MIN must be >= 5.');
-    if (containsProdHint(config.localBaseUrl) || containsProdHint(config.cloudBaseUrl)) {
-        warnings.push('One or more base URLs look production-like; prefer dedicated test environments.');
-    }
-    return {
-        ok: errors.length === 0,
-        config,
-        errors,
-        warnings
-    };
-}
-export function assertSyncEndurancePreflight(env = process.env) {
-    const config = loadSyncEndurancePreflightConfig(env);
-    const result = validateSyncEndurancePreflight(config);
-    if (!result.ok) {
-        const details = result.errors.map((entry) => `- ${entry}`).join('\n');
-        throw new Error(`Sync soak preflight failed:\n${details}`);
-    }
-    return result.config;
-}

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

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

package/dist/soak/preflight.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { assertSyncEndurancePreflight, loadSyncEndurancePreflightConfig, validateSyncEndurancePreflight } from './preflight';
-const validEnv = {
-    SYNC_SOAK_LOCAL_BASE_URL: 'http://localhost:5174',
-    SYNC_SOAK_CLOUD_BASE_URL: 'https://cloud.example.com',
-    SYNC_SOAK_WORKSPACE_ID: 'workspace-sync-test',
-    SYNC_SOAK_EMAIL: 'shared-sync-test@example.com',
-    SYNC_SOAK_PASSWORD: 'shared-password',
-    SYNC_SOAK_DURATION_MIN: '90',
-    SYNC_SOAK_PROFILE: 'stress',
-    SYNC_SOAK_SEED: 'seed-123'
-};
-describe('soak/preflight', () => {
-    it('loads typed preflight config from env', () => {
-        const config = loadSyncEndurancePreflightConfig(validEnv);
-        expect(config.localBaseUrl).toBe('http://localhost:5174');
-        expect(config.profile).toBe('stress');
-        expect(config.durationMin).toBe(90);
-        expect(config.seed).toBe('seed-123');
-        expect(config.workspaceId).toBe('workspace-sync-test');
-        expect(config.localWorkspaceId).toBe('workspace-sync-test');
-        expect(config.cloudWorkspaceId).toBe('workspace-sync-test');
-    });
-    it('fails validation when required fields are missing', () => {
-        const config = loadSyncEndurancePreflightConfig({});
-        const result = validateSyncEndurancePreflight(config);
-        expect(result.ok).toBe(false);
-        expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('throws with a readable error when preflight fails', () => {
-        expect(() => assertSyncEndurancePreflight({})).toThrowError(/preflight failed/i);
-    });
-    it('passes for valid environment', () => {
-        expect(() => assertSyncEndurancePreflight(validEnv)).not.toThrow();
-        const config = loadSyncEndurancePreflightConfig(validEnv);
-        expect(config.localEmail).toBe('shared-sync-test@example.com');
-        expect(config.cloudEmail).toBe('shared-sync-test@example.com');
-    });
-});

package/dist/storage/objectStorageClient.test.d.ts

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