chownr 3.0.0: chownrSync

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/chownr@3.0.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/chownr@3.0.0
Demonstrate these symbols/APIs:
  - chownr
  - chownrSync

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:6edc8d58f7f0bf2a592c42e53f2bf9f0e82467447956a24d593b19ab7a64e7c5","contract":["chownrSync(path, uid, gid) synchronously changes ownership of nested files and directories","chownr(path, uid, gid, callback) asynchronously changes ownership of nested files and directories","chownrSync ignores ENOENT when path does not exist"],"goal":"verify pkg:npm/chownr@3.0.0","kind":"HOW","packages":["pkg:npm/chownr@3.0.0"],"schemaVersion":1,"symbols":["chownr","chownrSync"]},"contractCommand":["node","test/contract.mjs"],"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/chownr@3.0.0"],"schemaVersion":1,"subject":"pkg:npm/chownr@3.0.0","symbols":["chownr","chownrSync"],"verifierAdapter":"node-typescript@1"}

import { chownr, chownrSync } from 'chownr';

/**
 * Asynchronously changes ownership of a path and all its contents recursively.
 * @param {string} targetPath - Path to change ownership for
 * @param {number} uid - User ID
 * @param {number} gid - Group ID
 * @returns {Promise<void>}
 */
export function changeOwnerTree(targetPath, uid, gid) {
  return new Promise((resolve, reject) => {
    chownr(targetPath, uid, gid, (err) => {
      if (err) reject(err);
      else resolve();
    });
  });
}

/**
 * Synchronously changes ownership of a path and all its contents recursively.
 * @param {string} targetPath - Path to change ownership for
 * @param {number} uid - User ID
 * @param {number} gid - Group ID
 */
export function changeOwnerTreeSync(targetPath, uid, gid) {
  chownrSync(targetPath, uid, gid);
}

export { chownr, chownrSync };

{
  "name": "verify-chownr",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "verify-chownr",
      "version": "1.0.0",
      "dependencies": {
        "chownr": "3.0.0"
      }
    },
    "node_modules/chownr": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
      "license": "BlueOak-1.0.0",
      "engines": {
        "node": ">=18"
      }
    }
  }
}

{
  "name": "verify-chownr",
  "version": "1.0.0",
  "description": "Clean-room verification sample for chownr 3.0.0",
  "type": "module",
  "main": "index.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "chownr": "3.0.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/chownr@3.0.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/chownr@3.0.0"
  ],
  "symbols": [
    "chownr",
    "chownrSync"
  ]
}

import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import { chownr, chownrSync } from 'chownr';

const uid = process.getuid ? process.getuid() : 1000;
const gid = process.getgid ? process.getgid() : 1000;

const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'csx-chownr-test-'));

try {
  // Test 1: chownrSync on a nested directory tree
  const syncDir = path.join(tmpRoot, 'sync-tree');
  fs.mkdirSync(path.join(syncDir, 'nested', 'deep'), { recursive: true });
  fs.writeFileSync(path.join(syncDir, 'file1.txt'), 'hello');
  fs.writeFileSync(path.join(syncDir, 'nested', 'file2.txt'), 'world');
  fs.writeFileSync(path.join(syncDir, 'nested', 'deep', 'file3.txt'), 'deep');

  chownrSync(syncDir, uid, gid);

  const statSyncDir = fs.statSync(syncDir);
  const statSyncFile1 = fs.statSync(path.join(syncDir, 'file1.txt'));
  const statSyncFile2 = fs.statSync(path.join(syncDir, 'nested', 'file2.txt'));
  const statSyncFile3 = fs.statSync(path.join(syncDir, 'nested', 'deep', 'file3.txt'));

  assert.equal(statSyncDir.uid, uid);
  assert.equal(statSyncDir.gid, gid);
  assert.equal(statSyncFile1.uid, uid);
  assert.equal(statSyncFile1.gid, gid);
  assert.equal(statSyncFile2.uid, uid);
  assert.equal(statSyncFile2.gid, gid);
  assert.equal(statSyncFile3.uid, uid);
  assert.equal(statSyncFile3.gid, gid);

  // Test 2: chownr (async) on a nested directory tree
  const asyncDir = path.join(tmpRoot, 'async-tree');
  fs.mkdirSync(path.join(asyncDir, 'sub'), { recursive: true });
  fs.writeFileSync(path.join(asyncDir, 'async-file.txt'), 'async');
  fs.writeFileSync(path.join(asyncDir, 'sub', 'nested.txt'), 'nested');

  await new Promise((resolve, reject) => {
    chownr(asyncDir, uid, gid, (err) => {
      if (err) reject(err);
      else resolve();
    });
  });

  const statAsyncDir = fs.statSync(asyncDir);
  const statAsyncFile1 = fs.statSync(path.join(asyncDir, 'async-file.txt'));
  const statAsyncFile2 = fs.statSync(path.join(asyncDir, 'sub', 'nested.txt'));

  assert.equal(statAsyncDir.uid, uid);
  assert.equal(statAsyncDir.gid, gid);
  assert.equal(statAsyncFile1.uid, uid);
  assert.equal(statAsyncFile1.gid, gid);
  assert.equal(statAsyncFile2.uid, uid);
  assert.equal(statAsyncFile2.gid, gid);

  // Test 3: non-existent path handling (ENOENT is ignored / no error)
  const nonExistent = path.join(tmpRoot, 'does-not-exist');
  assert.doesNotThrow(() => {
    chownrSync(nonExistent, uid, gid);
  });

  await new Promise((resolve, reject) => {
    chownr(nonExistent, uid, gid, (err) => {
      if (err) reject(err);
      else resolve();
    });
  });

  console.log('All chownr contract tests passed.');
} finally {
  fs.rmSync(tmpRoot, { recursive: true, force: true });
}