killm 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aidan Neel
+
+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,174 @@
+# killm
+
+**Temporarily block your machine from reaching LLM services, to curb AI dependency.**
+
+`killm` is a zero-dependency CLI. You give it a duration and a scope, and for
+that window it points the relevant LLM hostnames at a dead address in your
+system hosts file. When the timer runs out — or you hit `Ctrl+C` — it restores
+everything automatically.
+
+```bash
+npx killm for 1h --agents      # no coding agents for an hour
+npx killm 30m --web            # no chat websites for 30 minutes
+npx killm for 2h --all         # cut everything off for two hours
+```
+
+No account, no proxy, no daemon. Just a timed edit to your hosts file that
+cleans up after itself.
+
+---
+
+## Why
+
+It's easy to reach for an LLM by reflex — autocomplete in the editor, a chat tab
+for every small question — and lose the muscle of thinking a problem through.
+`killm` lets you put a hard, time-boxed wall between you and that reflex without
+uninstalling your tools or changing your accounts. The wall comes down on its
+own; you don't have to remember to turn anything back on.
+
+## Install / run
+
+No install needed — run it on demand with `npx`:
+
+```bash
+npx killm for 1h --agents
+```
+
+Editing the hosts file needs elevated privileges:
+
+- **macOS / Linux:** prefix with `sudo` → `sudo npx killm for 1h --agents`
+- **Windows:** run from an **Administrator** terminal
+
+## The key idea: agents vs. web
+
+The whole point of `killm` is that an agentic coding tool and a chat website
+talk to **different hostnames**, so you can cut one without losing the other:
+
+| Tool                        | Hostname            | Scope      |
+| --------------------------- | ------------------- | ---------- |
+| Claude Code, Aider, raw API | `api.anthropic.com` | `--agents` |
+| Claude chat website         | `claude.ai`         | `--web`    |
+| OpenAI API, Codex           | `api.openai.com`    | `--agents` |
+| ChatGPT website             | `chatgpt.com`       | `--web`    |
+
+So:
+
+- **`--agents`** blocks API endpoints and dedicated coding-assistant backends
+  (Cursor, GitHub Copilot, Codeium/Windsurf, Cody, Tabnine, Continue, …). Your
+  coding agents go dark, but you can still open `claude.ai` or `chatgpt.com` in a
+  browser if you genuinely need to.
+- **`--web`** blocks the consumer chat websites (`claude.ai`, `chatgpt.com`,
+  `gemini.google.com`, `perplexity.ai`, …). Your API-based tooling keeps working.
+- **`--all`** blocks both. This is the default if you don't pass a scope.
+
+## Usage
+
+```
+npx killm for <duration> [scope] [options]
+npx killm <duration> [scope] [options]
+```
+
+The word `for` is optional sugar — `killm for 1h --agents` and
+`killm 1h --agents` are identical.
+
+### Duration
+
+Combine units `d` / `h` / `m` / `s`:
+
+```
+90s    30m    1h    1h30m    2d
+```
+
+A bare number is treated as minutes (`45` = `45m`).
+
+### Scope
+
+| Flag       | Blocks                                   |
+| ---------- | ---------------------------------------- |
+| `--agents` | Agentic coding tools + raw API endpoints |
+| `--web`    | Consumer chat websites                   |
+| `--all`    | Both (default)                           |
+
+You can combine `--agents` and `--web`; that's the same as `--all`.
+
+### Options
+
+| Option            | Effect                                           |
+| ----------------- | ------------------------------------------------ |
+| `--restore`       | Lift any active block right now and exit         |
+| `--status`        | Report whether a block is currently active       |
+| `--list`          | Print the hostnames a given scope would block    |
+| `--dry-run`       | Show what would change without touching anything |
+| `-y`, `--yes`     | Skip the confirmation prompt                     |
+| `-h`, `--help`    | Show help                                        |
+| `-v`, `--version` | Show version                                     |
+
+### Examples
+
+```bash
+npx killm for 1h --agents          # coding agents off for an hour
+npx killm 30m --web                # chat websites off for 30 minutes
+npx killm for 2h --all             # everything off for two hours
+npx killm --list --agents          # see exactly what --agents blocks
+npx killm for 25m --web --dry-run  # preview, change nothing
+npx killm --restore                # end an active block early
+npx killm --status                 # is a block running right now?
+```
+
+## How it works
+
+`killm` writes a clearly-marked block into your system hosts file
+(`/etc/hosts`, or `…\System32\drivers\etc\hosts` on Windows) that points each
+target hostname at `0.0.0.0` (and `::1` for IPv6):
+
+```
+# >>> killm block (do not edit between markers) >>>
+# added by killm at 2026-06-09T17:58:07.849Z
+# auto-removed at 2026-06-09T18:58:07.849Z (or when killm exits)
+0.0.0.0	api.anthropic.com
+::1	api.anthropic.com
+...
+# <<< killm block <<<
+```
+
+It then flushes the OS DNS cache so the change takes effect immediately. When
+the timer expires, or on `Ctrl+C`, `SIGTERM`, or process exit, it strips that
+block back out and flushes again. The markers mean it only ever touches its own
+lines — your existing hosts entries are left alone.
+
+If something goes wrong and a block is left behind, `sudo npx killm --restore`
+(or the Administrator equivalent) cleans it up.
+
+## Limitations & honesty
+
+`killm` is a **speed bump, not a vault.** It's designed to defeat reflex, not a
+determined workaround:
+
+- It blocks by **hostname**, so it can't block a single path on a shared domain.
+- Anyone with admin rights can edit the hosts file back, use a different DNS
+  resolver, a VPN, or a phone. That's fine — the goal is to make the easy thing
+  hard, not to make it impossible.
+- Hostname lists drift as providers add endpoints. `--list` shows the current
+  set; PRs to keep it current are welcome.
+
+## Development
+
+The CLI is written in TypeScript (ESM) with zero runtime dependencies; tests
+run against the compiled output, so they exercise exactly what ships.
+
+```bash
+npm ci               # install dev toolchain
+npm run build        # compile TypeScript to dist/
+npm test             # build + run the test suite (node:test)
+npm run lint         # eslint
+npm run format       # prettier --write
+npm run typecheck    # tsc --noEmit
+```
+
+CI runs lint, format, typecheck, and the test matrix (Linux/macOS/Windows ×
+Node 18/20/22) on every push and PR. Publishing happens automatically when a
+GitHub release is published (requires the `NPM_TOKEN` repo secret).
+
+## License
+
+MIT © Aidan Neel

