git0 0.2.12 → 0.2.14

package/src/package-menu.ts

@@ -0,0 +1,183 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import type { CategorizedRelease, ReleaseAsset, PlatformInfo } from './types.js';
+
+/** Emoji and display label for each supported platform key. @internal */
+const PLATFORM_META: Record<string, { emoji: string; label: string }> = {
+  windows: { emoji: '🪟', label: 'Windows'   },
+  macos:   { emoji: '🍎', label: 'macOS'     },
+  linux:   { emoji: '🐧', label: 'Linux'     },
+  universal:{ emoji: '🌐', label: 'Universal' },
+};
+
+/** Fixed display order for platform sections in the menu. @internal */
+const PLATFORM_ORDER = ['windows', 'macos', 'linux', 'universal'] as const;
+
+/**
+ * Builds the colored header line shown above each platform's asset group.
+ *
+ * The header is highlighted in green when it matches the user's current OS or
+ * is the `universal` bucket, and dimmed gray otherwise.
+ *
+ * @param platform         - Platform key, e.g. `'linux'`.
+ * @param tagName          - Release tag, e.g. `'v1.2.3'`.
+ * @param isCurrentPlatform - Whether this platform matches the running OS.
+ * @returns A formatted `inquirer` separator-style choice object.
+ *
+ * @internal
+ */
+function buildPlatformHeader(
+  platform: string,
+  tagName: string,
+  isCurrentPlatform: boolean
+): { name: string; disabled: true } {
+  const { emoji, label } = PLATFORM_META[platform];
+  const platformLabel = isCurrentPlatform
+    ? chalk.green(`${emoji} ${label} (Your Platform)`)
+    : chalk.gray(`${emoji} ${label}`);
+
+  return {
+    name: `${chalk.bold(tagName)} - ${platformLabel}`,
+    disabled: true,
+  };
+}
+
+/**
+ * Builds a selectable `inquirer` choice for a single release asset.
+ *
+ * Shows the asset filename, detected CPU architecture (when known), and size
+ * in MB. The row is white when it belongs to the current platform and gray
+ * when it belongs to a different one.
+ *
+ * @param asset             - The release asset to represent.
+ * @param isCurrentPlatform - Whether the asset's platform matches the running OS.
+ * @param release           - Parent release (included in the choice value).
+ * @returns An `inquirer` choice object with a `value` of `{ release, asset }`.
+ *
+ * @internal
+ */
+function buildAssetChoice(
+  asset: ReleaseAsset,
+  isCurrentPlatform: boolean,
+  release: CategorizedRelease
+): { name: string; value: { release: CategorizedRelease; asset: ReleaseAsset } } {
+  const sizeMB  = (asset.size / 1024 / 1024).toFixed(2);
+  const archTag = asset.detectedArch !== 'unknown' && asset.detectedArch !== 'universal'
+    ? chalk.cyan(`[${asset.detectedArch}]`)
+    : '';
+  const color   = isCurrentPlatform ? chalk.white : chalk.gray;
+
+  return {
+    name: `  ${color(`${asset.name} ${archTag} (${sizeMB} MB)`)}`,
+    value: { release, asset },
+  };
+}
+
+/**
+ * Appends a visual separator to `choices` unless the last entry is already a
+ * separator. Prevents double-separators between adjacent platform groups.
+ *
+ * @param choices - Mutable choice list to append into.
+ *
+ * @internal
+ */
+function maybeAddSeparator(choices: any[]): void {
+  const last = choices[choices.length - 1];
+  if (choices.length > 0 && !last?.name?.includes('────')) {
+    choices.push({ name: chalk.gray('────────────────────────────────'), disabled: true });
+  }
+}
+
+/**
+ * Builds the complete flat choice list for `inquirer` from a list of releases.
+ *
+ * Iterates platforms in {@link PLATFORM_ORDER}, then assets within each
+ * platform, inserting section headers and separators as it goes. Only the
+ * first `limit` releases are shown to keep the list manageable.
+ *
+ * @param releases        - Categorized release objects to render.
+ * @param currentPlatform - The user's platform, used to highlight matching rows.
+ * @param limit           - Maximum number of releases to display (default 2).
+ * @returns Flat array of `inquirer` choice objects (headers, separators, assets).
+ *
+ * @example
+ * const choices = buildReleaseChoices(repo.allReleases, getCurrentPlatform());
+ * // → [{ name: 'v1.0 - 🐧 Linux (Your Platform)', disabled: true }, { name: '  app-linux-x64 (12.34 MB)', value: … }, …]
+ */
+export function buildReleaseChoices(
+  releases: CategorizedRelease[],
+  currentPlatform: PlatformInfo,
+  limit = 2
+): any[] {
+  const choices: any[] = [];
+
+  for (const release of releases.slice(0, limit)) {
+    for (const platform of PLATFORM_ORDER) {
+      const assets = release.platformAssets[platform];
+      if (!assets?.length) continue;
+
+      const isCurrentPlatform = platform === currentPlatform.os || platform === 'universal';
+
+      maybeAddSeparator(choices);
+      choices.push(buildPlatformHeader(platform, release.tag_name, isCurrentPlatform));
+
+      for (const asset of assets) {
+        choices.push(buildAssetChoice(asset, isCurrentPlatform, release));
+      }
+    }
+  }
+
+  return choices;
+}
+
+/**
+ * Presents an interactive terminal menu of release packages grouped by
+ * platform and prompts the user to pick one to download.
+ *
+ * The menu shows up to 2 releases (configurable via {@link buildReleaseChoices})
+ * with each release's assets grouped under platform headings. The heading for
+ * the user's current OS is highlighted in green. After selection, the asset is
+ * downloaded to the current working directory.
+ *
+ * Returns early with a warning when no downloadable assets exist.
+ *
+ * @param selectedRepo   - Repo object that must include `allReleases`.
+ * @param downloadPackage - Async function that performs the actual file download.
+ * @param currentPlatform - Platform info used to highlight the matching section.
+ *
+ * @example
+ * await showPackageMenu(
+ *   selectedRepo,
+ *   github.downloadPackage.bind(github),
+ *   github.getCurrentPlatform()
+ * );
+ */
+export async function showPackageMenu(
+  selectedRepo: { allReleases: CategorizedRelease[] },
+  downloadPackage: (url: string, dest: string) => Promise<string>,
+  currentPlatform: PlatformInfo
+): Promise<void> {
+  const choices = buildReleaseChoices(selectedRepo.allReleases, currentPlatform);
+  const selectableChoices = choices.filter(c => !c.disabled);
+
+  if (selectableChoices.length === 0) {
+    console.log(chalk.yellow('No packages found for download.'));
+    return;
+  }
+
+  const { selectedPackage } = await inquirer.prompt({
+    type: 'list',
+    name: 'selectedPackage',
+    message: 'Select a package to download:',
+    choices,
+    pageSize: 15,
+  });
+
+  const downloadDir = path.resolve(process.cwd());
+  fs.mkdirSync(downloadDir, { recursive: true });
+
+  const downloadPath = path.join(downloadDir, selectedPackage.asset.name);
+  await downloadPackage(selectedPackage.asset.browser_download_url, downloadPath);
+}

