code-alarm 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yevhen Mishchenko
+
+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

@@ -1,3 +1,124 @@
-# Temporary Holding Version
+<h1 align="center">Code Alarm</h1>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<p align="center">
+  <b>Start a long agent task, walk away, and get woken up when it's done.</b><br>
+  A real alarm on your phone when Claude Code or Codex finishes or needs you.
+</p>
+
+<p align="center">
+  <a href="https://github.com/Draganoider/code-alarm/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/Draganoider/code-alarm/actions/workflows/ci.yml/badge.svg?branch=main"></a>
+  <img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue">
+  <img alt="Agents: Claude Code and Codex" src="https://img.shields.io/badge/agents-Claude%20Code%20%7C%20Codex-8A63D2">
+  <img alt="Node 22+" src="https://img.shields.io/badge/node-%E2%89%A522-339933">
+</p>
+
+---
+
+Coding agents now work for an hour or more on their own. Their phone apps will *notify* you when
+they're done, but Do Not Disturb swallows a notification and it rings once. **Code Alarm rings like
+an alarm**, until you dismiss it, and only for work you armed.
+
+- **One command to arm:** `/code-alarm:alarm` in Claude Code, or ask Codex to use the code-alarm
+  skill. Sessions you didn't arm stay silent.
+- **Knows why it stopped:** *done*, *needs you* (a question or a permission prompt), *failed*, or
+  *stopped*.
+- **Nothing leaves your computer** except the event type and the project folder's name: no prompts,
+  code, paths or transcripts ([protocol](docs/protocol.md)).
+- **Never slows your agent down:** hooks return at once and send in the background. A network
+  problem can't stall a session.
+- **Free:** it rings your phone through the [ntfy](https://ntfy.sh) app today. A dedicated Code
+  Alarm Android app is coming.
+
+## Set up (5 minutes)
+
+You need **Node.js 22 or newer** on the computer that runs your agent.
+
+**1. Create your private alarm channel:**
+
+```bash
+npx code-alarm init
+```
+
+It prints a long random ntfy topic. Treat it like a password: anyone who knows it can ring your
+phone.
+
+**2. On your phone:** install **ntfy** ([Google Play](https://play.google.com/store/apps/details?id=io.heckel.ntfy),
+[F-Droid](https://f-droid.org/packages/io.heckel.ntfy/), [App Store](https://apps.apple.com/app/ntfy/id1625396347))
+and subscribe to that topic. In the subscription's settings, turn on **keep alerting for the
+highest priority** and the **Do Not Disturb override**. Then check it:
+
+```bash
+npx code-alarm test
+```
+
+**3. Connect your agent.**
+
+Claude Code:
+
+```bash
+claude plugin marketplace add Draganoider/code-alarm
+```
+
+```bash
+claude plugin install code-alarm@code-alarm
+```
+
+Codex (adds user-level hooks and a skill; open Codex afterwards and **trust the new hooks**):
+
+```bash
+npx code-alarm install codex
+```
+
+## Use
+
+Before a long task, arm it:
+
+| Agent | How |
+|---|---|
+| Claude Code | `/code-alarm:alarm`, then give it the task (or say "wake me when it's done") |
+| Codex | "Use the code-alarm skill and …", or "wake me when it's done" |
+| Any terminal | `code-alarm arm` in the project folder; `code-alarm nap 2h` arms every session for 2 hours |
+
+**Prefer a plain notification?** Say *quiet*: `/code-alarm:alarm quiet …`, "quietly notify me
+when done", or `code-alarm arm --notify`. You get one normal notification, which pops up with sound
+and vibration and follows your phone's sound settings, instead of the repeating alarm.
+
+The agent ends its work with `done`, `needs-you` or `failed`, and your phone rings with that
+reason. If it forgets, the alarm still rings when it stops, labelled *stopped*.
+
+`code-alarm status` shows what's set up, what's armed and the last alerts. `code-alarm disarm`
+cancels arming.
+
+## How it works
+
+```mermaid
+sequenceDiagram
+    actor You
+    participant Agent as Claude Code / Codex
+    participant CLI as code-alarm (hooks)
+    participant Phone as ntfy on your phone
+    You->>Agent: /code-alarm:alarm + the task
+    Agent->>CLI: code-alarm arm
+    Note over Agent: works for minutes or hours
+    Agent->>CLI: code-alarm done (or the Stop hook)
+    CLI-->>Phone: {kind, folder name}, max priority
+    Phone->>You: rings until you dismiss it
+```
+
+Details: [event protocol](docs/protocol.md) · [agent integration notes](docs/agents.md).
+
+## Develop
+
+```bash
+cd cli
+npm install
+npm run check
+```
+
+`npm run check` type-checks, runs the tests, and builds the bundle into `cli/dist/` and the Claude
+Code plugin. The bundled files are committed, because plugins install straight from the repository.
+To try your working copy in Claude Code: `claude --plugin-dir plugins/claude-code`.
+
+## License
+
+[MIT](LICENSE). Not affiliated with Anthropic or OpenAI.

package/dist/code-alarm.mjs

@@ -0,0 +1,1102 @@
+#!/usr/bin/env node
+// code-alarm, MIT License, https://github.com/Draganoider/code-alarm. Generated by cli/build.mjs: do not edit.
+
+// src/main.ts
+import { homedir as homedir2 } from "node:os";
+import { resolve as resolve3 } from "node:path";
+import { parseArgs } from "node:util";
+
+// src/config.ts
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/fsutil.ts
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function writeFileAtomic(path, data, mode) {
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temp, data, mode === void 0 ? void 0 : { mode });
+  renameSync(temp, path);
+}
+
+// src/config.ts
+var ConfigError = class extends Error {
+};
+var DEFAULT_NTFY_SERVER = "https://ntfy.sh";
+function configPath(home) {
+  return join(home, "config.json");
+}
+function loadConfig(home) {
+  const path = configPath(home);
+  if (!existsSync(path)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new ConfigError(`${path} isn't valid JSON. Fix it, or run \`code-alarm init --force\` to start over.`);
+  }
+  const config = raw;
+  const ntfy = config.ntfy;
+  if (config.transport !== "ntfy" || !ntfy || typeof ntfy.server !== "string" || typeof ntfy.topic !== "string") {
+    throw new ConfigError(`${path} is missing its ntfy settings. Run \`code-alarm init --force\`.`);
+  }
+  return { version: 1, transport: "ntfy", ntfy: { server: ntfy.server, topic: ntfy.topic, ...ntfy.token ? { token: ntfy.token } : {} } };
+}
+function saveConfig(home, config) {
+  writeFileAtomic(configPath(home), JSON.stringify(config, null, 2) + "\n", 384);
+}
+function newTopic() {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const bytes = randomBytes(24);
+  let suffix = "";
+  for (let i = 0; i < 24; i++) suffix += alphabet[bytes[i] % alphabet.length];
+  return `code-alarm-${suffix}`;
+}
+function isValidTopic(topic) {
+  return /^[A-Za-z0-9_-]{1,64}$/.test(topic);
+}
+
+// src/deliver.ts
+import { spawn } from "node:child_process";
+import { appendFileSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/events.ts
+import { createHash, randomUUID } from "node:crypto";
+var EVENT_FIELDS = ["v", "id", "kind", "level", "label", "agent", "sent_at", "expires_at"];
+var KINDS = ["done", "needs_input", "failed", "stopped", "test"];
+var DEFAULT_TTL_MS = 30 * 6e4;
+var MAX_LABEL = 40;
+function labelFor(dir) {
+  const name = (dir.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "").replace(/[^A-Za-z0-9._ -]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-. ]+|[-. ]+$/g, "").slice(0, MAX_LABEL).trim();
+  return name || "project";
+}
+function eventId(parts) {
+  if (!parts || parts.some((part) => !part)) return randomUUID();
+  const hex = createHash("sha256").update(parts.join("|")).digest("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function buildEvent(args) {
+  return {
+    v: 1,
+    id: eventId(args.idParts),
+    kind: args.kind,
+    level: args.level ?? "alarm",
+    label: args.label.slice(0, MAX_LABEL),
+    agent: args.agent,
+    sent_at: args.now,
+    expires_at: args.now + (args.ttlMs ?? DEFAULT_TTL_MS)
+  };
+}
+function agentName(agent) {
+  return agent === "claude-code" ? "Claude Code" : agent === "codex" ? "Codex" : "Your task";
+}
+
+// src/ntfy.ts
+var TEXT = {
+  done: { title: "Done", message: (a) => `${a} finished the task.`, tags: ["white_check_mark"] },
+  needs_input: { title: "Needs you", message: (a) => `${a} is waiting for your answer or approval.`, tags: ["raising_hand"] },
+  failed: { title: "Failed", message: (a) => `${a} stopped on an error.`, tags: ["x"] },
+  stopped: { title: "Stopped", message: (a) => `${a} stopped. It may be done, or waiting for you.`, tags: ["warning"] },
+  test: { title: "Test alarm", message: () => "If your phone rang loudly, Code Alarm is set up.", tags: ["bell"] }
+};
+function ntfyRequest(event, config) {
+  const text = TEXT[event.kind];
+  const headers = { "content-type": "application/json" };
+  if (config.token) headers.authorization = `Bearer ${config.token}`;
+  return {
+    url: `${config.server.replace(/\/+$/, "")}/`,
+    init: {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        topic: config.topic,
+        title: event.kind === "test" ? text.title : `${text.title}: ${event.label}`,
+        message: text.message(agentName(event.agent)),
+        // 5 ("max") is the alarm: the ntfy app keeps alerting until dismissed, through Do Not
+        // Disturb if the subscription allows it. 4 ("high") is a normal notification that pops up
+        // with sound and vibration, once. 3 ("default") often arrives silently, without a pop-up.
+        priority: event.level === "notify" ? 4 : 5,
+        tags: text.tags
+      })
+    }
+  };
+}
+async function sendNtfy(event, config, fetchImpl = fetch, timeoutMs = 4e3) {
+  const { url, init } = ntfyRequest(event, config);
+  try {
+    const res = await fetchImpl(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+    return res.ok ? { ok: true, detail: `HTTP ${res.status}` } : { ok: false, detail: `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, detail: e instanceof Error ? e.name : "error" };
+  }
+}
+
+// src/deliver.ts
+var logPath = (home) => join2(home, "log.txt");
+function logLine(home, line) {
+  try {
+    mkdirSync2(home, { recursive: true });
+    const path = logPath(home);
+    appendFileSync(path, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+    if (statSync(path).size > 64e3) {
+      const lines = readFileSync2(path, "utf8").trimEnd().split("\n");
+      writeFileAtomic(path, lines.slice(-200).join("\n") + "\n");
+    }
+  } catch {
+  }
+}
+function recentLog(home, count) {
+  try {
+    return readFileSync2(logPath(home), "utf8").trimEnd().split("\n").slice(-count);
+  } catch {
+    return [];
+  }
+}
+async function sendNow(home, event, fetchImpl) {
+  const config = loadConfig(home);
+  if (!config) return { ok: false, detail: "not set up: run `code-alarm init`" };
+  const result = await sendNtfy(event, config.ntfy, fetchImpl);
+  logLine(home, `${event.kind}/${event.level} ${event.agent} "${event.label}" ${result.ok ? "sent" : "FAILED"} (${result.detail})`);
+  return result;
+}
+function sendDetached(event, script = process.argv[1]) {
+  const payload = Buffer.from(JSON.stringify(event)).toString("base64url");
+  runDetached(script, ["__send", payload]);
+}
+function waitDetached(id, at, script = process.argv[1]) {
+  runDetached(script, ["__wait", id, String(at)]);
+}
+function runDetached(script, args) {
+  if (!script) return;
+  const child = spawn(process.execPath, [script, ...args], { detached: true, stdio: "ignore", windowsHide: true });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function decodeEvent(arg) {
+  try {
+    const event = JSON.parse(Buffer.from(arg, "base64url").toString("utf8"));
+    const keys = Object.keys(event);
+    const allowed = new Set(EVENT_FIELDS);
+    if (keys.some((key) => !allowed.has(key))) return null;
+    if (event.v !== 1 || typeof event.id !== "string" || typeof event.label !== "string") return null;
+    if (!KINDS.includes(event.kind)) return null;
+    if (typeof event.sent_at !== "number" || typeof event.expires_at !== "number") return null;
+    return event;
+  } catch {
+    return null;
+  }
+}
+
+// src/duration.ts
+var HOUR = 36e5;
+var MINUTE = 6e4;
+var MAX_ARM_MS = 24 * HOUR;
+function parseDuration(text) {
+  const trimmed = text.trim().toLowerCase();
+  const match = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/.exec(trimmed);
+  if (!match || trimmed === "") return null;
+  const [, h, m, s] = match;
+  const ms = Number(h ?? 0) * HOUR + Number(m ?? 0) * MINUTE + Number(s ?? 0) * 1e3;
+  return ms > 0 ? ms : null;
+}
+function formatDuration(ms) {
+  if (ms < MINUTE) return `${Math.max(0, Math.round(ms / 1e3))}s`;
+  const h = Math.floor(ms / HOUR);
+  const m = Math.round(ms % HOUR / MINUTE);
+  if (h === 0) return `${m}m`;
+  return m === 0 ? `${h}h` : `${h}h ${m}m`;
+}
+
+// src/hook.ts
+import { createHash as createHash3 } from "node:crypto";
+import { resolve as resolve2 } from "node:path";
+
+// src/state.ts
+import { createHash as createHash2 } from "node:crypto";
+import { closeSync, existsSync as existsSync2, linkSync, mkdirSync as mkdirSync3, openSync, readdirSync, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, statSync as statSync2 } from "node:fs";
+import { isAbsolute, join as join3, relative, resolve } from "node:path";
+var NAP_KEY = "nap";
+function normalize(dir, platform = process.platform) {
+  const full = resolve(dir);
+  return platform === "win32" ? full.toLowerCase() : full;
+}
+function keyFor(dir) {
+  return createHash2("sha256").update(normalize(dir)).digest("hex").slice(0, 16);
+}
+var armedDir = (home) => join3(home, "armed");
+var signalFile = (home, key) => join3(home, "signaled", `${key}.json`);
+var sentFile = (home, key, kind) => join3(home, "sent", `${key}-${kind}.json`);
+function armProject(home, dir, until, now, level = "alarm") {
+  const arming = { kind: "project", level, dir: resolve(dir), armedAt: now, until };
+  const key = keyFor(dir);
+  writeFileAtomic(join3(armedDir(home), `${key}.json`), JSON.stringify(arming));
+  startFresh(home, key);
+  return { ...arming, key };
+}
+function armNap(home, until, now, level = "alarm") {
+  const arming = { kind: "nap", level, armedAt: now, until };
+  writeFileAtomic(join3(armedDir(home), `${NAP_KEY}.json`), JSON.stringify(arming));
+  startFresh(home, NAP_KEY);
+  return { ...arming, key: NAP_KEY };
+}
+function startFresh(home, key) {
+  clearSignaled(home, key);
+  const dir = join3(home, "sent");
+  if (!existsSync2(dir)) return;
+  for (const file of readdirSync(dir)) if (file.startsWith(`${key}-`)) rmSync(join3(dir, file), { force: true });
+}
+function listArmings(home, now) {
+  const dir = armedDir(home);
+  if (!existsSync2(dir)) return [];
+  const found = [];
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith(".json")) continue;
+    const path = join3(dir, file);
+    try {
+      const arming = JSON.parse(readFileSync3(path, "utf8"));
+      if (typeof arming.until !== "number" || arming.until <= now) {
+        rmSync(path, { force: true });
+        continue;
+      }
+      found.push({ ...arming, key: file.slice(0, -".json".length) });
+    } catch {
+      rmSync(path, { force: true });
+    }
+  }
+  return found;
+}
+function contains(parent, child) {
+  const rel = relative(normalize(parent), normalize(child));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function findArming(home, cwd, now) {
+  const armings = listArmings(home, now);
+  let best = null;
+  for (const arming of armings) {
+    if (arming.kind !== "project" || !arming.dir || !contains(arming.dir, cwd)) continue;
+    if (!best || (best.dir?.length ?? 0) < arming.dir.length) best = arming;
+  }
+  return best ?? armings.find((arming) => arming.kind === "nap") ?? null;
+}
+function claim(home, arming) {
+  if (arming.kind !== "project") return true;
+  const path = join3(armedDir(home), `${arming.key}.json`);
+  const claimed = `${path}.${process.pid}.${Date.now()}.claimed`;
+  try {
+    renameSync2(path, claimed);
+  } catch (e) {
+    if (e.code === "ENOENT") return false;
+    rmSync(path, { force: true });
+    return true;
+  }
+  try {
+    const taken = JSON.parse(readFileSync3(claimed, "utf8"));
+    if (taken.armedAt !== arming.armedAt || taken.until !== arming.until) {
+      try {
+        linkSync(claimed, path);
+      } catch {
+      }
+      rmSync(claimed, { force: true });
+      return false;
+    }
+  } catch {
+  }
+  rmSync(claimed, { force: true });
+  return true;
+}
+function claimEvent(home, id, now) {
+  const dir = join3(home, "events");
+  try {
+    mkdirSync3(dir, { recursive: true });
+    for (const file of readdirSync(dir)) {
+      try {
+        const path = join3(dir, file);
+        if (now - statSync2(path).mtimeMs > 24 * 60 * 6e4) rmSync(path, { force: true });
+      } catch {
+      }
+    }
+    closeSync(openSync(join3(dir, id), "wx"));
+    return true;
+  } catch (e) {
+    return e.code !== "EEXIST";
+  }
+}
+function disarmProject(home, dir) {
+  const path = join3(armedDir(home), `${keyFor(dir)}.json`);
+  const existed = existsSync2(path);
+  rmSync(path, { force: true });
+  return existed;
+}
+function disarmAll(home) {
+  const dir = armedDir(home);
+  if (!existsSync2(dir)) return 0;
+  const files = readdirSync(dir).filter((file) => file.endsWith(".json"));
+  for (const file of files) rmSync(join3(dir, file), { force: true });
+  return files.length;
+}
+function signalKey(armingKey, sessionId) {
+  return sessionId ? `session-${createHash2("sha256").update(sessionId).digest("hex").slice(0, 16)}` : armingKey;
+}
+function markSignaled(home, key, now, kind) {
+  writeFileAtomic(signalFile(home, key), JSON.stringify({ at: now, kind }));
+}
+function isSignaled(home, key) {
+  return existsSync2(signalFile(home, key));
+}
+function signaledKind(home, key) {
+  try {
+    const { kind } = JSON.parse(readFileSync3(signalFile(home, key), "utf8"));
+    return kind ?? null;
+  } catch {
+    return null;
+  }
+}
+function clearSignaled(home, key) {
+  rmSync(signalFile(home, key), { force: true });
+}
+var pendingFile = (home, id) => join3(home, "pending", `${id}.json`);
+var sessionPrefix = (sessionId) => `${signalKey("", sessionId)}-`;
+function pendingId(sessionId, requestHash) {
+  return `${sessionPrefix(sessionId)}${requestHash}`;
+}
+function recordPending(home, id, pending) {
+  writeFileAtomic(pendingFile(home, id), JSON.stringify(pending));
+}
+function takePending(home, id, at) {
+  const path = pendingFile(home, id);
+  try {
+    const pending = JSON.parse(readFileSync3(path, "utf8"));
+    if (pending.at !== at) return null;
+    rmSync(path, { force: true });
+    return pending;
+  } catch {
+    return null;
+  }
+}
+function clearPending(home, id) {
+  const path = pendingFile(home, id);
+  const existed = existsSync2(path);
+  rmSync(path, { force: true });
+  return existed;
+}
+function clearSessionPending(home, sessionId) {
+  const dir = join3(home, "pending");
+  if (!existsSync2(dir)) return;
+  const prefix = sessionPrefix(sessionId);
+  for (const file of readdirSync(dir)) if (file.startsWith(prefix)) rmSync(join3(dir, file), { force: true });
+}
+function rateLimited(home, key, kind, now, windowMs) {
+  const path = sentFile(home, key, kind);
+  try {
+    const { at } = JSON.parse(readFileSync3(path, "utf8"));
+    if (typeof at === "number" && now - at < windowMs) return true;
+  } catch {
+  }
+  mkdirSync3(join3(home, "sent"), { recursive: true });
+  writeFileAtomic(path, JSON.stringify({ at: now }));
+  return false;
+}
+
+// src/hook.ts
+var NEEDS_INPUT_WINDOW_MS = 2 * 6e4;
+var PENDING_WAIT_MS = 45e3;
+var NEEDS_INPUT = { type: "send", kind: "needs_input", fallback: false, consume: false, rateLimitMs: NEEDS_INPUT_WINDOW_MS };
+var ENDS_WAITING = /* @__PURE__ */ new Set(["Stop", "StopFailure", "UserPromptSubmit"]);
+var str = (value) => typeof value === "string" && value !== "" ? value : void 0;
+function parseHookInput(raw) {
+  try {
+    const data = JSON.parse(raw);
+    const event = str(data.hook_event_name);
+    if (!event) return null;
+    const toolInput = data.tool_input && typeof data.tool_input === "object" ? data.tool_input : {};
+    const command = str(toolInput.command);
+    const request = command ?? (data.tool_input === void 0 ? void 0 : JSON.stringify(data.tool_input));
+    return {
+      event,
+      sessionId: str(data.session_id),
+      cwd: str(data.cwd),
+      turnId: str(data.turn_id),
+      promptId: str(data.prompt_id),
+      command,
+      requestHash: request === void 0 ? void 0 : createHash3("sha256").update(request).digest("hex").slice(0, 16)
+    };
+  } catch {
+    return null;
+  }
+}
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["arm", "disarm", "nap", "status", "test", "init", "install", "uninstall", "done", "needs-you", "failed", "help", "version"]);
+var SIGNALS = /* @__PURE__ */ new Set(["done", "needs-you", "failed"]);
+var SHELL = /^(?:pwsh|powershell|bash|sh|zsh|cmd)(?:\.exe)?$/;
+var SCRIPT_FLAG = /^[-/](?:c|lc|command)$/i;
+var CHANGE_DIR = /^(?:cd|chdir|pushd|set-location|sl)$/;
+var EXPANSION = /\$\(|`|[<>]\(/;
+var basename = (word) => (word.split(/[\\/]/).pop() ?? "").toLowerCase();
+function simpleCommands(line) {
+  const commands = [];
+  let words = [];
+  let word = "";
+  let inWord = false;
+  let quote = null;
+  const endWord = () => {
+    if (inWord && !/^\d*[<>]/.test(word)) words.push(word);
+    word = "";
+    inWord = false;
+  };
+  const endCommand = () => {
+    endWord();
+    if (words.length > 0) commands.push(words);
+    words = [];
+  };
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (quote) {
+      if (c === quote) quote = null;
+      else if (c === "\\" && quote === '"' && (line[i + 1] === '"' || line[i + 1] === "\\")) word += line[++i];
+      else word += c;
+    } else if (c === '"' || c === "'") {
+      quote = c;
+      inWord = true;
+    } else if (c === "&" && word.endsWith(">")) {
+      word += c;
+    } else if (c === "(" || c === ")") {
+      return null;
+    } else if (";&|\n\r".includes(c)) {
+      endCommand();
+    } else if (/\s/.test(c)) {
+      endWord();
+    } else {
+      word += c;
+      inWord = true;
+    }
+  }
+  endCommand();
+  return commands;
+}
+function ownInWords(words, cwd) {
+  const first = basename(words[0]);
+  let i = 0;
+  if (/^npx(?:\.cmd)?$/.test(first)) {
+    i++;
+    while (words[i]?.startsWith("-")) i++;
+  } else if (/^node(?:\.exe)?$/.test(first)) {
+    i++;
+  }
+  if (!words[i] || !/^code-alarm(?:\.mjs|\.cmd|\.ps1)?$/.test(basename(words[i]))) return null;
+  const sub = words[i + 1];
+  return sub && SUBCOMMANDS.has(sub) ? { sub, cwd } : null;
+}
+function ownInLine(line, cwd, depth) {
+  const commands = depth > 3 || EXPANSION.test(line) ? null : simpleCommands(line);
+  if (!commands) return null;
+  let own = null;
+  let dir = cwd;
+  for (const words of commands) {
+    const first = basename(words[0]);
+    if (CHANGE_DIR.test(first)) {
+      const args = words.slice(1).filter((word) => !/^-(?:path|literalpath)$/i.test(word));
+      if (args.length !== 1 || /[$%*?]|^~/.test(args[0]) || args[0] === "-") return null;
+      dir = resolve2(dir, args[0]);
+      continue;
+    }
+    let found;
+    if (SHELL.test(first)) {
+      const flag = words.findIndex((word, i) => i > 0 && SCRIPT_FLAG.test(word));
+      const script = flag > 0 ? words.slice(flag + 1) : [];
+      const inner = script.length === 1 ? script[0] : script.map((word) => /\s/.test(word) ? `"${word}"` : word).join(" ");
+      found = script.length > 0 ? ownInLine(inner, dir, depth + 1) : null;
+    } else {
+      found = ownInWords(words, dir);
+    }
+    if (!found) return null;
+    if (!own || !SIGNALS.has(own.sub) && SIGNALS.has(found.sub)) own = found;
+  }
+  return own;
+}
+function ownCommand(command, cwd) {
+  return command ? ownInLine(command, resolve2(cwd), 0) : null;
+}
+function actionFor(agent, input, cwd) {
+  switch (input.event) {
+    case "Stop":
+      return { type: "send", kind: "stopped", fallback: true, consume: true };
+    case "StopFailure":
+      return { type: "send", kind: "failed", fallback: false, consume: true };
+    case "PermissionRequest": {
+      const own = ownCommand(input.command, cwd);
+      if (own?.sub === "done") return { type: "signal", kind: "done", cwd: own.cwd };
+      if (own?.sub === "needs-you") return { type: "signal", kind: "needs_input", cwd: own.cwd };
+      if (own?.sub === "failed") return { type: "signal", kind: "failed", cwd: own.cwd };
+      if (own) return { type: "none" };
+      return agent === "codex" ? { type: "await-answer" } : NEEDS_INPUT;
+    }
+    case "PostToolUse":
+      return agent === "codex" ? { type: "tool-ran" } : { type: "none" };
+    case "UserPromptSubmit":
+      return { type: "clear-signal" };
+    default:
+      return { type: "none" };
+  }
+}
+var agentOf = (agent) => agent === "claude" ? "claude-code" : "codex";
+async function runHook(agent, raw, deps) {
+  try {
+    const input = parseHookInput(raw);
+    if (!input) return "";
+    const cwd = input.cwd ?? deps.cwd();
+    if (input.sessionId && ENDS_WAITING.has(input.event)) {
+      try {
+        clearSessionPending(deps.home, input.sessionId);
+      } catch {
+      }
+    }
+    const action = actionFor(agent, input, cwd);
+    if (action.type === "none") return "";
+    if (action.type === "signal") {
+      const result = await sendSignal(action.kind, agentOf(agent), action.cwd, deps, input.sessionId);
+      return result.sent ? `hook ${agent} ${input.event}: ${action.kind} signal sent while awaiting approval` : "";
+    }
+    if (action.type === "tool-ran") {
+      if (!input.sessionId || !input.requestHash) return "";
+      const answered = clearPending(deps.home, pendingId(input.sessionId, input.requestHash));
+      return answered ? `hook ${agent} ${input.event}: the approval request was answered, no needs_input` : "";
+    }
+    const now = deps.now();
+    if (action.type === "clear-signal") {
+      if (input.sessionId) clearSignaled(deps.home, signalKey("", input.sessionId));
+      const arming = findArming(deps.home, cwd, now);
+      if (arming) clearSignaled(deps.home, arming.key);
+      return "";
+    }
+    if (action.type === "await-answer") {
+      if (!findArming(deps.home, cwd, now)) return "";
+      if (input.sessionId && input.requestHash) {
+        const id = pendingId(input.sessionId, input.requestHash);
+        try {
+          recordPending(deps.home, id, { at: now, cwd, sessionId: input.sessionId, turnId: input.turnId });
+          deps.wait(id, now);
+          return `hook ${agent} ${input.event}: needs_input in ${PENDING_WAIT_MS / 1e3}s unless answered`;
+        } catch {
+        }
+      }
+      return await sendAction(agent, NEEDS_INPUT, input, cwd, deps);
+    }
+    return await sendAction(agent, action, input, cwd, deps);
+  } catch (e) {
+    return `hook ${agent}: error ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+async function firePending(id, at, deps) {
+  try {
+    const pending = takePending(deps.home, id, at);
+    if (!pending) return "";
+    const input = { event: "PermissionRequest", sessionId: pending.sessionId, turnId: pending.turnId };
+    const note = await sendAction("codex", NEEDS_INPUT, input, pending.cwd, deps);
+    return note && `${note}, unanswered for ${PENDING_WAIT_MS / 1e3}s`;
+  } catch (e) {
+    return `hook codex: error ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+async function sendAction(agent, action, input, cwd, deps) {
+  const now = deps.now();
+  const arming = findArming(deps.home, cwd, now);
+  if (!arming) return "";
+  const event = buildEvent({
+    kind: action.kind,
+    level: arming.level ?? "alarm",
+    label: labelFor(arming.dir ?? cwd),
+    agent: agentOf(agent),
+    now,
+    idParts: [agent, input.sessionId, input.turnId ?? input.promptId, action.kind]
+  });
+  if (action.consume && !claimEvent(deps.home, event.id, now)) {
+    return `hook ${agent} ${input.event}: skipped, already handled for this turn`;
+  }
+  if (action.fallback) {
+    const keys = [signalKey(arming.key, input.sessionId), arming.key];
+    if (keys.some((key) => isSignaled(deps.home, key))) {
+      for (const key of keys) clearSignaled(deps.home, key);
+      return `hook ${agent} ${input.event}: skipped, the agent already signalled this turn`;
+    }
+  }
+  if (action.rateLimitMs && rateLimited(deps.home, arming.key, action.kind, now, action.rateLimitMs)) {
+    return `hook ${agent} ${input.event}: skipped, ${action.kind} sent less than ${action.rateLimitMs / 1e3}s ago`;
+  }
+  if (action.consume && !claim(deps.home, arming)) {
+    return `hook ${agent} ${input.event}: skipped, another alert already ended this arming`;
+  }
+  await deps.send(event);
+  return `hook ${agent} ${input.event}: ${action.kind} queued`;
+}
+async function sendSignal(kind, agent, cwd, deps, sessionId) {
+  const now = deps.now();
+  const arming = findArming(deps.home, cwd, now);
+  if (!arming) return { sent: false, message: "Not armed here, so nothing was sent." };
+  const key = signalKey(arming.key, sessionId);
+  const already = { sent: false, message: "That alert was already sent." };
+  if (signaledKind(deps.home, key) === kind) return already;
+  try {
+    markSignaled(deps.home, key, now, kind);
+  } catch {
+  }
+  if (kind !== "needs_input" && !claim(deps.home, arming)) return already;
+  const event = buildEvent({ kind, level: arming.level ?? "alarm", label: labelFor(arming.dir ?? cwd), agent, now });
+  await deps.send(event);
+  const what = kind === "needs_input" ? "needs you" : kind;
+  return { sent: true, message: `${arming.level === "notify" ? "Notification" : "Alarm"} sent: ${what} (${event.label}).` };
+}
+async function runSignal(kind, agent, deps, sessionId) {
+  return sendSignal(kind, agent, deps.cwd(), deps, sessionId);
+}
+function sessionFromEnv(agent, env) {
+  if (agent === "claude-code") return env.CLAUDE_CODE_SESSION_ID || void 0;
+  if (agent === "codex") return env.CODEX_THREAD_ID || env.CODEX_SESSION_ID || void 0;
+  return void 0;
+}
+
+// src/install.ts
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmdirSync, rmSync as rmSync2 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+
+// src/skill.ts
+function skillMarkdown(cli, name, allowedTools) {
+  return `---
+name: ${name}
+description: Ring the user's phone with a loud alarm when this task is finished or when you need their input. Use when the user asks to be woken, alarmed, called or pinged when the work is done, says they're going to sleep or stepping away while you work, or invokes this skill directly.
+${allowedTools ? `allowed-tools: ${allowedTools}
+` : ""}---
+
+# Code Alarm
+
+The user wants their phone to ring when this task needs them. The alarm is loud, so send it only
+when it's really time for them to come back.
+
+1. **Before you start the work**, arm it from the project folder:
+   \`${cli} arm\`
+   If the user wants a quiet notification instead of an alarm (they said "quiet", "notify" or "no
+   alarm", or passed it as an argument), arm with \`${cli} arm --notify\` instead.
+   If it says Code Alarm isn't set up, tell the user to run \`code-alarm init\` in a terminal, and
+   continue with the task without the alarm.
+2. Do the task as usual.
+3. At the end, as your very last action, send exactly one of these:
+   - \`${cli} done\` when the user's whole request is complete.
+   - \`${cli} needs-you\` right before you stop to ask a question or wait for a decision you can't
+     make yourself.
+   - \`${cli} failed\` when you're giving up because something is broken.
+
+These commands take no message, on purpose: the alarm only says done, needs you or failed, and the
+project folder's name. Never add task details, code or file paths to them.
+
+If you forget step 3, the alarm still rings when you stop, labelled "stopped". It's less helpful,
+but the user isn't left waiting.
+`;
+}
+
+// src/install.ts
+function codexPaths(alarmHome2, userHome) {
+  return {
+    hooksFile: join4(userHome, ".codex", "hooks.json"),
+    rulesFile: join4(userHome, ".codex", "rules", "code-alarm.rules"),
+    skillDir: join4(userHome, ".agents", "skills", "code-alarm"),
+    // A fixed path: Codex trusts a hook by its exact command, so updating code-alarm must not change it.
+    cli: join4(alarmHome2, "bin", "code-alarm.mjs")
+  };
+}
+var CODEX_EVENTS = ["Stop", "PermissionRequest", "PostToolUse", "UserPromptSubmit"];
+var slashes = (path) => path.replace(/\\/g, "/");
+function codexCommand(cli) {
+  return `node "${slashes(cli)}" hook codex`;
+}
+var UNSAFE_IN_QUOTES = /["$`]/;
+var RULES_MARK = "Written by `code-alarm install codex`";
+var SKILL_MARK = "<!-- Written by `code-alarm install codex`";
+function codexRules(cli) {
+  const path = JSON.stringify(slashes(cli));
+  return `# ${RULES_MARK}; removed by \`code-alarm uninstall codex\`.
+# Lets Codex run Code Alarm's own commands without asking: they only change its arming state
+# and send an alarm.
+prefix_rule(
+    pattern = ["node", ${path}, ["arm", "disarm", "nap", "status", "done", "needs-you", "failed"]],
+    decision = "allow",
+    justification = "Code Alarm's own commands: arming state and alarms only.",
+    match = [["node", ${path}, "done"], ["node", ${path}, "arm", "--notify"]],
+    not_match = [["node", ${path}, "install", "codex"]],
+)
+`;
+}
+var isOurs = (handler) => typeof handler.command === "string" && /code-alarm\.mjs"? hook codex/.test(handler.command);
+function withoutCodeAlarm(file) {
+  if (!file.hooks) return { ...file };
+  const hooks = {};
+  for (const [event, groups] of Object.entries(file.hooks)) {
+    const kept = groups.map((group) => ({ ...group, hooks: (group.hooks ?? []).filter((handler) => !isOurs(handler)) })).filter((group) => group.hooks.length > 0);
+    if (kept.length > 0) hooks[event] = kept;
+  }
+  return { ...file, hooks };
+}
+function withCodeAlarm(file, cli) {
+  const result = withoutCodeAlarm(file);
+  const hooks = { ...result.hooks ?? {} };
+  for (const event of CODEX_EVENTS) {
+    const group = { hooks: [{ type: "command", command: codexCommand(cli), timeout: 10, async: true }] };
+    hooks[event] = [...hooks[event] ?? [], group];
+  }
+  return { ...result, hooks };
+}
+function readHooksFile(path) {
+  if (!existsSync3(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  throw new Error(`${path} isn't valid JSON, so code-alarm won't touch it. Fix or move it, then run this again.`);
+}
+var isOurFile = (path, mark) => readFileSync4(path, "utf8").includes(mark);
+function setAside(path, mark, now, notes) {
+  if (!existsSync3(path) || isOurFile(path, mark)) return;
+  const backup = `${path}.code-alarm-backup-${now}`;
+  copyFileSync(path, backup);
+  notes.push(`Backed up ${path} to ${backup}`);
+}
+function removeOurs(path, mark, notes) {
+  if (!existsSync3(path)) return;
+  if (!isOurFile(path, mark)) {
+    notes.push(`Left ${path} alone: code-alarm didn't write it`);
+    return;
+  }
+  rmSync2(path, { force: true });
+  notes.push(`Removed ${path}`);
+}
+function installCodex(args) {
+  const paths = codexPaths(args.alarmHome, args.userHome);
+  const notes = [];
+  if (UNSAFE_IN_QUOTES.test(paths.cli)) {
+    throw new Error(`${paths.cli} contains " $ or \`, which can't be quoted safely in a hook command. Set CODE_ALARM_HOME to another folder and run this again.`);
+  }
+  const current = readHooksFile(paths.hooksFile);
+  mkdirSync4(dirname2(paths.cli), { recursive: true });
+  copyFileSync(args.bundle, paths.cli);
+  notes.push(`Copied the CLI to ${paths.cli}`);
+  if (existsSync3(paths.hooksFile)) {
+    const backup = `${paths.hooksFile}.code-alarm-backup-${args.now}`;
+    copyFileSync(paths.hooksFile, backup);
+    notes.push(`Backed up ${paths.hooksFile} to ${backup}`);
+  }
+  writeFileAtomic(paths.hooksFile, JSON.stringify(withCodeAlarm(current, paths.cli), null, 2) + "\n");
+  notes.push(`Added hooks for ${CODEX_EVENTS.join(", ")} to ${paths.hooksFile}`);
+  setAside(paths.rulesFile, RULES_MARK, args.now, notes);
+  writeFileAtomic(paths.rulesFile, codexRules(paths.cli));
+  notes.push(`Allowed Code Alarm's own commands in ${paths.rulesFile}`);
+  const skillFile = join4(paths.skillDir, "SKILL.md");
+  setAside(skillFile, SKILL_MARK, args.now, notes);
+  const skill = skillMarkdown(`node "${slashes(paths.cli)}"`, "code-alarm");
+  writeFileAtomic(skillFile, `${skill}
+${SKILL_MARK}; removed by \`code-alarm uninstall codex\`. -->
+`);
+  notes.push(`Installed the skill in ${paths.skillDir}`);
+  return notes;
+}
+function uninstallCodex(args) {
+  const paths = codexPaths(args.alarmHome, args.userHome);
+  const notes = [];
+  if (existsSync3(paths.hooksFile)) {
+    writeFileAtomic(paths.hooksFile, JSON.stringify(withoutCodeAlarm(readHooksFile(paths.hooksFile)), null, 2) + "\n");
+    notes.push(`Removed code-alarm's hooks from ${paths.hooksFile}`);
+  }
+  removeOurs(paths.rulesFile, RULES_MARK, notes);
+  removeOurs(join4(paths.skillDir, "SKILL.md"), SKILL_MARK, notes);
+  try {
+    rmdirSync(paths.skillDir);
+  } catch {
+  }
+  rmSync2(paths.cli, { force: true });
+  return notes;
+}
+function codexInstalled(alarmHome2, userHome) {
+  try {
+    const file = readHooksFile(codexPaths(alarmHome2, userHome).hooksFile);
+    return Object.values(file.hooks ?? {}).some((groups) => groups.some((group) => (group.hooks ?? []).some(isOurs)));
+  } catch {
+    return false;
+  }
+}
+
+// src/paths.ts
+import { homedir } from "node:os";
+import { join as join5 } from "node:path";
+function alarmHome(env = process.env, platform = process.platform) {
+  if (env.CODE_ALARM_HOME) return env.CODE_ALARM_HOME;
+  if (platform === "win32" && env.APPDATA) return join5(env.APPDATA, "code-alarm");
+  return join5(env.XDG_CONFIG_HOME || join5(homedir(), ".config"), "code-alarm");
+}
+
+// src/main.ts
+var VERSION = true ? "0.1.0" : "dev";
+var DEFAULT_ARM_MS = 12 * HOUR;
+var HELP = `code-alarm ${VERSION}: a real alarm on your phone when Claude Code or Codex finishes or needs you.
+
+Setup
+  code-alarm init [--server URL] [--topic NAME] [--token TOKEN] [--force]
+                                 Create a private ntfy topic and show how to subscribe on the phone
+  code-alarm test [--notify]     Ring the phone now (or send a plain notification)
+  code-alarm install codex       Add Code Alarm's hooks and skill to Codex (uninstall codex removes them)
+
+Arming (only armed work rings)
+  code-alarm arm [--for 12h] [--notify]
+                                 Ring when the agent in this folder next finishes, stops or needs you
+  code-alarm nap <2h> [--notify] Ring for every session until the time is up
+                                 --notify: one ordinary notification instead of the alarm
+  code-alarm disarm [--all]      Cancel arming for this folder (or everything)
+  code-alarm status              What's set up, what's armed, the last alerts
+
+Run by the agent (its skill says when)
+  code-alarm done | needs-you | failed
+
+Run by agent hooks
+  code-alarm hook claude|codex   Reads the hook's JSON on stdin; prints nothing, always exits 0
+
+Claude Code users install the plugin instead of running anything here by hand:
+  claude plugin marketplace add Draganoider/code-alarm
+  claude plugin install code-alarm@code-alarm
+
+https://github.com/Draganoider/code-alarm`;
+async function readStdin(timeoutMs = 3e3) {
+  if (process.stdin.isTTY) return "";
+  return new Promise((done) => {
+    let data = "";
+    const timer = setTimeout(() => {
+      process.stdin.destroy();
+      done(data);
+    }, timeoutMs);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      done(data);
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      done(data);
+    });
+  });
+}
+function detectAgent(env) {
+  if (env.CLAUDECODE === "1" || env.CLAUDE_CODE_ENTRYPOINT) return "claude-code";
+  if (Object.keys(env).some((key) => key.startsWith("CODEX_"))) return "codex";
+  return "cli";
+}
+var clock = (ms) => new Date(ms).toTimeString().slice(0, 5);
+function setupHint() {
+  return "Code Alarm isn't set up on this computer yet. Run `code-alarm init` in a terminal.";
+}
+async function main(argv) {
+  const [command, ...rest] = argv;
+  const home = alarmHome();
+  const deps = {
+    home,
+    now: Date.now,
+    send: (event) => sendDetached(event),
+    wait: (id, at) => waitDetached(id, at),
+    cwd: () => process.cwd()
+  };
+  switch (command) {
+    case "hook": {
+      const agent = rest[0];
+      if (agent !== "claude" && agent !== "codex") return 0;
+      const note = await runHook(agent, await readStdin(), deps);
+      if (note) logLine(home, note);
+      return 0;
+    }
+    case "__send": {
+      const event = decodeEvent(rest[0] ?? "");
+      if (event) await sendNow(home, event);
+      return 0;
+    }
+    case "__wait": {
+      const [id = "", at = ""] = rest;
+      if (!/^[\w-]+$/.test(id) || !/^\d+$/.test(at)) return 0;
+      await new Promise((done) => setTimeout(done, PENDING_WAIT_MS));
+      const note = await firePending(id, Number(at), deps);
+      if (note) logLine(home, note);
+      return 0;
+    }
+    case "__skill":
+      process.stdout.write(skillMarkdown(rest[0] ?? "code-alarm", rest[1] ?? "alarm", rest[2]));
+      return 0;
+    case "init": {
+      const { values } = parseArgs({
+        args: rest,
+        options: { server: { type: "string" }, topic: { type: "string" }, token: { type: "string" }, force: { type: "boolean" } }
+      });
+      const existing = values.force ? null : loadConfig(home);
+      if (existing) {
+        console.log(`Already set up: ntfy topic ${existing.ntfy.topic} on ${existing.ntfy.server}.`);
+        console.log("Run `code-alarm init --force` to start over with a new topic.");
+        return 0;
+      }
+      const topic = values.topic ?? newTopic();
+      if (!isValidTopic(topic)) throw new ConfigError("A topic can only use letters, digits, - and _ (at most 64).");
+      const server = (values.server ?? DEFAULT_NTFY_SERVER).replace(/\/+$/, "");
+      saveConfig(home, { version: 1, transport: "ntfy", ntfy: { server, topic, ...values.token ? { token: values.token } : {} } });
+      console.log(`Code Alarm is set up.
+
+  Server: ${server}
+  Topic:  ${topic}
+  Treat the topic like a password: anyone who knows it can ring your phone.
+
+On your phone:
+  1. Install the ntfy app (Google Play, F-Droid or the App Store).
+  2. Subscribe to the topic above${server === DEFAULT_NTFY_SERVER ? "" : `, on the server ${server}`}.
+  3. In that subscription's settings, turn on the option that keeps alerting for highest-priority
+     messages, and the one that lets it through Do Not Disturb. (Names vary a little between app
+     versions.)
+  4. Back here, run: code-alarm test
+
+Then connect your agent:
+  Claude Code:  claude plugin marketplace add Draganoider/code-alarm
+                claude plugin install code-alarm@code-alarm
+  Codex:        code-alarm install codex`);
+      return 0;
+    }
+    case "test": {
+      const { values } = parseArgs({ args: rest, options: { notify: { type: "boolean" } } });
+      if (!loadConfig(home)) {
+        console.log(setupHint());
+        return 1;
+      }
+      const event = buildEvent({ kind: "test", level: values.notify ? "notify" : "alarm", label: "test", agent: "cli", now: Date.now() });
+      const result = await sendNow(home, event);
+      const expected = values.notify ? "You should get one notification now, with sound and vibration." : "Your phone should be ringing now, until you dismiss it.";
+      console.log(result.ok ? `Sent. ${expected}` : `Couldn't send the test: ${result.detail}.`);
+      return result.ok ? 0 : 1;
+    }
+    case "arm": {
+      const { values } = parseArgs({ args: rest, options: { for: { type: "string" }, notify: { type: "boolean" } } });
+      if (!loadConfig(home)) {
+        console.log(setupHint());
+        return 1;
+      }
+      const ms = values.for ? parseDuration(values.for) : DEFAULT_ARM_MS;
+      if (!ms || ms > MAX_ARM_MS) throw new ConfigError(`--for takes a duration like 2h, 90m or 1h30m, at most 24h.`);
+      const now = Date.now();
+      const level = values.notify ? "notify" : "alarm";
+      const arming = armProject(home, process.cwd(), now + ms, now, level);
+      console.log(
+        `Armed "${labelFor(arming.dir ?? process.cwd())}" until ${clock(arming.until)} (${formatDuration(ms)}). ` + (level === "notify" ? "The phone gets one notification the next time the agent here finishes, stops or needs you." : "The phone rings the next time the agent here finishes, stops or needs you.")
+      );
+      return 0;
+    }
+    case "nap": {
+      const { values, positionals } = parseArgs({ args: rest, allowPositionals: true, options: { notify: { type: "boolean" } } });
+      const ms = positionals[0] ? parseDuration(positionals[0]) : null;
+      if (!ms || ms > MAX_ARM_MS) throw new ConfigError("Usage: code-alarm nap <duration>, like 2h or 45m (at most 24h).");
+      if (!loadConfig(home)) {
+        console.log(setupHint());
+        return 1;
+      }
+      const now = Date.now();
+      armNap(home, now + ms, now, values.notify ? "notify" : "alarm");
+      console.log(
+        `Nap mode until ${clock(now + ms)}: every session that finishes, stops or needs you ` + (values.notify ? "sends a notification." : "rings the phone.")
+      );
+      return 0;
+    }
+    case "disarm": {
+      const { values } = parseArgs({ args: rest, options: { all: { type: "boolean" } } });
+      if (values.all) {
+        console.log(`Disarmed ${disarmAll(home)} arming(s).`);
+      } else {
+        console.log(disarmProject(home, process.cwd()) ? "Disarmed this folder." : "This folder wasn't armed.");
+      }
+      return 0;
+    }
+    case "status": {
+      const config = loadConfig(home);
+      console.log(
+        config ? (
+          // Never any part of the topic: people paste this output into bug reports.
+          `Transport: ntfy, ${config.ntfy.server}, topic set${config.ntfy.token ? ", with a token" : ""}`
+        ) : "Not set up: run `code-alarm init`."
+      );
+      const now = Date.now();
+      const armings = listArmings(home, now);
+      console.log(armings.length ? "Armed:" : "Nothing is armed.");
+      for (const arming of armings) {
+        const what = arming.kind === "nap" ? "nap mode, every session" : `${arming.dir}`;
+        const level = arming.level === "notify" ? ", notification only" : "";
+        console.log(`  - ${what} until ${clock(arming.until)} (${formatDuration(arming.until - now)} left${level})`);
+      }
+      console.log(`Codex hooks: ${codexInstalled(home, homedir2()) ? "installed" : "not installed"}`);
+      const log = recentLog(home, 5);
+      if (log.length) console.log(`Last activity:
+${log.map((line) => `  ${line}`).join("\n")}`);
+      return 0;
+    }
+    case "done":
+    case "needs-you":
+    case "failed": {
+      const kind = command === "needs-you" ? "needs_input" : command;
+      const agent = detectAgent(process.env);
+      const result = await runSignal(kind, agent, deps, sessionFromEnv(agent, process.env));
+      console.log(result.message);
+      return 0;
+    }
+    case "install":
+    case "uninstall": {
+      if (rest[0] !== "codex") throw new ConfigError(`Usage: code-alarm ${command} codex`);
+      const script = process.argv[1];
+      if (command === "install") {
+        if (!script) throw new ConfigError("Can't tell where this code-alarm script is.");
+        for (const note of installCodex({ alarmHome: home, userHome: homedir2(), bundle: resolve3(script), now: Date.now() })) console.log(note);
+        console.log(
+          `
+Next: quit Codex completely and start it again. It reads rules only at startup, and closing
+its window may leave it running in the background. Then approve (trust) the new hooks when it
+asks; Codex skips hooks until you do.
+Then, before a long task, ask Codex to use the code-alarm skill (or say "wake me when it's done").`
+        );
+      } else {
+        for (const note of uninstallCodex({ alarmHome: home, userHome: homedir2() })) console.log(note);
+      }
+      return 0;
+    }
+    case "version":
+    case "--version":
+    case "-v":
+      console.log(VERSION);
+      return 0;
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(HELP);
+      return 0;
+    default:
+      console.error(`Unknown command: ${command}
+
+${HELP}`);
+      return 1;
+  }
+}
+var quiet = ["hook", "__send", "__wait"].includes(process.argv[2] ?? "");
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = quiet ? 0 : code;
+  },
+  (e) => {
+    if (quiet) {
+      process.exitCode = 0;
+      return;
+    }
+    console.error(`code-alarm: ${e instanceof Error ? e.message : String(e)}`);
+    process.exitCode = 1;
+  }
+);
+export {
+  main
+};

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "code-alarm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Wake up when Claude Code or Codex finishes or needs you: a real alarm on your phone, from agent hooks.",
+  "license": "MIT",
+  "author": "Yevhen Mishchenko",
+  "homepage": "https://github.com/Draganoider/code-alarm#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Draganoider/code-alarm.git",
+    "directory": "cli"
+  },
+  "bugs": "https://github.com/Draganoider/code-alarm/issues",
+  "keywords": ["claude-code", "codex", "alarm", "notifications", "ntfy", "hooks", "ai-agents"],
+  "type": "module",
+  "bin": {
+    "code-alarm": "dist/code-alarm.mjs"
+  },
+  "files": ["dist/code-alarm.mjs"],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build": "node build.mjs",
+    "test": "tsc -p tsconfig.test.json && node --test \"build/test/**/*.test.js\"",
+    "check": "npm run typecheck && npm test && npm run build",
+    "prepack": "node -e \"for (const f of ['LICENSE', 'README.md']) require('node:fs').copyFileSync('../' + f, f)\""
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "esbuild": "^0.28.2",
+    "typescript": "^7.0.2"
+  }
+}