package/dist/src/bin.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { main } from './index.js';
+// Exit quietly if our output is piped into something that closes early
+// (e.g. `killm --list | head`), rather than crashing on EPIPE.
+process.stdout.on('error', (err) => {
+    if (err?.code === 'EPIPE')
+        process.exit(0);
+    throw err;
+});
+main(process.argv.slice(2))
+    .then((code) => {
+    process.exitCode = code || 0;
+})
+    .catch((err) => {
+    const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+    process.stderr.write(`killm: unexpected error: ${detail}\n`);
+    process.exitCode = 1;
+});

package/dist/src/cli.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs';
+import { parseDuration } from './duration.js';
+export const VERSION = JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+export const HELP = `killm — temporarily block your machine from reaching LLM services
+
+USAGE
+  npx killm for <duration> [scope] [options]
+  npx killm <duration> [scope] [options]
+
+  The word "for" is optional sugar:  killm for 1h --agents  ==  killm 1h --agents
+
+DURATION
+  Combine units d/h/m/s, e.g.  90s  30m  1h  1h30m  2d
+  A bare number means minutes, e.g.  45  ==  45m
+
+SCOPE  (pick one or more; default is --all)
+  --agents   Block agentic coding + raw API endpoints (api.anthropic.com,
+             api.openai.com, Cursor, Copilot, Codeium, ...). Leaves the
+             chat websites (claude.ai, chatgpt.com) reachable.
+  --web      Block consumer chat websites (claude.ai, chatgpt.com,
+             gemini.google.com, perplexity.ai, ...). Leaves API endpoints
+             reachable so other tooling keeps working.
+  --all      Block both of the above. This is the default if no scope is given.
+
+OPTIONS
+  --restore        Remove any active killm block right now and exit.
+  --status         Show whether a block is currently active and exit.
+  --list           Print the hostnames that would be blocked and exit.
+  --dry-run        Show what would change without touching the hosts file.
+  -y, --yes        Don't prompt for confirmation.
+  -h, --help       Show this help.
+  -v, --version    Show version.
+
+EXAMPLES
+  npx killm for 1h --agents          Block coding agents for an hour.
+  npx killm 30m --web                Block chat websites for 30 minutes.
+  npx killm for 2h --all             Block everything for two hours.
+  npx killm --restore                Lift an active block early.
+
+NOTE
+  Editing the hosts file requires elevated privileges. Run with sudo on
+  macOS/Linux, or from an Administrator terminal on Windows.
+`;
+/**
+ * Parse argv (without node/script) into a structured command.
+ */
+export function parseArgs(argv) {
+    const result = {
+        command: 'run',
+        scope: { agents: false, web: false, all: false },
+        dryRun: false,
+        yes: false,
+    };
+    let explicit;
+    let durationInput;
+    for (const arg of argv) {
+        switch (arg) {
+            case '-h':
+            case '--help':
+                return { ...result, command: 'help' };
+            case '-v':
+            case '--version':
+                return { ...result, command: 'version' };
+            case '--status':
+                explicit = 'status';
+                break;
+            case '--list':
+                explicit = 'list';
+                break;
+            case '--restore':
+            case '--unblock':
+                explicit = 'restore';
+                break;
+            case '--dry-run':
+                result.dryRun = true;
+                break;
+            case '-y':
+            case '--yes':
+                result.yes = true;
+                break;
+            case '--agents':
+                result.scope.agents = true;
+                break;
+            case '--web':
+                result.scope.web = true;
+                break;
+            case '--all':
+                result.scope.all = true;
+                break;
+            case 'for':
+                // Noise word, ignore.
+                break;
+            default:
+                if (arg.startsWith('-')) {
+                    return { ...result, command: 'help', error: `unknown option: ${arg}` };
+                }
+                if (durationInput !== undefined) {
+                    return { ...result, command: 'help', error: `unexpected argument: ${arg}` };
+                }
+                durationInput = arg;
+                break;
+        }
+    }
+    // Terminal sub-commands that don't need a duration.
+    if (explicit === 'restore')
+        return { ...result, command: 'restore' };
+    if (explicit === 'status')
+        return { ...result, command: 'status' };
+    // --list needs to know the scope but not a duration.
+    if (explicit === 'list') {
+        if (!result.scope.agents && !result.scope.web && !result.scope.all) {
+            result.scope.all = true;
+        }
+        return { ...result, command: 'list' };
+    }
+    // From here we're running a block, which requires a duration.
+    if (durationInput === undefined) {
+        return {
+            ...result,
+            command: 'help',
+            error: 'a duration is required, e.g. "killm for 1h --agents"',
+        };
+    }
+    let durationMs;
+    try {
+        durationMs = parseDuration(durationInput);
+    }
+    catch (err) {
+        return { ...result, command: 'help', error: err.message };
+    }
+    // Default scope: everything.
+    if (!result.scope.agents && !result.scope.web && !result.scope.all) {
+        result.scope.all = true;
+    }
+    return { ...result, command: 'run', durationInput, durationMs };
+}