package/src/platform.ts

@@ -0,0 +1,53 @@
+import os from 'os';
+import type { PlatformInfo } from './types.js';
+
+/**
+ * Maps Node.js `os.platform()` strings to canonical OS names used throughout
+ * the release-categorisation logic.
+ *
+ * @internal
+ */
+const PLATFORM_MAP: Record<string, string> = {
+  win32: 'windows',
+  darwin: 'macos',
+  linux: 'linux',
+};
+
+/**
+ * Maps Node.js `os.arch()` strings to the canonical architecture names that
+ * are matched against release-asset filenames.
+ *
+ * @internal
+ */
+const ARCH_MAP: Record<string, string> = {
+  x64: 'x86_64',
+  arm64: 'arm64',
+  arm: 'arm',
+  ia32: 'i386',
+};
+
+/**
+ * Returns normalized OS and CPU architecture information for the current machine.
+ *
+ * Node.js uses platform-specific strings (`darwin`, `win32`, `x64`) that differ
+ * from the naming conventions used in GitHub release asset filenames. This function
+ * maps them to the canonical names used by the rest of the codebase.
+ *
+ * @returns A {@link PlatformInfo} object with both canonical and raw values.
+ *
+ * @example
+ * const p = getCurrentPlatform();
+ * // Apple Silicon Mac → { os: 'macos', arch: 'arm64', platform: 'darwin', architecture: 'arm64' }
+ * // x86-64 Linux     → { os: 'linux', arch: 'x86_64', platform: 'linux',  architecture: 'x64'  }
+ */
+export function getCurrentPlatform(): PlatformInfo {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  return {
+    os: PLATFORM_MAP[platform] || platform,
+    arch: ARCH_MAP[arch] || arch,
+    platform,
+    architecture: arch,
+  };
+}

