feat: add image support across web and twilio

src/media/host.ts

@@ -0,0 +1,68 @@
+import { once } from "node:events";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { danger, warn } from "../globals.js";
+import { logInfo, logWarn } from "../logger.js";
+import { defaultRuntime, type RuntimeEnv } from "../runtime.js";
+import { ensurePortAvailable, PortInUseError } from "../infra/ports.js";
+import { getTailnetHostname } from "../infra/tailscale.js";
+import { saveMediaSource } from "./store.js";
+import { startMediaServer } from "./server.js";
+
+const DEFAULT_PORT = 42873;
+const TTL_MS = 2 * 60 * 1000;
+
+let mediaServer: import("http").Server | null = null;
+
+export type HostedMedia = {
+	url: string;
+	id: string;
+	size: number;
+};
+
+export async function ensureMediaHosted(
+	source: string,
+	opts: {
+		port?: number;
+		startServer?: boolean;
+		runtime?: RuntimeEnv;
+	} = {},
+): Promise<HostedMedia> {
+	const port = opts.port ?? DEFAULT_PORT;
+	const runtime = opts.runtime ?? defaultRuntime;
+
+	const saved = await saveMediaSource(source);
+	const hostname = await getTailnetHostname();
+
+	// Decide whether we must start a media server.
+	const needsServerStart = await isPortFree(port);
+	if (needsServerStart && !opts.startServer) {
+		await fs.rm(saved.path).catch(() => {});
+		throw new Error(
+			"Media hosting requires the webhook/Funnel server. Start `warelay webhook`/`warelay up` or re-run with --serve-media.",
+		);
+	}
+	if (needsServerStart && opts.startServer) {
+		if (!mediaServer) {
+			mediaServer = await startMediaServer(port, TTL_MS, runtime);
+			logInfo(
+				`📡 Started temporary media host on http://localhost:${port}/media/:id (TTL ${TTL_MS / 1000}s)`,
+				runtime,
+			);
+			mediaServer.unref?.();
+		}
+	}
+
+	const url = `https://${hostname}/media/${saved.id}`;
+	return { url, id: saved.id, size: saved.size };
+}
+
+async function isPortFree(port: number) {
+	try {
+		await ensurePortAvailable(port);
+		return true;
+	} catch (err) {
+		if (err instanceof PortInUseError) return false;
+		throw err;
+	}
+}

src/media/server.ts

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import express, { type Express } from "express";
+import type { Server } from "http";
+import { danger } from "../globals.js";
+import { defaultRuntime, type RuntimeEnv } from "../runtime.js";
+import { cleanOldMedia, getMediaDir } from "./store.js";
+
+const DEFAULT_TTL_MS = 2 * 60 * 1000;
+
+export function attachMediaRoutes(
+	app: Express,
+	ttlMs = DEFAULT_TTL_MS,
+	runtime: RuntimeEnv = defaultRuntime,
+) {
+	const mediaDir = getMediaDir();
+
+	app.get("/media/:id", async (req, res) => {
+		const id = req.params.id;
+		const file = path.join(mediaDir, id);
+		try {
+			const stat = await fs.stat(file);
+			if (Date.now() - stat.mtimeMs > ttlMs) {
+				await fs.rm(file).catch(() => {});
+				res.status(410).send("expired");
+				return;
+			}
+			res.sendFile(file);
+			// best-effort single-use cleanup after response ends
+			res.on("finish", () => {
+				setTimeout(() => {
+					fs.rm(file).catch(() => {});
+				}, 500);
+			});
+		} catch {
+			res.status(404).send("not found");
+		}
+	});
+
+	// periodic cleanup
+	setInterval(() => {
+		void cleanOldMedia(ttlMs);
+	}, ttlMs).unref();
+
+}
+
+export async function startMediaServer(
+	port: number,
+	ttlMs = DEFAULT_TTL_MS,
+	runtime: RuntimeEnv = defaultRuntime,
+): Promise<Server> {
+	const app = express();
+	attachMediaRoutes(app, ttlMs, runtime);
+	return await new Promise((resolve, reject) => {
+		const server = app.listen(port);
+		server.once("listening", () => resolve(server));
+		server.once("error", (err) => {
+			runtime.error(danger(`Media server failed: ${String(err)}`));
+			reject(err);
+		});
+	});
+}

src/media/store.ts

@@ -0,0 +1,93 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { pipeline } from "node:stream/promises";
+import { createWriteStream } from "node:fs";
+import { request } from "node:https";
+
+const MEDIA_DIR = path.join(os.homedir(), ".warelay", "media");
+const MAX_BYTES = 5 * 1024 * 1024; // 5MB
+const DEFAULT_TTL_MS = 2 * 60 * 1000; // 2 minutes
+
+export function getMediaDir() {
+	return MEDIA_DIR;
+}
+
+export async function ensureMediaDir() {
+	await fs.mkdir(MEDIA_DIR, { recursive: true });
+	return MEDIA_DIR;
+}
+
+export async function cleanOldMedia(ttlMs = DEFAULT_TTL_MS) {
+	await ensureMediaDir();
+	const entries = await fs.readdir(MEDIA_DIR).catch(() => []);
+	const now = Date.now();
+	await Promise.all(
+		entries.map(async (file) => {
+			const full = path.join(MEDIA_DIR, file);
+			const stat = await fs.stat(full).catch(() => null);
+			if (!stat) return;
+			if (now - stat.mtimeMs > ttlMs) {
+				await fs.rm(full).catch(() => {});
+			}
+		}),
+	);
+}
+
+function looksLikeUrl(src: string) {
+	return /^https?:\/\//i.test(src);
+}
+
+async function downloadToFile(url: string, dest: string) {
+	await new Promise<void>((resolve, reject) => {
+		const req = request(url, (res) => {
+			if (!res.statusCode || res.statusCode >= 400) {
+				reject(new Error(`HTTP ${res.statusCode ?? "?"} downloading media`));
+				return;
+			}
+			let total = 0;
+			const out = createWriteStream(dest);
+			res.on("data", (chunk) => {
+				total += chunk.length;
+				if (total > MAX_BYTES) {
+					req.destroy(new Error("Media exceeds 5MB limit"));
+				}
+			});
+			pipeline(res, out).then(() => resolve()).catch(reject);
+		});
+		req.on("error", reject);
+		req.end();
+	});
+}
+
+export type SavedMedia = {
+	id: string;
+	path: string;
+	size: number;
+	contentType?: string;
+};
+
+export async function saveMediaSource(
+	source: string,
+): Promise<SavedMedia> {
+	await ensureMediaDir();
+	await cleanOldMedia();
+	const id = crypto.randomUUID();
+	const dest = path.join(MEDIA_DIR, id);
+	if (looksLikeUrl(source)) {
+		await downloadToFile(source, dest);
+		const stat = await fs.stat(dest);
+		return { id, path: dest, size: stat.size };
+	}
+	// local path
+	const stat = await fs.stat(source);
+	if (!stat.isFile()) {
+		throw new Error("Media path is not a file");
+	}
+	if (stat.size > MAX_BYTES) {
+		throw new Error("Media exceeds 5MB limit");
+	}
+	await fs.copyFile(source, dest);
+	return { id, path: dest, size: stat.size };
+}