git0 0.3.35 → 0.3.36

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "git0",
     "description": "CLI tool to search GitHub repositories, download source & releases for your system, and instantly set up, then install dependencies and open code editor.",
-    "version": "0.3.35",
+    "version": "0.3.36",
     "author": "vtempest",
     "scripts": {
         "build": "bun build src/cli.ts --outdir dist --target node --format esm --sourcemap",

package/src/fm.js

@@ -4,9 +4,10 @@ import path from 'path';
 import readline from 'readline';
 import { execSync } from 'child_process';
 import os from 'os';
+import { fileURLToPath } from 'url';
 
 
-class FileManager {
+export class FileManager {
   constructor() {
     this.currentPath = process.cwd();
     this.selectedIndex = 0;
@@ -765,8 +766,8 @@ class FileManager {
     const selected = this.items[this.selectedIndex];
     
     if (selected.isDirectory) {
-      this.addToHistory(this.currentPath);
       this.currentPath = selected.fullPath;
+      this.addToHistory(this.currentPath);
       this.selectedIndex = 0;
       this.selectedItems.clear();
       await this.loadDirectory();
@@ -786,14 +787,15 @@ class FileManager {
   async goUp() {
     const parentPath = path.dirname(this.currentPath);
     if (parentPath !== this.currentPath) {
-      this.addToHistory(this.currentPath);
       this.currentPath = parentPath;
+      this.addToHistory(this.currentPath);
       this.selectedIndex = 0;
       this.selectedItems.clear();
       await this.loadDirectory();
     }
   }
 
+  // Records the directory just navigated *to*, so back/forward can return to it.
   addToHistory(path) {
     // Remove forward history when adding new path
     this.history = this.history.slice(0, this.historyIndex + 1);
@@ -990,8 +992,8 @@ class FileManager {
       const bookmarkPath = this.bookmarks[bookmarkName];
       
       if (fs.existsSync(bookmarkPath)) {
-        this.addToHistory(this.currentPath);
         this.currentPath = bookmarkPath;
+        this.addToHistory(this.currentPath);
         this.selectedIndex = 0;
         this.selectedItems.clear();
         await this.loadDirectory();
@@ -1126,5 +1128,19 @@ class FileManager {
   }
 }
 
-var fm = new FileManager()
-fm.run()
+/**
+ * True when this file is the program being run (the `fm` bin), as opposed to
+ * being imported — so importing the class for tests doesn't take over the
+ * terminal. `realpath` on both sides because npm links bins through symlinks.
+ */
+function isMainModule() {
+  try {
+    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  new FileManager().run();
+}

package/src/github-api.ts

@@ -104,6 +104,20 @@ export function parseTarget(query: string): RepoTarget | false {
  * const repos  = await github.searchRepositories('nodejs template');
  * const dir    = await github.downloadRepo('facebook/react');
  */
+/**
+ * Coerces a `/releases` response to a plain array.
+ *
+ * `grab-api.js` hands a JSON array back as an array-like object
+ * (`{ 0: …, 1: …, data: […] }`), which has no `length`, so every
+ * `releases.length` check downstream would read as "no releases". Older
+ * versions return the bare array; accept both.
+ */
+function toReleaseList(response: any): any[] {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response?.data)) return response.data;
+  return [];
+}
+
 class GithubAPI {
   /** Default number of repository search results returned per query. */
   static DEFAULT_RESULTS_PER_PAGE = 10;
@@ -216,8 +230,8 @@ class GithubAPI {
 
       return Promise.all(
         response.items.map(async (repo: SearchResult) => {
-          const releases = await this.callGithub(
-            `/repos/${repo.owner.login}/${repo.name}/releases`
+          const releases = toReleaseList(
+            await this.callGithub(`/repos/${repo.owner.login}/${repo.name}/releases`)
           );
           const platform = getCurrentPlatform();
 
@@ -321,7 +335,7 @@ class GithubAPI {
    * const releases = await github.getReleases('microsoft', 'vscode');
    */
   async getReleases(owner: string, repo: string): Promise<CategorizedRelease[]> {
-    const releases = await this.callGithub(`/repos/${owner}/${repo}/releases`);
+    const releases = toReleaseList(await this.callGithub(`/repos/${owner}/${repo}/releases`));
     return categorizeReleasesByPlatform(releases);
   }
 
@@ -335,7 +349,7 @@ class GithubAPI {
    *   current platform (including `universal` assets).
    */
   async getCompatibleReleases(owner: string, repo: string): Promise<CategorizedRelease[]> {
-    const releases = await this.callGithub(`/repos/${owner}/${repo}/releases`);
+    const releases = toReleaseList(await this.callGithub(`/repos/${owner}/${repo}/releases`));
     return filterReleasesByPlatform(releases, getCurrentPlatform());
   }
 }

package/src/ide.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
-import { execSync, spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
+import { shell } from './utils.js';
 import type { IdeInfo } from './types.js';
 
 /**
@@ -39,7 +39,7 @@ export function getInstalledIde(): IdeInfo | null {
 
   for (const ide of SUPPORTED_IDES) {
     try {
-      execSync(probe(ide.cmd), { stdio: 'ignore' });
+      shell.execSync(probe(ide.cmd), { stdio: 'ignore' });
       return ide;
     } catch {
       continue;
@@ -96,7 +96,7 @@ function findEntryDocument(dir = '.'): string | null {
  * @internal
  */
 function spawnDetached(ide: IdeInfo, args: string[]): void {
-  spawn(ide.cmd, args, {
+  shell.spawn(ide.cmd, args, {
     detached: true,
     stdio: 'ignore',
     shell: process.platform === 'win32',

package/src/install.ts

@@ -1,6 +1,5 @@
-import { execSync } from 'child_process';
 import fs from 'fs';
-import { exec } from './utils.js';
+import { exec, shell } from './utils.js';
 
 /**
  * A detector checks whether a specific project type is present in the current
@@ -28,7 +27,7 @@ type Installer = () => void;
  */
 function bunAvailable(): boolean {
   try {
-    execSync(
+    shell.execSync(
       process.platform === 'win32' ? 'where bun' : 'command -v bun',
       { stdio: 'ignore' }
     );

package/src/utils.ts

@@ -1,7 +1,17 @@
 import chalk from 'chalk';
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 
 /** Set once the logo has been printed, so repeat calls are no-ops. */
+/**
+ * The process-spawning primitives the rest of the CLI shells out through.
+ *
+ * Routed through one object so tests can replace them: `bun test` (what CI runs
+ * for this package) supports neither `vi.mock` nor a runtime `PATH` change for
+ * `child_process`, so a seam like this is the only way to observe — rather than
+ * perform — an install or an IDE launch.
+ */
+export const shell = { execSync, spawn };
+
 let logoPrinted = false;
 
 /**
@@ -62,7 +72,7 @@ export function resetLogo(): void {
  */
 export function exec(cmd: string, showError = false): void {
   try {
-    execSync(cmd, { stdio: 'inherit' });
+    shell.execSync(cmd, { stdio: 'inherit' });
   } catch {
     if (showError) console.error(chalk.red(`❌ Failed: ${cmd}`));
   }

package/test/cli.test.ts

@@ -0,0 +1,51 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+
+/**
+ * Only the offline branch of the CLI entry is exercised here: with no
+ * arguments it prints usage and exits 1 before touching the network. The
+ * download and search branches talk to GitHub and are covered through
+ * downloadRepo / GithubAPI instead.
+ */
+describe('cli entry', () => {
+  let lines: string[];
+  let exits: Array<number | undefined>;
+  let origLog: typeof console.log;
+  let origErr: typeof console.error;
+  let origExit: typeof process.exit;
+  let origArgv: string[];
+
+  beforeEach(() => {
+    lines = [];
+    exits = [];
+    origLog = console.log;
+    origErr = console.error;
+    origExit = process.exit;
+    origArgv = process.argv;
+    console.log = (...a: unknown[]) => void lines.push(a.join(' '));
+    console.error = (...a: unknown[]) => void lines.push(a.join(' '));
+    (process as any).exit = (code?: number) => {
+      exits.push(code);
+      // First exit halts main(); the .catch handler's own exit must not throw.
+      if (exits.length === 1) throw new Error('process.exit');
+    };
+  });
+
+  afterEach(() => {
+    console.log = origLog;
+    console.error = origErr;
+    process.exit = origExit;
+    process.argv = origArgv;
+  });
+
+  test('prints usage and exits 1 when given no arguments', async () => {
+    process.argv = ['bun', 'cli.ts'];
+    await import('../src/cli.ts?no-args');
+    await new Promise((r) => setTimeout(r, 20));
+
+    const text = lines.join('\n');
+    expect(text).toContain('Usage: git0 <github-url | owner/repo[/path] | search-query>');
+    expect(text).toContain('--history-only');
+    expect(text).toContain('--mirror');
+    expect(exits[0]).toBe(1);
+  });
+});

package/test/download-package.test.ts

@@ -0,0 +1,153 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Readable } from 'stream';
+import { downloadPackage, printInstallInstructions } from '../src/download.ts';
+import { showPackageMenu, buildReleaseChoices } from '../src/package-menu.ts';
+
+/** Captures console.log / console.error output for the duration of a test. */
+function captureConsole() {
+  const lines: string[] = [];
+  const orig = { log: console.log, error: console.error };
+  console.log = (...a: unknown[]) => void lines.push(a.join(' '));
+  console.error = (...a: unknown[]) => void lines.push(a.join(' '));
+  return {
+    text: () => lines.join('\n'),
+    restore() {
+      console.log = orig.log;
+      console.error = orig.error;
+    },
+  };
+}
+
+/** Pretends to run on `platform` for both `process.platform` and `os.platform()`. */
+async function withPlatform<T>(platform: string, fn: () => T | Promise<T>): Promise<T> {
+  const original = Object.getOwnPropertyDescriptor(process, 'platform')!;
+  const originalOs = os.platform;
+  Object.defineProperty(process, 'platform', { value: platform });
+  (os as any).platform = () => platform;
+  try {
+    return await fn();
+  } finally {
+    Object.defineProperty(process, 'platform', original);
+    (os as any).platform = originalOs;
+  }
+}
+
+/** A `callGithub` stand-in that streams `body` to `onStream`, like `grab` does. */
+const fakeGithub =
+  (body: string | Error) =>
+  async (_url: string, params: { onStream: (r: ReadableStream) => Promise<void> }) => {
+    if (body instanceof Error) throw body;
+    await params.onStream(Readable.toWeb(Readable.from([Buffer.from(body)])) as ReadableStream);
+    return {};
+  };
+
+describe('downloadPackage', () => {
+  let tmp: string;
+  let con: ReturnType<typeof captureConsole>;
+
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'git0-pkg-'));
+    con = captureConsole();
+  });
+
+  afterEach(() => {
+    con.restore();
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test('streams the asset to disk and returns its path', async () => {
+    const dest = path.join(tmp, 'app.deb');
+    const result = await downloadPackage(fakeGithub('payload'), 'https://x/app.deb', dest);
+    expect(result).toBe(dest);
+    expect(fs.readFileSync(dest, 'utf8')).toBe('payload');
+    expect(con.text()).toContain('Downloaded app.deb');
+    expect(con.text()).toContain('sudo dpkg -i');
+  });
+
+  test('marks extension-less binaries executable (non-Windows)', async () => {
+    const dest = path.join(tmp, 'tool');
+    await downloadPackage(fakeGithub('#!/bin/sh\n'), 'https://x/tool', dest);
+    expect(fs.statSync(dest).mode & 0o111).not.toBe(0);
+    expect(con.text()).toContain('Made tool executable');
+    expect(con.text()).toContain('Binary is ready to use');
+  });
+
+  test('does not chmod on Windows', async () => {
+    const dest = path.join(tmp, 'tool');
+    await withPlatform('win32', () => downloadPackage(fakeGithub('x'), 'https://x/tool', dest));
+    expect(con.text()).not.toContain('executable');
+  });
+
+  test('reports and rethrows download failures', async () => {
+    const dest = path.join(tmp, 'app.deb');
+    await expect(
+      downloadPackage(fakeGithub(new Error('HTTP 404')), 'https://x/app.deb', dest)
+    ).rejects.toThrow('HTTP 404');
+    expect(con.text()).toContain('Failed to download app.deb');
+  });
+});
+
+describe('printInstallInstructions', () => {
+  let con: ReturnType<typeof captureConsole>;
+  beforeEach(() => void (con = captureConsole()));
+  afterEach(() => con.restore());
+
+  const run = async (platform: string, file: string) => {
+    await withPlatform(platform, () => printInstallInstructions(`/dl/${file}`, file));
+    return con.text();
+  };
+
+  test('Windows: exe and msi', async () => {
+    expect(await run('win32', 'a.exe')).toContain('Run the executable');
+    expect(await run('win32', 'a.msi')).toContain('msiexec /i "/dl/a.msi"');
+  });
+
+  test('Windows: other files print nothing', async () => {
+    expect(await run('win32', 'a.zip')).toBe('');
+  });
+
+  test('macOS: dmg and pkg', async () => {
+    expect(await run('darwin', 'a.dmg')).toContain('open "/dl/a.dmg"');
+    expect(await run('darwin', 'a.pkg')).toContain('sudo installer -pkg "/dl/a.pkg" -target /');
+  });
+
+  test('macOS: other files print nothing', async () => {
+    expect(await run('darwin', 'a.zip')).toBe('');
+  });
+
+  test('Linux: deb, rpm, AppImage and bare binaries', async () => {
+    expect(await run('linux', 'a.deb')).toContain('sudo dpkg -i "/dl/a.deb"');
+    expect(await run('linux', 'a.rpm')).toContain('sudo rpm -i "/dl/a.rpm"');
+    expect(await run('linux', 'a.AppImage')).toContain('chmod +x "/dl/a.AppImage"');
+    expect(await run('linux', 'bin')).toContain('sudo mv "/dl/bin" /usr/local/bin/');
+  });
+
+  test('Linux: archives print nothing', async () => {
+    expect(await run('linux', 'a.tar.gz')).toBe('');
+  });
+});
+
+describe('showPackageMenu', () => {
+  test('says so and downloads nothing when no packages are selectable', async () => {
+    const con = captureConsole();
+    let called = false;
+    try {
+      await showPackageMenu(
+        { allReleases: [] },
+        async () => {
+          called = true;
+          return '';
+        },
+        { os: 'linux', arch: 'x64', platform: 'linux' } as any
+      );
+      expect(con.text()).toContain('No packages found for download.');
+      expect(called).toBe(false);
+      expect(buildReleaseChoices([], { os: 'linux' } as any)).toEqual([]);
+    } finally {
+      con.restore();
+    }
+  });
+});

package/test/exec.test.ts

@@ -0,0 +1,38 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+import { exec } from '../src/utils.ts';
+import { installFakeShell, type FakeShell } from './helpers/fake-shell.ts';
+
+describe('exec', () => {
+  let fake: FakeShell;
+  let errors: string[];
+  let origError: typeof console.error;
+
+  beforeEach(() => {
+    errors = [];
+    origError = console.error;
+    console.error = (...a: unknown[]) => void errors.push(a.join(' '));
+  });
+
+  afterEach(() => {
+    console.error = origError;
+    fake?.restore();
+  });
+
+  test('runs the command through the shell', () => {
+    fake = installFakeShell();
+    exec('tool --flag value');
+    expect(fake.commands).toEqual(['tool --flag value']);
+  });
+
+  test('swallows failures silently by default', () => {
+    fake = installFakeShell({ failing: ['tool'] });
+    expect(() => exec('tool')).not.toThrow();
+    expect(errors).toEqual([]);
+  });
+
+  test('reports the failed command when showError is set', () => {
+    fake = installFakeShell({ failing: ['tool'] });
+    exec('tool', true);
+    expect(errors.join('\n')).toContain('Failed: tool');
+  });
+});