package/src/releases.ts

@@ -0,0 +1,159 @@
+import type { PlatformInfo, ReleaseAsset, PlatformAssets, CategorizedRelease } from './types.js';
+
+/**
+ * Filename substrings used to identify which operating system a release asset
+ * targets. Matching is case-insensitive and applied to the full asset filename.
+ *
+ * @internal
+ */
+const PLATFORM_KEYWORDS: Record<keyof Omit<PlatformAssets, 'universal'>, string[]> = {
+  windows: ['win', 'windows', 'win32', 'win64', '.exe', '.msi'],
+  macos: ['mac', 'macos', 'darwin', 'osx', '.dmg', '.pkg'],
+  linux: ['linux', 'ubuntu', 'debian', '.deb', '.rpm', '.tar.gz', '.AppImage'],
+};
+
+/**
+ * Filename substrings used to identify the CPU architecture of a release asset.
+ * Matching is case-insensitive and runs after platform detection.
+ *
+ * @internal
+ */
+const ARCH_KEYWORDS: Record<string, string[]> = {
+  arm64: ['aarch64', 'arm64'],   // must come before x86_64 — 'aarch64' contains '64'
+  arm:   ['armv7', 'armv6'],     // must come before bare 'arm' to avoid partial matches
+  x86_64: ['x86_64', 'amd64', 'x64'],
+  i386:  ['i386', 'x86_32'],
+};
+
+/**
+ * Detects the CPU architecture of a release asset from its filename.
+ *
+ * Iterates over {@link ARCH_KEYWORDS} in insertion order and returns the first
+ * match. Returns `'unknown'` when no keyword matches.
+ *
+ * @param name - Lowercased asset filename.
+ * @returns Canonical arch string, e.g. `'arm64'`, or `'unknown'`.
+ *
+ * @example
+ * detectArch('myapp-v1.0-linux-aarch64.tar.gz'); // → 'arm64'
+ * detectArch('myapp-v1.0-linux.tar.gz');          // → 'unknown'
+ */
+function detectArch(name: string): string {
+  for (const [arch, keys] of Object.entries(ARCH_KEYWORDS)) {
+    if (keys.some(k => name.includes(k.toLowerCase()))) return arch;
+  }
+  return 'unknown';
+}
+
+/**
+ * Determines whether an asset filename matches any known platform keyword.
+ *
+ * @param name - Lowercased asset filename.
+ * @returns `true` if at least one platform keyword is found.
+ *
+ * @internal
+ */
+function hasKnownPlatformKeyword(name: string): boolean {
+  return Object.values(PLATFORM_KEYWORDS)
+    .flat()
+    .some(kw => name.includes(kw.toLowerCase()));
+}
+
+/**
+ * Classifies a single release asset into a platform bucket and annotates it
+ * with the detected architecture.
+ *
+ * Assets that match no known platform keyword are placed into `universal` if
+ * their filename contains `'universal'` or `'all'`, or if it contains none of
+ * the three major platform words (`win`, `mac`, `linux`).
+ *
+ * @param asset - Raw GitHub release asset object.
+ * @param platformAssets - Mutable bucket object to push the asset into.
+ *
+ * @internal
+ */
+function classifyAsset(asset: ReleaseAsset, platformAssets: PlatformAssets): void {
+  const name = asset.name.toLowerCase();
+
+  // Explicit universal label wins regardless of any other keyword matches
+  // (e.g. 'app-universal.tar.gz' should not be mis-filed under linux).
+  if (name.includes('universal')) {
+    platformAssets.universal.push({ ...asset, detectedArch: 'universal', platform: 'universal' });
+    return;
+  }
+
+  let categorized = false;
+
+  for (const [platform, keywords] of Object.entries(PLATFORM_KEYWORDS)) {
+    if (keywords.some(kw => name.includes(kw.toLowerCase()))) {
+      (platformAssets as unknown as Record<string, ReleaseAsset[]>)[platform].push({
+        ...asset,
+        detectedArch: detectArch(name),
+        platform,
+      });
+      categorized = true;
+    }
+  }
+
+  if (!categorized) {
+    platformAssets.universal.push({ ...asset, detectedArch: 'universal', platform: 'universal' });
+  }
+}
+
+/**
+ * Groups every asset in each release into per-platform buckets.
+ *
+ * Releases that have no assets in any bucket are dropped from the result so
+ * the caller never sees empty entries.
+ *
+ * @param releases - Raw release array from the GitHub API.
+ * @returns Releases annotated with a `platformAssets` map. Only releases that
+ *   have at least one asset in at least one platform bucket are included.
+ *
+ * @example
+ * const categorized = categorizeReleasesByPlatform(rawReleases);
+ * categorized[0].platformAssets.linux; // → ReleaseAsset[]
+ */
+export function categorizeReleasesByPlatform(releases: any[]): CategorizedRelease[] {
+  const result: CategorizedRelease[] = [];
+
+  for (const release of Object.values(releases)) {
+    const platformAssets: PlatformAssets = { windows: [], macos: [], linux: [], universal: [] };
+
+    for (const asset of release?.assets ?? []) {
+      classifyAsset(asset, platformAssets);
+    }
+
+    if (Object.values(platformAssets).some(a => a.length > 0)) {
+      result.push({ ...release, platformAssets });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Filters a raw release list down to releases that have at least one asset
+ * compatible with the given platform.
+ *
+ * "Compatible" means the release has assets in the platform's own bucket
+ * **or** in the `universal` bucket.
+ *
+ * @param releases - Raw release array from the GitHub API.
+ * @param currentPlatform - Platform info from {@link getCurrentPlatform}.
+ * @returns Subset of categorized releases that can run on `currentPlatform`.
+ *
+ * @example
+ * const compatible = filterReleasesByPlatform(raw, getCurrentPlatform());
+ * // Only releases with linux or universal assets on a Linux machine
+ */
+export function filterReleasesByPlatform(
+  releases: any[],
+  currentPlatform: PlatformInfo
+): CategorizedRelease[] {
+  return categorizeReleasesByPlatform(releases).filter(
+    r =>
+      (r.platformAssets as unknown as Record<string, ReleaseAsset[]>)[currentPlatform.os]?.length > 0 ||
+      r.platformAssets.universal?.length > 0
+  );
+}

package/src/setup.ts

@@ -0,0 +1,9 @@
+/**
+ * Re-exports the IDE launcher and dependency installer from their dedicated
+ * modules. Kept for backwards compatibility with any code that imported from
+ * `setup.ts` directly.
+ *
+ * @module setup
+ */
+export { openInIDE } from './ide.js';
+export { installDependencies } from './install.js';

package/src/types.ts

@@ -0,0 +1,97 @@
+/**
+ * Normalized operating system and CPU architecture for the current machine.
+ * All string values are lowercased and mapped to a canonical form.
+ * @example
+ * // On an Apple Silicon Mac:
+ * // { os: 'macos', arch: 'arm64', platform: 'darwin', architecture: 'arm64' }
+ */
+export interface PlatformInfo {
+  /** Canonical OS name: `'windows'`, `'macos'`, or `'linux'`. */
+  os: string;
+  /** Canonical arch name: `'x86_64'`, `'arm64'`, `'arm'`, or `'i386'`. */
+  arch: string;
+  /** Raw `os.platform()` value, e.g. `'darwin'`, `'win32'`, `'linux'`. */
+  platform: string;
+  /** Raw `os.arch()` value, e.g. `'x64'`, `'arm64'`. */
+  architecture: string;
+}
+
+/**
+ * A single downloadable file attached to a GitHub release,
+ * extended with platform/arch fields detected from the filename.
+ */
+export interface ReleaseAsset {
+  /** Original filename as uploaded to the GitHub release. */
+  name: string;
+  /** File size in bytes. */
+  size: number;
+  /** Direct HTTPS URL to download this asset. */
+  browser_download_url: string;
+  /** Detected CPU architecture from the filename, or `'unknown'` / `'universal'`. */
+  detectedArch: string;
+  /** Detected OS platform from the filename, e.g. `'linux'` or `'universal'`. */
+  platform: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Release assets bucketed by target operating system.
+ * Assets that match no known platform keyword land in `universal`.
+ */
+export interface PlatformAssets {
+  windows: ReleaseAsset[];
+  macos: ReleaseAsset[];
+  linux: ReleaseAsset[];
+  /** Assets with no platform keyword, or explicitly labelled `universal` / `all`. */
+  universal: ReleaseAsset[];
+}
+
+/**
+ * A GitHub release object enriched with per-platform asset buckets.
+ */
+export interface CategorizedRelease {
+  /** Git tag name, e.g. `'v1.2.3'`. */
+  tag_name: string;
+  /** Assets grouped by target platform. */
+  platformAssets: PlatformAssets;
+  /** Raw asset list from the GitHub API. */
+  assets: ReleaseAsset[];
+  [key: string]: unknown;
+}
+
+/**
+ * A GitHub repository search result enriched with release availability flags.
+ */
+export interface SearchResult {
+  /** `owner/name` slug, e.g. `'facebook/react'`. */
+  full_name: string;
+  /** Repository name without owner prefix. */
+  name: string;
+  /** Short description from the repo's About field. */
+  description: string;
+  /** Total number of GitHub stars. */
+  stargazers_count: number;
+  /** Primary programming language detected by GitHub. */
+  language: string;
+  /** HTTPS URL of the repository. */
+  url: string;
+  /** Repository owner info. */
+  owner: { login: string };
+  /** True if the repo has at least one release with any assets. */
+  hasReleases: boolean;
+  /** True if the repo has at least one release compatible with the current platform. */
+  hasCompatibleReleases: boolean;
+  /** Releases filtered to the current platform. */
+  releases: CategorizedRelease[];
+  /** All releases with every platform's assets categorized. */
+  allReleases: CategorizedRelease[];
+  [key: string]: unknown;
+}
+
+/** Candidate IDE entry used when probing for an installed editor. */
+export interface IdeInfo {
+  /** Human-readable name shown in log output, e.g. `'VSCode'`. */
+  name: string;
+  /** Shell command used to invoke the editor, e.g. `'code'`. */
+  cmd: string;
+}

package/src/utils.ts

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+/**
+ * Prints the git0 ASCII-art logo in cyan to stdout.
+ *
+ * Called at the start of every major CLI action so the user always sees the
+ * branding regardless of which code path is entered.
+ *
+ * @example
+ * printLogo();
+ * //                 ___
+ * //     __ _(_)‾|_ / _ \
+ * //    / _  | | __| | | |
+ * //   | (_| | | |_| |_| |
+ * //    \__, |_|\__|\___/
+ * //    |___/
+ */
+export function printLogo(): void {
+  console.log(chalk.cyan(`                ___
+    __ _(_)‾|_ / _ \\
+   / _  | | __| | | |
+  | (_| | | |_| |_| |
+   \\__, |_|\\__|\\___/
+   |___/`));
+}
+
+/**
+ * Runs a shell command synchronously, inheriting the parent's stdio so output
+ * streams directly to the terminal.
+ *
+ * Errors are swallowed silently by default because many install commands (e.g.
+ * `bun run dev`) exit non-zero when a script is not defined, which should not
+ * abort the overall setup flow.
+ *
+ * @param cmd       - Shell command string to execute.
+ * @param showError - When `true`, prints a red failure message on non-zero exit.
+ *
+ * @example
+ * exec('npm install');
+ * exec('npm run build', true); // prints error if build fails
+ */
+export function exec(cmd: string, showError = false): void {
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+  } catch {
+    if (showError) console.error(chalk.red(`❌ Failed: ${cmd}`));
+  }
+}

package/test/download.test.ts

@@ -0,0 +1,48 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getAvailableDirectoryName } from '../src/download.ts';
+
+describe('getAvailableDirectoryName', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'git0-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test('returns basePath unchanged when it does not exist', () => {
+    const target = path.join(tmp, 'newdir');
+    expect(getAvailableDirectoryName(target)).toBe(target);
+  });
+
+  test('appends -2 when basePath already exists', () => {
+    const target = path.join(tmp, 'repo');
+    fs.mkdirSync(target);
+    expect(getAvailableDirectoryName(target)).toBe(`${target}-2`);
+  });
+
+  test('increments counter until a free slot is found', () => {
+    const target = path.join(tmp, 'repo');
+    fs.mkdirSync(target);
+    fs.mkdirSync(`${target}-2`);
+    fs.mkdirSync(`${target}-3`);
+    expect(getAvailableDirectoryName(target)).toBe(`${target}-4`);
+  });
+
+  test('returns basePath when only suffixed variants exist', () => {
+    const target = path.join(tmp, 'repo');
+    // Create repo-2 but NOT repo — basePath itself is free.
+    fs.mkdirSync(`${target}-2`);
+    expect(getAvailableDirectoryName(target)).toBe(target);
+  });
+
+  test('works with deeply nested non-existent paths', () => {
+    const target = path.join(tmp, 'a', 'b', 'c');
+    expect(getAvailableDirectoryName(target)).toBe(target);
+  });
+});

