onmymachine 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sreejith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# onmymachine
+
+> Kill "works on my machine" in 10 seconds.
+
+<!-- TODO(record): asciinema/vhs demo before launch -->
+![demo](docs/demo.gif)
+
+## The problem
+
+Your code runs fine. Your teammate pulls it and it crashes. Now you're playing
+20 questions on Slack: *"What Node version? What's in your PATH? Do you even
+have Docker?"*
+
+Stop asking. Diff the machines.
+
+## Quick start
+
+**You** (the person it works for):
+
+```sh
+npx onmymachine
+```
+
+This writes `onmymachine.json` — a fingerprint of your dev environment.
+Send that file to your teammate (Slack, email, carrier pigeon).
+
+**Your teammate** (the person it's broken for):
+
+```sh
+npx onmymachine diff onmymachine.json
+```
+
+```
+Tools
+  ✖ node           snapshot: 20.11.0   this machine: 22.3.0
+  ● docker         in snapshot (27.1.1) — missing here
+
+Env values
+  ✖ JAVA_HOME      snapshot: ~/jdk-21   this machine: ~/jdk-17
+
+✓ 24 tools match
+3 differences found — one of these might be your "works on my machine".
+```
+
+Done. No more guessing.
+
+## What it captures
+
+- **Tool versions** — node, npm, python, git, docker, java, go, rustc, and ~20 more
+- **System** — OS, release, architecture, shell
+- **Env vars** — all *names*; values only for dev-relevant vars (`JAVA_HOME`, `GOPATH`, ...)
+- **PATH** — every entry, so "it's not even on my PATH" gets caught too
+
+## Privacy
+
+Built to be safe to share:
+
+- **No hostname, no username** — never collected
+- Paths under your home directory become `~`
+- Anything that looks like a secret (`*_TOKEN`, `*_KEY`, `*PASSWORD*`, ...) is `[redacted]`
+- **Zero network calls, zero telemetry, zero dependencies** — read the entire
+  source over coffee
+
+## More
+
+```sh
+onmymachine --label "sree-laptop"   # name your snapshot
+onmymachine diff snap.json --all    # also show what matches
+onmymachine diff snap.json --json   # machine-readable diff
+```
+
+**CI drift guard:** commit a golden snapshot of your build box; `onmymachine
+diff golden.json` exits `1` when the runner drifts.
+
+## FAQ
+
+**Why not just use Docker?**
+Because the bug report says "works on my machine", not "works in my container".
+Real development happens on hosts — with host Node, host PATH, host env vars.
+
+**Windows?**
+First-class. Windows, macOS, and Linux.
+
+**Does it upload my snapshot anywhere?**
+Never. It writes a local file. You choose who sees it.
+
+## Contributing
+
+Issues and PRs welcome. The whole tool is ~400 lines of dependency-free
+Node — `npm test` runs everything.
+
+## License
+
+[MIT](LICENSE)

package/bin/onmymachine.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { collect } from '../src/collect.js';
+import { diffSnapshots } from '../src/diff.js';
+import { renderSnapshotSummary, renderDiff, shouldColor } from '../src/render.js';
+
+const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+const HELP = `onmymachine — kill "works on my machine" in 10 seconds.
+
+Usage:
+  onmymachine                     snapshot this machine to onmymachine.json
+  onmymachine snapshot [options]
+  onmymachine diff <file>         compare a snapshot file with this machine
+
+Options:
+  -o, --out <file>   snapshot output path (default: onmymachine.json)
+  --label <name>     label this snapshot (e.g. your name)
+  --json             print machine-readable JSON to stdout
+  --all              diff: show matching entries too
+  -h, --help         show this help
+  -v, --version      show version
+
+Exit codes: 0 ok / no differences · 1 differences found · 2 error`;
+
+function fail(msg) {
+  process.stderr.write(`error: ${msg}\n\nRun onmymachine --help for usage.\n`);
+  process.exit(2);
+}
+
+async function main() {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: process.argv.slice(2),
+      allowPositionals: true,
+      options: {
+        out: { type: 'string', short: 'o', default: 'onmymachine.json' },
+        label: { type: 'string' },
+        json: { type: 'boolean', default: false },
+        all: { type: 'boolean', default: false },
+        help: { type: 'boolean', short: 'h', default: false },
+        version: { type: 'boolean', short: 'v', default: false },
+      },
+    });
+  } catch (e) {
+    fail(e.message);
+  }
+  const { values, positionals } = parsed;
+
+  if (values.help) { console.log(HELP); return; }
+  if (values.version) { console.log(pkg.version); return; }
+
+  const command = positionals[0] ?? 'snapshot';
+  const color = shouldColor();
+
+  if (command === 'snapshot') {
+    const snapshot = await collect({ label: values.label });
+    if (values.json) { console.log(JSON.stringify(snapshot, null, 2)); return; }
+    writeFileSync(values.out, JSON.stringify(snapshot, null, 2) + '\n');
+    console.log(renderSnapshotSummary(snapshot, { color }));
+    console.log(`\nWrote ${values.out}`);
+    console.log(`Send it to your teammate and have them run:\n  npx onmymachine diff ${values.out}`);
+    return;
+  }
+
+  if (command === 'diff') {
+    const file = positionals[1];
+    if (!file) fail('diff needs a snapshot file: onmymachine diff <file>');
+    let snapshot;
+    try {
+      snapshot = JSON.parse(readFileSync(file, 'utf8'));
+    } catch (e) {
+      fail(`cannot read snapshot file "${file}": ${e.message}`);
+    }
+    if (snapshot.$schema !== 'onmymachine/v1') {
+      process.stderr.write(`warning: unexpected schema "${snapshot.$schema}" — trying anyway\n`);
+    }
+    const current = await collect();
+    const diff = diffSnapshots(snapshot, current);
+    if (values.json) console.log(JSON.stringify(diff, null, 2));
+    else console.log(renderDiff(diff, { color, all: values.all }));
+    process.exit(diff.differences === 0 ? 0 : 1);
+  }
+
+  fail(`unknown command "${command}"`);
+}
+
+main().catch((e) => fail(e.stack ?? String(e)));

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "onmymachine",
+  "version": "0.1.0",
+  "description": "Kill \"works on my machine\": snapshot your dev environment, share the file, diff it on another machine.",
+  "type": "module",
+  "bin": { "onmymachine": "bin/onmymachine.js" },
+  "engines": { "node": ">=18" },
+  "files": ["bin", "src", "README.md", "LICENSE"],
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": ["cli", "environment", "diff", "debugging", "works-on-my-machine", "devtools", "devx"],
+  "author": "Sreejith <iSreejith@gmail.com> (https://github.com/iSreejith)",
+  "repository": { "type": "git", "url": "git+https://github.com/iSreejith/onmymachine.git" },
+  "bugs": { "url": "https://github.com/iSreejith/onmymachine/issues" },
+  "homepage": "https://github.com/iSreejith/onmymachine#readme",
+  "license": "MIT"
+}

