killm 1.0.2 → 1.0.3

package/README.md

@@ -163,12 +163,26 @@ target hostname at `0.0.0.0` (and `::1` for IPv6):
 ```
 
 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.
+the timer expires — or on `Ctrl+C`, `SIGTERM`, or closing the terminal
+(`SIGHUP`) — 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.
+### If the killm process dies, the block stays — until killm heals it
+
+The timer lives in the killm process, so **keep it running** for the duration.
+Ctrl+C and closing the terminal both lift the block cleanly, but a `kill -9`,
+a crash, or a machine shutdown can strand the block in your hosts file.
+
+killm writes the expiry time into the block itself, so it self-heals: **any
+later killm command** (`--status`, `--restore`, or starting a new block)
+notices an expired stranded block and removes it. To lift one immediately:
+
+```bash
+sudo npx killm --restore
+```
+
+`killm --status` also tells you when an active block is scheduled to lift.
 
 ## Firewall mode (`--firewall`)
 

package/dist/src/hosts.js

@@ -4,6 +4,8 @@ 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 <<<';
+/** Machine-parseable expiry marker inside the block. */
+export const EXPIRES_PREFIX = '# killm-expires: ';
 const SINK4 = '0.0.0.0';
 const SINK6 = '::1';
 function errnoCode(err) {
@@ -59,6 +61,7 @@ export function buildBlock(hosts, opts = {}) {
     lines.push(`# added by killm at ${new Date().toISOString()}`);
     if (opts.until) {
         lines.push(`# auto-removed at ${opts.until.toISOString()} (or when killm exits)`);
+        lines.push(`${EXPIRES_PREFIX}${opts.until.toISOString()}`);
     }
     for (const h of hosts) {
         lines.push(`${SINK4}\t${h}`);
@@ -125,6 +128,36 @@ export function removeBlock() {
 export function isBlocked() {
     return readHosts().includes(BEGIN);
 }
+/**
+ * When the current block is scheduled to expire, or null when no block is
+ * present or it carries no (valid) expiry marker — e.g. blocks written by
+ * killm <= 1.0.2.
+ */
+export function blockExpiry(text = readHosts()) {
+    const begin = text.indexOf(BEGIN);
+    if (begin === -1)
+        return null;
+    const idx = text.indexOf(EXPIRES_PREFIX, begin);
+    if (idx === -1)
+        return null;
+    const start = idx + EXPIRES_PREFIX.length;
+    const lineEnd = text.indexOf('\n', start);
+    const stamp = text.slice(start, lineEnd === -1 ? undefined : lineEnd).trim();
+    const date = new Date(stamp);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+/**
+ * Remove the block if its expiry has passed — heals hosts files stranded by
+ * a killed process (terminal closed, kill -9, crash, machine shutdown).
+ *
+ * @returns true when an expired block was found and removed
+ */
+export function clearExpiredBlock(now = new Date()) {
+    const expiry = blockExpiry();
+    if (expiry === null || expiry.getTime() > now.getTime())
+        return false;
+    return removeBlock();
+}
 /**
  * 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.

package/dist/src/index.js

@@ -94,6 +94,15 @@ async function runBlock(parsed) {
             return 0;
         }
     }
+    // Heal any expired block stranded by a killed process before applying ours.
+    try {
+        if (hosts.clearExpiredBlock()) {
+            out(c.dim('  (cleaned up an expired block left behind by a previous run)'));
+        }
+    }
+    catch {
+        /* no privileges; the apply below will surface the real error */
+    }
     const endTime = Date.now() + durationMs;
     const until = new Date(endTime);
     try {
@@ -138,6 +147,11 @@ async function runBlock(parsed) {
         '\n' +
         c.dim('  file entirely — restart the browser / disable Secure DNS if needed.'));
     out();
+    out(c.yellow('  ⚠ keep this process running — killm lifts the block when the timer'));
+    out(c.yellow('    ends or you press Ctrl+C / close the terminal. If it dies harder'));
+    out(c.yellow('    than that (kill -9, crash, shutdown), the block stays in place'));
+    out(c.yellow('    until you run any killm command again, e.g.  killm --restore'));
+    out();
     let timer = null;
     let ticker = null;
     let restored = false;
@@ -199,6 +213,9 @@ async function runBlock(parsed) {
         };
         process.once('SIGINT', () => onSignal('interrupted'));
         process.once('SIGTERM', () => onSignal('terminated'));
+        // Closing the terminal window sends SIGHUP; without this handler Node
+        // dies without cleanup and the block is stranded in the hosts file.
+        process.once('SIGHUP', () => onSignal('terminal closed'));
     });
     return 0;
 }
@@ -224,9 +241,31 @@ export async function main(argv) {
             out(VERSION);
             return 0;
         case 'status': {
+            const expiry = hosts.blockExpiry();
+            const expired = expiry !== null && expiry.getTime() <= Date.now();
+            if (expired) {
+                // A previous run was killed before it could clean up. Heal it now.
+                try {
+                    hosts.clearExpiredBlock();
+                    await hosts.flushDns();
+                    out(c.green('killm: no block active.'));
+                    out(c.dim('(cleaned up an expired block left behind by a previous run)'));
+                    return 0;
+                }
+                catch {
+                    err(c.yellow('killm: an EXPIRED block is still stuck in the hosts file.'));
+                    err('  Clean it up with elevated privileges:  sudo npx killm --restore');
+                    return 1;
+                }
+            }
             if (hosts.isBlocked()) {
                 out(c.yellow('killm: a block is currently ACTIVE.'));
-                out(c.dim('Run "killm --restore" to lift it.'));
+                if (expiry) {
+                    out(c.dim(`Scheduled to lift at ${expiry.toLocaleString()}.`));
+                    out(c.dim('If the killm process that created it is no longer running, it will not\n' +
+                        'lift itself on time — but any later killm command cleans it up once expired.'));
+                }
+                out(c.dim('Run "killm --restore" to lift it now.'));
             }
             else {
                 out(c.green('killm: no block active.'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killm",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Temporarily block your machine from reaching LLM services to curb AI dependency. npx killm for 1h --agents",
   "bin": {
     "killm": "dist/src/bin.js"