CLI: unify webhook ingress and keep up as tailscale alias

src/cli/program.ts

@@ -173,11 +173,16 @@ Examples:
 	program
 		.command("webhook")
 		.description(
-			"Run a local webhook server for inbound WhatsApp (works with Tailscale/port forward)",
+			"Run inbound webhook. ingress=tailscale updates Twilio; ingress=none stays local-only.",
 		)
 		.option("-p, --port <port>", "Port to listen on", "42873")
 		.option("-r, --reply <text>", "Optional auto-reply text")
 		.option("--path <path>", "Webhook path", "/webhook/whatsapp")
+		.option(
+			"--ingress <mode>",
+			"Ingress: tailscale (funnel + Twilio update) | none (local only)",
+			"tailscale",
+		)
 		.option("--verbose", "Log inbound and auto-replies", false)
 		.option("-y, --yes", "Auto-confirm prompts when possible", false)
 		.option("--dry-run", "Print planned actions without starting server", false)
@@ -185,13 +190,10 @@ Examples:
 			"after",
 			`
 Examples:
-  warelay webhook                       # listen on 42873
+  warelay webhook                       # ingress=tailscale (funnel + Twilio update)
+  warelay webhook --ingress none        # local-only server (no funnel / no Twilio update)
   warelay webhook --port 45000          # pick a high, less-colliding port
-  warelay webhook --reply "Got it!"     # static auto-reply; otherwise use config file
-
-With Tailscale:
-  tailscale serve tcp 42873 127.0.0.1:42873
-  (then set Twilio webhook URL to your tailnet IP:42873/webhook/whatsapp)`,
+  warelay webhook --reply "Got it!"     # static auto-reply; otherwise use config file`,
 		)
 		// istanbul ignore next
 		.action(async (opts) => {
@@ -222,7 +224,7 @@ With Tailscale:
 	program
 		.command("up")
 		.description(
-			"Bring up webhook + Tailscale Funnel + Twilio callback (default webhook mode)",
+			"Alias: webhook --ingress tailscale (Funnel + Twilio callback)",
 		)
 		.option("-p, --port <port>", "Port to listen on", "42873")
 		.option("--path <path>", "Webhook path", "/webhook/whatsapp")

src/commands/send.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { CliDeps } from "../cli/deps.js";
+import type { RuntimeEnv } from "../runtime.js";
+import { sendCommand } from "./send.js";
+
+const runtime: RuntimeEnv = {
+	log: vi.fn(),
+	error: vi.fn(),
+	exit: vi.fn(() => {
+		throw new Error("exit");
+	}),
+};
+
+const baseDeps = {
+	assertProvider: vi.fn(),
+	sendMessageWeb: vi.fn(),
+	resolveTwilioMediaUrl: vi.fn(),
+	sendMessage: vi.fn(),
+	waitForFinalStatus: vi.fn(),
+} as unknown as CliDeps;
+
+describe("sendCommand", () => {
+	it("validates wait and poll", async () => {
+		await expect(() =>
+			sendCommand(
+				{
+					to: "+1",
+					message: "hi",
+					wait: "-1",
+					poll: "2",
+					provider: "twilio",
+				},
+				baseDeps,
+				runtime,
+			),
+		).rejects.toThrow("Wait must be >= 0 seconds");
+
+		await expect(() =>
+			sendCommand(
+				{
+					to: "+1",
+					message: "hi",
+					wait: "0",
+					poll: "0",
+					provider: "twilio",
+				},
+				baseDeps,
+				runtime,
+			),
+		).rejects.toThrow("Poll must be > 0 seconds");
+	});
+
+	it("handles web dry-run and warns on wait", async () => {
+		const deps = {
+			...baseDeps,
+			sendMessageWeb: vi.fn(),
+		} as CliDeps;
+		await sendCommand(
+			{
+				to: "+1",
+				message: "hi",
+				wait: "5",
+				poll: "2",
+				provider: "web",
+				dryRun: true,
+				media: "pic.jpg",
+			},
+			deps,
+			runtime,
+		);
+		expect(deps.sendMessageWeb).not.toHaveBeenCalled();
+	});
+
+	it("sends via web and outputs JSON", async () => {
+		const deps = {
+			...baseDeps,
+			sendMessageWeb: vi.fn().mockResolvedValue({ messageId: "web1" }),
+		} as CliDeps;
+		await sendCommand(
+			{
+				to: "+1",
+				message: "hi",
+				wait: "1",
+				poll: "2",
+				provider: "web",
+				json: true,
+			},
+			deps,
+			runtime,
+		);
+		expect(deps.sendMessageWeb).toHaveBeenCalled();
+		expect(runtime.log).toHaveBeenCalledWith(
+			expect.stringContaining("\"provider\": \"web\""),
+		);
+	});
+
+	it("supports twilio dry-run", async () => {
+		const deps = { ...baseDeps } as CliDeps;
+		await sendCommand(
+			{
+				to: "+1",
+				message: "hi",
+				wait: "0",
+				poll: "2",
+				provider: "twilio",
+				dryRun: true,
+			},
+			deps,
+			runtime,
+		);
+		expect(deps.sendMessage).not.toHaveBeenCalled();
+	});
+
+	it("sends via twilio with media and skips wait when zero", async () => {
+		const deps = {
+			...baseDeps,
+			resolveTwilioMediaUrl: vi.fn().mockResolvedValue("https://media"),
+			sendMessage: vi.fn().mockResolvedValue({ sid: "SM1", client: {} }),
+			waitForFinalStatus: vi.fn(),
+		} as CliDeps;
+		await sendCommand(
+			{
+				to: "+1",
+				message: "hi",
+				wait: "0",
+				poll: "2",
+				provider: "twilio",
+				media: "pic.jpg",
+				serveMedia: true,
+				json: true,
+			},
+			deps,
+			runtime,
+		);
+		expect(deps.resolveTwilioMediaUrl).toHaveBeenCalledWith("pic.jpg", {
+			serveMedia: true,
+			runtime,
+		});
+		expect(deps.waitForFinalStatus).not.toHaveBeenCalled();
+		expect(runtime.log).toHaveBeenCalledWith(
+			expect.stringContaining("\"provider\": \"twilio\""),
+		);
+	});
+});

src/commands/status.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { CliDeps } from "../cli/deps.js";
+import type { RuntimeEnv } from "../runtime.js";
+import { statusCommand } from "./status.js";
+
+vi.mock("../twilio/messages.js", () => ({
+	formatMessageLine: (m: any) => `LINE:${m.sid}`,
+}));
+
+const runtime: RuntimeEnv = {
+	log: vi.fn(),
+	error: vi.fn(),
+	exit: vi.fn(() => {
+		throw new Error("exit");
+	}),
+};
+
+const deps: CliDeps = {
+	listRecentMessages: vi.fn(),
+} as unknown as CliDeps;
+
+describe("statusCommand", () => {
+	it("validates limit and lookback", async () => {
+		await expect(
+			statusCommand({ limit: "0", lookback: "10" }, deps, runtime),
+		).rejects.toThrow("limit must be between 1 and 200");
+		await expect(
+			statusCommand({ limit: "10", lookback: "0" }, deps, runtime),
+		).rejects.toThrow("lookback must be > 0 minutes");
+	});
+
+	it("prints JSON when requested", async () => {
+		(deps.listRecentMessages as any).mockResolvedValue([{ sid: "1" }]);
+		await statusCommand(
+			{ limit: "5", lookback: "10", json: true },
+			deps,
+			runtime,
+		);
+		expect(runtime.log).toHaveBeenCalledWith(
+			JSON.stringify([{ sid: "1" }], null, 2),
+		);
+	});
+
+	it("prints formatted lines otherwise", async () => {
+		(deps.listRecentMessages as any).mockResolvedValue([{ sid: "123" }]);
+		await statusCommand({ limit: "1", lookback: "5" }, deps, runtime);
+		expect(runtime.log).toHaveBeenCalledWith("LINE:123");
+	});
+});

src/commands/webhook.ts

@@ -1,6 +1,7 @@
 import type { CliDeps } from "../cli/deps.js";
 import { retryAsync } from "../infra/retry.js";
 import type { RuntimeEnv } from "../runtime.js";
+import { upCommand } from "./up.js";
 
 export async function webhookCommand(
 	opts: {
@@ -9,6 +10,8 @@ export async function webhookCommand(
 		reply?: string;
 		verbose?: boolean;
 		yes?: boolean;
+		ingress?: "tailscale" | "none";
+		dryRun?: boolean;
 	},
 	deps: CliDeps,
 	runtime: RuntimeEnv,
@@ -17,8 +20,28 @@ export async function webhookCommand(
 	if (Number.isNaN(port) || port <= 0 || port >= 65536) {
 		throw new Error("Port must be between 1 and 65535");
 	}
+
+	const ingress = opts.ingress ?? "tailscale";
+
+	// Tailscale ingress: reuse the `up` flow (Funnel + Twilio webhook update).
+	if (ingress === "tailscale") {
+		const result = await upCommand(
+			{
+				port: opts.port,
+				path: opts.path,
+				verbose: opts.verbose,
+				yes: opts.yes,
+				dryRun: opts.dryRun,
+			},
+			deps,
+			runtime,
+		);
+		return result.server;
+	}
+
+	// Local-only webhook (no ingress / no Twilio update).
 	await deps.ensurePortAvailable(port);
-	if (opts.reply === "dry-run") {
+	if (opts.reply === "dry-run" || opts.dryRun) {
 		runtime.log(
 			`[dry-run] would start webhook on port ${port} path ${opts.path}`,
 		);

src/env.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { ensureTwilioEnv, readEnv } from "./env.js";
+import type { RuntimeEnv } from "./runtime.js";
+
+const baseEnv = {
+	TWILIO_ACCOUNT_SID: "AC123",
+	TWILIO_WHATSAPP_FROM: "whatsapp:+1555",
+};
+
+describe("env helpers", () => {
+	const runtime: RuntimeEnv = {
+		log: vi.fn(),
+		error: vi.fn(),
+		exit: vi.fn(() => {
+			throw new Error("exit");
+		}),
+	};
+
+	function setEnv(vars: Record<string, string | undefined>) {
+		Object.assign(process.env, vars);
+	}
+
+	it("reads env with auth token", () => {
+		setEnv({
+			...baseEnv,
+			TWILIO_AUTH_TOKEN: "token",
+			TWILIO_API_KEY: undefined,
+			TWILIO_API_SECRET: undefined,
+		});
+		const cfg = readEnv(runtime);
+		expect(cfg.accountSid).toBe("AC123");
+		expect(cfg.whatsappFrom).toBe("whatsapp:+1555");
+		expect("authToken" in cfg.auth && cfg.auth.authToken).toBe("token");
+	});
+
+	it("reads env with API key/secret", () => {
+		setEnv({
+			...baseEnv,
+			TWILIO_AUTH_TOKEN: undefined,
+			TWILIO_API_KEY: "key",
+			TWILIO_API_SECRET: "secret",
+		});
+		const cfg = readEnv(runtime);
+		expect("apiKey" in cfg.auth && cfg.auth.apiKey).toBe("key");
+		expect("apiSecret" in cfg.auth && cfg.auth.apiSecret).toBe("secret");
+	});
+
+	it("fails fast on invalid env", () => {
+		setEnv({
+			TWILIO_ACCOUNT_SID: "",
+			TWILIO_WHATSAPP_FROM: "",
+			TWILIO_AUTH_TOKEN: undefined,
+			TWILIO_API_KEY: undefined,
+			TWILIO_API_SECRET: undefined,
+		});
+		expect(() => readEnv(runtime)).toThrow("exit");
+		expect(runtime.error).toHaveBeenCalled();
+	});
+
+	it("ensureTwilioEnv passes when token present", () => {
+		setEnv({
+			...baseEnv,
+			TWILIO_AUTH_TOKEN: "token",
+			TWILIO_API_KEY: undefined,
+			TWILIO_API_SECRET: undefined,
+		});
+		expect(() => ensureTwilioEnv(runtime)).not.toThrow();
+	});
+
+	it("ensureTwilioEnv fails when missing auth", () => {
+		setEnv({
+			...baseEnv,
+			TWILIO_AUTH_TOKEN: undefined,
+			TWILIO_API_KEY: undefined,
+			TWILIO_API_SECRET: undefined,
+		});
+		expect(() => ensureTwilioEnv(runtime)).toThrow("exit");
+	});
+});

src/providers/web/index.ts

@@ -1,12 +1,12 @@
 export {
 	createWaSocket,
+	waitForWaConnection,
+	sendMessageWeb,
 	loginWeb,
-	logWebSelfId,
 	monitorWebInbox,
 	monitorWebProvider,
-	pickProvider,
-	sendMessageWeb,
-	WA_WEB_AUTH_DIR,
-	waitForWaConnection,
 	webAuthExists,
+	logWebSelfId,
+	pickProvider,
+	WA_WEB_AUTH_DIR,
 } from "../../provider-web.js";