@grada-run/grada 0.0.1 → 0.33.0

package/tests/ecs.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import {
+    SESSION_MANAGER_PLUGIN_URL,
+    resolveContainer,
+    hasSessionManagerPlugin,
+    fetchActiveService,
+    pickRuntimeContainer,
+    printAwsCliGuidance,
+    printSessionManagerGuidance,
+    printNoTasksGuidance,
+} from '../src/utils/ecs.js';
+
+afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env.ECS_CONTAINER;
+});
+
+function capturedOutput(fn) {
+    const lines = [];
+    vi.spyOn(console, 'log').mockImplementation((...args) => {
+        lines.push(args.join(' '));
+    });
+    fn();
+    return lines.join('\n');
+}
+
+describe('ecs shared module', () => {
+    it('exposes the Session Manager plugin install URL', () => {
+        expect(SESSION_MANAGER_PLUGIN_URL).toContain('session-manager-working-with-install-plugin.html');
+    });
+
+    it('resolveContainer prefers explicit flags, then ECS_CONTAINER, then project default', () => {
+        expect(resolveContainer({ projectName: 'myapp' }, '/tmp')).toBe('myapp-container');
+        expect(resolveContainer({ projectName: 'myapp', container: '  web  ' }, '/tmp')).toBe('web');
+        expect(resolveContainer({ projectName: 'myapp', containerName: 'api' }, '/tmp')).toBe('api');
+        process.env.ECS_CONTAINER = 'from-env';
+        expect(resolveContainer({ projectName: 'myapp' }, '/tmp')).toBe('from-env');
+    });
+
+    it('hasSessionManagerPlugin reports ENOENT and spawn failures as missing', () => {
+        const enoent = new Error('not found');
+        enoent.code = 'ENOENT';
+        expect(hasSessionManagerPlugin({ spawnSyncImpl: () => { throw new Error('boom'); } })).toBe(false);
+        expect(hasSessionManagerPlugin({ spawnSyncImpl: () => ({ error: enoent }) })).toBe(false);
+        expect(hasSessionManagerPlugin({ spawnSyncImpl: () => ({}) })).toBe(true);
+    });
+
+    it('printAwsCliGuidance defaults to exec wording', () => {
+        const out = capturedOutput(() => printAwsCliGuidance());
+        expect(out).toContain('exec');
+        expect(out).toContain('to open a shell in your container.');
+        expect(out).toContain(SESSION_MANAGER_PLUGIN_URL);
+    });
+
+    it('printAwsCliGuidance accepts per-command wording', () => {
+        const out = capturedOutput(() => printAwsCliGuidance({
+            commandName: 'db connect',
+            purpose: 'to open a secure tunnel to your database',
+        }));
+        expect(out).toContain('db connect');
+        expect(out).toContain('to open a secure tunnel to your database.');
+    });
+
+    it('printSessionManagerGuidance defaults to exec wording', () => {
+        const out = capturedOutput(() => printSessionManagerGuidance());
+        expect(out).toContain('exec');
+        expect(out).toContain('to securely tunnel into your container.');
+    });
+
+    it('printSessionManagerGuidance accepts per-command wording', () => {
+        const out = capturedOutput(() => printSessionManagerGuidance({
+            commandName: 'db connect',
+            purpose: 'to securely tunnel to your database',
+        }));
+        expect(out).toContain('db connect');
+        expect(out).toContain('to securely tunnel to your database.');
+    });
+
+    it('printNoTasksGuidance names the service, cluster, and reason', () => {
+        const out = capturedOutput(() => printNoTasksGuidance('svc', 'clu'));
+        expect(out).toContain('svc');
+        expect(out).toContain('clu');
+        expect(out).toContain('to open an interactive shell.');
+        const dbOut = capturedOutput(() => printNoTasksGuidance('svc', 'clu', 'to act as a jump host for the tunnel'));
+        expect(dbOut).toContain('to act as a jump host for the tunnel.');
+    });
+
+    it('fetchActiveService returns the service only when ACTIVE', async () => {
+        const active = { serviceName: 's', status: 'ACTIVE' };
+        const seen = [];
+        const client = {
+            send: vi.fn((cmd) => {
+                seen.push(cmd.input);
+                return Promise.resolve({ services: [active] });
+            }),
+        };
+        await expect(fetchActiveService(client, 'c', 's')).resolves.toBe(active);
+        expect(seen[0]).toEqual({ cluster: 'c', services: ['s'] });
+
+        const inactive = { send: vi.fn(() => Promise.resolve({ services: [{ status: 'INACTIVE' }] })) };
+        await expect(fetchActiveService(inactive, 'c', 's')).resolves.toBeNull();
+        const missing = { send: vi.fn(() => Promise.resolve({ services: [] })) };
+        await expect(fetchActiveService(missing, 'c', 's')).resolves.toBeNull();
+    });
+
+    it('pickRuntimeContainer prefers the expected name, then RUNNING, then first', () => {
+        const task = {
+            containers: [
+                { name: 'redis', lastStatus: 'RUNNING', runtimeId: 'rt-redis' },
+                { name: 'myapp-container', lastStatus: 'RUNNING', runtimeId: 'rt-app' },
+            ],
+        };
+        expect(pickRuntimeContainer(task, 'myapp-container').runtimeId).toBe('rt-app');
+        expect(pickRuntimeContainer(task, 'missing').runtimeId).toBe('rt-redis');
+        expect(pickRuntimeContainer({ containers: [{ name: 'only' }] }, 'missing').name).toBe('only');
+        expect(pickRuntimeContainer({ containers: [] }, 'missing')).toBeNull();
+    });
+
+    it('pickRuntimeContainer also reads task-definition containerDefinitions', () => {
+        const taskDef = { containerDefinitions: [{ name: 'a' }, { name: 'b' }] };
+        expect(pickRuntimeContainer(taskDef, 'b').name).toBe('b');
+        expect(pickRuntimeContainer(taskDef, 'missing').name).toBe('a');
+        expect(pickRuntimeContainer({}, 'missing')).toBeNull();
+    });
+
+    it.each([null, undefined, 'string', 42, true, { port: 'string' }])('resolveContainer(%s) behaves like {}', (bad) => {
+        expect(resolveContainer(bad)).toBe(resolveContainer({}));
+        expect(resolveContainer(bad, 42)).toBe(resolveContainer({}));
+    });
+});

