@boyingliu01/xp-gate 0.35.22 → 0.35.24

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

@@ -17,37 +17,60 @@ function listDirs(root) {
     .sort();
 }
 
-describe('install-skill', () => {
-  let tmpHome, originalHome;
-
-  beforeEach(() => {
-    originalHome = process.env.HOME;
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-in-'));
-    process.env.HOME = tmpHome;
+/**
+ * Shared fixture for the blocks that need a throwaway HOME and a clean module
+ * cache.
+ *
+ * install-skill reads caches HOME at module load, so every test has to reset
+ * four modules and silence three console channels. Two copies of that boilerplate
+ * tripped the clone detector, and the two copies had already drifted (one
+ * afterEach waited for a pending setImmediate, the other did not) -- which is
+ * exactly how a teardown race starts. The stricter teardown wins here.
+ */
+function makeHomeFixture(prefix) {
+  const handle = { tmpHome: null, originalHome: null };
+  const MODULES = ['../install-skill', '../detect-deps', '../shared-paths', '../rollback'];
+
+  handle.dropModuleCache = () => {
+    for (const mod of MODULES) delete require.cache[require.resolve(mod)];
+  };
+
+  handle.beforeEach = () => {
+    handle.originalHome = process.env.HOME;
+    handle.tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    process.env.HOME = handle.tmpHome;
     vi.resetModules();
-    for (const mod of ['../install-skill', '../detect-deps', '../shared-paths', '../rollback']) {
-      delete require.cache[require.resolve(mod)];
-    }
+    handle.dropModuleCache();
     vi.spyOn(console, 'log').mockImplementation(() => {});
     vi.spyOn(console, 'error').mockImplementation(() => {});
     vi.spyOn(console, 'warn').mockImplementation(() => {});
-  });
+  };
 
-  afterEach(async () => {
+  handle.afterEach = async () => {
     await new Promise((resolve) => setImmediate(resolve));
-    process.env.HOME = originalHome;
+    process.env.HOME = handle.originalHome;
     vi.restoreAllMocks();
-    if (fs.existsSync(tmpHome)) {
-      fs.rmSync(tmpHome, { recursive: true, force: true });
+    if (fs.existsSync(handle.tmpHome)) {
+      fs.rmSync(handle.tmpHome, { recursive: true, force: true });
     }
-  });
+    handle.dropModuleCache();
+  };
+
+  return handle;
+}
+
+describe('install-skill', () => {
+  const fx = makeHomeFixture('xpgate-in-');
+
+  beforeEach(fx.beforeEach);
+  afterEach(fx.afterEach);
 
   function skillsDir() {
-    return path.join(tmpHome, '.config', 'opencode', 'skills');
+    return path.join(fx.tmpHome, '.config', 'opencode', 'skills');
   }
 
   function configDir() {
-    return path.join(tmpHome, '.config', 'xp-gate');
+    return path.join(fx.tmpHome, '.config', 'xp-gate');
   }
 
   function setupValidDeps() {
@@ -161,8 +184,13 @@ describe('install-skill', () => {
     expect(fs.existsSync(configFile)).toBe(true);
     const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
     expect(config.installedSkills).toHaveProperty('delphi-review');
-    // Read version dynamically from VERSION file — no hardcoded version to break on bump
-    const expectedVersion = fs.readFileSync(path.join(__dirname, '..', '..', '..', '..', 'VERSION'), 'utf8').trim();
+    // Read the version dynamically so a bump never breaks this test. The source
+    // is package.json, not the repo's VERSION: that file is a release stamp
+    // ('0.35.23.0'), is not shipped in the npm package, and resolving it from
+    // __dirname only works inside a checkout (#713).
+    const expectedVersion = JSON.parse(
+      fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8')
+    ).version;
     expect(config.installedSkills['delphi-review'].version).toBe(expectedVersion);
     expect(config.installedSkills['delphi-review'].installedAt).toMatch(/^\d{4}-/);
   });
@@ -246,3 +274,62 @@ describe('install-skill', () => {
     expect(result).toBe(0);
   });
 });
+
+// ── #713: the "unknown skill" hint must not print a fake version ─────────────
+// getCliVersion() resolved `../../../VERSION` relative to __dirname. In an
+// installed package __dirname is
+// `node_modules/@boyingliu01/xp-gate/lib`, so three levels up lands in
+// `node_modules/` -- and the package does not ship a VERSION file at all. The
+// catch therefore fed `0.0.0` to every caller that prints it, so a user seeing
+//
+//   xp-gate 0.0.0 bundles: ...
+//
+// reasonably concluded their install was broken. The version has to come from
+// the package.json the CLI is actually running out of.
+describe('install-skill #713 CLI version reporting', () => {
+  const fx = makeHomeFixture('xpgate-ver-');
+
+  beforeEach(fx.beforeEach);
+  afterEach(fx.afterEach);
+
+  /**
+   * @test REQ-713 Honest version reporting
+   * @intent An unknown-skill error must name the real package version, never 0.0.0
+   * @covers AC-713-04
+   *
+   * The repo checkout masks this bug: `<repo>/VERSION` exists, so resolving
+   * `../../../VERSION` from `src/npm-package/lib/` lands on it and looks correct.
+   * An installed package has no such luck -- npm's `files` list does not include
+   * VERSION, and three levels up from `node_modules/@boyingliu01/xp-gate/lib` is
+   * `node_modules/`. So the assertion that matters is the one that holds in the
+   * shipped layout, which is measured here by demanding the value AGREE with
+   * package.json rather than with whatever VERSION happens to sit above the tree.
+   */
+  it('AC-713-04: unknown-skill error reports the package version, not 0.0.0 and not repo VERSION', async () => {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'));
+
+    // install-skill destructures checkDeps at require time, so a spy on the
+    // module object cannot intercept it. Inject a stub into the require cache
+    // BEFORE install-skill loads -- the deps gate runs ahead of the name check,
+    // and this test measures version reporting, not dependency probing.
+    const detectPath = require.resolve('../detect-deps.js');
+    require.cache[detectPath] = {
+      id: detectPath,
+      filename: detectPath,
+      loaded: true,
+      exports: {
+        ...require('../detect-deps.js'),
+        checkDeps: async () => ({ ok: true }),
+      },
+    };
+
+    const { installSkill } = require('../install-skill');
+    const code = await installSkill('definitely-not-a-bundled-skill', { force: true });
+    expect(code).toBe(1);
+
+    const said = console.error.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(said).toMatch(/Unknown skill/);
+    expect(said).not.toContain('0.0.0');
+    expect(said).toContain(`xp-gate ${pkg.version} bundles:`);
+  });
+});

package/lib/__tests__/uninstall-global-residue.test.js

@@ -44,6 +44,21 @@ function makeHome() {
   return home;
 }
 
+/**
+ * Load a module fresh so it re-reads HOME. Every lib reads os.homedir() at call
+ * time, but a cached module still holds `GLOBAL_DIRS` values captured earlier.
+ * Shared by every describe block here: three copies of this loop tripped the
+ * clone detector, and they had to stay byte-identical to be correct.
+ */
+function freshRequire(relPath) {
+  for (const key of Object.keys(require.cache)) {
+    if (key.includes(`${path.sep}npm-package${path.sep}lib${path.sep}`)) {
+      delete require.cache[key];
+    }
+  }
+  return require(relPath);
+}
+
 /**
  * Reproduce the on-disk shape `xp-gate setup-global` leaves behind, including the
  * parts that were measured as residue in #663.
@@ -84,15 +99,6 @@ describe('uninstall --global plans the whole installation, not just hooks (#663)
    * Load a module fresh so it re-reads HOME. Every lib reads os.homedir() at call
    * time, but a cached module still holds `GLOBAL_DIRS` values captured earlier.
    */
-  function freshRequire(relPath) {
-    for (const key of Object.keys(require.cache)) {
-      if (key.includes(`${path.sep}npm-package${path.sep}lib${path.sep}`)) {
-        delete require.cache[key];
-      }
-    }
-    return require(relPath);
-  }
-
   it('AC-670-37: modules, node_modules and the manifest files are all in scope', () => {
     const { buildPlan } = freshRequire('../uninstall');
     expect(typeof buildPlan).toBe('function');
@@ -158,3 +164,218 @@ describe('uninstall --global plans the whole installation, not just hooks (#663)
     expect(names).not.toContain('edited-skill');
   });
 });
+
+// -- #714: the residue must be DELETED, not merely scheduled --------------------
+// #663 taught `buildPlan()` to list modules/, node_modules/, package.json,
+// package-lock.json and xp-gate.json, so AC-670-37 passed -- but it only ever
+// asserted those paths appear in the plan. On Windows the run still printed
+//
+//   Warning: ~/.config/xp-gate/xp-gate.json does not contain xp-gate signature - skipping
+//
+// for all three files (the two directories were deleted, because a `dir` step
+// recurses without an ownership check). The plan entries carried neither
+// `signature` nor `manifestKey`, so removeFile() reached
+// `content.includes(undefined)`, which is always false. Worst case: the
+// uninstaller had just written `"mode": "uninstalled"` into xp-gate.json and
+// then reported that file as "not xp-gate's".
+//
+// The lesson these tests encode: a residue test that only inspects the PLAN
+// cannot see a broken DELETE. Every assertion below runs the real uninstall.
+describe('uninstall --global actually removes the residue (#714)', () => {
+  let home;
+  const savedEnv = {};
+  const realArgv = process.argv;
+
+  beforeEach(() => {
+    home = makeHome();
+    savedEnv.HOME = process.env.HOME;
+    savedEnv.USERPROFILE = process.env.USERPROFILE;
+    process.env.HOME = home;
+    process.env.USERPROFILE = home;
+    process.argv = ['node', 'xp-gate', 'uninstall', '--global', '--force'];
+  });
+
+  afterEach(() => {
+    process.argv = realArgv;
+    process.env.HOME = savedEnv.HOME;
+    process.env.USERPROFILE = savedEnv.USERPROFILE;
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  function configDir() {
+    return path.join(home, '.config', 'xp-gate');
+  }
+
+  /**
+   * Seed a REAL setup-global layout: the three manifest-ish files carry the
+   * content `setup-global` writes, so a signature check has to succeed or fail
+   * on realistic input rather than on `{}`.
+   */
+  function seedRealisticInstall() {
+    for (const rel of ['hooks', 'adapters', 'modules/principles', 'node_modules/js-yaml']) {
+      fs.mkdirSync(path.join(configDir(), rel), { recursive: true });
+      fs.writeFileSync(path.join(configDir(), rel, 'index.js'), 'module.exports = {};\n');
+    }
+    fs.writeFileSync(
+      path.join(configDir(), 'package.json'),
+      JSON.stringify({ dependencies: { 'js-yaml': '^5.2.2', zod: '^4.4.3' } }, null, 2)
+    );
+    fs.writeFileSync(
+      path.join(configDir(), 'package-lock.json'),
+      JSON.stringify({ name: 'xp-gate-global', lockfileVersion: 3, packages: {} }, null, 2)
+    );
+    // `mode: 'global'` is what uninstall() reads to decide there is anything to
+    // do; without it the run exits "No xp-gate installation found" and the test
+    // would pass while touching nothing.
+    fs.writeFileSync(
+      path.join(configDir(), 'xp-gate.json'),
+      JSON.stringify(
+        {
+          lastInit: new Date().toISOString(),
+          mode: 'global',
+          manifest: { files: {} },
+        },
+        null,
+        2
+      )
+    );
+    fs.writeFileSync(path.join(configDir(), '.delphi-config.json'), '{ "active_profile": "default" }\n');
+  }
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent A file step in the residue plan must be deleted, not skipped for lack of a signature
+   * @covers AC-717-01
+   */
+  it('AC-717-01: package.json, package-lock.json and xp-gate.json are gone after uninstall', async () => {
+    seedRealisticInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    for (const file of ['package.json', 'package-lock.json']) {
+      expect(
+        fs.existsSync(path.join(configDir(), file)),
+        `${file} survived uninstall - it is xp-gate's own file, not user data`
+      ).toBe(false);
+    }
+
+    // xp-gate.json is deliberately retained: the state machine rewrites it with
+    // `mode: "uninstalled"` so a second `uninstall` is a clean no-op (AC-09).
+    // What #714 broke was not the retention but the CLAIM about it -- the run
+    // called this file "not xp-gate's" while rewriting it. AC-717-04 pins that.
+    const manifestFile = path.join(configDir(), 'xp-gate.json');
+    expect(fs.existsSync(manifestFile)).toBe(true);
+    const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    expect(manifest.mode).toBe('uninstalled');
+  });
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent The two residue directories must go too, so a later setup-global cannot reuse them
+   * @covers AC-717-02
+   */
+  it('AC-717-02: modules/ and node_modules/ are gone after uninstall', async () => {
+    seedRealisticInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    expect(fs.existsSync(path.join(configDir(), 'modules'))).toBe(false);
+    expect(fs.existsSync(path.join(configDir(), 'node_modules'))).toBe(false);
+    expect(fs.existsSync(path.join(configDir(), 'adapters'))).toBe(false);
+  });
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent User data must still survive the now-working deletion path
+   * @covers AC-717-03
+   */
+  it('AC-717-03: .delphi-config.json survives the completed uninstall', async () => {
+    seedRealisticInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    expect(fs.existsSync(path.join(configDir(), '.delphi-config.json'))).toBe(true);
+  });
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent The uninstall must not report success while leaving its own residue behind
+   * @covers AC-717-04
+   */
+  it('AC-717-04: uninstall does not warn that its own residue files are foreign', async () => {
+    seedRealisticInstall();
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      const { uninstall } = freshRequire('../uninstall');
+      await uninstall(['--global', '--force']);
+
+      const said = warnSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+      for (const file of ['package.json', 'package-lock.json', 'xp-gate.json']) {
+        expect(
+          said.includes(`${file} does not contain xp-gate signature`),
+          `uninstall disowned ${file}: ${said}`
+        ).toBe(false);
+      }
+    } finally {
+      warnSpy.mockRestore();
+      logSpy.mockRestore();
+    }
+  });
+});
+
+describe('uninstall hooks directory ownership (#714)', () => {
+  let home;
+  const savedEnv = {};
+
+  beforeEach(() => {
+    home = makeHome();
+    savedEnv.HOME = process.env.HOME;
+    savedEnv.USERPROFILE = process.env.USERPROFILE;
+    process.env.HOME = home;
+    process.env.USERPROFILE = home;
+  });
+
+  afterEach(() => {
+    process.env.HOME = savedEnv.HOME;
+    process.env.USERPROFILE = savedEnv.USERPROFILE;
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  /**
+   * @test REQ-717 Hook ownership
+   * @intent post-commit is installed by copyHooks(), so it must count as xp-gate's own
+   * @covers AC-717-05
+   */
+  it('AC-717-05: post-commit is classified as xp-gate-owned, not foreign', () => {
+    const { planHooksDirRemoval } = freshRequire('../uninstall');
+    const hooksDir = path.join(process.env.HOME, '.config', 'xp-gate', 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    // copyHooks() installs exactly these; post-commit was the one it forgot.
+    for (const f of ['pre-commit', 'pre-push', 'post-merge', 'post-commit', 'hook-module-resolution.sh']) {
+      fs.writeFileSync(path.join(hooksDir, f), '#!/bin/sh\n');
+    }
+
+    const result = planHooksDirRemoval(hooksDir);
+    const foreignNames = (result.foreign || []).map((f) => f.name);
+    expect(foreignNames).not.toContain('post-commit');
+  });
+
+  /**
+   * @test REQ-717 Hook ownership
+   * @intent A genuinely foreign hook (git-lfs) must still be protected
+   * @covers AC-717-06
+   */
+  it('AC-717-06: a third-party hook is still classified as foreign and kept', () => {
+    const { planHooksDirRemoval } = freshRequire('../uninstall');
+    const hooksDir = path.join(process.env.HOME, '.config', 'xp-gate', 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(path.join(hooksDir, 'pre-commit'), '#!/bin/sh\n');
+    fs.writeFileSync(path.join(hooksDir, 'post-checkout'), '#!/bin/sh\n# git-lfs\n');
+
+    const result = planHooksDirRemoval(hooksDir);
+    const foreignNames = (result.foreign || []).map((f) => f.name);
+    expect(foreignNames).toContain('post-checkout');
+    expect(result.action).toBe('remove-owned-only');
+  });
+});