package/src/collect.js

@@ -0,0 +1,84 @@
+import os from 'node:os';
+import { exec, execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { TOOLS, parseVersion } from './registry.js';
+import { redactValue, normalizeHome } from './redact.js';
+
+const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+export const DEV_ENV_ALLOWLIST = [
+  'NODE_ENV', 'JAVA_HOME', 'JDK_HOME', 'GOPATH', 'GOROOT', 'PYTHONPATH',
+  'VIRTUAL_ENV', 'CONDA_DEFAULT_ENV', 'NVM_DIR', 'ANDROID_HOME',
+  'CARGO_HOME', 'RUSTUP_HOME', 'DOTNET_ROOT', 'MAVEN_HOME', 'GRADLE_HOME',
+  'DOCKER_HOST', 'KUBECONFIG', 'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY',
+  'LANG', 'LC_ALL', 'TZ', 'TERM', 'SHELL', 'EDITOR',
+];
+
+export function defaultProbe(cmd, args, timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    const done = (err, stdout, stderr) => {
+      const out = `${stdout || ''}\n${stderr || ''}`.trim(); // java prints to stderr
+      resolve(out ? out : null);
+    };
+    const opts = { timeout: timeoutMs, windowsHide: true };
+    if (process.platform === 'win32') {
+      // cmd/args come only from the static TOOLS registry — never user input.
+      // A shell is required on Windows to resolve .cmd shims (npm, pnpm, ...).
+      exec(`${cmd} ${args.join(' ')}`, opts, done);
+    } else {
+      execFile(cmd, args, opts, done);
+    }
+  });
+}
+
+export function detectShell(env = process.env, platform = process.platform) {
+  if (platform === 'win32') {
+    if (env.PSModulePath) return 'powershell';
+    if (env.ComSpec) return 'cmd';
+    return 'unknown';
+  }
+  const sh = env.SHELL || '';
+  return sh ? sh.split('/').pop() : 'unknown';
+}
+
+export async function collect({
+  probe = defaultProbe,
+  env = process.env,
+  platform = process.platform,
+  home = os.homedir(),
+  label,
+} = {}) {
+  const toolEntries = await Promise.all(
+    TOOLS.map(async (t) => [t.name, parseVersion(await probe(t.cmd, t.args))]),
+  );
+
+  const values = {};
+  for (const name of DEV_ENV_ALLOWLIST) {
+    if (env[name] !== undefined) {
+      values[name] = redactValue(name, normalizeHome(env[name], home, platform));
+    }
+  }
+
+  const rawPath = env.PATH ?? env.Path ?? '';
+  const path = rawPath
+    .split(platform === 'win32' ? ';' : ':')
+    .filter(Boolean)
+    .map((p) => normalizeHome(p, home, platform));
+
+  return {
+    $schema: 'onmymachine/v1',
+    meta: {
+      version: pkg.version,
+      createdAt: new Date().toISOString(),
+      ...(label ? { label } : {}),
+    },
+    system: {
+      platform,
+      release: os.release(),
+      arch: os.arch(),
+      shell: detectShell(env, platform),
+    },
+    tools: Object.fromEntries(toolEntries),
+    env: { names: Object.keys(env).sort(), values, path },
+  };
+}