package/tests/eject.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { stripTerraformMetadata, stripGitignoreMetadata } from '../src/commands/eject.js';
+
+describe('eject metadata stripping', () => {
+    it('strips grada headers and tag blocks', () => {
+        const content = '# grada generated infrastructure\n'
+            + 'provider "aws" {\n'
+            + '  region = "us-east-2"\n\n'
+            + '  default_tags {\n'
+            + '    tags = {\n'
+            + '      ManagedBy = "grada"\n'
+            + '    }\n'
+            + '  }\n'
+            + '}\n';
+        const cleaned = stripTerraformMetadata(content);
+        expect(cleaned).not.toContain('grada generated infrastructure');
+        expect(cleaned).not.toContain('ManagedBy');
+        expect(cleaned).toContain('provider "aws"');
+        expect(cleaned).toContain('region = "us-east-2"');
+    });
+
+    it('strips legacy deploy-stack headers, tag blocks, and lambda suffixes', () => {
+        const content = '# deploy-stack generated infrastructure (Lambda target)\n'
+            + 'provider "aws" {\n'
+            + '  default_tags {\n'
+            + '    tags = {\n'
+            + '      ManagedBy = "deploy-stack"\n'
+            + '    }\n'
+            + '  }\n'
+            + '}\n';
+        const cleaned = stripTerraformMetadata(content);
+        expect(cleaned).not.toContain('deploy-stack');
+        expect(cleaned).not.toContain('Lambda target');
+        expect(cleaned).toContain('provider "aws"');
+    });
+
+    it.each([
+        ['grada', '# grada addon: storage:s3\n# Generated by `grada add storage:s3`. Do not edit by hand unless\n'],
+        ['legacy', '# deploy-stack addon: storage:s3\n# Generated by `deploy-stack add storage:s3`. Do not edit by hand unless\n'],
+    ])('strips %s addon headers but keeps billing docs', (_label, header) => {
+        const content = `${header}# you know what you are doing — re-running with --force overwrites this file.\n`
+            + '#\n# Billing: usage-billed.\n\nresource "aws_s3_bucket" "x" {}\n';
+        const cleaned = stripTerraformMetadata(content);
+        expect(cleaned).not.toContain('addon: storage:s3');
+        expect(cleaned).not.toContain('Generated by');
+        expect(cleaned).not.toContain('overwrites this file');
+        expect(cleaned).toContain('# Billing: usage-billed.');
+        expect(cleaned).toContain('resource "aws_s3_bucket" "x" {}');
+    });
+
+    it('strips both gitignore backup stanzas', () => {
+        const content = 'node_modules/\n\n# grada backups\n*.bak.*\n\n# deploy-stack backups\n*.bak.*\n';
+        const cleaned = stripGitignoreMetadata(content);
+        expect(cleaned).not.toContain('backups');
+        expect(cleaned).not.toContain('*.bak.*');
+        expect(cleaned).toContain('node_modules/');
+    });
+
+    it('leaves domain markers and user content untouched', () => {
+        const content = '# grada:domain-mode=route53\n# grada:zone-id=Z123\n'
+            + '# A user comment about grada add workflows.\n';
+        expect(stripTerraformMetadata(content)).toBe(content);
+        expect(stripGitignoreMetadata('dist/\n')).toBe('dist/\n');
+    });
+});

