@boyingliu01/xp-gate 0.35.23 → 0.36.0

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.
@@ -61,6 +76,40 @@ function seedGlobalInstall() {
   fs.writeFileSync(path.join(configDir, '.delphi-config.json'), '{}\n');
 }
 
+/**
+ * A REAL setup-global layout at an arbitrary config dir.
+ *
+ * The three manifest-ish files carry the content `setup-global` actually writes,
+ * so a signature check has to succeed or fail on realistic input rather than on
+ * `{}`. Shared by every block below -- the per-describe copies were identical
+ * and tripped the clone detector.
+ *
+ * @param {string} configDir the ~/.config/xp-gate directory to populate
+ */
+function seedRealisticLayout(configDir) {
+  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)
+  );
+  // User data: must survive the uninstall, and must be reported as retained.
+  fs.writeFileSync(path.join(configDir, '.delphi-config.json'), '{ "active_profile": "default" }\n');
+}
+
 
 describe('uninstall --global plans the whole installation, not just hooks (#663)', () => {
   let home;
@@ -84,15 +133,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 +198,348 @@ 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() {
+    seedRealisticLayout(configDir());
+  }
+
+  /**
+   * @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');
+  });
+});
+
+describe('uninstall --global does not grow the config directory (#724)', () => {
+  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');
+  }
+
+  /**
+   * Same realistic layout as the #714 block. Delegates to the file-scope helper:
+   * two copies of this body tripped the clone detector, and they had to stay
+   * byte-identical to remain correct.
+   */
+  function seedInstall() {
+    seedRealisticLayout(configDir());
+  }
+
+  function countFiles(dir) {
+    if (!fs.existsSync(dir)) return 0;
+    let n = 0;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name);
+      n += entry.isDirectory() ? countFiles(p) : 1;
+    }
+    return n;
+  }
+
+  function snapshotDirs() {
+    const base = path.join(configDir(), '.uninstall-backup');
+    if (!fs.existsSync(base)) return [];
+    return fs.readdirSync(base, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && e.name.startsWith('uninstall-'))
+      .map((e) => e.name);
+  }
+
+  /**
+   * @test REQ-724 Uninstall leaves no growing residue
+   * @intent A dependency tree has no rollback value and must not be copied into the snapshot
+   * @covers AC-724-01
+   */
+  it('AC-724-01: the rollback snapshot does not copy node_modules/ or modules/', async () => {
+    seedInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    const sessions = snapshotDirs();
+    expect(sessions.length, 'one snapshot per uninstall run').toBe(1);
+    const snap = path.join(configDir(), '.uninstall-backup', sessions[0]);
+
+    // The config is worth restoring; the dependency tree is not. Copying it was
+    // what made an uninstall write ~1000 files / 12 MB and leave the deleted
+    // directory LARGER than it found it.
+    expect(fs.existsSync(path.join(snap, 'node_modules')), 'node_modules must not be snapshotted').toBe(false);
+    expect(fs.existsSync(path.join(snap, 'modules')), 'modules must not be snapshotted').toBe(false);
+    expect(fs.existsSync(path.join(snap, 'xp-gate.json')), 'the manifest IS worth restoring').toBe(true);
+  });
+
+  /**
+   * @test REQ-724 Uninstall leaves no growing residue
+   * @intent Repeated uninstalls must not accumulate unbounded snapshots
+   * @covers AC-724-02
+   */
+  it('AC-724-02: snapshots are pruned to a bounded number', async () => {
+    const { uninstall } = freshRequire('../uninstall');
+    // Five separate setups/uninstalls in the same HOME -- the shape of a user
+    // re-running install/uninstall while debugging.
+    for (let i = 0; i < 5; i += 1) {
+      seedInstall();
+      await uninstall(['--global', '--force']);
+    }
+
+    const sessions = snapshotDirs();
+    expect(sessions.length, 'snapshots must not accumulate without bound').toBeLessThanOrEqual(3);
+
+    // Retention keeps the NEWEST snapshots. Names are `uninstall-<epoch-ms>`, so
+    // the survivors must be the highest-numbered ones -- a prune that kept the
+    // oldest would discard the recovery point the user is most likely to want.
+    const stamps = sessions.map((n) => Number(n.replace('uninstall-', '')));
+    const newest = Math.max(...stamps);
+    expect(
+      stamps.includes(newest),
+      'the most recent snapshot must survive pruning'
+    ).toBe(true);
+    // Five runs, three retained: the two oldest are the ones evicted.
+    expect(sessions.length).toBe(3);
+  });
+
+  /**
+   * @test REQ-724 Uninstall leaves no growing residue
+   * @intent Retained user data must be advertised as retained, not listed for removal
+   * @covers AC-724-03
+   */
+  it('AC-724-03: the preview puts .delphi-config.json under KEPT, not "will be removed"', async () => {
+    seedInstall();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    let said;
+    try {
+      // The spy must be installed BEFORE freshRequire. Dropping the module cache
+      // re-runs uninstall.js, and the module binds its own `console` reference at
+      // load time -- a spy taken afterwards captures nothing, so every assertion
+      // below would pass vacuously against an empty string.
+      const { uninstall } = freshRequire('../uninstall');
+      await uninstall(['--global', '--force']);
+      said = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    } finally {
+      logSpy.mockRestore();
+    }
+
+    // #724: the preview announced it would be removed and then kept it, with no
+    // mention anywhere. Anyone scripting cleanup from that preview would delete
+    // a directory they had been told was already gone.
+    const keptHeader = said.indexOf('KEPT');
+    expect(keptHeader, 'the output must name a KEPT group').toBeGreaterThan(-1);
+
+    const removedSection = said.slice(0, keptHeader);
+    expect(removedSection).not.toContain('.delphi-config.json');
+    expect(said.slice(keptHeader)).toContain('.delphi-config.json');
+    // And it is restated in the summary, which is the last thing users read.
+    expect(said).toMatch(/Kept: .*delphi-config\.json/);
+  });
+
+  /**
+   * @test REQ-724 Uninstall leaves no growing residue
+   * @intent The snapshot must not be written where deleting the config dir destroys it
+   * @covers AC-724-04
+   */
+  it('AC-724-04: the snapshot lives inside the config dir it backs up (documented tradeoff)', async () => {
+    seedInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    // Pins the CURRENT location so a future move to an out-of-tree path is a
+    // deliberate, tested change rather than a silent behaviour shift. The
+    // summary now prints the path, which is what makes it discoverable.
+    const sessions = snapshotDirs();
+    expect(sessions.length).toBe(1);
+    expect(path.join(configDir(), '.uninstall-backup', sessions[0])).toContain('.uninstall-backup');
+  });
+});

