@vforsh/notif 0.1.0

package/README.md

@@ -0,0 +1,115 @@
+# notif
+
+CLI for sending push notifications via [ntfy](https://ntfy.sh). No ntfy binary needed — uses the REST API directly.
+
+## Install
+
+```bash
+bun install -g @vforsh/notif
+```
+
+## Setup
+
+```bash
+notif cfg init
+# or manually:
+notif cfg set server https://ntfy.example.com
+notif cfg set topic my-topic
+```
+
+Verify setup:
+
+```bash
+notif doctor
+```
+
+## Usage
+
+```bash
+# Simple message
+notif "Hello world"
+
+# With title and priority
+notif -t "Alert" -p high "Backups failed"
+
+# Tags / emojis
+notif -T warning,skull "Oh no"
+
+# Clickable notification
+notif --click "https://example.com" "Check this out"
+
+# File attachment
+notif --file report.pdf "Daily report"
+
+# Markdown
+notif --md "**Build** passed in \`main\`"
+
+# Pipe from stdin
+echo "Deploy complete" | notif -t "CI"
+
+# Override topic
+notif --topic other-channel "Message"
+```
+
+## Config
+
+Stored at `~/.config/notif/config.json`. Keys: `server`, `topic`, `user`, `token`.
+
+```bash
+notif cfg ls          # show path + contents
+notif cfg init        # interactive setup
+notif cfg set <k> <v> # set value
+notif cfg unset <k>   # remove value
+```
+
+Secrets (`user`, `token`) must be set via stdin:
+
+```bash
+echo "tk_abc123" | notif cfg set token
+```
+
+Precedence: CLI flags > env vars (`NOTIF_SERVER`, `NOTIF_TOPIC`, `NOTIF_USER`, `NOTIF_TOKEN`) > config file.
+
+## Auth
+
+```bash
+# Access token
+echo "tk_abc123" | notif cfg set token
+
+# Username:password
+echo "admin:secret" | notif cfg set user
+
+# Or per-message
+notif --token tk_abc123 "message"
+```
+
+## All flags
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--title` | `-t` | Message title |
+| `--priority` | `-p` | Priority: 1=min, 2=low, 3=default, 4=high, 5=max |
+| `--tags` | `-T` | Comma-separated tags/emojis |
+| `--click` | | URL to open on notification click |
+| `--icon` | | Notification icon URL |
+| `--attach` | | External attachment URL |
+| `--file` | | Local file to upload as attachment |
+| `--filename` | | Override attachment filename |
+| `--delay` | | Schedule message: `10s`, `30m`, ISO timestamp |
+| `--email` | | Also send to email |
+| `--actions` | | Actions JSON array or simple definition |
+| `--md` | | Markdown formatting |
+| `--no-cache` | | Don't cache server-side |
+| `--no-firebase` | | Don't forward to Firebase |
+| `--sid` | | Sequence ID for notification updates |
+| `--topic` | | Override default topic |
+| `--server` | | Override default server |
+| `--user` | | `username:password` auth |
+| `--token` | | Access token auth |
+| `--json` | | Output raw JSON response |
+| `--plain` | | Output only message ID |
+| `-q` | | Suppress all output |
+
+## License
+
+MIT

package/bin/notif

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+import { main } from "../src/index.ts";
+await main(process.argv);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@vforsh/notif",
+  "version": "0.1.0",
+  "description": "CLI for sending push notifications via ntfy",
+  "type": "module",
+  "license": "MIT",
+  "author": "Vladislav Forsh <vforsh@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vforsh/notif.git"
+  },
+  "bin": {
+    "notif": "bin/notif"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skill"
+  ],
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test",
+    "cmd": "bun run bin/notif"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "picocolors": "^1.1.1",
+    "zod": "^4.3.6"
+  }
+}

package/skill/notif/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: notif
+description: Send push notifications via ntfy using the `notif` CLI. Use when the agent needs to send notifications, alerts, or messages to a phone/desktop — task completion alerts, clickable links, file attachments, build status, deploy results, or any event worth notifying about. Triggers on mentions of notify, notification, push, alert, ntfy, notif, "send me", "let me know", "ping me".
+---
+
+# notif
+
+CLI for sending push notifications via ntfy. Server and topic are pre-configured — run `notif doctor` to verify setup.
+
+## Usage
+
+```bash
+notif "Hello world"
+notif -t "Alert" -p high "Backups failed"
+notif -T warning,skull "Oh no"
+notif --click "http://192.168.1.12:8080" "Server ready"
+notif --file report.pdf "Daily report"
+notif --md "**Build** passed in \`main\`"
+notif --attach "https://example.com/image.png" "See this"
+echo "Done" | notif -t "CI"
+notif --topic other-channel "Override topic"
+```
+
+## Flags
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--title` | `-t` | Message title |
+| `--priority` | `-p` | `1`=min, `2`=low, `3`=default, `4`=high, `5`=max |
+| `--tags` | `-T` | Comma-separated tags/emojis |
+| `--click` | | URL to open on tap |
+| `--file` | | Local file attachment |
+| `--attach` | | Remote URL attachment |
+| `--md` | | Markdown formatting |
+| `--delay` | | Schedule: `10s`, `30m`, ISO timestamp |
+| `--topic` | | Override default topic |
+| `--server` | | Override default server |
+| `--json` | | JSON response to stdout |
+| `--plain` | | Message ID only to stdout |
+| `-q` | | Suppress output |
+
+## Localhost rule
+
+**NEVER send `localhost` or `127.0.0.1` URLs in notifications.** Notifications arrive on mobile devices on the same Wi-Fi network — localhost is unreachable there.
+
+Replace with the machine's LAN IP before sending:
+
+```bash
+LAN_IP=$(ipconfig getifaddr en0)
+notif --click "http://$LAN_IP:3000" "Dev server ready"
+```
+
+This applies to `--click` URLs, URLs in message body, and any other link.
+
+## Config
+
+- `notif cfg ls` — show config path and contents
+- `notif cfg init` — interactive setup (TTY)
+- `notif cfg set <key> <value>` — set value (`server`, `topic`; secrets via stdin)
+- `notif cfg unset <key>` — remove value
+- `notif doctor` — verify setup (config, server reachability)
+
+## Errors
+
+| Message | Cause |
+|---------|-------|
+| `No server configured` | Run `notif cfg set server <url>` |
+| `No topic configured` | Run `notif cfg set topic <name>` |
+| `ntfy error 401` | Auth failed |
+| `ntfy error 429` | Rate limited |

package/src/cli/commands/config.ts

@@ -0,0 +1,139 @@
+import { Command } from "commander";
+import pc from "picocolors";
+import {
+	getConfigPath,
+	readConfig,
+	writeConfig,
+	setConfigValue,
+	setConfigValueFromStdin,
+	unsetConfigValue,
+	type Config,
+} from "../../lib/config.ts";
+
+const SECRET_KEYS = new Set(["user", "token"]);
+
+function redact(key: string, value: string): string {
+	return SECRET_KEYS.has(key) ? "*".repeat(Math.min(value.length, 12)) : value;
+}
+
+async function prompt(label: string, current?: string, secret = false): Promise<string | undefined> {
+	const suffix = current ? pc.dim(` [${secret ? "****" : current}]`) : "";
+	process.stderr.write(`${label}${suffix}: `);
+
+	for await (const chunk of Bun.stdin.stream()) {
+		const line = new TextDecoder().decode(chunk).trim();
+		return line || current;
+	}
+
+	return current;
+}
+
+export function registerConfigCommand(program: Command) {
+	const config = program
+		.command("config")
+		.alias("cfg")
+		.description("Manage notif configuration");
+
+	config
+		.command("ls")
+		.description("Print config path and contents")
+		.action(async () => {
+			const path = getConfigPath();
+			console.log(pc.dim(path));
+
+			const cfg = await readConfig();
+			if (Object.keys(cfg).length === 0) {
+				console.log(pc.dim("(empty)"));
+				return;
+			}
+
+			for (const [key, value] of Object.entries(cfg)) {
+				if (value !== undefined) {
+					console.log(`${key}: ${redact(key, value)}`);
+				}
+			}
+		});
+
+	config
+		.command("init")
+		.description("Interactively configure notif")
+		.action(async () => {
+			if (!process.stdin.isTTY) {
+				console.error(pc.red("cfg init requires a TTY"));
+				process.exit(1);
+			}
+
+			const current = await readConfig();
+			console.error(pc.bold("notif config") + pc.dim(" (Enter to keep current value, empty to clear)\n"));
+
+			const server = await prompt("server", current.server);
+			const topic = await prompt("topic", current.topic);
+			const user = await prompt("user", current.user, true);
+			const token = await prompt("token", current.token, true);
+
+			const updated: Config = {};
+			if (server) updated.server = server;
+			if (topic) updated.topic = topic;
+			if (user) updated.user = user;
+			if (token) updated.token = token;
+
+			await writeConfig(updated);
+			console.error(pc.green("\nSaved"), pc.dim(getConfigPath()));
+		});
+
+	config
+		.command("path")
+		.description("Print config file path")
+		.action(() => {
+			console.log(getConfigPath());
+		});
+
+	config
+		.command("get")
+		.description("Print current config values")
+		.action(async () => {
+			const cfg = await readConfig();
+			if (Object.keys(cfg).length === 0) {
+				console.error(pc.dim("(empty config)"));
+				return;
+			}
+
+			for (const [key, value] of Object.entries(cfg)) {
+				if (value !== undefined) {
+					console.log(`${key}: ${redact(key, value)}`);
+				}
+			}
+		});
+
+	config
+		.command("set")
+		.description("Set a config value")
+		.argument("<key>", "Config key (server, topic, user, token)")
+		.argument("[value]", "Value (omit for secrets — pipe via stdin)")
+		.action(async (key: string, value: string | undefined) => {
+			if (SECRET_KEYS.has(key)) {
+				if (value) {
+					console.error(pc.yellow(`Secrets must be set via stdin:`));
+					console.error(pc.dim(`  echo "value" | notif cfg set ${key}`));
+					process.exit(1);
+				}
+				await setConfigValueFromStdin(key);
+			} else {
+				if (!value) {
+					console.error(pc.red(`Value required for ${key}`));
+					process.exit(1);
+				}
+				await setConfigValue(key, value);
+			}
+			console.error(pc.green(`Set ${key}`));
+		});
+
+	config
+		.command("unset")
+		.description("Remove a config value")
+		.argument("<key>", "Config key to remove")
+		.action(async (key: string) => {
+			await unsetConfigValue(key);
+			console.error(pc.green(`Unset ${key}`));
+		});
+}

package/src/cli/commands/doctor.ts

@@ -0,0 +1,136 @@
+import { Command } from "commander";
+import pc from "picocolors";
+import { getConfigPath, readConfig } from "../../lib/config.ts";
+
+const PASS = pc.green("OK");
+const FAIL = pc.red("FAIL");
+const WARN = pc.yellow("WARN");
+
+interface CheckResult {
+	status: "pass" | "fail" | "warn";
+	detail: string;
+	hint?: string;
+}
+
+interface Check {
+	name: string;
+	run: () => Promise<CheckResult>;
+}
+
+const checks: Check[] = [
+	{
+		name: "Config file",
+		run: async () => {
+			const path = getConfigPath();
+			const file = Bun.file(path);
+			if (!(await file.exists())) {
+				return { status: "fail", detail: `not found: ${path}`, hint: "notif cfg init" };
+			}
+
+			try {
+				await readConfig();
+				return { status: "pass", detail: path };
+			} catch (err) {
+				return {
+					status: "fail",
+					detail: err instanceof Error ? err.message : String(err),
+					hint: `Fix or delete ${path}, then run: notif cfg init`,
+				};
+			}
+		},
+	},
+	{
+		name: "Server",
+		run: async () => {
+			const cfg = await readConfig();
+			const server = process.env.NOTIF_SERVER || cfg.server;
+			if (!server) {
+				return { status: "fail", detail: "not configured", hint: "notif cfg set server https://ntfy.example.com" };
+			}
+			return { status: "pass", detail: server };
+		},
+	},
+	{
+		name: "Topic",
+		run: async () => {
+			const cfg = await readConfig();
+			const topic = process.env.NOTIF_TOPIC || cfg.topic;
+			if (!topic) {
+				return { status: "fail", detail: "not configured", hint: "notif cfg set topic my-topic" };
+			}
+			return { status: "pass", detail: topic };
+		},
+	},
+	{
+		name: "Auth",
+		run: async () => {
+			const cfg = await readConfig();
+			const token = process.env.NOTIF_TOKEN || cfg.token;
+			const user = process.env.NOTIF_USER || cfg.user;
+
+			if (token) return { status: "pass", detail: "token" };
+			if (user) {
+				if (!user.includes(":")) {
+					return {
+						status: "warn",
+						detail: "user format should be username:password",
+						hint: 'echo "user:pass" | notif cfg set user',
+					};
+				}
+				return { status: "pass", detail: "user:pass" };
+			}
+			return { status: "pass", detail: "none (anonymous)" };
+		},
+	},
+	{
+		name: "Server reachable",
+		run: async () => {
+			const cfg = await readConfig();
+			const server = process.env.NOTIF_SERVER || cfg.server;
+			if (!server) {
+				return { status: "fail", detail: "no server to check", hint: "set server first" };
+			}
+
+			const url = `${server.replace(/\/+$/, "")}/v1/health`;
+			try {
+				const resp = await fetch(url, { signal: AbortSignal.timeout(5000) });
+				if (!resp.ok) {
+					return { status: "fail", detail: `HTTP ${resp.status}`, hint: `check server URL: ${server}` };
+				}
+				const body = (await resp.json()) as { healthy?: boolean };
+				if (body.healthy) {
+					return { status: "pass", detail: "healthy" };
+				}
+				return { status: "warn", detail: "responded but not healthy", hint: "check ntfy server logs" };
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { status: "fail", detail: msg, hint: `verify server is running at ${server}` };
+			}
+		},
+	},
+];
+
+export function registerDoctorCommand(program: Command) {
+	program
+		.command("doctor")
+		.alias("check")
+		.description("Verify notif setup")
+		.action(async () => {
+			let hasFailure = false;
+
+			for (const check of checks) {
+				const result = await check.run();
+				const icon = result.status === "pass" ? PASS : result.status === "warn" ? WARN : FAIL;
+				let line = `${icon}  ${check.name}: ${pc.dim(result.detail)}`;
+				if (result.hint && result.status !== "pass") {
+					line += `\n     ${pc.yellow(">")} ${result.hint}`;
+				}
+				console.log(line);
+				if (result.status === "fail") hasFailure = true;
+			}
+
+			if (hasFailure) {
+				process.exit(1);
+			}
+		});
+}

package/src/cli/commands/pub.ts

@@ -0,0 +1,67 @@
+import { Command } from "commander";
+import pc from "picocolors";
+import { publish, type PublishOptions } from "../../lib/publish.ts";
+
+export function registerPubCommand(program: Command) {
+	program
+		.argument("[message...]", "Message to send")
+		.option("-t, --title <title>", "Message title")
+		.option("-p, --priority <priority>", "Priority (1=min, 2=low, 3=default, 4=high, 5=max)")
+		.option("-T, --tags <tags>", "Comma-separated tags/emojis")
+		.option("--click <url>", "URL to open on notification click")
+		.option("--icon <url>", "Notification icon URL")
+		.option("--attach <url>", "URL to send as external attachment")
+		.option("--file <path>", "File to upload as attachment")
+		.option("--filename <name>", "Filename for the attachment")
+		.option("--delay <delay>", "Delay/schedule message (e.g. 10s, 30m, 2025-01-01T10:00:00)")
+		.option("--email <email>", "Also send to email address")
+		.option("--actions <actions>", "Actions JSON array or simple definition")
+		.option("--md", "Treat message as Markdown")
+		.option("--no-cache", "Do not cache message server-side")
+		.option("--no-firebase", "Do not forward to Firebase")
+		.option("--sid <id>", "Sequence ID for updating notifications")
+		.option("--topic <topic>", "Override default topic")
+		.option("--server <url>", "Override default server")
+		.option("--user <user:pass>", "Username:password for auth")
+		.option("--token <token>", "Access token for auth")
+		.action(async (messageParts: string[], opts: Record<string, unknown>) => {
+			let message = messageParts.join(" ") || undefined;
+
+			// Read from stdin if no message and not a TTY
+			if (!message && !process.stdin.isTTY) {
+				message = (await Bun.stdin.text()).trim() || undefined;
+			}
+
+			const publishOpts: PublishOptions = {
+				server: opts.server as string | undefined,
+				topic: opts.topic as string | undefined,
+				title: opts.title as string | undefined,
+				priority: opts.priority as string | undefined,
+				tags: opts.tags as string | undefined,
+				click: opts.click as string | undefined,
+				icon: opts.icon as string | undefined,
+				attach: opts.attach as string | undefined,
+				filename: opts.filename as string | undefined,
+				delay: opts.delay as string | undefined,
+				email: opts.email as string | undefined,
+				actions: opts.actions as string | undefined,
+				markdown: opts.md as boolean | undefined,
+				noCache: opts.cache === false,
+				noFirebase: opts.firebase === false,
+				sequenceId: opts.sid as string | undefined,
+				file: opts.file as string | undefined,
+				user: opts.user as string | undefined,
+				token: opts.token as string | undefined,
+			};
+
+			const result = await publish(message, publishOpts);
+
+			if (program.opts().json) {
+				console.log(JSON.stringify(result));
+			} else if (program.opts().plain) {
+				console.log(result.id);
+			} else if (!program.opts().quiet) {
+				console.error(pc.green("Sent"), pc.dim(result.id));
+			}
+		});
+}

package/src/cli/program.ts

@@ -0,0 +1,22 @@
+import { Command } from "commander";
+import { registerPubCommand } from "./commands/pub.ts";
+import { registerConfigCommand } from "./commands/config.ts";
+import { registerDoctorCommand } from "./commands/doctor.ts";
+
+export function buildProgram(): Command {
+	const program = new Command();
+
+	program
+		.name("notif")
+		.version("0.1.0")
+		.description("Send push notifications via ntfy")
+		.option("--json", "Output raw JSON response")
+		.option("--plain", "Output only the message ID")
+		.option("-q, --quiet", "Suppress all output");
+
+	registerPubCommand(program);
+	registerConfigCommand(program);
+	registerDoctorCommand(program);
+
+	return program;
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+import pc from "picocolors";
+import { buildProgram } from "./cli/program.ts";
+
+export async function main(argv: string[]) {
+	const program = buildProgram();
+
+	try {
+		await program.parseAsync(argv);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+
+		if (program.opts().json) {
+			console.log(JSON.stringify({ error: { message, exitCode: 1 } }));
+		} else {
+			console.error(pc.red(message));
+		}
+
+		process.exit(1);
+	}
+}

package/src/lib/config.test.ts

@@ -0,0 +1,62 @@
+import { test, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { readConfig, writeConfig, isValidKey, type Config } from "./config.ts";
+
+let originalXDG: string | undefined;
+let tempDir: string;
+
+beforeEach(async () => {
+	originalXDG = process.env.XDG_CONFIG_HOME;
+	tempDir = join(tmpdir(), `notif-test-${Date.now()}`);
+	process.env.XDG_CONFIG_HOME = tempDir;
+});
+
+afterEach(async () => {
+	if (originalXDG !== undefined) {
+		process.env.XDG_CONFIG_HOME = originalXDG;
+	} else {
+		delete process.env.XDG_CONFIG_HOME;
+	}
+	await Bun.$`rm -rf ${tempDir}`.quiet().nothrow();
+});
+
+test("readConfig returns empty object when no config file", async () => {
+	const config = await readConfig();
+	expect(config).toEqual({});
+});
+
+test("writeConfig + readConfig roundtrip", async () => {
+	const config: Config = {
+		server: "https://ntfy.example.com",
+		topic: "test-topic",
+	};
+	await writeConfig(config);
+	const read = await readConfig();
+	expect(read).toEqual(config);
+});
+
+test("writeConfig preserves all fields", async () => {
+	const config: Config = {
+		server: "https://ntfy.example.com",
+		topic: "test",
+		user: "admin:pass",
+		token: "tk_abc123",
+	};
+	await writeConfig(config);
+	const read = await readConfig();
+	expect(read).toEqual(config);
+});
+
+test("isValidKey accepts valid keys", () => {
+	expect(isValidKey("server")).toBe(true);
+	expect(isValidKey("topic")).toBe(true);
+	expect(isValidKey("user")).toBe(true);
+	expect(isValidKey("token")).toBe(true);
+});
+
+test("isValidKey rejects invalid keys", () => {
+	expect(isValidKey("foo")).toBe(false);
+	expect(isValidKey("")).toBe(false);
+	expect(isValidKey("SERVER")).toBe(false);
+});

package/src/lib/config.ts

@@ -0,0 +1,93 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod/v4";
+
+const CONFIG_DIR_NAME = "notif";
+const CONFIG_FILE_NAME = "config.json";
+
+const ConfigSchema = z.object({
+	server: z.url().optional(),
+	topic: z.string().optional(),
+	user: z.string().optional(),
+	token: z.string().optional(),
+});
+
+export type Config = z.infer<typeof ConfigSchema>;
+
+const VALID_KEYS = ["server", "topic", "user", "token"] as const;
+type ConfigKey = (typeof VALID_KEYS)[number];
+
+export function isValidKey(key: string): key is ConfigKey {
+	return VALID_KEYS.includes(key as ConfigKey);
+}
+
+export function getConfigDir(): string {
+	const xdg = process.env.XDG_CONFIG_HOME;
+	const base = xdg || join(homedir(), ".config");
+	return join(base, CONFIG_DIR_NAME);
+}
+
+export function getConfigPath(): string {
+	return join(getConfigDir(), CONFIG_FILE_NAME);
+}
+
+export async function readConfig(): Promise<Config> {
+	const path = getConfigPath();
+	const file = Bun.file(path);
+	if (!(await file.exists())) return {};
+
+	const raw = await file.json();
+	const result = ConfigSchema.safeParse(raw);
+	if (!result.success) {
+		throw new Error(`Invalid config: ${z.prettifyError(result.error)}`);
+	}
+
+	return result.data;
+}
+
+export async function writeConfig(config: Config): Promise<void> {
+	const dir = getConfigDir();
+	await Bun.$`mkdir -p ${dir}`.quiet();
+
+	const path = getConfigPath();
+	await Bun.write(path, JSON.stringify(config, null, 2) + "\n");
+}
+
+export async function setConfigValue(key: string, value: string): Promise<void> {
+	if (!isValidKey(key)) {
+		throw new Error(`Unknown config key: ${key}. Valid keys: ${VALID_KEYS.join(", ")}`);
+	}
+
+	if (key === "user" || key === "token") {
+		throw new Error(`Secrets must be set via stdin: echo "value" | notif config set ${key}`);
+	}
+
+	const config = await readConfig();
+	config[key] = value;
+	await writeConfig(config);
+}
+
+export async function setConfigValueFromStdin(key: string): Promise<void> {
+	if (!isValidKey(key)) {
+		throw new Error(`Unknown config key: ${key}. Valid keys: ${VALID_KEYS.join(", ")}`);
+	}
+
+	const value = (await Bun.stdin.text()).trim();
+	if (!value) {
+		throw new Error("No value provided via stdin");
+	}
+
+	const config = await readConfig();
+	config[key] = value;
+	await writeConfig(config);
+}
+
+export async function unsetConfigValue(key: string): Promise<void> {
+	if (!isValidKey(key)) {
+		throw new Error(`Unknown config key: ${key}. Valid keys: ${VALID_KEYS.join(", ")}`);
+	}
+
+	const config = await readConfig();
+	delete config[key];
+	await writeConfig(config);
+}

package/src/lib/publish.test.ts

@@ -0,0 +1,163 @@
+import { test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { writeConfig } from "./config.ts";
+
+let originalXDG: string | undefined;
+let tempDir: string;
+let originalFetch: typeof globalThis.fetch;
+
+function mockFetch(handler: (url: string, init: RequestInit) => void) {
+	const fn = mock(async (input: string | URL | Request, init?: RequestInit) => {
+		handler(String(input), init || {});
+		return new Response(JSON.stringify({ id: "abc123", time: 1, expires: 2, event: "message", topic: "test-topic" }), {
+			status: 200,
+			headers: { "Content-Type": "application/json" },
+		});
+	});
+	globalThis.fetch = Object.assign(fn, { preconnect: globalThis.fetch.preconnect }) as typeof fetch;
+}
+
+function mockFetchError(status: number, body: string) {
+	const fn = mock(async () => new Response(body, { status }));
+	globalThis.fetch = Object.assign(fn, { preconnect: globalThis.fetch.preconnect }) as typeof fetch;
+}
+
+beforeEach(async () => {
+	originalXDG = process.env.XDG_CONFIG_HOME;
+	tempDir = join(tmpdir(), `notif-test-${Date.now()}`);
+	process.env.XDG_CONFIG_HOME = tempDir;
+	originalFetch = globalThis.fetch;
+
+	await writeConfig({
+		server: "https://ntfy.test.local",
+		topic: "test-topic",
+	});
+});
+
+afterEach(async () => {
+	globalThis.fetch = originalFetch;
+	if (originalXDG !== undefined) {
+		process.env.XDG_CONFIG_HOME = originalXDG;
+	} else {
+		delete process.env.XDG_CONFIG_HOME;
+	}
+	delete process.env.NOTIF_SERVER;
+	delete process.env.NOTIF_TOPIC;
+	await Bun.$`rm -rf ${tempDir}`.quiet().nothrow();
+});
+
+test("publish sends JSON POST to server base URL", async () => {
+	let capturedUrl = "";
+	let capturedBody: Record<string, unknown> = {};
+
+	mockFetch((url, init) => {
+		capturedUrl = url;
+		capturedBody = JSON.parse(init.body as string);
+	});
+
+	const { publish } = await import("./publish.ts");
+	const result = await publish("hello world", {});
+
+	expect(capturedUrl).toBe("https://ntfy.test.local");
+	expect(capturedBody.topic).toBe("test-topic");
+	expect(capturedBody.message).toBe("hello world");
+	expect(result.id).toBe("abc123");
+});
+
+test("publish includes all options in JSON body", async () => {
+	let capturedBody: Record<string, unknown> = {};
+
+	mockFetch((_url, init) => {
+		capturedBody = JSON.parse(init.body as string);
+	});
+
+	const { publish } = await import("./publish.ts");
+	await publish("msg", {
+		title: "My Title",
+		priority: "high",
+		tags: "warning,skull",
+		click: "https://example.com",
+		markdown: true,
+	});
+
+	expect(capturedBody.title).toBe("My Title");
+	expect(capturedBody.priority).toBe("high");
+	expect(capturedBody.tags).toEqual(["warning", "skull"]);
+	expect(capturedBody.click).toBe("https://example.com");
+	expect(capturedBody.markdown).toBe(true);
+});
+
+test("publish uses Bearer auth when token is set", async () => {
+	let capturedHeaders: Record<string, string> = {};
+
+	mockFetch((_url, init) => {
+		capturedHeaders = Object.fromEntries(Object.entries(init.headers || {}));
+	});
+
+	const { publish } = await import("./publish.ts");
+	await publish("msg", { token: "tk_abc" });
+
+	expect(capturedHeaders["Authorization"]).toBe("Bearer tk_abc");
+});
+
+test("publish throws on missing server", async () => {
+	await writeConfig({});
+	const { publish } = await import("./publish.ts");
+	expect(publish("msg", {})).rejects.toThrow("No server configured");
+});
+
+test("publish throws on HTTP error", async () => {
+	mockFetchError(401, "Unauthorized");
+	const { publish } = await import("./publish.ts");
+	expect(publish("msg", {})).rejects.toThrow("ntfy error 401");
+});
+
+test("env vars override config", async () => {
+	let capturedBody: Record<string, unknown> = {};
+
+	process.env.NOTIF_SERVER = "https://env.server.com";
+	process.env.NOTIF_TOPIC = "env-topic";
+
+	mockFetch((_url, init) => {
+		capturedBody = JSON.parse(init.body as string);
+	});
+
+	const { publish } = await import("./publish.ts");
+	await publish("msg", {});
+
+	expect(capturedBody.topic).toBe("env-topic");
+});
+
+test("CLI flags override env and config", async () => {
+	let capturedUrl = "";
+	let capturedBody: Record<string, unknown> = {};
+
+	process.env.NOTIF_SERVER = "https://env.server.com";
+	process.env.NOTIF_TOPIC = "env-topic";
+
+	mockFetch((url, init) => {
+		capturedUrl = url;
+		capturedBody = JSON.parse(init.body as string);
+	});
+
+	const { publish } = await import("./publish.ts");
+	await publish("msg", { server: "https://flag.server.com", topic: "flag-topic" });
+
+	expect(capturedUrl).toBe("https://flag.server.com");
+	expect(capturedBody.topic).toBe("flag-topic");
+});
+
+test("publish handles UTF-8 title correctly", async () => {
+	let capturedBody: Record<string, unknown> = {};
+
+	mockFetch((_url, init) => {
+		capturedBody = JSON.parse(init.body as string);
+	});
+
+	const { publish } = await import("./publish.ts");
+	await publish("Привет мир", { title: "Тест — уведомление" });
+
+	expect(capturedBody.title).toBe("Тест — уведомление");
+	expect(capturedBody.message).toBe("Привет мир");
+});

package/src/lib/publish.ts

@@ -0,0 +1,129 @@
+import { readConfig } from "./config.ts";
+
+export interface PublishOptions {
+	server?: string;
+	topic?: string;
+	title?: string;
+	priority?: string;
+	tags?: string;
+	click?: string;
+	icon?: string;
+	attach?: string;
+	filename?: string;
+	delay?: string;
+	email?: string;
+	actions?: string;
+	markdown?: boolean;
+	noCache?: boolean;
+	noFirebase?: boolean;
+	sequenceId?: string;
+	file?: string;
+	user?: string;
+	token?: string;
+}
+
+export interface PublishResult {
+	id: string;
+	time: number;
+	expires: number;
+	event: string;
+	topic: string;
+	message?: string;
+	title?: string;
+	priority?: number;
+	tags?: string[];
+	[key: string]: unknown;
+}
+
+export async function publish(message: string | undefined, opts: PublishOptions): Promise<PublishResult> {
+	const config = await readConfig();
+
+	const server = opts.server || process.env.NOTIF_SERVER || config.server;
+	const topic = opts.topic || process.env.NOTIF_TOPIC || config.topic;
+	const user = opts.user || process.env.NOTIF_USER || config.user;
+	const token = opts.token || process.env.NOTIF_TOKEN || config.token;
+
+	if (!server) {
+		throw new Error("No server configured. Run: notif config set server https://ntfy.example.com");
+	}
+	if (!topic) {
+		throw new Error("No topic configured. Run: notif config set topic my-topic");
+	}
+
+	const baseUrl = server.replace(/\/+$/, "");
+	const authHeaders: Record<string, string> = {};
+
+	if (token) {
+		authHeaders["Authorization"] = `Bearer ${token}`;
+	} else if (user) {
+		authHeaders["Authorization"] = `Basic ${btoa(user)}`;
+	}
+
+	// File upload via PUT (must use headers for metadata)
+	if (opts.file) {
+		const file = Bun.file(opts.file);
+		if (!(await file.exists())) {
+			throw new Error(`File not found: ${opts.file}`);
+		}
+
+		const headers: Record<string, string> = { ...authHeaders };
+		if (opts.title) headers["Title"] = opts.title;
+		if (opts.priority) headers["Priority"] = opts.priority;
+		if (opts.tags) headers["Tags"] = opts.tags;
+		if (opts.click) headers["Click"] = opts.click;
+		if (opts.icon) headers["Icon"] = opts.icon;
+		if (opts.delay) headers["Delay"] = opts.delay;
+		if (opts.email) headers["Email"] = opts.email;
+		if (opts.actions) headers["Actions"] = opts.actions;
+		if (opts.markdown) headers["Markdown"] = "yes";
+		if (opts.noCache) headers["Cache"] = "no";
+		if (opts.noFirebase) headers["Firebase"] = "no";
+		if (opts.sequenceId) headers["X-Sequence-ID"] = opts.sequenceId;
+		headers["Filename"] = opts.filename || opts.file.split("/").pop() || opts.file;
+		if (message) headers["Message"] = message;
+
+		const resp = await fetch(`${baseUrl}/${topic}`, {
+			method: "PUT",
+			headers,
+			body: file,
+		});
+
+		if (!resp.ok) {
+			const text = await resp.text();
+			throw new Error(`ntfy error ${resp.status}: ${text}`);
+		}
+
+		return (await resp.json()) as PublishResult;
+	}
+
+	// Regular message via JSON body (supports UTF-8 in all fields)
+	const body: Record<string, unknown> = { topic };
+	if (message) body.message = message;
+	if (opts.title) body.title = opts.title;
+	if (opts.priority) body.priority = isNaN(Number(opts.priority)) ? opts.priority : Number(opts.priority);
+	if (opts.tags) body.tags = opts.tags.split(",").map((t) => t.trim());
+	if (opts.click) body.click = opts.click;
+	if (opts.icon) body.icon = opts.icon;
+	if (opts.attach) body.attach = opts.attach;
+	if (opts.filename) body.filename = opts.filename;
+	if (opts.delay) body.delay = opts.delay;
+	if (opts.email) body.email = opts.email;
+	if (opts.actions) body.actions = opts.actions;
+	if (opts.markdown) body.markdown = true;
+	if (opts.noCache) body.cache = "no";
+	if (opts.noFirebase) body.firebase = "no";
+	if (opts.sequenceId) body["x-sequence-id"] = opts.sequenceId;
+
+	const resp = await fetch(baseUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/json", ...authHeaders },
+		body: JSON.stringify(body),
+	});
+
+	if (!resp.ok) {
+		const text = await resp.text();
+		throw new Error(`ntfy error ${resp.status}: ${text}`);
+	}
+
+	return (await resp.json()) as PublishResult;
+}