package/tests/exec.test.js

@@ -0,0 +1,366 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory } from './helpers/clack.js';
+import { telemetryMockFactory } from './helpers/telemetry.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { EventEmitter } from 'events';
+import {
+    runExec,
+    parseExecArgs,
+    buildExecuteCommandArgs,
+    hasSessionManagerPlugin,
+    findRunningTask,
+    resolveContainer,
+    DEFAULT_SHELL,
+} from '../src/commands/exec.js';
+import {
+    resolveCluster,
+    resolveService,
+} from '../src/utils/resolvers.js';
+import { hasAwsCli } from '../src/utils/aws.js';
+import { trackEvent } from '../src/core/telemetry.js';
+
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
+
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
+
+const {
+    MockListTasksCommand,
+    MockDescribeTasksCommand,
+} = vi.hoisted(() => ({
+    MockListTasksCommand: vi.fn(function (input) { Object.assign(this, input); }),
+    MockDescribeTasksCommand: vi.fn(function (input) { Object.assign(this, input); }),
+}));
+
+vi.mock('@aws-sdk/client-ecs', () => ({
+    ECSClient: vi.fn(function () { this.send = vi.fn(); }),
+    ListTasksCommand: MockListTasksCommand,
+    DescribeTasksCommand: MockDescribeTasksCommand,
+}));
+
+function mockEcsClient({ taskArns = [], tasks = [] } = {}) {
+    return {
+        send: vi.fn((cmd) => {
+            if (cmd instanceof MockListTasksCommand) return Promise.resolve({ taskArns });
+            if (cmd instanceof MockDescribeTasksCommand) return Promise.resolve({ tasks });
+            return Promise.resolve({});
+        }),
+    };
+}
+
+function mockSpawnImpl(calls, exitCode = 0) {
+    return vi.fn((cmd, args, opts) => {
+        calls.push({ cmd, args, opts });
+        const child = new EventEmitter();
+        queueMicrotask(() => child.emit('close', exitCode));
+        return child;
+    });
+}
+
+describe('exec: CLI args', () => {
+    it('parses cluster/service/container/command/region flags', () => {
+        expect(parseExecArgs(['exec', '--cluster', 'c1', '--service', 's1', '--container', 'web', '--command', '/bin/bash', '--region', 'eu-west-1'])).toEqual({
+            cluster: 'c1',
+            service: 's1',
+            container: 'web',
+            command: '/bin/bash',
+            region: 'eu-west-1',
+        });
+    });
+
+    it('supports = syntax and bare exec', () => {
+        expect(parseExecArgs(['exec', '--cluster=c1', '--region=us-west-2'])).toEqual({ cluster: 'c1', region: 'us-west-2' });
+        expect(parseExecArgs(['exec'])).toEqual({});
+    });
+
+    it('resolves names from project directory with env overrides', () => {
+        expect(resolveCluster({ projectName: 'myapp' }, '/tmp')).toBe('myapp-cluster');
+        expect(resolveService({ projectName: 'myapp' }, '/tmp')).toBe('myapp-service');
+        expect(resolveContainer({ projectName: 'myapp' }, '/tmp')).toBe('myapp-container');
+    });
+});
+
+describe('exec: AWS CLI command construction', () => {
+    it('builds the exact execute-command arguments', () => {
+        const args = buildExecuteCommandArgs({
+            cluster: 'myapp-cluster',
+            taskArn: 'arn:aws:ecs:us-east-2:123:task/myapp-cluster/abc',
+            container: 'myapp-container',
+            command: '/bin/sh',
+            region: 'us-east-2',
+        });
+        expect(args).toEqual([
+            'ecs', 'execute-command',
+            '--cluster', 'myapp-cluster',
+            '--task', 'arn:aws:ecs:us-east-2:123:task/myapp-cluster/abc',
+            '--container', 'myapp-container',
+            '--interactive',
+            '--command', '/bin/sh',
+            '--region', 'us-east-2',
+        ]);
+    });
+
+    it('defaults to /bin/sh', () => {
+        const args = buildExecuteCommandArgs({ cluster: 'c', taskArn: 't', container: 'web' });
+        expect(args).toContain('/bin/sh');
+        expect(DEFAULT_SHELL).toBe('/bin/sh');
+    });
+
+    it('detects a missing AWS CLI via spawnSync', () => {
+        expect(hasAwsCli({ spawnSyncImpl: () => { throw new Error('ENOENT'); } })).toBe(false);
+        expect(hasAwsCli({ spawnSyncImpl: () => ({ status: 0 }) })).toBe(true);
+        expect(hasAwsCli({ spawnSyncImpl: () => ({ status: 1 }) })).toBe(false);
+    });
+
+    it('detects a missing Session Manager plugin via spawnSync', () => {
+        expect(hasSessionManagerPlugin({ spawnSyncImpl: () => { throw new Error('ENOENT'); } })).toBe(false);
+        const enoent = new Error('spawnSync session-manager-plugin ENOENT');
+        enoent.code = 'ENOENT';
+        expect(hasSessionManagerPlugin({ spawnSyncImpl: () => ({ error: enoent }) })).toBe(false);
+        expect(hasSessionManagerPlugin({ spawnSyncImpl: () => ({}) })).toBe(true);
+    });
+});
+
+describe('Command: exec (mocked ECS + spawn)', () => {
+    let exitSpy;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { });
+    });
+
+    afterEach(() => {
+        exitSpy.mockRestore();
+    });
+
+    it('spawns aws ecs execute-command with inherited stdio on success', async () => {
+        const taskArn = 'arn:aws:ecs:us-east-2:123:task/myapp-cluster/abc123';
+        const ecsClient = mockEcsClient({
+            taskArns: [taskArn],
+            tasks: [{ taskArn, containers: [{ name: 'myapp-container', lastStatus: 'RUNNING' }] }],
+        });
+        const calls = [];
+        const spawnImpl = mockSpawnImpl(calls, 0);
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        try {
+            const result = await runExec({
+                projectName: 'myapp',
+                region: 'us-east-2',
+                ecsClient,
+                spawnImpl,
+                hasAwsCli: true,
+                hasSsmPlugin: true,
+            });
+            expect(result.ok).toBe(true);
+            expect(result.taskArn).toBe(taskArn);
+            expect(exitSpy).not.toHaveBeenCalled();
+            expect(spawnImpl).toHaveBeenCalledTimes(1);
+            const [cmd, args, opts] = spawnImpl.mock.calls[0];
+            expect(cmd).toBe('aws');
+            expect(args).toEqual(expect.arrayContaining([
+                'ecs', 'execute-command',
+                '--cluster', 'myapp-cluster',
+                '--task', taskArn,
+                '--container', 'myapp-container',
+                '--interactive',
+                '--command', '/bin/sh',
+            ]));
+            expect(opts).toEqual(expect.objectContaining({ stdio: 'inherit' }));
+            expect(calls).toHaveLength(1);
+        } finally {
+            consoleSpy.mockRestore();
+        }
+    });
+
+    it('exits gracefully when no tasks are running', async () => {
+        const ecsClient = mockEcsClient({ taskArns: [], tasks: [] });
+        const spawnImpl = mockSpawnImpl([], 0);
+        const output = [];
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.join(' '));
+        });
+
+        try {
+            const result = await runExec({
+                projectName: 'myapp',
+                region: 'us-east-2',
+                ecsClient,
+                spawnImpl,
+                hasAwsCli: true,
+                hasSsmPlugin: true,
+            });
+            expect(result.ok).toBe(false);
+            expect(spawnImpl).not.toHaveBeenCalled();
+            expect(output.join('\n')).toMatch(/running container is required|No running containers/i);
+            expect(exitSpy).toHaveBeenCalledWith(1);
+        } finally {
+            consoleSpy.mockRestore();
+        }
+    });
+
+    it('fails fast with install guidance when AWS CLI is missing', async () => {
+        const ecsClient = mockEcsClient({ taskArns: ['t'], tasks: [] });
+        const spawnImpl = mockSpawnImpl([], 0);
+        const output = [];
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.join(' '));
+        });
+
+        try {
+            const result = await runExec({
+                projectName: 'myapp',
+                region: 'us-east-2',
+                ecsClient,
+                spawnImpl,
+                hasAwsCli: false,
+            });
+            expect(result.ok).toBe(false);
+            expect(spawnImpl).not.toHaveBeenCalled();
+            expect(ecsClient.send).not.toHaveBeenCalled();
+            expect(output.join('\n')).toMatch(/AWS CLI not found/);
+            expect(output.join('\n')).toMatch(/https:\/\//);
+            expect(exitSpy).toHaveBeenCalledWith(1);
+        } finally {
+            consoleSpy.mockRestore();
+        }
+    });
+
+    it('fails fast with platform guidance when the Session Manager plugin is missing', async () => {
+        const ecsClient = mockEcsClient({ taskArns: ['t'], tasks: [] });
+        const spawnImpl = mockSpawnImpl([], 0);
+        const output = [];
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.join(' '));
+        });
+
+        try {
+            const result = await runExec({
+                projectName: 'myapp',
+                region: 'us-east-2',
+                ecsClient,
+                spawnImpl,
+                hasAwsCli: true,
+                hasSsmPlugin: false,
+            });
+            expect(result.ok).toBe(false);
+            expect(result.reason).toBe('ssm-plugin-missing');
+            expect(spawnImpl).not.toHaveBeenCalled();
+            expect(ecsClient.send).not.toHaveBeenCalled();
+            expect(output.join('\n')).toMatch(/Session Manager plugin not found/);
+            expect(exitSpy).toHaveBeenCalledWith(1);
+        } finally {
+            consoleSpy.mockRestore();
+        }
+    });
+
+    it('finds a running task via ListTasks + DescribeTasks', async () => {
+        const taskArn = 'arn:task/1';
+        const ecsClient = mockEcsClient({
+            taskArns: [taskArn],
+            tasks: [{ taskArn, containers: [{ name: 'myapp-container' }] }],
+        });
+        const found = await findRunningTask(ecsClient, { cluster: 'myapp-cluster', service: 'myapp-service' });
+        expect(found.taskArn).toBe(taskArn);
+        expect(ecsClient.send).toHaveBeenCalledTimes(2);
+    });
+
+    it('returns null when no RUNNING tasks exist', async () => {
+        const ecsClient = mockEcsClient({ taskArns: [] });
+        await expect(findRunningTask(ecsClient, { cluster: 'c', service: 's' })).resolves.toBeNull();
+    });
+
+    it('is wired into bin/cli.js', () => {
+        const cliPath = path.resolve(__dirname, '../bin/cli.js');
+        const content = fs.readFileSync(cliPath, 'utf8');
+        expect(content).toContain('runExec');
+        expect(content).toContain("'exec'");
+    });
+
+    it('enables ECS Exec in Terraform templates with SSM permissions on the task role', () => {
+        const mainTf = fs.readFileSync(path.resolve(__dirname, '../templates/terraform/main.tf'), 'utf8');
+        expect(mainTf).toContain('enable_execute_command = true');
+        for (const perm of [
+            'ssmmessages:CreateControlChannel',
+            'ssmmessages:CreateDataChannel',
+            'ssmmessages:OpenControlChannel',
+            'ssmmessages:OpenDataChannel',
+        ]) {
+            expect(mainTf).toContain(perm);
+        }
+        expect(mainTf).toMatch(/resource\s+"aws_iam_role_policy"\s+"ecs_exec"/);
+        expect(mainTf).toMatch(/aws_iam_role\.task_role/);
+    });
+});
+
+describe('exec: fuzzer hardening', () => {
+    let exitSpy;
+    let consoleSpy;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { });
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+
+    afterEach(() => {
+        exitSpy.mockRestore();
+        consoleSpy.mockRestore();
+    });
+
+    it('routes unresolvable projects through PROJECT_NOT_INITIALIZED', async () => {
+        const cwdSpy = vi.spyOn(process, 'cwd').mockImplementation(() => { throw new Error('deleted'); });
+        try {
+            const result = await runExec(null);
+            expect(result).toEqual({ ok: false, reason: 'project-not-initialized' });
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            expect(trackEvent).toHaveBeenCalledWith('exec_run', expect.objectContaining({
+                success: false,
+                error_code: 'PROJECT_NOT_INITIALIZED',
+            }));
+        } finally {
+            cwdSpy.mockRestore();
+        }
+    });
+
+    it.each([null, 42, true, { port: 'string' }])('parseExecArgs(%s) returns defaults', (bad) => {
+        expect(parseExecArgs(bad)).toEqual({});
+    });
+});
+
+describe('exec on --target lambda projects', () => {
+    let exitSpy;
+    let logSpy;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { });
+        logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+
+    afterEach(() => {
+        exitSpy.mockRestore();
+        logSpy.mockRestore();
+    });
+
+    it('fails gracefully with logs guidance instead of ECS Exec', async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'exec-lambda-test-'));
+        try {
+            fs.mkdirSync(path.join(dir, 'terraform'), { recursive: true });
+            fs.writeFileSync(
+                path.join(dir, 'terraform', 'main.tf'),
+                'locals {\n  app_name = "myapp${local.env_suffix}"\n}\nresource "aws_lambda_function" "app" {}\n'
+            );
+            const result = await runExec({ cwd: dir, hasAwsCli: true, hasSsmPlugin: true });
+            expect(result).toMatchObject({ ok: false, reason: 'lambda-target-unsupported' });
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            expect(trackEvent).toHaveBeenCalledWith('exec_run', expect.objectContaining({ error_code: 'LAMBDA_TARGET_UNSUPPORTED' }));
+            expect(logSpy.mock.calls.map((call) => String(call[0])).join('\n')).toContain('npx grada-run logs');
+        } finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});