package/src/diff.js

@@ -0,0 +1,55 @@
+function pairStatus(a, b) {
+  if (a === b) return 'match';
+  if (a != null && b != null) return 'mismatch';
+  return a != null ? 'only-in-snapshot' : 'only-on-this-machine';
+}
+
+function setDiff(a, b) {
+  const sa = new Set(a), sb = new Set(b);
+  return {
+    onlyInSnapshot: [...sa].filter(x => !sb.has(x)).sort(),
+    onlyOnThisMachine: [...sb].filter(x => !sa.has(x)).sort(),
+  };
+}
+
+export function diffSnapshots(snapshot, current) {
+  const tools = [];
+  const toolNames = new Set([
+    ...Object.keys(snapshot.tools ?? {}),
+    ...Object.keys(current.tools ?? {}),
+  ]);
+  for (const name of [...toolNames].sort()) {
+    const a = snapshot.tools?.[name] ?? null;
+    const b = current.tools?.[name] ?? null;
+    tools.push({ name, snapshot: a, current: b, status: pairStatus(a, b) });
+  }
+
+  const system = ['platform', 'release', 'arch', 'shell'].map((key) => {
+    const a = snapshot.system?.[key] ?? null;
+    const b = current.system?.[key] ?? null;
+    return { key, snapshot: a, current: b, status: a === b ? 'match' : 'mismatch' };
+  });
+
+  const envValues = [];
+  const valueNames = new Set([
+    ...Object.keys(snapshot.env?.values ?? {}),
+    ...Object.keys(current.env?.values ?? {}),
+  ]);
+  for (const name of [...valueNames].sort()) {
+    const a = snapshot.env?.values?.[name] ?? null;
+    const b = current.env?.values?.[name] ?? null;
+    envValues.push({ name, snapshot: a, current: b, status: pairStatus(a, b) });
+  }
+
+  const envNames = setDiff(snapshot.env?.names ?? [], current.env?.names ?? []);
+  const path = setDiff(snapshot.env?.path ?? [], current.env?.path ?? []);
+
+  const differences =
+    tools.filter(t => t.status !== 'match').length +
+    system.filter(s => s.status !== 'match').length +
+    envValues.filter(v => v.status !== 'match').length +
+    envNames.onlyInSnapshot.length + envNames.onlyOnThisMachine.length +
+    path.onlyInSnapshot.length + path.onlyOnThisMachine.length;
+
+  return { tools, system, envValues, envNames, path, differences };
+}

package/src/redact.js

@@ -0,0 +1,16 @@
+const SECRET_NAME = /(token|secret|key|passwd|password|pwd|credential|auth|private)/i;
+
+export function isSecretName(name) {
+  return SECRET_NAME.test(String(name));
+}
+
+export function redactValue(name, value) {
+  return isSecretName(name) ? '[redacted]' : value;
+}
+
+export function normalizeHome(value, home, platform = process.platform) {
+  if (!home || typeof value !== 'string') return value;
+  const escaped = home.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const flags = platform === 'win32' ? 'gi' : 'g';
+  return value.replace(new RegExp(escaped, flags), '~');
+}

package/src/registry.js

@@ -0,0 +1,39 @@
+const VERSION_RE = /\d+\.\d+(?:\.\d+)?/;
+
+export function parseVersion(output) {
+  if (!output) return null;
+  const m = String(output).match(VERSION_RE);
+  return m ? m[0] : null;
+}
+
+const v = (name, cmd = name, args = ['--version']) => ({ name, cmd, args });
+
+export const TOOLS = [
+  v('node'),
+  v('npm'),
+  v('pnpm'),
+  v('yarn'),
+  v('bun'),
+  v('deno'),
+  v('python'),
+  v('python3'),
+  v('pip'),
+  v('git'),
+  v('docker'),
+  v('java', 'java', ['-version']),
+  v('go', 'go', ['version']),
+  v('rustc'),
+  v('cargo'),
+  v('ruby'),
+  v('gem'),
+  v('php'),
+  v('composer'),
+  v('dotnet'),
+  v('kubectl', 'kubectl', ['version', '--client']),
+  v('terraform', 'terraform', ['version']),
+  v('aws'),
+  v('gcc'),
+  v('clang'),
+  v('make'),
+  v('cmake'),
+];