package/lib/__tests__/update-skill-flags.test.js

@@ -0,0 +1,78 @@
+/**
+ * @test REQ-725
+ * @intent `xp-gate update-skill --check` treated the flag itself as a skill name
+ *         and failed with "--check is not installed". #347 fixed exactly this for
+ *         --all and the sibling flag was left broken, so the regression is pinned
+ *         here at the CLI boundary -- where the bug was -- rather than at the
+ *         parser, which was never wrong.
+ * @covers AC-725-03
+ */
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const BIN = path.join(__dirname, '..', '..', 'bin', 'xp-gate.js');
+
+/** Run the real CLI against a throwaway HOME so no real install is touched. */
+function runCli(args, home) {
+  const env = { ...process.env, HOME: home, USERPROFILE: home };
+  return spawnSync(process.execPath, [BIN, ...args], {
+    encoding: 'utf8',
+    env,
+    timeout: 120000,
+  });
+}
+
+describe('update-skill flag parsing (#725)', () => {
+  let home;
+
+  beforeEach(() => {
+    home = fs.mkdtempSync(path.join(os.tmpdir(), 'xpg-725-cli-'));
+    // An empty but present config dir keeps the command on the update path
+    // instead of bailing out with "not installed" for the wrong reason.
+    fs.mkdirSync(path.join(home, '.config', 'xp-gate'), { recursive: true });
+    fs.writeFileSync(
+      path.join(home, '.config', 'xp-gate', 'xp-gate.json'),
+      JSON.stringify({ installedSkills: {} })
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  /**
+   * @covers AC-725-03
+   */
+  it('AC-725-03: --check is not mistaken for a skill name', () => {
+    const result = runCli(['update-skill', '--check'], home);
+    const said = `${result.stdout}\n${result.stderr}`;
+
+    // The bug printed exactly this. Anything mentioning it means the flag went
+    // through the name slot again.
+    expect(said, '--check must not be read as a skill name').not.toMatch(/--check is not installed/i);
+    // It should reach check mode instead: a listing pass, exit 0.
+    expect(result.status).toBe(0);
+  });
+
+  /**
+   * @covers AC-725-03
+   */
+  it('AC-725-03: --all --check keeps working (the combination #347 fixed)', () => {
+    const result = runCli(['update-skill', '--all', '--check'], home);
+    expect(`${result.stdout}\n${result.stderr}`).not.toMatch(/--all is not installed/i);
+    expect(result.status).toBe(0);
+  });
+
+  /**
+   * @covers AC-725-03
+   */
+  it('AC-725-03: a bare name still routes to the single-skill path', () => {
+    // A name that is not installed must be rejected BY NAME -- proof the name
+    // slot still works after the flag extraction.
+    const result = runCli(['update-skill', 'definitely-not-a-skill'], home);
+    const said = `${result.stdout}\n${result.stderr}`;
+    expect(said).toMatch(/definitely-not-a-skill/);
+  });
+});