xp-gate 0.5.1

package/lib/__tests__/download-skill.test.js

@@ -0,0 +1,281 @@
+/**
+ * @test download-skill
+ * @intent Verify downloadFromGitHub/downloadTarball/downloadWithRetry/downloadFile/verifyChecksum behaviors
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const crypto = require('crypto');
+const { EventEmitter } = require('events');
+const { Writable } = require('stream');
+
+/**
+ * Mock https.get with controllable behavior.
+ * opts (or array of opts for sequential calls):
+ *   - statusCode (default 200)
+ *   - body (default 'data')
+ *   - errorAfter (boolean) — emit 'error' on the request instead of responding
+ *   - redirectTo (string url) — sends 302 with location header
+ */
+function mockHttpsGet(optsOrList) {
+  const list = Array.isArray(optsOrList) ? [...optsOrList] : [optsOrList];
+  // Synchronous fake createWriteStream — the real one opens the FD asynchronously
+  // and races against downloadFile's unlinkSync(dest) in 301/302/error branches,
+  // causing ENOENT unhandled errors. The fake writes via writeFileSync (sync,
+  // file present immediately) and emits 'finish' on end().
+  vi.spyOn(fs, 'createWriteStream').mockImplementation((dest) => {
+    let buf = '';
+    try {
+      fs.writeFileSync(dest, '');
+    } catch {
+      /* dest dir may not exist; downstream code will surface that */
+    }
+    const stream = new EventEmitter();
+    stream.write = (chunk) => {
+      buf += chunk;
+      return true;
+    };
+    stream.end = () => {
+      try {
+        fs.writeFileSync(dest, buf);
+      } catch {
+        /* file may have been unlinked by source; safe to ignore */
+      }
+      process.nextTick(() => stream.emit('finish'));
+    };
+    stream.close = () => {};
+    return stream;
+  });
+
+  vi.spyOn(https, 'get').mockImplementation((url, options, cb) => {
+    const callback = typeof options === 'function' ? options : cb;
+    const req = new EventEmitter();
+    const config = list.shift() || { statusCode: 200, body: 'data' };
+    process.nextTick(() => {
+      if (config.errorAfter) {
+        req.emit('error', new Error('Network error'));
+        return;
+      }
+      const response = new EventEmitter();
+      response.statusCode = config.statusCode != null ? config.statusCode : 200;
+      response.headers = config.redirectTo ? { location: config.redirectTo } : {};
+      response.pipe = (file) => {
+        file.write(config.body != null ? config.body : 'data');
+        file.end();
+      };
+      callback(response);
+    });
+    return req;
+  });
+}
+
+describe('download-skill', () => {
+  let tmpHome, originalHome;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dl-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../download-skill')];
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(async () => {
+    vi.useRealTimers();
+    await new Promise((resolve) => setImmediate(resolve));
+    process.env.HOME = originalHome;
+    vi.restoreAllMocks();
+    if (fs.existsSync(tmpHome)) {
+      fs.rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  function cacheDir() {
+    return path.join(tmpHome, '.config', 'xp-gate', 'cache');
+  }
+
+  describe('downloadFromGitHub', () => {
+    // Flat repo name avoids '/' becoming a subdir in cacheFile (source only mkdirs CACHE_DIR root).
+    it('downloads file to cache dir and returns the path', async () => {
+      mockHttpsGet({ statusCode: 200, body: '# Skill content' });
+      const { downloadFromGitHub } = require('../download-skill');
+
+      const result = await downloadFromGitHub('flatrepo', 'skills/foo/SKILL.md');
+
+      expect(result).toBe(
+        path.join(cacheDir(), 'flatrepo-skills-foo-SKILL.md.md')
+      );
+      expect(fs.existsSync(result)).toBe(true);
+      expect(fs.readFileSync(result, 'utf8')).toBe('# Skill content');
+    });
+
+    it('creates cache directory if missing', async () => {
+      mockHttpsGet({ statusCode: 200, body: 'data' });
+      const { downloadFromGitHub } = require('../download-skill');
+
+      expect(fs.existsSync(cacheDir())).toBe(false);
+      await downloadFromGitHub('flatrepo', 'a/b');
+      expect(fs.existsSync(cacheDir())).toBe(true);
+    });
+
+    it('uses default version=main when not specified', async () => {
+      mockHttpsGet({ statusCode: 200, body: 'data' });
+      const { downloadFromGitHub } = require('../download-skill');
+      await downloadFromGitHub('flatrepo', 'path/to/file');
+      expect(https.get).toHaveBeenCalled();
+      const calledUrl = https.get.mock.calls[0][0];
+      expect(calledUrl).toContain('/main/');
+    });
+
+    it('uses custom version when specified', async () => {
+      mockHttpsGet({ statusCode: 200, body: 'data' });
+      const { downloadFromGitHub } = require('../download-skill');
+      await downloadFromGitHub('flatrepo', 'path/file', 'v1.2.3');
+      expect(https.get.mock.calls[0][0]).toContain('/v1.2.3/');
+    });
+  });
+
+  describe('downloadTarball', () => {
+    it('downloads tarball with correct filename', async () => {
+      mockHttpsGet({ statusCode: 200, body: 'tarball-bytes' });
+      const { downloadTarball } = require('../download-skill');
+
+      const result = await downloadTarball('boyingliu01/xp-gate');
+
+      expect(result).toBe(path.join(cacheDir(), 'boyingliu01-xp-gate.tgz'));
+      expect(fs.existsSync(result)).toBe(true);
+    });
+
+    it('uses default main version', async () => {
+      mockHttpsGet({ statusCode: 200, body: 'data' });
+      const { downloadTarball } = require('../download-skill');
+      await downloadTarball('user/repo');
+      expect(https.get.mock.calls[0][0]).toContain('/tarball/main');
+    });
+  });
+
+  describe('downloadWithRetry', () => {
+    it('succeeds on first try when no errors', async () => {
+      mockHttpsGet({ statusCode: 200, body: 'ok' });
+      const { downloadWithRetry } = require('../download-skill');
+
+      const dest = path.join(tmpHome, 'out.txt');
+      await downloadWithRetry('https://example.com/x', dest, 3);
+
+      expect(https.get).toHaveBeenCalledTimes(1);
+      expect(fs.readFileSync(dest, 'utf8')).toBe('ok');
+    });
+
+    it('retries and eventually succeeds (sleep delays stubbed)', async () => {
+      // Stub setTimeout so sleep() resolves immediately, without patching setImmediate.
+      vi.spyOn(global, 'setTimeout').mockImplementation((fn) => {
+        Promise.resolve().then(fn);
+        return 0;
+      });
+      mockHttpsGet([
+        { errorAfter: true },
+        { statusCode: 200, body: 'recovered' },
+      ]);
+      const { downloadWithRetry } = require('../download-skill');
+
+      const dest = path.join(tmpHome, 'retry.txt');
+      await downloadWithRetry('https://example.com/x', dest, 3);
+
+      expect(fs.readFileSync(dest, 'utf8')).toBe('recovered');
+    });
+
+    it('throws original error after exhausting retries', async () => {
+      vi.spyOn(global, 'setTimeout').mockImplementation((fn) => {
+        Promise.resolve().then(fn);
+        return 0;
+      });
+      mockHttpsGet([
+        { errorAfter: true },
+        { errorAfter: true },
+      ]);
+      const { downloadWithRetry } = require('../download-skill');
+
+      const dest = path.join(tmpHome, 'fail.txt');
+      await expect(
+        downloadWithRetry('https://example.com/x', dest, 2)
+      ).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('downloadFile (via downloadWithRetry retries=1)', () => {
+    it('follows 302 redirect to new location', async () => {
+      mockHttpsGet([
+        { statusCode: 302, redirectTo: 'https://newlocation.example.com/final' },
+        { statusCode: 200, body: 'redirected-content' },
+      ]);
+      const { downloadWithRetry } = require('../download-skill');
+
+      const dest = path.join(tmpHome, 'redirect.txt');
+      await downloadWithRetry('https://example.com/orig', dest, 1);
+
+      expect(fs.readFileSync(dest, 'utf8')).toBe('redirected-content');
+    });
+
+    it('follows 301 redirect', async () => {
+      mockHttpsGet([
+        { statusCode: 301, redirectTo: 'https://newloc.example/final' },
+        { statusCode: 200, body: 'permanent-redirect' },
+      ]);
+      const { downloadWithRetry } = require('../download-skill');
+
+      const dest = path.join(tmpHome, 'r301.txt');
+      await downloadWithRetry('https://example.com/orig', dest, 1);
+
+      expect(fs.readFileSync(dest, 'utf8')).toBe('permanent-redirect');
+    });
+
+    it('rejects with HTTP error for non-2xx/3xx status', async () => {
+      mockHttpsGet({ statusCode: 404 });
+      const { downloadWithRetry } = require('../download-skill');
+
+      const dest = path.join(tmpHome, '404.txt');
+      await expect(downloadWithRetry('https://example.com/x', dest, 1)).rejects.toThrow(
+        'HTTP 404'
+      );
+    });
+
+    it('rejects and unlinks dest on request error', async () => {
+      mockHttpsGet({ errorAfter: true });
+      const { downloadWithRetry } = require('../download-skill');
+
+      const dest = path.join(tmpHome, 'err.txt');
+      await expect(downloadWithRetry('https://example.com/x', dest, 1)).rejects.toThrow(
+        'Network error'
+      );
+      // The createWriteStream call will create the file, the error handler should unlink it
+      expect(fs.existsSync(dest)).toBe(false);
+    });
+  });
+
+  describe('verifyChecksum', () => {
+    it('does not throw when checksum matches', () => {
+      const file = path.join(tmpHome, 'data.txt');
+      const content = 'hello world';
+      fs.writeFileSync(file, content);
+      const expected = crypto.createHash('sha256').update(content).digest('hex');
+
+      const { verifyChecksum } = require('../download-skill');
+      expect(() => verifyChecksum(file, expected)).not.toThrow();
+      // File preserved
+      expect(fs.existsSync(file)).toBe(true);
+    });
+
+    it('throws and deletes file on mismatch', () => {
+      const file = path.join(tmpHome, 'bad.txt');
+      fs.writeFileSync(file, 'real-content');
+
+      const { verifyChecksum } = require('../download-skill');
+      expect(() => verifyChecksum(file, 'wrong-hash-zzz')).toThrow(/Checksum mismatch/);
+      expect(fs.existsSync(file)).toBe(false);
+    });
+  });
+});

package/lib/__tests__/init.test.js

@@ -0,0 +1,327 @@
+/**
+ * @test init
+ * @intent Verify init() correctly handles global/local installation modes, dependency checks, and config persistence
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const childProcess = require('child_process');
+
+describe('init', () => {
+  let tmpHome;
+  let tmpProject;
+  let originalHome;
+  let logSpy;
+  let warnSpy;
+  let errorSpy;
+  let execSpy;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-init-'));
+    tmpProject = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-proj-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../init')];
+    delete require.cache[require.resolve('../detect-deps.js')];
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+    fs.rmSync(tmpProject, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function skillsDir() {
+    return path.join(tmpHome, '.config', 'opencode', 'skills');
+  }
+
+  function configFile() {
+    return path.join(tmpHome, '.config', 'xp-gate', 'xp-gate.json');
+  }
+
+  function setupValidDeps() {
+    ['superpowers', 'gstack'].forEach((name) => {
+      const dir = path.join(skillsDir(), name);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(
+        path.join(dir, 'package.json'),
+        JSON.stringify({ version: '2.0.0' })
+      );
+    });
+  }
+
+  function mockExecSuccess() {
+    execSpy = vi.spyOn(childProcess, 'execSync').mockImplementation((cmd) => {
+      if (cmd === 'git rev-parse --git-dir') {
+        return path.join(tmpProject, '.git') + '\n';
+      }
+      if (cmd.includes('git config --global')) {
+        return '';
+      }
+      return '';
+    });
+  }
+
+  function mockExecGitDirOnly() {
+    execSpy = vi.spyOn(childProcess, 'execSync').mockImplementation((cmd) => {
+      if (cmd === 'git rev-parse --git-dir') {
+        return path.join(tmpProject, '.git') + '\n';
+      }
+      if (cmd.includes('git config --global')) {
+        throw new Error('git config failed');
+      }
+      return '';
+    });
+  }
+
+  function mockExecFail() {
+    execSpy = vi.spyOn(childProcess, 'execSync').mockImplementation(() => {
+      throw new Error('Not a git repo');
+    });
+  }
+
+  it('init([]) prints usage and returns 0', async () => {
+    const { init } = require('../init');
+    const result = await init([]);
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith('Choose installation mode:');
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Usage:'));
+  });
+
+  it('init([]) with valid deps logs Dependencies: OK', async () => {
+    setupValidDeps();
+    const { init } = require('../init');
+    const result = await init([]);
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith('Dependencies: OK\n');
+  });
+
+  it('init([]) with missing superpowers warns Missing dependencies', async () => {
+    const { init } = require('../init');
+    const result = await init([]);
+    expect(result).toBe(0);
+    expect(warnSpy).toHaveBeenCalledWith('Warning: Missing dependencies');
+    expect(warnSpy).toHaveBeenCalledWith('  - superpowers (required)');
+  });
+
+  it('init([]) with versionMismatch warns version detail', async () => {
+    // superpowers too old, gstack good
+    const sp = path.join(skillsDir(), 'superpowers');
+    fs.mkdirSync(sp, { recursive: true });
+    fs.writeFileSync(path.join(sp, 'package.json'), JSON.stringify({ version: '0.0.1' }));
+    const gs = path.join(skillsDir(), 'gstack');
+    fs.mkdirSync(gs, { recursive: true });
+    fs.writeFileSync(path.join(gs, 'package.json'), JSON.stringify({ version: '2.0.0' }));
+
+    const { init } = require('../init');
+    const result = await init([]);
+    expect(result).toBe(0);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('superpowers: need 1.0.0, found 0.0.1')
+    );
+  });
+
+  it('init --global creates global hooks/adapters dirs and writes config', async () => {
+    setupValidDeps();
+    mockExecSuccess();
+    const { init } = require('../init');
+    const result = await init(['--global']);
+    expect(result).toBe(0);
+    expect(fs.existsSync(path.join(tmpHome, '.config', 'xp-gate', 'hooks'))).toBe(true);
+    expect(fs.existsSync(path.join(tmpHome, '.config', 'xp-gate', 'adapters'))).toBe(true);
+    expect(fs.existsSync(configFile())).toBe(true);
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    expect(cfg.mode).toBe('global');
+    expect(cfg.lastInit).toBeDefined();
+  });
+
+  it('init --core-only fails when not in git repo (returns 1)', async () => {
+    mockExecFail();
+    const { init } = require('../init');
+    const result = await init(['--core-only']);
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: Not a git repository');
+    expect(errorSpy).toHaveBeenCalledWith('Run xp-gate init from inside a git repository');
+  });
+
+  it('init --core-only succeeds in git repo: creates hooks dir + githooks dir + config', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    const { init } = require('../init');
+    const result = await init(['--core-only']);
+    expect(result).toBe(0);
+    expect(fs.existsSync(path.join(tmpProject, 'githooks', 'adapters'))).toBe(true);
+    expect(fs.existsSync(configFile())).toBe(true);
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    expect(cfg.mode).toBe('local');
+  });
+
+  it('init --full takes the same installLocal path', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    const { init } = require('../init');
+    const result = await init(['--full']);
+    expect(result).toBe(0);
+    expect(fs.existsSync(path.join(tmpProject, 'githooks', 'adapters'))).toBe(true);
+  });
+
+  it('init --global preserves pre-existing config keys (merge)', async () => {
+    setupValidDeps();
+    mockExecSuccess();
+    fs.mkdirSync(path.dirname(configFile()), { recursive: true });
+    fs.writeFileSync(configFile(), JSON.stringify({ existing: 'data' }));
+
+    const { init } = require('../init');
+    const result = await init(['--global']);
+    expect(result).toBe(0);
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    expect(cfg.existing).toBe('data');
+    expect(cfg.mode).toBe('global');
+  });
+
+  it('init --global with corrupt JSON config overwrites with valid JSON', async () => {
+    setupValidDeps();
+    mockExecSuccess();
+    fs.mkdirSync(path.dirname(configFile()), { recursive: true });
+    fs.writeFileSync(configFile(), '{ invalid json');
+
+    const { init } = require('../init');
+    const result = await init(['--global']);
+    expect(result).toBe(0);
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    expect(cfg.mode).toBe('global');
+  });
+
+  it('init --global warns when git config --global throws', async () => {
+    setupValidDeps();
+    mockExecGitDirOnly();
+    const { init } = require('../init');
+    const result = await init(['--global']);
+    expect(result).toBe(0);
+    expect(warnSpy).toHaveBeenCalledWith('Warning: Could not set git core.hooksPath config');
+  });
+
+  it('init --global logs success messages including final summary', async () => {
+    setupValidDeps();
+    mockExecSuccess();
+    const { init } = require('../init');
+    await init(['--global']);
+    expect(logSpy).toHaveBeenCalledWith('\nGlobal setup complete!');
+    expect(logSpy).toHaveBeenCalledWith(
+      'All git repositories will now use xp-gate quality gates.'
+    );
+  });
+
+  it('init --core-only logs final installation complete', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    const { init } = require('../init');
+    await init(['--core-only']);
+    expect(logSpy).toHaveBeenCalledWith('\nInstallation complete!');
+    expect(logSpy).toHaveBeenCalledWith('Run git commit to trigger quality gates');
+  });
+
+  it('copyHooks copies pre-commit when source file exists', async () => {
+    // Write fake hooks to a temp src dir
+    // init.js uses srcDir = path.dirname(__dirname) — the src/npm-package dir.
+    // We test indirectly via setupGlobal — verify it doesn't throw and creates dest dir.
+    setupValidDeps();
+    mockExecSuccess();
+    // Pre-create a fake hooks file at the real srcDir location
+    const realSrcDir = path.dirname(path.dirname(require.resolve('../init')));
+    // realSrcDir = src/npm-package
+    const hooksSrcDir = path.join(realSrcDir, 'hooks');
+    // Don't pollute repo — just verify the dest dir is created even if hooks not present
+    const { init } = require('../init');
+    const result = await init(['--global']);
+    expect(result).toBe(0);
+    const destHooks = path.join(tmpHome, '.config', 'xp-gate', 'hooks');
+    expect(fs.existsSync(destHooks)).toBe(true);
+    // If real hooks exist in repo, they should have been copied
+    if (fs.existsSync(path.join(hooksSrcDir, 'pre-commit'))) {
+      expect(fs.existsSync(path.join(destHooks, 'pre-commit'))).toBe(true);
+    }
+  });
+
+  it('init --core-only also creates template dir under HOME', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    const { init } = require('../init');
+    const result = await init(['--core-only']);
+    expect(result).toBe(0);
+    const tplDir = path.join(tmpHome, '.config', 'opencode', 'git-hooks-template');
+    expect(fs.existsSync(tplDir)).toBe(true);
+    expect(fs.existsSync(path.join(tplDir, 'adapters'))).toBe(true);
+  });
+
+  it('init prints XP-Gate Initialization header', async () => {
+    const { init } = require('../init');
+    await init([]);
+    expect(logSpy).toHaveBeenCalledWith('XP-Gate Initialization');
+    expect(logSpy).toHaveBeenCalledWith('====================\n');
+  });
+
+  // --- injectKarpathyPrinciples tests ---
+
+  it('injectKarpathyPrinciples appends section when AGENTS.md exists without Karpathy Principles', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    setupValidDeps();
+    const agentsMd = path.join(tmpProject, 'AGENTS.md');
+    fs.writeFileSync(agentsMd, '# Project\n\nSome content.\n');
+
+    const { init } = require('../init');
+    const result = await init(['--core-only']);
+    expect(result).toBe(0);
+
+    const content = fs.readFileSync(agentsMd, 'utf8');
+    expect(content).toContain('## AI CODING DISCIPLINE (Karpathy Principles)');
+    expect(content).toContain('原则 3: Surgical Changes');
+    expect(content).toContain('原则 4: Goal-Driven Execution');
+  });
+
+  it('injectKarpathyPrinciples is idempotent — second init does not duplicate section', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    setupValidDeps();
+    const agentsMd = path.join(tmpProject, 'AGENTS.md');
+    fs.writeFileSync(agentsMd, '# Project\n\nSome content.\n');
+
+    const { init } = require('../init');
+    await init(['--core-only']);
+    await init(['--core-only']);
+
+    const content = fs.readFileSync(agentsMd, 'utf8');
+    const matches = content.match(/## AI CODING DISCIPLINE \(Karpathy Principles\)/g);
+    expect(matches).toBeTruthy();
+    expect(matches.length).toBe(1);
+  });
+
+  it('injectKarpathyPrinciples appends when AGENTS.md has reference to Karpathy but no section header', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    setupValidDeps();
+    const agentsMd = path.join(tmpProject, 'AGENTS.md');
+    fs.writeFileSync(agentsMd, '# Project\n\nSee Karpathy Principles at https://example.com\n');
+
+    const { init } = require('../init');
+    await init(['--core-only']);
+
+    const content = fs.readFileSync(agentsMd, 'utf8');
+    expect(content).toContain('## AI CODING DISCIPLINE (Karpathy Principles)');
+  });
+
+  it('injectKarpathyPrinciples skips gracefully when AGENTS.md does not exist', async () => {
+    fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+    mockExecSuccess();
+    setupValidDeps();
+    const { init } = require('../init');
+    const result = await init(['--core-only']);
+    expect(result).toBe(0);
+  });
+});