git0 0.3.66 → 0.3.67

package/src/service/system-service.ts

@@ -0,0 +1,190 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { shell } from '../utils.js';
+
+/**
+ * Registers the git0 service with the OS so it starts at login and keeps
+ * running, and registers the `git0://` URL scheme where the OS allows a CLI to.
+ *
+ * It is a **per-user** service on every platform, not a system-wide daemon:
+ * the whole job ends in launching a desktop app, and only a process inside the
+ * user's session can do that. It also means no admin rights to install.
+ *
+ * | OS | Runs as | URL scheme |
+ * | --- | --- | --- |
+ * | Linux | `systemd --user` unit | `.desktop` handler + `xdg-mime` |
+ * | macOS | LaunchAgent | not registered — macOS delivers URLs by Apple Event to app bundles only; buttons use the HTTP endpoint |
+ * | Windows | Scheduled task at logon | `HKCU\Software\Classes\git0` |
+ */
+
+/** Paths and command the service files are generated from. */
+export interface ServiceSpec {
+  /** Absolute path of the runtime (`process.execPath`). */
+  runtime: string;
+  /** Absolute path of the git0 entry script. */
+  script: string;
+  port: number;
+  home?: string;
+}
+
+export const SERVICE_LABEL = 'org.git0.service';
+const TASK_NAME = 'git0-service';
+
+/** `systemd --user` unit. Restarts on failure; `default.target` starts it at login. */
+export function systemdUnit(spec: ServiceSpec): string {
+  return `[Unit]
+Description=git0 background install service
+After=network-online.target
+
+[Service]
+ExecStart="${spec.runtime}" "${spec.script}" --service --port=${spec.port}
+Restart=on-failure
+RestartSec=3
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+/** The `.desktop` entry that makes git0 the handler for `git0://` links on Linux. */
+export function desktopEntry(spec: ServiceSpec): string {
+  return `[Desktop Entry]
+Type=Application
+Name=git0
+Comment=Install GitHub releases from download links
+Exec="${spec.runtime}" "${spec.script}" %u
+NoDisplay=true
+Terminal=false
+MimeType=x-scheme-handler/git0;
+`;
+}
+
+const xml = (s: string) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+/** macOS LaunchAgent: runs at load, restarted if it exits. */
+export function launchAgentPlist(spec: ServiceSpec): string {
+  const logDir = path.join(spec.home ?? os.homedir(), 'Library', 'Logs');
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xml(spec.runtime)}</string>
+    <string>${xml(spec.script)}</string>
+    <string>--service</string>
+    <string>--port=${spec.port}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${xml(path.join(logDir, 'git0-service.log'))}</string>
+  <key>StandardErrorPath</key><string>${xml(path.join(logDir, 'git0-service.log'))}</string>
+</dict>
+</plist>
+`;
+}
+
+/** Windows: commands that create the logon task and the `git0://` protocol keys. */
+export function windowsCommands(spec: ServiceSpec): string[] {
+  const run = `\\"${spec.runtime}\\" \\"${spec.script}\\" --service --port=${spec.port}`;
+  const open = `\\"${spec.runtime}\\" \\"${spec.script}\\" \\"%1\\"`;
+  return [
+    `schtasks /Create /F /SC ONLOGON /RL LIMITED /TN ${TASK_NAME} /TR "${run}"`,
+    `reg add "HKCU\\Software\\Classes\\git0" /ve /d "URL:git0 Protocol" /f`,
+    `reg add "HKCU\\Software\\Classes\\git0" /v "URL Protocol" /d "" /f`,
+    `reg add "HKCU\\Software\\Classes\\git0\\shell\\open\\command" /ve /d "${open}" /f`,
+  ];
+}
+
+/** Where each OS's service file lives. */
+export function serviceFiles(home = os.homedir()) {
+  return {
+    systemdUnit: path.join(home, '.config', 'systemd', 'user', 'git0.service'),
+    desktopEntry: path.join(home, '.local', 'share', 'applications', 'git0-handler.desktop'),
+    launchAgent: path.join(home, 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`),
+  };
+}
+
+function run(cmd: string, quiet = false): boolean {
+  try {
+    shell.execSync(cmd, { stdio: quiet ? 'ignore' : 'inherit' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function write(file: string, content: string): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content);
+}
+
+/**
+ * Installs and starts the service for the current user. Returns lines to
+ * print — what was written, and anything that needs the user.
+ */
+export function installSystemService(spec: ServiceSpec, platform = process.platform): string[] {
+  const files = serviceFiles(spec.home);
+  const out: string[] = [];
+
+  if (platform === 'linux') {
+    write(files.systemdUnit, systemdUnit(spec));
+    out.push(`Wrote ${files.systemdUnit}`);
+    const started = run('systemctl --user daemon-reload', true) && run('systemctl --user enable --now git0.service', true);
+    out.push(started
+      ? 'Started git0.service (systemctl --user status git0)'
+      : 'systemd --user is not available here — run `git0 --service` from your session startup instead');
+
+    write(files.desktopEntry, desktopEntry(spec));
+    run(`xdg-mime default git0-handler.desktop x-scheme-handler/git0`, true);
+    run(`update-desktop-database ${JSON.stringify(path.dirname(files.desktopEntry))}`, true);
+    out.push('Registered git0:// links');
+    return out;
+  }
+
+  if (platform === 'darwin') {
+    write(files.launchAgent, launchAgentPlist(spec));
+    run(`launchctl unload ${JSON.stringify(files.launchAgent)}`, true);
+    out.push(run(`launchctl load -w ${JSON.stringify(files.launchAgent)}`, true)
+      ? `Loaded LaunchAgent ${SERVICE_LABEL}`
+      : `Wrote ${files.launchAgent} — load it with launchctl load -w`);
+    out.push('git0:// links are not registered on macOS; buttons reach the service over HTTP');
+    return out;
+  }
+
+  if (platform === 'win32') {
+    for (const cmd of windowsCommands(spec)) run(cmd, true);
+    out.push(`Created logon task ${TASK_NAME} and registered git0:// links`);
+    out.push(run(`schtasks /Run /TN ${TASK_NAME}`, true) ? 'Started the service' : 'Will start at next logon');
+    return out;
+  }
+
+  throw new Error(`Installing as a service is not supported on ${platform}`);
+}
+
+/** Stops the service and removes everything {@link installSystemService} added. */
+export function uninstallSystemService(platform = process.platform, home = os.homedir()): string[] {
+  const files = serviceFiles(home);
+
+  if (platform === 'linux') {
+    run('systemctl --user disable --now git0.service', true);
+    fs.rmSync(files.systemdUnit, { force: true });
+    fs.rmSync(files.desktopEntry, { force: true });
+    run('systemctl --user daemon-reload', true);
+    return ['Removed git0.service and the git0:// handler'];
+  }
+  if (platform === 'darwin') {
+    run(`launchctl unload -w ${JSON.stringify(files.launchAgent)}`, true);
+    fs.rmSync(files.launchAgent, { force: true });
+    return [`Removed LaunchAgent ${SERVICE_LABEL}`];
+  }
+  if (platform === 'win32') {
+    run(`schtasks /End /TN ${TASK_NAME}`, true);
+    run(`schtasks /Delete /F /TN ${TASK_NAME}`, true);
+    run(`reg delete "HKCU\\Software\\Classes\\git0" /f`, true);
+    return [`Removed task ${TASK_NAME} and the git0:// handler`];
+  }
+  throw new Error(`Not supported on ${platform}`);
+}

package/test/args.test.ts

@@ -41,4 +41,15 @@ describe('parseArgs', () => {
     expect(warn).toHaveBeenCalled();
     warn.mockRestore();
   });
+
+  test('reads --service with and without an action, and --port', () => {
+    expect(parseArgs(['--service']).flags.service).toBe('run');
+    expect(parseArgs(['--service=install']).flags.service).toBe('install');
+    expect(parseArgs(['--service=status', '--port=5000']).flags).toMatchObject({ service: 'status', port: 5000 });
+    expect(parseArgs([]).flags.service).toBeUndefined();
+  });
+
+  test('keeps git0:// links as positional arguments', () => {
+    expect(parseArgs(['git0://install/acme/app']).positional).toEqual(['git0://install/acme/app']);
+  });
 });

