sauron-cli 1.2.0 → 1.3.0

package/OpenSpec-main/test/commands/schema.test.ts

@@ -0,0 +1,467 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+describe('schema command', () => {
+  let tempDir: string;
+  let originalCwd: string;
+  let originalEnv: NodeJS.ProcessEnv;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // Create unique temp directory for each test
+    tempDir = path.join(
+      os.tmpdir(),
+      `openspec-schema-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    );
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    // Create openspec directory structure
+    fs.mkdirSync(path.join(tempDir, 'openspec', 'schemas'), { recursive: true });
+
+    // Save original cwd and env
+    originalCwd = process.cwd();
+    originalEnv = { ...process.env };
+
+    // Change to temp directory
+    process.chdir(tempDir);
+
+    // Set XDG paths to temp to avoid polluting user directories
+    process.env.XDG_DATA_HOME = path.join(tempDir, 'xdg-data');
+    process.env.XDG_CONFIG_HOME = path.join(tempDir, 'xdg-config');
+
+    // Spy on console
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restore cwd and env
+    process.chdir(originalCwd);
+    process.env = originalEnv;
+
+    // Clean up temp directory
+    fs.rmSync(tempDir, { recursive: true, force: true });
+
+    // Restore spies
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+
+    // Reset module cache
+    vi.resetModules();
+  });
+
+  describe('schema which', () => {
+    it('should show schema resolution from package', async () => {
+      const { getSchemaDir, listSchemas } = await import(
+        '../../src/core/artifact-graph/resolver.js'
+      );
+
+      // Verify spec-driven exists in package
+      const schemas = listSchemas(tempDir);
+      expect(schemas).toContain('spec-driven');
+
+      const schemaDir = getSchemaDir('spec-driven', tempDir);
+      expect(schemaDir).not.toBeNull();
+      expect(schemaDir).toContain('schemas');
+    });
+
+    it('should detect project schema shadowing package', async () => {
+      // Create a project-local spec-driven schema
+      const projectSchemaDir = path.join(tempDir, 'openspec', 'schemas', 'spec-driven');
+      fs.mkdirSync(projectSchemaDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(projectSchemaDir, 'schema.yaml'),
+        `name: spec-driven
+version: 1
+description: Custom spec-driven
+artifacts:
+  - id: proposal
+    generates: proposal.md
+    description: Proposal
+    template: proposal.md
+`
+      );
+      fs.writeFileSync(path.join(projectSchemaDir, 'proposal.md'), '# Proposal');
+
+      const { getSchemaDir } = await import('../../src/core/artifact-graph/resolver.js');
+
+      // Should resolve to project
+      const schemaDir = getSchemaDir('spec-driven', tempDir);
+      expect(schemaDir).toBe(projectSchemaDir);
+    });
+
+    it('should list all schemas with --all flag', async () => {
+      const { listSchemas } = await import('../../src/core/artifact-graph/resolver.js');
+
+      const schemas = listSchemas(tempDir);
+      expect(schemas.length).toBeGreaterThan(0);
+      expect(schemas).toContain('spec-driven');
+    });
+  });
+
+  describe('schema validate', () => {
+    it('should validate a valid schema', async () => {
+      // Create a valid project schema
+      const schemaDir = path.join(tempDir, 'openspec', 'schemas', 'test-schema');
+      fs.mkdirSync(schemaDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(schemaDir, 'schema.yaml'),
+        `name: test-schema
+version: 1
+description: Test schema
+artifacts:
+  - id: proposal
+    generates: proposal.md
+    description: Proposal
+    template: proposal.md
+`
+      );
+      fs.writeFileSync(path.join(schemaDir, 'proposal.md'), '# Proposal Template');
+
+      const { parseSchema } = await import('../../src/core/artifact-graph/schema.js');
+      const content = fs.readFileSync(path.join(schemaDir, 'schema.yaml'), 'utf-8');
+      const schema = parseSchema(content);
+
+      expect(schema.name).toBe('test-schema');
+      expect(schema.artifacts).toHaveLength(1);
+    });
+
+    it('should detect missing template file', async () => {
+      const schemaDir = path.join(tempDir, 'openspec', 'schemas', 'bad-schema');
+      fs.mkdirSync(schemaDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(schemaDir, 'schema.yaml'),
+        `name: bad-schema
+version: 1
+description: Bad schema
+artifacts:
+  - id: proposal
+    generates: proposal.md
+    description: Proposal
+    template: missing-template.md
+`
+      );
+
+      // Template file doesn't exist, validation should report this
+      const templatePath = path.join(schemaDir, 'missing-template.md');
+      expect(fs.existsSync(templatePath)).toBe(false);
+    });
+
+    it('should detect circular dependencies', async () => {
+      const { parseSchema, SchemaValidationError } = await import(
+        '../../src/core/artifact-graph/schema.js'
+      );
+
+      const content = `name: circular-schema
+version: 1
+description: Schema with circular deps
+artifacts:
+  - id: a
+    generates: a.md
+    description: A
+    template: a.md
+    requires:
+      - b
+  - id: b
+    generates: b.md
+    description: B
+    template: b.md
+    requires:
+      - a
+`;
+
+      expect(() => parseSchema(content)).toThrow(SchemaValidationError);
+      expect(() => parseSchema(content)).toThrow(/[Cc]yclic/);
+    });
+
+    it('should detect unknown dependency reference', async () => {
+      const { parseSchema, SchemaValidationError } = await import(
+        '../../src/core/artifact-graph/schema.js'
+      );
+
+      const content = `name: bad-ref-schema
+version: 1
+description: Schema with bad ref
+artifacts:
+  - id: a
+    generates: a.md
+    description: A
+    template: a.md
+    requires:
+      - nonexistent
+`;
+
+      expect(() => parseSchema(content)).toThrow(SchemaValidationError);
+      expect(() => parseSchema(content)).toThrow(/nonexistent/);
+    });
+  });
+
+  describe('schema fork', () => {
+    it('should copy schema to project directory', async () => {
+      const { getSchemaDir } = await import('../../src/core/artifact-graph/resolver.js');
+
+      // Get the package spec-driven schema
+      const sourceDir = getSchemaDir('spec-driven', tempDir);
+      expect(sourceDir).not.toBeNull();
+
+      // Copy manually to simulate fork
+      const destDir = path.join(tempDir, 'openspec', 'schemas', 'my-custom');
+      fs.mkdirSync(destDir, { recursive: true });
+
+      // Copy files
+      const files = fs.readdirSync(sourceDir!);
+      for (const file of files) {
+        const srcPath = path.join(sourceDir!, file);
+        const destPath = path.join(destDir, file);
+        const stat = fs.statSync(srcPath);
+
+        if (stat.isFile()) {
+          fs.copyFileSync(srcPath, destPath);
+        }
+      }
+
+      // Verify destination exists
+      expect(fs.existsSync(path.join(destDir, 'schema.yaml'))).toBe(true);
+    });
+
+    it('should reject invalid schema names', () => {
+      // Test kebab-case validation
+      const isValidSchemaName = (name: string): boolean => {
+        return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name);
+      };
+
+      expect(isValidSchemaName('my-schema')).toBe(true);
+      expect(isValidSchemaName('my-schema-v2')).toBe(true);
+      expect(isValidSchemaName('schema123')).toBe(true);
+      expect(isValidSchemaName('My Schema')).toBe(false);
+      expect(isValidSchemaName('my_schema')).toBe(false);
+      expect(isValidSchemaName('MySchema')).toBe(false);
+      expect(isValidSchemaName('-my-schema')).toBe(false);
+      expect(isValidSchemaName('123schema')).toBe(false);
+    });
+  });
+
+  describe('schema init', () => {
+    it('should create schema directory with schema.yaml', async () => {
+      const schemaDir = path.join(tempDir, 'openspec', 'schemas', 'new-schema');
+      fs.mkdirSync(schemaDir, { recursive: true });
+
+      const { stringify: stringifyYaml } = await import('yaml');
+
+      const schema = {
+        name: 'new-schema',
+        version: 1,
+        description: 'A new schema',
+        artifacts: [
+          {
+            id: 'proposal',
+            generates: 'proposal.md',
+            description: 'Proposal',
+            template: 'proposal.md',
+            requires: [],
+          },
+        ],
+      };
+
+      fs.writeFileSync(path.join(schemaDir, 'schema.yaml'), stringifyYaml(schema));
+      fs.writeFileSync(path.join(schemaDir, 'proposal.md'), '# Proposal');
+
+      // Verify
+      expect(fs.existsSync(path.join(schemaDir, 'schema.yaml'))).toBe(true);
+      expect(fs.existsSync(path.join(schemaDir, 'proposal.md'))).toBe(true);
+    });
+
+    it('should validate schema name format', () => {
+      const isValidSchemaName = (name: string): boolean => {
+        return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name);
+      };
+
+      expect(isValidSchemaName('valid-name')).toBe(true);
+      expect(isValidSchemaName('Invalid Name')).toBe(false);
+    });
+
+    it('should set up artifact dependencies correctly', async () => {
+      const { parseSchema } = await import('../../src/core/artifact-graph/schema.js');
+
+      // Create schema with standard artifact chain
+      const content = `name: test-workflow
+version: 1
+description: Test workflow
+artifacts:
+  - id: proposal
+    generates: proposal.md
+    description: Proposal
+    template: proposal.md
+  - id: specs
+    generates: specs/**/*.md
+    description: Specs
+    template: specs/spec.md
+    requires:
+      - proposal
+  - id: design
+    generates: design.md
+    description: Design
+    template: design.md
+    requires:
+      - specs
+  - id: tasks
+    generates: tasks.md
+    description: Tasks
+    template: tasks.md
+    requires:
+      - design
+`;
+
+      const schema = parseSchema(content);
+      expect(schema.artifacts[0].requires).toEqual([]);
+      expect(schema.artifacts[1].requires).toEqual(['proposal']);
+      expect(schema.artifacts[2].requires).toEqual(['specs']);
+      expect(schema.artifacts[3].requires).toEqual(['design']);
+    });
+  });
+
+  describe('JSON output format', () => {
+    it('should output valid JSON for schema which', async () => {
+      const { listSchemas } = await import('../../src/core/artifact-graph/resolver.js');
+
+      const schemas = listSchemas(tempDir);
+      const jsonOutput = JSON.stringify(schemas);
+
+      expect(() => JSON.parse(jsonOutput)).not.toThrow();
+    });
+
+    it('should include expected fields in validation JSON', () => {
+      const validationResult = {
+        valid: true,
+        name: 'test-schema',
+        path: '/path/to/schema',
+        issues: [],
+      };
+
+      const json = JSON.stringify(validationResult);
+      const parsed = JSON.parse(json);
+
+      expect(parsed).toHaveProperty('valid');
+      expect(parsed).toHaveProperty('name');
+      expect(parsed).toHaveProperty('path');
+      expect(parsed).toHaveProperty('issues');
+    });
+
+    it('should include expected fields in fork JSON', () => {
+      const forkResult = {
+        forked: true,
+        source: 'spec-driven',
+        sourcePath: '/path/to/source',
+        sourceLocation: 'package',
+        destination: 'my-custom',
+        destinationPath: '/path/to/dest',
+      };
+
+      const json = JSON.stringify(forkResult);
+      const parsed = JSON.parse(json);
+
+      expect(parsed).toHaveProperty('forked');
+      expect(parsed).toHaveProperty('source');
+      expect(parsed).toHaveProperty('sourceLocation');
+      expect(parsed).toHaveProperty('destination');
+    });
+
+    it('should include expected fields in init JSON', () => {
+      const initResult = {
+        created: true,
+        path: '/path/to/schema',
+        schema: 'new-schema',
+        artifacts: ['proposal', 'specs'],
+        setAsDefault: false,
+      };
+
+      const json = JSON.stringify(initResult);
+      const parsed = JSON.parse(json);
+
+      expect(parsed).toHaveProperty('created');
+      expect(parsed).toHaveProperty('path');
+      expect(parsed).toHaveProperty('schema');
+      expect(parsed).toHaveProperty('artifacts');
+    });
+  });
+});
+
+describe('schema command shell completion registry', () => {
+  it('should have schema command in registry', async () => {
+    const { COMMAND_REGISTRY } = await import(
+      '../../src/core/completions/command-registry.js'
+    );
+
+    const schemaCmd = COMMAND_REGISTRY.find((cmd) => cmd.name === 'schema');
+    expect(schemaCmd).toBeDefined();
+    expect(schemaCmd?.description).toBe('Manage workflow schemas');
+  });
+
+  it('should have all schema subcommands in registry', async () => {
+    const { COMMAND_REGISTRY } = await import(
+      '../../src/core/completions/command-registry.js'
+    );
+
+    const schemaCmd = COMMAND_REGISTRY.find((cmd) => cmd.name === 'schema');
+    const subcommandNames = schemaCmd?.subcommands?.map((s) => s.name) ?? [];
+
+    expect(subcommandNames).toContain('which');
+    expect(subcommandNames).toContain('validate');
+    expect(subcommandNames).toContain('fork');
+    expect(subcommandNames).toContain('init');
+  });
+
+  it('should have --json flag on all subcommands', async () => {
+    const { COMMAND_REGISTRY } = await import(
+      '../../src/core/completions/command-registry.js'
+    );
+
+    const schemaCmd = COMMAND_REGISTRY.find((cmd) => cmd.name === 'schema');
+    const subcommands = schemaCmd?.subcommands ?? [];
+
+    for (const subcmd of subcommands) {
+      const flagNames = subcmd.flags?.map((f) => f.name) ?? [];
+      expect(flagNames).toContain('json');
+    }
+  });
+
+  it('should have --all flag on which subcommand', async () => {
+    const { COMMAND_REGISTRY } = await import(
+      '../../src/core/completions/command-registry.js'
+    );
+
+    const schemaCmd = COMMAND_REGISTRY.find((cmd) => cmd.name === 'schema');
+    const whichCmd = schemaCmd?.subcommands?.find((s) => s.name === 'which');
+    const flagNames = whichCmd?.flags?.map((f) => f.name) ?? [];
+
+    expect(flagNames).toContain('all');
+  });
+
+  it('should have --verbose flag on validate subcommand', async () => {
+    const { COMMAND_REGISTRY } = await import(
+      '../../src/core/completions/command-registry.js'
+    );
+
+    const schemaCmd = COMMAND_REGISTRY.find((cmd) => cmd.name === 'schema');
+    const validateCmd = schemaCmd?.subcommands?.find((s) => s.name === 'validate');
+    const flagNames = validateCmd?.flags?.map((f) => f.name) ?? [];
+
+    expect(flagNames).toContain('verbose');
+  });
+
+  it('should have --force flag on fork and init subcommands', async () => {
+    const { COMMAND_REGISTRY } = await import(
+      '../../src/core/completions/command-registry.js'
+    );
+
+    const schemaCmd = COMMAND_REGISTRY.find((cmd) => cmd.name === 'schema');
+    const forkCmd = schemaCmd?.subcommands?.find((s) => s.name === 'fork');
+    const initCmd = schemaCmd?.subcommands?.find((s) => s.name === 'init');
+
+    expect(forkCmd?.flags?.map((f) => f.name)).toContain('force');
+    expect(initCmd?.flags?.map((f) => f.name)).toContain('force');
+  });
+});

package/OpenSpec-main/test/commands/show.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+describe('top-level show command', () => {
+  const projectRoot = process.cwd();
+  const testDir = path.join(projectRoot, 'test-show-command-tmp');
+  const changesDir = path.join(testDir, 'openspec', 'changes');
+  const specsDir = path.join(testDir, 'openspec', 'specs');
+  const openspecBin = path.join(projectRoot, 'bin', 'openspec.js');
+
+
+  beforeEach(async () => {
+    await fs.mkdir(changesDir, { recursive: true });
+    await fs.mkdir(specsDir, { recursive: true });
+
+    const changeContent = `# Change: Demo\n\n## Why\nBecause reasons.\n\n## What Changes\n- **auth:** Add requirement\n`;
+    await fs.mkdir(path.join(changesDir, 'demo'), { recursive: true });
+    await fs.writeFile(path.join(changesDir, 'demo', 'proposal.md'), changeContent, 'utf-8');
+
+    const specContent = `## Purpose\nAuth spec.\n\n## Requirements\n\n### Requirement: User Authentication\nText\n`;
+    await fs.mkdir(path.join(specsDir, 'auth'), { recursive: true });
+    await fs.writeFile(path.join(specsDir, 'auth', 'spec.md'), specContent, 'utf-8');
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('prints hint and non-zero exit when no args and non-interactive', () => {
+    const originalCwd = process.cwd();
+    const originalEnv = { ...process.env };
+    try {
+      process.chdir(testDir);
+      process.env.OPEN_SPEC_INTERACTIVE = '0';
+      let err: any;
+      try {
+        execSync(`node ${openspecBin} show`, { encoding: 'utf-8' });
+      } catch (e) { err = e; }
+      expect(err).toBeDefined();
+      expect(err.status).not.toBe(0);
+      const stderr = err.stderr.toString();
+      expect(stderr).toContain('Nothing to show.');
+      expect(stderr).toContain('openspec show <item>');
+      expect(stderr).toContain('openspec change show');
+      expect(stderr).toContain('openspec spec show');
+    } finally {
+      process.chdir(originalCwd);
+      process.env = originalEnv;
+    }
+  });
+
+  it('auto-detects change id and supports --json', () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(testDir);
+      const output = execSync(`node ${openspecBin} show demo --json`, { encoding: 'utf-8' });
+      const json = JSON.parse(output);
+      expect(json.id).toBe('demo');
+      expect(Array.isArray(json.deltas)).toBe(true);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('auto-detects spec id and supports spec-only flags', () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(testDir);
+      const output = execSync(`node ${openspecBin} show auth --json --requirements`, { encoding: 'utf-8' });
+      const json = JSON.parse(output);
+      expect(json.id).toBe('auth');
+      expect(Array.isArray(json.requirements)).toBe(true);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('handles ambiguity and suggests --type', async () => {
+    // create matching spec and change named 'foo'
+    await fs.mkdir(path.join(changesDir, 'foo'), { recursive: true });
+    await fs.writeFile(path.join(changesDir, 'foo', 'proposal.md'), '# Change: Foo\n\n## Why\n\n## What Changes\n', 'utf-8');
+    await fs.mkdir(path.join(specsDir, 'foo'), { recursive: true });
+    await fs.writeFile(path.join(specsDir, 'foo', 'spec.md'), '## Purpose\n\n## Requirements\n\n### Requirement: R\nX', 'utf-8');
+
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(testDir);
+      let err: any;
+      try {
+        execSync(`node ${openspecBin} show foo`, { encoding: 'utf-8' });
+      } catch (e) { err = e; }
+      expect(err).toBeDefined();
+      expect(err.status).not.toBe(0);
+      const stderr = err.stderr.toString();
+      expect(stderr).toContain('Ambiguous item');
+      expect(stderr).toContain('--type change|spec');
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('prints nearest matches when not found', () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(testDir);
+      let err: any;
+      try {
+        execSync(`node ${openspecBin} show unknown-item`, { encoding: 'utf-8' });
+      } catch (e) { err = e; }
+      expect(err).toBeDefined();
+      expect(err.status).not.toBe(0);
+      const stderr = err.stderr.toString();
+      expect(stderr).toContain("Unknown item 'unknown-item'");
+      expect(stderr).toContain('Did you mean:');
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});
+
+

package/OpenSpec-main/test/commands/spec.interactive-show.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+describe('spec show (interactive behavior)', () => {
+  const projectRoot = process.cwd();
+  const testDir = path.join(projectRoot, 'test-spec-show-tmp');
+  const specsDir = path.join(testDir, 'openspec', 'specs');
+  const bin = path.join(projectRoot, 'bin', 'openspec.js');
+
+
+  beforeEach(async () => {
+    await fs.mkdir(specsDir, { recursive: true });
+    const content = `## Purpose\nX\n\n## Requirements\n\n### Requirement: R\nText`;
+    await fs.mkdir(path.join(specsDir, 's1'), { recursive: true });
+    await fs.writeFile(path.join(specsDir, 's1', 'spec.md'), content, 'utf-8');
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('errors when no arg and non-interactive', () => {
+    const originalCwd = process.cwd();
+    const originalEnv = { ...process.env };
+    try {
+      process.chdir(testDir);
+      process.env.OPEN_SPEC_INTERACTIVE = '0';
+      let err: any;
+      try {
+        execSync(`node ${bin} spec show`, { encoding: 'utf-8' });
+      } catch (e) { err = e; }
+      expect(err).toBeDefined();
+      expect(err.status).not.toBe(0);
+      expect(err.stderr.toString()).toContain('Missing required argument <spec-id>');
+    } finally {
+      process.chdir(originalCwd);
+      process.env = originalEnv;
+    }
+  });
+});
+
+

package/OpenSpec-main/test/commands/spec.interactive-validate.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+describe('spec validate (interactive behavior)', () => {
+  const projectRoot = process.cwd();
+  const testDir = path.join(projectRoot, 'test-spec-validate-tmp');
+  const specsDir = path.join(testDir, 'openspec', 'specs');
+  const bin = path.join(projectRoot, 'bin', 'openspec.js');
+
+
+  beforeEach(async () => {
+    await fs.mkdir(specsDir, { recursive: true });
+    const content = `## Purpose\nValid spec for interactive test.\n\n## Requirements\n\n### Requirement: X\nText`;
+    await fs.mkdir(path.join(specsDir, 's1'), { recursive: true });
+    await fs.writeFile(path.join(specsDir, 's1', 'spec.md'), content, 'utf-8');
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('errors when no arg and non-interactive', () => {
+    const originalCwd = process.cwd();
+    const originalEnv = { ...process.env };
+    try {
+      process.chdir(testDir);
+      process.env.OPEN_SPEC_INTERACTIVE = '0';
+      let err: any;
+      try {
+        execSync(`node ${bin} spec validate`, { encoding: 'utf-8' });
+      } catch (e) { err = e; }
+      expect(err).toBeDefined();
+      expect(err.status).not.toBe(0);
+      expect(err.stderr.toString()).toContain('Missing required argument <spec-id>');
+    } finally {
+      process.chdir(originalCwd);
+      process.env = originalEnv;
+    }
+  });
+});
+
+