shadow-git 1.0.3 → 1.1.1

package/tests/core/update-check.test.ts

@@ -0,0 +1,494 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  vi,
+  type MockInstance,
+} from 'vitest';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  utimesSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const { spawnMock } = vi.hoisted(() => ({ spawnMock: vi.fn() }));
+vi.mock('node:child_process', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('node:child_process')>()),
+  spawn: spawnMock,
+}));
+
+import {
+  UPDATE_CHECK_ARG,
+  getCacheDir,
+  isNewerVersion,
+  runUpdateCheckWorker,
+  setupUpdateNotifier,
+} from '../../src/core/update-check';
+
+const HOUR = 60 * 60 * 1000;
+const ENTRY = '/opt/shadow-git/dist/cli.js';
+const REGISTRY_URL = 'https://registry.npmjs.org/-/package/shadow-git/dist-tags';
+const HANDLED_ENV = 'SGIT_UPDATE_NOTICE_HANDLED';
+
+describe('isNewerVersion', () => {
+  it('detects newer major, minor and patch versions', () => {
+    expect(isNewerVersion('1.1.1', '1.1.0')).toBe(true);
+    expect(isNewerVersion('1.2.0', '1.1.9')).toBe(true);
+    expect(isNewerVersion('2.0.0', '1.9.9')).toBe(true);
+  });
+
+  it('compares numerically, not alphabetically', () => {
+    expect(isNewerVersion('1.10.0', '1.9.0')).toBe(true);
+    expect(isNewerVersion('1.9.0', '1.10.0')).toBe(false);
+  });
+
+  it('is false for the same version', () => {
+    expect(isNewerVersion('1.1.0', '1.1.0')).toBe(false);
+  });
+
+  it('is false when the installed version is ahead of the registry', () => {
+    expect(isNewerVersion('1.0.3', '1.1.0')).toBe(false);
+  });
+
+  it('treats a release as newer than its own prerelease', () => {
+    expect(isNewerVersion('1.2.0', '1.2.0-beta.1')).toBe(true);
+    expect(isNewerVersion('1.2.0-beta.1', '1.2.0')).toBe(false);
+    expect(isNewerVersion('1.2.0-beta.1', '1.1.0')).toBe(true);
+  });
+
+  it('is false for anything that is not a version', () => {
+    expect(isNewerVersion('latest', '1.1.0')).toBe(false);
+    expect(isNewerVersion('1.2', '1.1.0')).toBe(false);
+    expect(isNewerVersion('1.2.0\n', '1.1.0')).toBe(false);
+    expect(isNewerVersion('9.9.9\x1b[31m', '1.1.0')).toBe(false);
+    expect(isNewerVersion('1.2.0', 'unknown')).toBe(false);
+  });
+});
+
+describe('update check', () => {
+  let cacheHome: string;
+  let dir: string;
+  let stderrSpy: MockInstance<typeof process.stderr.write>;
+  let child: { on: ReturnType<typeof vi.fn>; unref: ReturnType<typeof vi.fn> };
+  let exitListenersBefore: Function[];
+  const origStdoutTTY = process.stdout.isTTY;
+  const origStderrTTY = process.stderr.isTTY;
+
+  const statePath = () => join(dir, 'update-check.json');
+  const lockPath = () => join(dir, 'update-check.lock');
+
+  function writeState(state: object): void {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(statePath(), JSON.stringify(state));
+  }
+
+  function readState(): { checkedAt: number; latest: string } {
+    return JSON.parse(readFileSync(statePath(), 'utf-8'));
+  }
+
+  // One user-typed sgit invocation. The marker an earlier invocation left in
+  // this process's environment is cleared — a real one starts without it.
+  function invoke(args: string[] = ['status']): void {
+    process.env[HANDLED_ENV] = '';
+    setupUpdateNotifier('1.1.0', ENTRY, args);
+  }
+
+  // Ends the invocation: runs the 'exit' listeners it registered, once
+  function fireExit(): void {
+    for (const listener of process.listeners('exit')) {
+      if (!exitListenersBefore.includes(listener)) {
+        process.removeListener('exit', listener as () => void);
+        (listener as (code: number) => void)(0);
+      }
+    }
+  }
+
+  function printed(): string {
+    return stderrSpy.mock.calls.map((call) => String(call[0])).join('');
+  }
+
+  beforeEach(() => {
+    cacheHome = mkdtempSync(join(tmpdir(), 'sgit-update-'));
+    dir = join(cacheHome, 'shadow-git');
+    vi.stubEnv('XDG_CACHE_HOME', cacheHome);
+    vi.stubEnv('NO_UPDATE_NOTIFIER', '');
+    vi.stubEnv(HANDLED_ENV, '');
+    process.stdout.isTTY = true;
+    process.stderr.isTTY = true;
+    stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    child = { on: vi.fn(), unref: vi.fn() };
+    spawnMock.mockReset().mockReturnValue(child);
+    exitListenersBefore = process.listeners('exit');
+  });
+
+  afterEach(() => {
+    for (const listener of process.listeners('exit')) {
+      if (!exitListenersBefore.includes(listener)) {
+        process.removeListener('exit', listener as () => void);
+      }
+    }
+    process.stdout.isTTY = origStdoutTTY;
+    process.stderr.isTTY = origStderrTTY;
+    vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+    vi.unstubAllGlobals();
+    rmSync(cacheHome, { recursive: true, force: true });
+  });
+
+  // ---------------------------------------------------------------
+  // getCacheDir
+  // ---------------------------------------------------------------
+  describe('getCacheDir', () => {
+    it('uses XDG_CACHE_HOME when set', () => {
+      expect(getCacheDir()).toBe(join(cacheHome, 'shadow-git'));
+    });
+
+    it('falls back to ~/.cache when XDG_CACHE_HOME is unset or relative', () => {
+      const fallback = join(homedir(), '.cache', 'shadow-git');
+      vi.stubEnv('XDG_CACHE_HOME', '');
+      expect(getCacheDir()).toBe(fallback);
+      vi.stubEnv('XDG_CACHE_HOME', 'relative/cache');
+      expect(getCacheDir()).toBe(fallback);
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // setupUpdateNotifier — when the registry check runs
+  // ---------------------------------------------------------------
+  describe('scheduling the check', () => {
+    it('starts a detached check on the very first run', () => {
+      invoke();
+
+      expect(spawnMock).toHaveBeenCalledOnce();
+      const [command, args, options] = spawnMock.mock.calls[0];
+      expect(command).toBe(process.execPath);
+      expect(args).toEqual([ENTRY, UPDATE_CHECK_ARG]);
+      expect(options).toMatchObject({ detached: true, stdio: 'ignore' });
+      expect(child.unref).toHaveBeenCalledOnce();
+      expect(existsSync(lockPath())).toBe(true);
+    });
+
+    it('does not check again within a day of a successful check', () => {
+      writeState({ checkedAt: Date.now() - 23 * HOUR, latest: '1.1.0' });
+      invoke();
+      expect(spawnMock).not.toHaveBeenCalled();
+    });
+
+    it('checks again once a day has passed', () => {
+      writeState({ checkedAt: Date.now() - 25 * HOUR, latest: '1.1.0' });
+      invoke();
+      expect(spawnMock).toHaveBeenCalledOnce();
+    });
+
+    it('checks again when the last check is dated in the future', () => {
+      writeState({ checkedAt: Date.now() + 48 * HOUR, latest: '1.1.0' });
+      invoke();
+      expect(spawnMock).toHaveBeenCalledOnce();
+    });
+
+    it('treats a corrupt state file as never checked', () => {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(statePath(), '{ not json');
+      invoke();
+      expect(spawnMock).toHaveBeenCalledOnce();
+    });
+
+    it('does not start a second check while one is in flight', () => {
+      invoke();
+      invoke();
+      expect(spawnMock).toHaveBeenCalledOnce();
+    });
+
+    it('takes over a lock left behind by a worker that died', () => {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(lockPath(), '12345');
+      const twoMinutesAgo = (Date.now() - 2 * 60 * 1000) / 1000;
+      utimesSync(lockPath(), twoMinutesAgo, twoMinutesAgo);
+
+      invoke();
+      expect(spawnMock).toHaveBeenCalledOnce();
+    });
+
+    it('releases the lock when the worker cannot be spawned', () => {
+      spawnMock.mockImplementation(() => {
+        throw new Error('spawn EAGAIN');
+      });
+      expect(() => invoke()).not.toThrow();
+      expect(existsSync(lockPath())).toBe(false);
+    });
+
+    it('releases the lock when the worker fails to start asynchronously', () => {
+      invoke();
+      expect(existsSync(lockPath())).toBe(true);
+
+      const [event, onError] = child.on.mock.calls[0];
+      expect(event).toBe('error');
+      onError(new Error('spawn ENOENT'));
+      expect(existsSync(lockPath())).toBe(false);
+    });
+
+    it('stays out of the way when the cache directory cannot be created', () => {
+      const file = join(cacheHome, 'not-a-directory');
+      writeFileSync(file, '');
+      vi.stubEnv('XDG_CACHE_HOME', file);
+
+      expect(() => invoke()).not.toThrow();
+      expect(spawnMock).not.toHaveBeenCalled();
+      expect(() => fireExit()).not.toThrow();
+      expect(stderrSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // setupUpdateNotifier — when it does nothing at all
+  // ---------------------------------------------------------------
+  describe('disabled', () => {
+    function expectUntouched(): void {
+      expect(spawnMock).not.toHaveBeenCalled();
+      expect(process.listeners('exit')).toEqual(exitListenersBefore);
+      expect(existsSync(dir)).toBe(false);
+    }
+
+    it('does nothing when stdout is not a terminal', () => {
+      process.stdout.isTTY = false;
+      invoke();
+      expectUntouched();
+    });
+
+    it('does nothing when stderr is not a terminal', () => {
+      process.stderr.isTTY = false;
+      invoke();
+      expectUntouched();
+    });
+
+    it('does nothing when NO_UPDATE_NOTIFIER is set', () => {
+      vi.stubEnv('NO_UPDATE_NOTIFIER', '1');
+      invoke();
+      expectUntouched();
+    });
+
+    it('does nothing for the hook-driven track verify', () => {
+      invoke(['track', 'verify', '--main']);
+      expectUntouched();
+    });
+
+    it('prints no notice even when an update is known', () => {
+      writeState({ checkedAt: Date.now(), latest: '1.2.0' });
+      process.stdout.isTTY = false;
+      invoke();
+      fireExit();
+      expect(stderrSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // setupUpdateNotifier — sgit started underneath another sgit (git hooks)
+  // ---------------------------------------------------------------
+  describe('nested invocations', () => {
+    it('leaves the check and the notice to the outermost sgit', () => {
+      writeState({ checkedAt: Date.now() - 25 * HOUR, latest: '1.2.0' });
+      invoke();
+      spawnMock.mockClear();
+      const outerListeners = process.listeners('exit');
+
+      // What a hook-run `sgit track sync` does, inheriting the environment
+      setupUpdateNotifier('1.1.0', ENTRY, ['track', 'sync']);
+
+      expect(spawnMock).not.toHaveBeenCalled();
+      expect(process.listeners('exit')).toEqual(outerListeners);
+      fireExit();
+      expect(stderrSpy).toHaveBeenCalledOnce();
+    });
+
+    it('keeps nested invocations quiet even when the outer one is not interactive', () => {
+      writeState({ checkedAt: Date.now(), latest: '1.2.0' });
+      process.stdout.isTTY = false;
+      invoke();
+      process.stdout.isTTY = true;
+
+      setupUpdateNotifier('1.1.0', ENTRY, ['track', 'sync']);
+
+      fireExit();
+      expect(stderrSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // setupUpdateNotifier — the notice printed when the command ends
+  // ---------------------------------------------------------------
+  describe('notice', () => {
+    it('is printed on exit when a newer version is known', () => {
+      writeState({ checkedAt: Date.now(), latest: '1.2.0' });
+      invoke();
+      expect(stderrSpy).not.toHaveBeenCalled();
+
+      fireExit();
+
+      expect(printed()).toContain('Update available: shadow-git 1.1.0 → 1.2.0');
+      expect(printed()).toContain("Please run 'npm install -g shadow-git' to update.");
+    });
+
+    it('is printed on every run for as long as the update is available', () => {
+      writeState({ checkedAt: Date.now(), latest: '1.2.0' });
+      for (let run = 1; run <= 3; run++) {
+        invoke();
+        fireExit();
+        expect(stderrSpy).toHaveBeenCalledTimes(run);
+      }
+      // The daily check is a separate matter: no run started one
+      expect(spawnMock).not.toHaveBeenCalled();
+    });
+
+    it('does not touch the recorded check when printing', () => {
+      const state = { checkedAt: Date.now() - 2 * HOUR, latest: '1.2.0' };
+      writeState(state);
+      invoke();
+      fireExit();
+      expect(readState()).toEqual(state);
+    });
+
+    it('is still printed from the last known result while a new check is pending', () => {
+      writeState({ checkedAt: Date.now() - 25 * HOUR, latest: '1.2.0' });
+      invoke();
+      fireExit();
+      expect(spawnMock).toHaveBeenCalledOnce();
+      expect(printed()).toContain('Update available: shadow-git 1.1.0 → 1.2.0');
+    });
+
+    it('picks up a result the worker wrote while the command was running', () => {
+      invoke();
+      writeState({ checkedAt: Date.now(), latest: '1.2.0' });
+      fireExit();
+      expect(printed()).toContain('Update available: shadow-git 1.1.0 → 1.2.0');
+    });
+
+    it('is not printed when already up to date', () => {
+      writeState({ checkedAt: Date.now(), latest: '1.1.0' });
+      invoke();
+      fireExit();
+      expect(stderrSpy).not.toHaveBeenCalled();
+    });
+
+    it('is not printed when the installed version is ahead of the registry', () => {
+      writeState({ checkedAt: Date.now(), latest: '1.0.3' });
+      invoke();
+      fireExit();
+      expect(stderrSpy).not.toHaveBeenCalled();
+    });
+
+    it('is not printed before any check has completed', () => {
+      invoke();
+      fireExit();
+      expect(stderrSpy).not.toHaveBeenCalled();
+    });
+
+    it('never throws out of the exit listener', () => {
+      writeState({ checkedAt: Date.now(), latest: '1.2.0' });
+      invoke();
+      stderrSpy.mockImplementation(() => {
+        throw new Error('write EIO');
+      });
+      expect(() => fireExit()).not.toThrow();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // runUpdateCheckWorker — the detached process
+  // ---------------------------------------------------------------
+  describe('runUpdateCheckWorker', () => {
+    function stubFetch(impl: () => Promise<Response>): ReturnType<typeof vi.fn> {
+      const fetchMock = vi.fn(impl);
+      vi.stubGlobal('fetch', fetchMock);
+      return fetchMock;
+    }
+
+    const registryAnswers = (latest: string) => async () =>
+      new Response(JSON.stringify({ latest }), { status: 200 });
+
+    beforeEach(() => {
+      // The parent creates the directory and takes the lock before spawning
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(lockPath(), '12345');
+    });
+
+    it('records the latest version reported by the npm registry', async () => {
+      const fetchMock = stubFetch(registryAnswers('1.2.0'));
+      const before = Date.now();
+
+      await runUpdateCheckWorker();
+
+      expect(fetchMock).toHaveBeenCalledOnce();
+      expect(fetchMock.mock.calls[0][0]).toBe(REGISTRY_URL);
+      expect(fetchMock.mock.calls[0][1].signal).toBeInstanceOf(AbortSignal);
+      const state = readState();
+      expect(Object.keys(state).sort()).toEqual(['checkedAt', 'latest']);
+      expect(state.latest).toBe('1.2.0');
+      expect(state.checkedAt).toBeGreaterThanOrEqual(before);
+      expect(existsSync(lockPath())).toBe(false);
+    });
+
+    // Every way the check can fail must look the same: no error, no output,
+    // nothing recorded (so the next invocation tries again), lock released.
+    const failures: Record<string, () => Promise<Response>> = {
+      'there is no internet connection': async () => {
+        throw new TypeError('fetch failed');
+      },
+      'the request times out': async () => {
+        throw new DOMException('The operation timed out.', 'TimeoutError');
+      },
+      'the registry is down': async () =>
+        new Response('Service Unavailable', { status: 503 }),
+      'the registry answers with an error status': async () =>
+        new Response(JSON.stringify({ latest: '9.9.9' }), { status: 500 }),
+      'the answer is not JSON': async () =>
+        new Response('<html>captive portal</html>', { status: 200 }),
+      'the answer has no latest version': async () =>
+        new Response(JSON.stringify({ next: '2.0.0-rc.1' }), { status: 200 }),
+      'the answer is JSON null': async () => new Response('null', { status: 200 }),
+    };
+
+    for (const [name, impl] of Object.entries(failures)) {
+      it(`stays silent and records nothing when ${name}`, async () => {
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        stubFetch(impl);
+
+        await expect(runUpdateCheckWorker()).resolves.toBeUndefined();
+
+        expect(existsSync(statePath())).toBe(false);
+        expect(existsSync(lockPath())).toBe(false);
+        expect(stderrSpy).not.toHaveBeenCalled();
+        expect(errorSpy).not.toHaveBeenCalled();
+      });
+    }
+
+    it('leaves the previous result untouched when the check fails', async () => {
+      const previous = { checkedAt: Date.now() - 25 * HOUR, latest: '1.1.0' };
+      writeState(previous);
+      stubFetch(async () => {
+        throw new TypeError('fetch failed');
+      });
+
+      await runUpdateCheckWorker();
+
+      expect(readState()).toEqual(previous);
+    });
+
+    it('checks again on the next invocation after a failed check', async () => {
+      stubFetch(async () => {
+        throw new TypeError('fetch failed');
+      });
+      await runUpdateCheckWorker();
+
+      invoke();
+      expect(spawnMock).toHaveBeenCalledOnce();
+    });
+  });
+});

package/tests/helpers/guard-child.mjs

@@ -5,7 +5,7 @@
  *
  * This script directly implements the guard's cleanup mechanism using plain
  * node:fs so it can run without TypeScript transpilation. It renames
- * .gitignore → .gitignore-sgit.bat, registers signal/exit handlers, then
+ * .gitignore → .gitignore.sgit-parked, registers signal/exit handlers, then
  * exits in the specified way.
  */
 import {
@@ -20,7 +20,7 @@ import { spawnSync } from 'node:child_process';
 
 const [,, root, exitMode] = process.argv;
 const manifestPaths = ['secret/'];
-const DISABLED_NAME = '.gitignore-sgit.bat';
+const DISABLED_NAME = '.gitignore.sgit-parked';
 
 // --- Minimal guard implementation (mirrors src/core/gitignore.ts) ---
 

package/.claude/settings.local.json

@@ -1,43 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git config:*)",
-      "Bash(echo \"exit: $?\")",
-      "Bash(npm install:*)",
-      "Bash(npm run:*)",
-      "Bash(node:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(npx vitest:*)",
-      "Read(//tmp/sgit-manual-test/**)",
-      "Bash(.git/hooks/pre-commit)",
-      "Bash(echo \"HOOK EXIT: $?\")",
-      "Bash(bash -x .git/hooks/pre-commit)",
-      "Bash(npx tsc:*)",
-      "Bash(README.md:*)",
-      "Bash(src/main.py:*)",
-      "Bash(lib/utils.py:*)",
-      "Bash(lib/__init__.py:*)",
-      "Bash(tests/test_utils.py:*)",
-      "Bash(docs/guide.md:*)",
-      "Bash(src/config.py:*)",
-      "Bash(sgit --help)",
-      "Bash(sgit track:*)",
-      "Bash(/home/hayk/Projects/shadow-git/.temp/temp.md:*)",
-      "Bash(git check-ignore:*)",
-      "Bash(node -e \":*)",
-      "Bash(echo:*)",
-      "Read(//home/hayk/**)",
-      "Read(//home/hayk/.config/fish/**)",
-      "Bash(bash --version)",
-      "Bash(complete -p)",
-      "Bash(pkg-config --variable=completionsdir bash-completion)",
-      "Bash(dpkg -l bash-completion)",
-      "Bash(git diff:*)",
-      "Bash(git --git-dir=.sgit --work-tree=. diff --cached --name-only)",
-      "Bash(git --git-dir=.sgit --work-tree=. reset HEAD temp/shouldnt-track)",
-      "Bash(git --git-dir=.sgit --work-tree=. add .)",
-      "Bash(git stash:*)"
-    ]
-  }
-}

package/.temp/.sgit/COMMIT_EDITMSG

@@ -1 +0,0 @@
-sgit: initialize shadow repository

package/.temp/.sgit/HEAD

@@ -1 +0,0 @@
-ref: refs/heads/master

package/.temp/.sgit/config

@@ -1,8 +0,0 @@
-[core]
-	repositoryformatversion = 0
-	filemode = true
-	bare = false
-	worktree = /home/hayk/Projects/shadow-git/.temp
-[user]
-	name = Demo User
-	email = demo@example.com

package/.temp/.sgit/description

@@ -1 +0,0 @@
-Unnamed repository; edit this file 'description' to name the repository.

package/.temp/.sgit/hooks/applypatch-msg.sample

@@ -1,15 +0,0 @@
-#!/bin/sh
-#
-# An example hook script to check the commit log message taken by
-# applypatch from an e-mail message.
-#
-# The hook should exit with non-zero status after issuing an
-# appropriate message if it wants to stop the commit.  The hook is
-# allowed to edit the commit message file.
-#
-# To enable this hook, rename this file to "applypatch-msg".
-
-. git-sh-setup
-commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
-test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
-:

package/.temp/.sgit/hooks/commit-msg.sample

@@ -1,24 +0,0 @@
-#!/bin/sh
-#
-# An example hook script to check the commit log message.
-# Called by "git commit" with one argument, the name of the file
-# that has the commit message.  The hook should exit with non-zero
-# status after issuing an appropriate message if it wants to stop the
-# commit.  The hook is allowed to edit the commit message file.
-#
-# To enable this hook, rename this file to "commit-msg".
-
-# Uncomment the below to add a Signed-off-by line to the message.
-# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
-# hook is more suited to it.
-#
-# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
-# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
-
-# This example catches duplicate Signed-off-by lines.
-
-test "" = "$(grep '^Signed-off-by: ' "$1" |
-	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
-	echo >&2 Duplicate Signed-off-by lines.
-	exit 1
-}