package/test/service-assets.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, test } from 'vitest';
+import {
+  assetArch,
+  assetOs,
+  installKind,
+  normalizeRepoSlug,
+  parseSchemeUrl,
+  pickAsset,
+  type RawRelease,
+} from '../src/service/assets.ts';
+import type { PlatformInfo } from '../src/types.ts';
+
+const linux: PlatformInfo = { os: 'linux', arch: 'x86_64', platform: 'linux', architecture: 'x64' };
+const linuxArm: PlatformInfo = { os: 'linux', arch: 'arm64', platform: 'linux', architecture: 'arm64' };
+const macArm: PlatformInfo = { os: 'macos', arch: 'arm64', platform: 'darwin', architecture: 'arm64' };
+const macIntel: PlatformInfo = { os: 'macos', arch: 'x86_64', platform: 'darwin', architecture: 'x64' };
+const win: PlatformInfo = { os: 'windows', arch: 'x86_64', platform: 'win32', architecture: 'x64' };
+
+const release = (tag: string, names: string[], extra: Partial<RawRelease> = {}): RawRelease => ({
+  tag_name: tag,
+  assets: names.map(name => ({ name, size: 100, browser_download_url: `https://dl/${tag}/${name}` })),
+  ...extra,
+});
+
+describe('assetOs', () => {
+  test('does not read darwin as windows', () => {
+    expect(assetOs('fzf-0.55.0-darwin_arm64.tar.gz')).toBe('macos');
+  });
+  test('reads OS from extension', () => {
+    expect(assetOs('App.Setup.1.0.exe')).toBe('windows');
+    expect(assetOs('App-1.0.dmg')).toBe('macos');
+    expect(assetOs('app_1.0_amd64.deb')).toBe('linux');
+  });
+  test('any when nothing says, ambiguous when several do', () => {
+    expect(assetOs('tool.tar.gz')).toBe('any');
+    expect(assetOs('tool-win-mac-linux.zip')).toBe('ambiguous');
+  });
+});
+
+describe('assetArch', () => {
+  test.each([
+    ['app-linux-aarch64.tar.gz', 'arm64'],
+    ['app_amd64.deb', 'x86_64'],
+    ['app-x86_64.AppImage', 'x86_64'],
+    ['app-armv7.tar.gz', 'arm'],
+    ['app-i686.exe', 'i386'],
+    ['App-universal.dmg', 'universal'],
+    ['app.tar.gz', 'unknown'],
+  ])('%s → %s', (name, arch) => {
+    expect(assetArch(name)).toBe(arch);
+  });
+});
+
+describe('installKind', () => {
+  test.each([
+    ['Obsidian-1.6.7.AppImage', 'appimage'],
+    ['a.deb', 'deb'],
+    ['a.rpm', 'rpm'],
+    ['a.dmg', 'dmg'],
+    ['a.pkg', 'pkg'],
+    ['a.exe', 'exe'],
+    ['a.msi', 'msi'],
+    ['a.tar.gz', 'archive'],
+    ['a.zip', 'archive'],
+    ['ripgrep', 'binary'],
+    ['fzf-0.55.0-linux_amd64', 'binary'],
+    ['notes.jar', null],
+  ])('%s → %s', (name, kind) => {
+    expect(installKind(name)).toBe(kind);
+  });
+});
+
+describe('pickAsset', () => {
+  const fzf = release('v0.55.0', [
+    'fzf-0.55.0-darwin_amd64.tar.gz',
+    'fzf-0.55.0-darwin_arm64.tar.gz',
+    'fzf-0.55.0-linux_amd64.tar.gz',
+    'fzf-0.55.0-linux_arm64.tar.gz',
+    'fzf-0.55.0-windows_amd64.zip',
+    'fzf_0.55.0_checksums.txt',
+  ]);
+
+  test('matches OS and architecture', () => {
+    expect(pickAsset([fzf], linux)?.name).toBe('fzf-0.55.0-linux_amd64.tar.gz');
+    expect(pickAsset([fzf], linuxArm)?.name).toBe('fzf-0.55.0-linux_arm64.tar.gz');
+    expect(pickAsset([fzf], macArm)?.name).toBe('fzf-0.55.0-darwin_arm64.tar.gz');
+    expect(pickAsset([fzf], win)?.name).toBe('fzf-0.55.0-windows_amd64.zip');
+  });
+
+  test('carries tag, url and install kind', () => {
+    expect(pickAsset([fzf], linux)).toEqual({
+      name: 'fzf-0.55.0-linux_amd64.tar.gz',
+      url: 'https://dl/v0.55.0/fzf-0.55.0-linux_amd64.tar.gz',
+      size: 100,
+      tag: 'v0.55.0',
+      kind: 'archive',
+    });
+  });
+
+  test('prefers installer formats over archives', () => {
+    const app = release('v1', [
+      'App-1.0.dmg', 'App-1.0-mac.zip', 'App-1.0.AppImage', 'app_1.0_amd64.deb',
+      'App-Setup-1.0.exe', 'App-1.0-win.zip', 'App-1.0.dmg.blockmap', 'latest.yml',
+    ]);
+    expect(pickAsset([app], macIntel)?.name).toBe('App-1.0.dmg');
+    expect(pickAsset([app], linux)?.name).toBe('App-1.0.AppImage');
+    expect(pickAsset([app], win)?.name).toBe('App-Setup-1.0.exe');
+  });
+
+  test('prefers an exact arch over an unlabelled one', () => {
+    const app = release('v1', ['app-linux.AppImage', 'app-linux-arm64.AppImage']);
+    expect(pickAsset([app], linuxArm)?.name).toBe('app-linux-arm64.AppImage');
+    expect(pickAsset([app], linux)?.name).toBe('app-linux.AppImage');
+  });
+
+  test('never picks a build for another architecture', () => {
+    const app = release('v1', ['app-linux-arm64.tar.gz']);
+    expect(pickAsset([app], linux)).toBeNull();
+  });
+
+  test('lets Apple Silicon fall back to an Intel build', () => {
+    const app = release('v1', ['app-darwin-x86_64.tar.gz']);
+    expect(pickAsset([app], macArm)?.name).toBe('app-darwin-x86_64.tar.gz');
+  });
+
+  test('takes the newest release that has a match', () => {
+    const newest = release('v2', ['app-windows.exe']);
+    const older = release('v1', ['app-linux.AppImage']);
+    expect(pickAsset([newest, older], linux)?.tag).toBe('v1');
+    expect(pickAsset([release('v3', ['a.AppImage']), older], linux)?.tag).toBe('v3');
+  });
+
+  test('skips drafts, and pre-releases while a stable one matches', () => {
+    const draft = release('v4', ['a.AppImage'], { draft: true });
+    const pre = release('v3-rc', ['a.AppImage'], { prerelease: true });
+    const stable = release('v2', ['a.AppImage']);
+    expect(pickAsset([draft, pre, stable], linux)?.tag).toBe('v2');
+    expect(pickAsset([draft, pre], linux)?.tag).toBe('v3-rc');
+  });
+
+  test('returns null when nothing fits', () => {
+    expect(pickAsset([], linux)).toBeNull();
+    expect(pickAsset([release('v1', ['source.tar.gz', 'SHA256SUMS'])], linux)).toBeNull();
+  });
+});
+
+describe('normalizeRepoSlug', () => {
+  test.each([
+    ['junegunn/fzf', 'junegunn/fzf'],
+    ['https://github.com/junegunn/fzf', 'junegunn/fzf'],
+    ['https://github.com/junegunn/fzf/releases/latest', 'junegunn/fzf'],
+    ['github.com/junegunn/fzf.git', 'junegunn/fzf'],
+    ['git@github.com:junegunn/fzf.git', 'junegunn/fzf'],
+  ])('%s → %s', (input, slug) => {
+    expect(normalizeRepoSlug(input)).toBe(slug);
+  });
+
+  test.each(['', 'fzf', '../etc/passwd', 'a/..', 'https://evil.com/a/b', 'own er/repo', null])(
+    'rejects %p',
+    input => {
+      expect(normalizeRepoSlug(input as any)).toBeNull();
+    }
+  );
+});
+
+describe('parseSchemeUrl', () => {
+  test.each([
+    ['git0://install/junegunn/fzf', 'junegunn/fzf'],
+    ['git0://install?repo=junegunn%2Ffzf', 'junegunn/fzf'],
+    ['git0://junegunn/fzf', 'junegunn/fzf'],
+    ['git0:junegunn/fzf', 'junegunn/fzf'],
+    ['git0://install/https%3A%2F%2Fgithub.com%2Fjunegunn%2Ffzf', 'junegunn/fzf'],
+  ])('%s → %s', (link, slug) => {
+    expect(parseSchemeUrl(link)).toBe(slug);
+  });
+
+  test('rejects other schemes and junk', () => {
+    expect(parseSchemeUrl('https://github.com/junegunn/fzf')).toBeNull();
+    expect(parseSchemeUrl('git0://install/')).toBeNull();
+  });
+});

