isexe 2.0.0

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:npm/isexe@2.0.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/isexe@2.0.0

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:2573b3431d272fca2b7239cdcf97234c2f09e344107891a031f11f55474fc15a","contract":["isexe.sync returns truthy for executable files and falsy for non-executable files","isexe asynchronously returns truthy for executable files and falsy for non-executable files","isexe handles ignoreErrors option when target file does not exist"],"goal":"verify pkg:npm/isexe@2.0.0","kind":"HOW","packages":["pkg:npm/isexe@2.0.0"],"schemaVersion":1},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/isexe@2.0.0"],"schemaVersion":1,"subject":"pkg:npm/isexe@2.0.0","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-isexe",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-isexe",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "isexe": "2.0.0"
      }
    },
    "node_modules/isexe": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
      "license": "ISC"
    }
  }
}

{
  "name": "sample-isexe",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification sample for isexe",
  "main": "src/index.js",
  "scripts": {
    "test": "node test/contract.js"
  },
  "dependencies": {
    "isexe": "2.0.0"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/isexe@2.0.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/isexe@2.0.0"
  ]
}

const isexe = require('isexe');

async function checkExecutable(filePath, options) {
  const result = await isexe(filePath, options);
  return Boolean(result);
}

function checkExecutableSync(filePath, options) {
  const result = isexe.sync(filePath, options);
  return Boolean(result);
}

module.exports = {
  checkExecutable,
  checkExecutableSync,
  isexe
};

const assert = require('node:assert');
const fs = require('node:fs');
const path = require('node:path');
const os = require('node:os');
const isexe = require('isexe');
const { checkExecutable, checkExecutableSync } = require('../src/index.js');

async function runTests() {
  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'isexe-contract-'));
  const execFile = path.join(tmpDir, 'executable-script.sh');
  const nonExecFile = path.join(tmpDir, 'plain-document.txt');
  const nonExistentFile = path.join(tmpDir, 'non-existent-target.bin');

  try {
    fs.writeFileSync(execFile, '#!/bin/sh\necho "test executable"\n', { mode: 0o755 });
    fs.writeFileSync(nonExecFile, 'plain document text content\n', { mode: 0o644 });

    // 1. Synchronous check with isexe.sync
    assert.strictEqual(Boolean(isexe.sync(execFile)), true, 'sync check on executable file should return truthy');
    assert.strictEqual(checkExecutableSync(execFile), true, 'helper sync check on executable file should return true');

    assert.strictEqual(Boolean(isexe.sync(nonExecFile)), false, 'sync check on non-executable file should return falsy');
    assert.strictEqual(checkExecutableSync(nonExecFile), false, 'helper sync check on non-executable file should return false');

    // 2. Asynchronous check with isexe (Promise)
    const asyncExecResult = await isexe(execFile);
    assert.strictEqual(Boolean(asyncExecResult), true, 'async check on executable file should resolve to truthy');
    const helperAsyncExecResult = await checkExecutable(execFile);
    assert.strictEqual(helperAsyncExecResult, true, 'helper async check on executable file should resolve to true');

    const asyncNonExecResult = await isexe(nonExecFile);
    assert.strictEqual(Boolean(asyncNonExecResult), false, 'async check on non-executable file should resolve to falsy');
    const helperAsyncNonExecResult = await checkExecutable(nonExecFile);
    assert.strictEqual(helperAsyncNonExecResult, false, 'helper async check on non-executable file should resolve to false');

    // 3. Callback style
    await new Promise((resolve, reject) => {
      isexe(execFile, (err, result) => {
        if (err) return reject(err);
        assert.strictEqual(Boolean(result), true, 'callback check on executable file should return truthy');
        resolve();
      });
    });

    // 4. ignoreErrors option
    assert.strictEqual(isexe.sync(nonExistentFile, { ignoreErrors: true }), false, 'sync check on non-existent file with ignoreErrors should return false');
    assert.strictEqual(checkExecutableSync(nonExistentFile, { ignoreErrors: true }), false, 'helper sync check on non-existent file with ignoreErrors should return false');

    const asyncNonExistent = await isexe(nonExistentFile, { ignoreErrors: true });
    assert.strictEqual(asyncNonExistent, false, 'async check on non-existent file with ignoreErrors should resolve to false');
    const helperAsyncNonExistent = await checkExecutable(nonExistentFile, { ignoreErrors: true });
    assert.strictEqual(helperAsyncNonExistent, false, 'helper async check on non-existent file with ignoreErrors should resolve to false');

    console.log('Contract tests passed successfully.');
  } finally {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  }
}

runTests().catch((err) => {
  console.error(err);
  process.exit(1);
});