package/src/render.js

@@ -0,0 +1,82 @@
+export function shouldColor(stream = process.stdout, env = process.env) {
+  return Boolean(stream.isTTY) && !env.NO_COLOR;
+}
+
+function palette(enabled) {
+  const wrap = (code) => (s) => (enabled ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+  return {
+    red: wrap('31'), green: wrap('32'), yellow: wrap('33'),
+    cyan: wrap('36'), bold: wrap('1'), dim: wrap('2'),
+  };
+}
+
+const pad = (s, n) => String(s).padEnd(n);
+
+export function renderSnapshotSummary(snapshot, { color = false } = {}) {
+  const c = palette(color);
+  const lines = [];
+  const label = snapshot.meta?.label ? ` (${snapshot.meta.label})` : '';
+  lines.push(c.bold(`onmymachine snapshot${label}`));
+  const sys = snapshot.system ?? {};
+  lines.push(c.dim(`${sys.platform} ${sys.release} · ${sys.arch} · shell: ${sys.shell}`));
+  lines.push('');
+  const tools = Object.entries(snapshot.tools ?? {});
+  const installed = tools.filter(([, v]) => v);
+  for (const [name, version] of installed) {
+    lines.push(`  ${c.green('✓')} ${pad(name, 12)} ${version}`);
+  }
+  const missing = tools.length - installed.length;
+  if (missing > 0) lines.push(c.dim(`  ${missing} of ${tools.length} tools not detected`));
+  lines.push('');
+  lines.push(c.dim(`${(snapshot.env?.names ?? []).length} env var names · ${(snapshot.env?.path ?? []).length} PATH entries`));
+  return lines.join('\n');
+}
+
+export function renderDiff(diff, { color = false, all = false } = {}) {
+  const c = palette(color);
+  const lines = [];
+
+  const statusLine = (label, a, b, status) => {
+    if (status === 'mismatch') {
+      return `  ${c.red('✖')} ${pad(label, 14)} snapshot: ${c.red(a)}   this machine: ${c.red(b)}`;
+    }
+    if (status === 'only-in-snapshot') {
+      return `  ${c.yellow('●')} ${pad(label, 14)} in snapshot (${a}) — ${c.yellow('missing here')}`;
+    }
+    if (status === 'only-on-this-machine') {
+      return `  ${c.yellow('●')} ${pad(label, 14)} on this machine (${b}) — ${c.yellow('missing in snapshot')}`;
+    }
+    return `  ${c.green('✓')} ${pad(label, 14)} ${a}`;
+  };
+
+  const section = (title, rows, toLine) => {
+    const visible = rows.filter(r => all || r.status !== 'match');
+    if (visible.length === 0) return;
+    lines.push(c.bold(title));
+    for (const r of visible) lines.push(toLine(r));
+    lines.push('');
+  };
+
+  section('Tools', diff.tools, r => statusLine(r.name, r.snapshot, r.current, r.status));
+  section('System', diff.system, r => statusLine(r.key, r.snapshot, r.current, r.status));
+  section('Env values', diff.envValues, r => statusLine(r.name, r.snapshot, r.current, r.status));
+
+  const listSection = (title, group) => {
+    if (group.onlyInSnapshot.length === 0 && group.onlyOnThisMachine.length === 0) return;
+    lines.push(c.bold(title));
+    for (const n of group.onlyInSnapshot) lines.push(`  ${c.yellow('●')} ${n} — only in snapshot`);
+    for (const n of group.onlyOnThisMachine) lines.push(`  ${c.yellow('●')} ${n} — only on this machine`);
+    lines.push('');
+  };
+  listSection('Env var names', diff.envNames);
+  listSection('PATH entries', diff.path);
+
+  const matched = diff.tools.filter(t => t.status === 'match').length;
+  if (matched > 0) lines.push(c.green(`✓ ${matched} tools match`));
+  lines.push(
+    diff.differences === 0
+      ? c.green('No differences — same setup. The bug is elsewhere. 🙃')
+      : c.bold(`${diff.differences} differences found — one of these might be your "works on my machine".`),
+  );
+  return lines.join('\n');
+}