package/test/service-installer.test.ts

@@ -0,0 +1,201 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execSync } from 'child_process';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import {
+  downloadWithProgress,
+  findLaunchable,
+  installAsset,
+  openCommand,
+} from '../src/service/installer.ts';
+import {
+  desktopEntry,
+  installSystemService,
+  launchAgentPlist,
+  serviceFiles,
+  systemdUnit,
+  uninstallSystemService,
+  windowsCommands,
+} from '../src/service/system-service.ts';
+import { installFakeShell } from './helpers/fake-shell.ts';
+import type { PickedAsset } from '../src/service/assets.ts';
+
+let tmp: string;
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'git0-inst-'));
+  process.env.GIT0_HOME = path.join(tmp, 'home');
+});
+afterEach(() => {
+  delete process.env.GIT0_HOME;
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+const asset = (name: string, kind: PickedAsset['kind']): PickedAsset =>
+  ({ name, kind, url: 'https://dl/x', size: 3, tag: 'v1' });
+
+describe('downloadWithProgress', () => {
+  test('streams to disk and reports progress against content-length', async () => {
+    const chunks = [new Uint8Array([1, 2]), new Uint8Array([3, 4, 5])];
+    const fakeFetch = (async () =>
+      new Response(new ReadableStream({
+        start(c) { chunks.forEach(ch => c.enqueue(ch)); c.close(); },
+      }), { headers: { 'content-length': '5' } })) as unknown as typeof fetch;
+
+    const seen: Array<[number, number]> = [];
+    const dest = path.join(tmp, 'd', 'file.bin');
+    await downloadWithProgress('https://x', dest, (r, t) => seen.push([r, t]), 0, fakeFetch);
+
+    expect([...fs.readFileSync(dest)]).toEqual([1, 2, 3, 4, 5]);
+    expect(seen).toEqual([[0, 5], [2, 5], [5, 5]]);
+    expect(fs.existsSync(`${dest}.part`)).toBe(false);
+  });
+
+  test('throws on an HTTP error and leaves no partial file', async () => {
+    const fakeFetch = (async () => new Response('nope', { status: 404 })) as unknown as typeof fetch;
+    const dest = path.join(tmp, 'f');
+    await expect(downloadWithProgress('https://x', dest, () => {}, 0, fakeFetch)).rejects.toThrow(/404/);
+    expect(fs.existsSync(dest)).toBe(false);
+  });
+});
+
+describe('openCommand', () => {
+  test('per platform', () => {
+    expect(openCommand('/a.app', 'darwin')).toEqual({ cmd: 'open', args: ['/a.app'] });
+    expect(openCommand('C:\\a.exe', 'win32')).toEqual({ cmd: 'explorer.exe', args: ['C:\\a.exe'] });
+    expect(openCommand('/a.AppImage', 'linux')).toEqual({ cmd: '/a.AppImage', args: [] });
+  });
+});
+
+describe('findLaunchable', () => {
+  test('prefers an executable named after the repo, then the shallowest', () => {
+    const d = path.join(tmp, 'x');
+    fs.mkdirSync(path.join(d, 'bin'), { recursive: true });
+    fs.writeFileSync(path.join(d, 'README'), 'x');
+    fs.writeFileSync(path.join(d, 'helper'), 'x', { mode: 0o755 });
+    fs.writeFileSync(path.join(d, 'bin', 'my-tool'), 'x', { mode: 0o755 });
+    fs.writeFileSync(path.join(d, 'libfoo.so'), 'x', { mode: 0o755 });
+    expect(findLaunchable(d, 'my-tool', 'linux')).toBe(path.join(d, 'bin', 'my-tool'));
+    expect(findLaunchable(d, 'other', 'linux')).toBe(path.join(d, 'helper'));
+  });
+
+  test('finds a .app bundle on macOS and an .exe on Windows', () => {
+    const d = path.join(tmp, 'y');
+    fs.mkdirSync(path.join(d, 'Thing.app', 'Contents'), { recursive: true });
+    fs.writeFileSync(path.join(d, 'Thing.exe'), 'x');
+    fs.writeFileSync(path.join(d, 'unins000.exe'), 'x');
+    expect(findLaunchable(d, 'thing', 'darwin')).toBe(path.join(d, 'Thing.app'));
+    expect(findLaunchable(d, 'thing', 'win32')).toBe(path.join(d, 'Thing.exe'));
+  });
+});
+
+describe('installAsset', () => {
+  test('AppImage: copied, made executable, launched', () => {
+    const file = path.join(tmp, 'App.AppImage');
+    fs.writeFileSync(file, 'elf');
+    const res = installAsset(file, asset('App.AppImage', 'appimage'), 'acme/app');
+    expect(res.installedPath).toBe(path.join(tmp, 'home', 'apps', 'acme__app', 'App.AppImage'));
+    expect(fs.statSync(res.installedPath).mode & 0o111).toBeTruthy();
+    expect(res.launch).toEqual({ cmd: res.installedPath, args: [] });
+  });
+
+  test('bare binary: installed, not launched', () => {
+    const file = path.join(tmp, 'tool');
+    fs.writeFileSync(file, 'elf');
+    const res = installAsset(file, asset('tool', 'binary'), 'acme/tool');
+    expect(res.launch).toBeNull();
+    expect(res.message).toMatch(/command-line tool/);
+  });
+
+  test.skipIf(process.platform === 'win32')('archive: extracted, and the CLI inside located', () => {
+    const src = path.join(tmp, 'src');
+    fs.mkdirSync(path.join(src, 'tool-1.0'), { recursive: true });
+    fs.writeFileSync(path.join(src, 'tool-1.0', 'tool'), '#!/bin/sh\n', { mode: 0o755 });
+    const archive = path.join(tmp, 'tool.tar.gz');
+    execSync(`tar -czf "${archive}" -C "${src}" tool-1.0`);
+
+    const res = installAsset(archive, asset('tool.tar.gz', 'archive'), 'acme/tool');
+    expect(res.installedPath).toBe(path.join(tmp, 'home', 'apps', 'acme__tool', 'v1', 'tool-1.0', 'tool'));
+    expect(res.launch).toBeNull();
+  });
+
+  test('installers open their own UI', () => {
+    const exe = installAsset('/d/Setup.exe', asset('Setup.exe', 'exe'), 'acme/app');
+    expect(exe.launch).toEqual({ cmd: '/d/Setup.exe', args: [] });
+    const msi = installAsset('/d/a.msi', asset('a.msi', 'msi'), 'acme/app');
+    expect(msi.launch).toEqual({ cmd: 'msiexec', args: ['/i', '/d/a.msi'] });
+  });
+
+  test('deb without pkexec: downloaded, with the command to finish', () => {
+    const sh = installFakeShell({ available: [] });
+    try {
+      const res = installAsset('/d/a.deb', asset('a.deb', 'deb'), 'acme/app');
+      expect(res.launch).toBeNull();
+      expect(res.message).toContain('sudo dpkg -i "/d/a.deb"');
+      expect(sh.commands).toEqual([]);
+    } finally {
+      sh.restore();
+    }
+  });
+
+  test('deb with pkexec: installs through the graphical prompt', () => {
+    const sh = installFakeShell({ available: ['pkexec', 'app'] });
+    try {
+      const res = installAsset('/d/a.deb', asset('a.deb', 'deb'), 'acme/app');
+      expect(sh.commands).toEqual(['pkexec dpkg -i "/d/a.deb"']);
+      expect(res.launch).toEqual({ cmd: 'app', args: [] });
+    } finally {
+      sh.restore();
+    }
+  });
+});
+
+describe('system service files', () => {
+  const spec = { runtime: '/usr/bin/node', script: '/opt/git0/dist/cli.js', port: 47100, home: '/home/u' };
+
+  test('systemd unit runs the service on the port', () => {
+    const unit = systemdUnit(spec);
+    expect(unit).toContain('ExecStart="/usr/bin/node" "/opt/git0/dist/cli.js" --service --port=47100');
+    expect(unit).toContain('WantedBy=default.target');
+  });
+
+  test('desktop entry handles git0:// links', () => {
+    const entry = desktopEntry(spec);
+    expect(entry).toContain('MimeType=x-scheme-handler/git0;');
+    expect(entry).toContain('Exec="/usr/bin/node" "/opt/git0/dist/cli.js" %u');
+  });
+
+  test('LaunchAgent keeps the service alive', () => {
+    const plist = launchAgentPlist(spec);
+    expect(plist).toContain('<string>--service</string>');
+    expect(plist).toContain('<key>KeepAlive</key><true/>');
+    expect(plist).toContain('/home/u/Library/Logs/git0-service.log');
+  });
+
+  test('Windows: logon task and protocol keys under HKCU', () => {
+    const cmds = windowsCommands(spec);
+    expect(cmds[0]).toMatch(/^schtasks \/Create .*\/SC ONLOGON .*\/TN git0-service/);
+    expect(cmds.join('\n')).toContain('HKCU\\Software\\Classes\\git0');
+    expect(cmds.join('\n')).toContain('URL Protocol');
+  });
+
+  test('install and uninstall on Linux write and remove the files', () => {
+    const home = path.join(tmp, 'u');
+    const sh = installFakeShell();
+    try {
+      const out = installSystemService({ ...spec, home }, 'linux');
+      const files = serviceFiles(home);
+      expect(fs.readFileSync(files.systemdUnit, 'utf8')).toContain('--service');
+      expect(fs.existsSync(files.desktopEntry)).toBe(true);
+      expect(sh.commands).toContain('systemctl --user enable --now git0.service');
+      expect(sh.commands).toContain('xdg-mime default git0-handler.desktop x-scheme-handler/git0');
+      expect(out.join('\n')).toMatch(/Started git0.service/);
+
+      uninstallSystemService('linux', home);
+      expect(fs.existsSync(files.systemdUnit)).toBe(false);
+      expect(fs.existsSync(files.desktopEntry)).toBe(false);
+    } finally {
+      sh.restore();
+    }
+  });
+});