package/dist/src/duration.js

@@ -0,0 +1,69 @@
+export const UNITS = {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+};
+/**
+ * Parse a human duration string into milliseconds.
+ *
+ * Accepts a single unit ("30m", "1h", "90s", "2d") or a combination
+ * ("1h30m", "1d12h"). A bare number is treated as minutes ("45" -> 45m).
+ *
+ * @throws {Error} when the string cannot be parsed
+ */
+export function parseDuration(input) {
+    if (input == null)
+        throw new Error('no duration given');
+    const raw = String(input).trim().toLowerCase();
+    if (raw === '')
+        throw new Error('empty duration');
+    // Bare number -> minutes.
+    if (/^\d+$/.test(raw)) {
+        const minutes = Number(raw) * UNITS.m;
+        if (minutes <= 0)
+            throw new Error(`duration must be greater than zero: "${input}"`);
+        return minutes;
+    }
+    const re = /(\d+)\s*(d|h|m|s)/g;
+    let total = 0;
+    let matched = false;
+    let consumed = 0;
+    let match;
+    while ((match = re.exec(raw)) !== null) {
+        matched = true;
+        consumed += match[0].length;
+        total += Number(match[1]) * UNITS[match[2]];
+    }
+    // Reject leftover junk like "1h!" or "abc".
+    if (!matched || consumed !== raw.replace(/\s/g, '').length) {
+        throw new Error(`could not parse duration: "${input}"`);
+    }
+    if (total <= 0)
+        throw new Error(`duration must be greater than zero: "${input}"`);
+    return total;
+}
+/**
+ * Format milliseconds back into a compact human string, e.g. "1h 30m 5s".
+ */
+export function formatDuration(ms) {
+    if (ms <= 0)
+        return '0s';
+    let remaining = Math.round(ms / 1000); // whole seconds
+    const days = Math.floor(remaining / 86400);
+    remaining %= 86400;
+    const hours = Math.floor(remaining / 3600);
+    remaining %= 3600;
+    const minutes = Math.floor(remaining / 60);
+    const seconds = remaining % 60;
+    const parts = [];
+    if (days)
+        parts.push(`${days}d`);
+    if (hours)
+        parts.push(`${hours}h`);
+    if (minutes)
+        parts.push(`${minutes}m`);
+    if (seconds || parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}

package/dist/src/hosts.js

@@ -0,0 +1,161 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+export const BEGIN = '# >>> killm block (do not edit between markers) >>>';
+export const END = '# <<< killm block <<<';
+const SINK4 = '0.0.0.0';
+const SINK6 = '::1';
+function errnoCode(err) {
+    return err?.code;
+}
+/**
+ * Absolute path to the OS hosts file.
+ * KILLM_HOSTS_PATH overrides it (used by the test suite).
+ */
+export function hostsPath() {
+    if (process.env.KILLM_HOSTS_PATH)
+        return process.env.KILLM_HOSTS_PATH;
+    if (process.platform === 'win32') {
+        const root = process.env.SystemRoot || 'C:\\Windows';
+        return path.join(root, 'System32', 'drivers', 'etc', 'hosts');
+    }
+    return '/etc/hosts';
+}
+/**
+ * Read the current hosts file as text. Returns '' if it does not exist.
+ */
+export function readHosts() {
+    try {
+        return fs.readFileSync(hostsPath(), 'utf8');
+    }
+    catch (err) {
+        if (errnoCode(err) === 'ENOENT')
+            return '';
+        throw err;
+    }
+}
+/**
+ * Strip any existing killm-managed block from hosts text.
+ */
+export function stripBlock(text) {
+    const begin = text.indexOf(BEGIN);
+    if (begin === -1)
+        return text;
+    const end = text.indexOf(END, begin);
+    if (end === -1) {
+        // Malformed (begin without end): drop everything from the marker on.
+        return text.slice(0, begin).replace(/\n+$/, '\n');
+    }
+    const before = text.slice(0, begin);
+    const after = text.slice(end + END.length);
+    return (before.replace(/\n+$/, '\n') + after.replace(/^\n+/, '')).replace(/\n{3,}/g, '\n\n');
+}
+/**
+ * Build the killm block text for the given hostnames.
+ */
+export function buildBlock(hosts, opts = {}) {
+    const lines = [BEGIN];
+    lines.push(`# added by killm at ${new Date().toISOString()}`);
+    if (opts.until) {
+        lines.push(`# auto-removed at ${opts.until.toISOString()} (or when killm exits)`);
+    }
+    for (const h of hosts) {
+        lines.push(`${SINK4}\t${h}`);
+        lines.push(`${SINK4}\twww.${h}`.replace('www.www.', 'www.'));
+        lines.push(`${SINK6}\t${h}`);
+    }
+    lines.push(END);
+    return lines.join('\n');
+}
+/**
+ * Atomically write hosts text by writing to a temp file then renaming.
+ * Falls back to a direct write if rename across devices fails.
+ */
+function writeHosts(text) {
+    const target = hostsPath();
+    const normalized = text.endsWith('\n') ? text : text + '\n';
+    const tmp = path.join(os.tmpdir(), `killm-hosts-${process.pid}-${Date.now()}.tmp`);
+    fs.writeFileSync(tmp, normalized, { mode: 0o644 });
+    try {
+        fs.renameSync(tmp, target);
+    }
+    catch (err) {
+        if (errnoCode(err) === 'EXDEV') {
+            // Temp dir is on a different filesystem; write in place instead.
+            fs.writeFileSync(target, normalized, { mode: 0o644 });
+            fs.unlinkSync(tmp);
+        }
+        else {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch {
+                /* ignore */
+            }
+            throw err;
+        }
+    }
+}
+/**
+ * Apply a block for the given hostnames. Removes any prior killm block first
+ * so repeated runs stay idempotent.
+ */
+export function applyBlock(hosts, opts = {}) {
+    const current = stripBlock(readHosts());
+    const base = current.replace(/\n+$/, '');
+    const next = (base ? base + '\n\n' : '') + buildBlock(hosts, opts) + '\n';
+    writeHosts(next);
+}
+/**
+ * Remove the killm block from the hosts file. No-op if absent.
+ *
+ * @returns whether a block was present and removed
+ */
+export function removeBlock() {
+    const current = readHosts();
+    if (!current.includes(BEGIN))
+        return false;
+    writeHosts(stripBlock(current));
+    return true;
+}
+/**
+ * Whether a killm block is currently present.
+ */
+export function isBlocked() {
+    return readHosts().includes(BEGIN);
+}
+/**
+ * Best-effort DNS cache flush so the new hosts entries take effect immediately.
+ * Silently ignores failures — the block still works, it may just take a moment.
+ */
+export function flushDns() {
+    // Pointless (and slow) when operating on a fake hosts file in tests.
+    if (process.env.KILLM_HOSTS_PATH)
+        return Promise.resolve();
+    const run = (cmd, args) => new Promise((resolve) => {
+        execFile(cmd, args, () => resolve());
+    });
+    if (process.platform === 'darwin') {
+        return run('dscacheutil', ['-flushcache']).then(() => run('killall', ['-HUP', 'mDNSResponder']));
+    }
+    if (process.platform === 'win32') {
+        return run('ipconfig', ['/flushdns']);
+    }
+    // Linux: try the common resolvers; whichever exists wins, the rest no-op.
+    return run('resolvectl', ['flush-caches'])
+        .then(() => run('systemd-resolve', ['--flush-caches']))
+        .then(() => run('systemctl', ['restart', 'nscd']));
+}
+/**
+ * True when the process likely has the privileges needed to edit the hosts
+ * file (root on POSIX). On Windows we can't cheaply tell, so assume yes and
+ * let the write surface EPERM/EACCES if not.
+ */
+export function hasPrivileges() {
+    if (process.env.KILLM_HOSTS_PATH)
+        return true; // test override, no root needed
+    if (process.platform === 'win32')
+        return true;
+    return typeof process.getuid === 'function' && process.getuid() === 0;
+}

package/dist/src/index.js

@@ -0,0 +1,233 @@
+import readline from 'node:readline';
+import { parseArgs, HELP, VERSION } from './cli.js';
+import { resolveTargets } from './targets.js';
+import { formatDuration } from './duration.js';
+import * as hosts from './hosts.js';
+// Minimal ANSI styling that degrades to plain text when not a TTY.
+const tty = process.stdout.isTTY === true;
+const c = {
+    bold: (s) => (tty ? `\x1b[1m${s}\x1b[0m` : s),
+    dim: (s) => (tty ? `\x1b[2m${s}\x1b[0m` : s),
+    red: (s) => (tty ? `\x1b[31m${s}\x1b[0m` : s),
+    green: (s) => (tty ? `\x1b[32m${s}\x1b[0m` : s),
+    yellow: (s) => (tty ? `\x1b[33m${s}\x1b[0m` : s),
+    cyan: (s) => (tty ? `\x1b[36m${s}\x1b[0m` : s),
+};
+function out(msg = '') {
+    process.stdout.write(msg + '\n');
+}
+function err(msg = '') {
+    process.stderr.write(msg + '\n');
+}
+function errnoCode(e) {
+    return e?.code;
+}
+function scopeLabel(scope) {
+    if (scope.all)
+        return 'everything (agents + web)';
+    const parts = [];
+    if (scope.agents)
+        parts.push('agentic coding + APIs');
+    if (scope.web)
+        parts.push('chat websites');
+    return parts.join(' + ') || 'nothing';
+}
+function privilegeHint() {
+    if (process.platform === 'win32') {
+        return 'Run this from an Administrator terminal (right-click > Run as administrator).';
+    }
+    return 'Re-run with sudo, e.g.  sudo npx killm for 1h --agents';
+}
+async function confirm(question) {
+    if (!process.stdin.isTTY)
+        return true; // non-interactive: assume yes
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => rl.question(question, resolve));
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Render a single-line live countdown that rewrites in place on a TTY.
+ */
+function makeCountdown(endTime) {
+    return function render() {
+        const remaining = Math.max(0, endTime - Date.now());
+        const text = `  ${c.cyan('⛔ blocked')} — ${c.bold(formatDuration(remaining))} remaining   ${c.dim('(Ctrl+C to lift early)')}`;
+        if (tty) {
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            process.stdout.write(text);
+        }
+    };
+}
+async function runBlock(parsed) {
+    const durationMs = parsed.durationMs;
+    const targets = resolveTargets(parsed.scope);
+    out();
+    out(`${c.bold('killm')} ${c.dim('v' + VERSION)}`);
+    out(`  scope:    ${c.bold(scopeLabel(parsed.scope))}`);
+    out(`  duration: ${c.bold(formatDuration(durationMs))}`);
+    out(`  hosts:    ${c.dim(hosts.hostsPath())}`);
+    out(`  blocking ${c.bold(String(targets.length))} hostnames`);
+    out();
+    if (parsed.dryRun) {
+        out(c.yellow('  --dry-run: no changes made. Hostnames that would be blocked:'));
+        for (const h of targets)
+            out('    ' + h);
+        out();
+        return 0;
+    }
+    if (!hosts.hasPrivileges()) {
+        err(c.red('  ✗ killm needs elevated privileges to edit the hosts file.'));
+        err('    ' + privilegeHint());
+        return 1;
+    }
+    if (!parsed.yes) {
+        const ok = await confirm(`  Block ${scopeLabel(parsed.scope)} for ${formatDuration(durationMs)}? [y/N] `);
+        if (!ok) {
+            out(c.dim('  cancelled.'));
+            return 0;
+        }
+    }
+    const endTime = Date.now() + durationMs;
+    const until = new Date(endTime);
+    try {
+        hosts.applyBlock(targets, { until });
+    }
+    catch (e) {
+        const code = errnoCode(e);
+        if (code === 'EACCES' || code === 'EPERM') {
+            err(c.red('  ✗ permission denied writing the hosts file.'));
+            err('    ' + privilegeHint());
+            return 1;
+        }
+        err(c.red('  ✗ failed to apply block: ' + e.message));
+        return 1;
+    }
+    await hosts.flushDns();
+    out(c.green(`  ✓ block active until ${until.toLocaleTimeString()}`));
+    out();
+    let timer = null;
+    let ticker = null;
+    let restored = false;
+    // Restore exactly once, no matter how we leave (timer, Ctrl+C, kill).
+    const restore = (reason) => {
+        if (restored)
+            return;
+        restored = true;
+        if (timer)
+            clearTimeout(timer);
+        if (ticker)
+            clearInterval(ticker);
+        try {
+            const removed = hosts.removeBlock();
+            void hosts.flushDns(); // fire and forget on the way out
+            if (tty) {
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+            }
+            if (removed) {
+                out(c.green(`  ✓ block lifted (${reason}). Access restored.`));
+            }
+            else {
+                out(c.dim(`  block already lifted (${reason}).`));
+            }
+        }
+        catch (e) {
+            err(c.red(`  ✗ could not restore hosts file automatically: ${e.message}`));
+            err(c.red('    Run "sudo npx killm --restore" to clean up.'));
+        }
+    };
+    const render = makeCountdown(endTime);
+    render();
+    ticker = tty ? setInterval(render, 1000) : null;
+    // Last-ditch synchronous cleanup if the event loop is torn down unexpectedly.
+    process.once('exit', () => {
+        if (!restored) {
+            try {
+                hosts.removeBlock();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    });
+    await new Promise((resolve) => {
+        timer = setTimeout(() => {
+            restore('time elapsed');
+            resolve();
+        }, durationMs);
+        const onSignal = (label) => {
+            restore(label);
+            resolve();
+        };
+        process.once('SIGINT', () => onSignal('interrupted'));
+        process.once('SIGTERM', () => onSignal('terminated'));
+    });
+    return 0;
+}
+/**
+ * Program entry point.
+ *
+ * @param argv process.argv.slice(2)
+ * @returns exit code
+ */
+export async function main(argv) {
+    const parsed = parseArgs(argv);
+    if (parsed.error) {
+        err(c.red('error: ' + parsed.error));
+        err('');
+        err('Run "killm --help" for usage.');
+        return 2;
+    }
+    switch (parsed.command) {
+        case 'help':
+            out(HELP);
+            return 0;
+        case 'version':
+            out(VERSION);
+            return 0;
+        case 'status': {
+            if (hosts.isBlocked()) {
+                out(c.yellow('killm: a block is currently ACTIVE.'));
+                out(c.dim('Run "killm --restore" to lift it.'));
+            }
+            else {
+                out(c.green('killm: no block active.'));
+            }
+            return 0;
+        }
+        case 'list': {
+            const targets = resolveTargets(parsed.scope);
+            out(`# ${scopeLabel(parsed.scope)} — ${targets.length} hostnames`);
+            for (const h of targets)
+                out(h);
+            return 0;
+        }
+        case 'restore': {
+            if (!hosts.hasPrivileges()) {
+                err(c.red('killm: needs elevated privileges to edit the hosts file.'));
+                err('  ' + privilegeHint());
+                return 1;
+            }
+            try {
+                const removed = hosts.removeBlock();
+                await hosts.flushDns();
+                out(removed
+                    ? c.green('killm: block lifted. Access restored.')
+                    : c.dim('killm: no block was active.'));
+                return 0;
+            }
+            catch (e) {
+                err(c.red('killm: failed to restore hosts file: ' + e.message));
+                return 1;
+            }
+        }
+        case 'run':
+            return runBlock(parsed);
+    }
+}

package/dist/src/targets.js

@@ -0,0 +1,113 @@
+/**
+ * Domain target lists, split by the kind of access they represent.
+ *
+ * The split between `agents` and `web` is the whole point of killm: an agentic
+ * coding tool (Claude Code, Cursor, Copilot, Aider, ...) talks to a *different*
+ * host than the consumer chat website. Claude Code hits `api.anthropic.com`
+ * while the chat UI lives on `claude.ai`; the OpenAI API lives on
+ * `api.openai.com` while ChatGPT lives on `chatgpt.com`. Because they are
+ * separate hostnames we can cut off one without touching the other.
+ *
+ * Blocking is done at the hostname level (via the hosts file), so we cannot
+ * block by URL path. Where a product only exposes a chat product behind a path
+ * we block the closest dedicated hostname instead.
+ */
+// API endpoints + dedicated coding-assistant backends. Blocking these stops
+// agentic coding tools and raw API usage WITHOUT touching the chat websites.
+export const AGENTS = [
+    // Provider API endpoints (used by Claude Code, Codex, Aider, Continue, etc.)
+    'api.anthropic.com',
+    'api.openai.com',
+    'api.x.ai',
+    'api.mistral.ai',
+    'api.groq.com',
+    'api.deepseek.com',
+    'api.together.xyz',
+    'api.fireworks.ai',
+    'api.cohere.com',
+    'api.perplexity.ai',
+    'generativelanguage.googleapis.com',
+    'api.replicate.com',
+    // Cursor
+    'cursor.com',
+    'api2.cursor.sh',
+    'api3.cursor.sh',
+    'api4.cursor.sh',
+    'repo42.cursor.sh',
+    // GitHub Copilot
+    'api.githubcopilot.com',
+    'copilot-proxy.githubusercontent.com',
+    'copilot-telemetry.githubusercontent.com',
+    'proxy.individual.githubcopilot.com',
+    'proxy.business.githubcopilot.com',
+    'api.individual.githubcopilot.com',
+    'api.business.githubcopilot.com',
+    // Codeium / Windsurf
+    'server.codeium.com',
+    'codeium.com',
+    'windsurf.com',
+    // Sourcegraph Cody
+    'cody-gateway.sourcegraph.com',
+    'sourcegraph.com',
+    // Tabnine
+    'api.tabnine.com',
+    'tabnine.com',
+    // Continue.dev
+    'api.continue.dev',
+    'continue.dev',
+    // Supermaven
+    'api.supermaven.com',
+    'supermaven.com',
+];
+// Consumer chat websites. Blocking these stops the browser apps WITHOUT
+// touching the API endpoints that coding agents rely on.
+export const WEB = [
+    // OpenAI ChatGPT
+    'chatgpt.com',
+    'chat.openai.com',
+    // Anthropic Claude
+    'claude.ai',
+    // Google Gemini
+    'gemini.google.com',
+    'bard.google.com',
+    // xAI Grok
+    'grok.com',
+    // Microsoft Copilot (consumer)
+    'copilot.microsoft.com',
+    // Mistral Le Chat
+    'chat.mistral.ai',
+    // DeepSeek
+    'chat.deepseek.com',
+    // Perplexity
+    'perplexity.ai',
+    'www.perplexity.ai',
+    // Meta AI
+    'meta.ai',
+    'www.meta.ai',
+    // Poe
+    'poe.com',
+    // Character.AI
+    'character.ai',
+    // You.com
+    'you.com',
+    // Phind
+    'phind.com',
+    // Hugging Face Chat
+    'huggingface.co',
+];
+/**
+ * Resolve the set of hostnames to block from the parsed category flags.
+ * Returns a de-duplicated, sorted array.
+ */
+export function resolveTargets(flags) {
+    const set = new Set();
+    if (flags.all || flags.agents) {
+        for (const h of AGENTS)
+            set.add(h);
+    }
+    if (flags.all || flags.web) {
+        for (const h of WEB)
+            set.add(h);
+    }
+    return Array.from(set).sort();
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "killm",
+  "version": "1.0.0",
+  "description": "Temporarily block your machine from reaching LLM services to curb AI dependency. npx killm for 1h --agents",
+  "bin": {
+    "killm": "dist/src/bin.js"
+  },
+  "type": "module",
+  "files": [
+    "dist/src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "pretest": "npm run build",
+    "test": "node --test dist/test/duration.test.js dist/test/targets.test.js dist/test/cli.test.js dist/test/hosts.test.js dist/test/e2e.test.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepublishOnly": "npm run lint && npm run format:check && npm test"
+  },
+  "keywords": [
+    "llm",
+    "ai",
+    "focus",
+    "block",
+    "hosts",
+    "productivity",
+    "digital-wellbeing",
+    "claude",
+    "chatgpt",
+    "copilot",
+    "cursor"
+  ],
+  "author": "Aidan Neel",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.17"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aidan-neel/killm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aidan-neel/killm/issues"
+  },
+  "homepage": "https://github.com/aidan-neel/killm#readme",
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.2",
+    "eslint": "^10.4.1",
+    "prettier": "^3.8.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.61.0"
+  }
+}