package/test/github-api.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, expect } from 'bun:test';
+import GithubAPI from '../src/github-api.ts';
+
+describe('GithubAPI.parseURL', () => {
+  const api = new GithubAPI();
+
+  test('parses full https github.com URL', () => {
+    const result = api.parseURL('https://github.com/facebook/react');
+    expect(result).not.toBe(false);
+    if (!result) return;
+    expect(result.owner).toBe('facebook');
+    expect(result.name).toBe('react');
+  });
+
+  test('parses owner/repo shorthand', () => {
+    const result = api.parseURL('vitejs/vite');
+    expect(result).not.toBe(false);
+    if (!result) return;
+    expect(result.owner).toBe('vitejs');
+    expect(result.name).toBe('vite');
+  });
+
+  test('parses SSH git@ URL', () => {
+    const result = api.parseURL('git@github.com:torvalds/linux.git');
+    expect(result).not.toBe(false);
+  });
+
+  test('parses git:// protocol URL', () => {
+    const result = api.parseURL('git://github.com/user/repo.git');
+    expect(result).not.toBe(false);
+  });
+
+  test('returns false for a plain search query', () => {
+    expect(api.parseURL('react starter template')).toBe(false);
+  });
+
+  test('returns false for a single word', () => {
+    expect(api.parseURL('react')).toBe(false);
+  });
+
+  test('returns false for an email-like string', () => {
+    expect(api.parseURL('user@example.com')).toBe(false);
+  });
+
+  test('owner/repo with dots in repo name is accepted', () => {
+    const result = api.parseURL('sass/node-sass.git');
+    expect(result).not.toBe(false);
+  });
+
+  test('owner/repo with hyphens is accepted', () => {
+    const result = api.parseURL('my-org/my-repo');
+    expect(result).not.toBe(false);
+    if (!result) return;
+    expect(result.name).toBe('my-repo');
+  });
+});
+
+describe('GithubAPI.getCurrentPlatform', () => {
+  const api = new GithubAPI();
+
+  test('returns an object with os, arch, platform, architecture fields', () => {
+    const p = api.getCurrentPlatform();
+    expect(p).toHaveProperty('os');
+    expect(p).toHaveProperty('arch');
+    expect(p).toHaveProperty('platform');
+    expect(p).toHaveProperty('architecture');
+  });
+
+  test('os is one of the known canonical values or a passthrough', () => {
+    const p = api.getCurrentPlatform();
+    expect(typeof p.os).toBe('string');
+    expect(p.os.length).toBeGreaterThan(0);
+  });
+
+  test('platform matches process.platform', () => {
+    const p = api.getCurrentPlatform();
+    expect(p.platform).toBe(process.platform);
+  });
+});