agentinbox-cli 0.0.0 → 0.1.0-nightly.1

package/dist/server-CWqKeCGn.js

@@ -0,0 +1,981 @@
+#!/usr/bin/env node
+import { t as Db } from "./db-DdagFmUY.js";
+import { t as AuditLog } from "./audit-DETqygzG.js";
+import { a as errorMessage, i as conflict, n as PolicyDenied, r as badRequest, t as HttpError } from "./errors-CJLUPllS.js";
+import { a as verifyPasswordAsync, n as hashPasswordAsync, r as safeEqual, t as Crypto } from "./crypto-DYZ4R7c2.js";
+import { a as adminAuth, c as csrfGuard, d as hasSession, f as isClaimed, g as requireAdmin, h as rejection, l as currentSetupToken, m as lockedOut, n as MAX_PASSWORD_LENGTH, o as checkSecret, s as clientIp, u as endSession, v as sessionToken, y as startSession } from "./auth-BniddcRD.js";
+import { a as setupTokenPath, r as readSetupToken, t as deleteSetupToken } from "./setup-token-Bkwk84l7.js";
+import { t as createBus } from "./bus-Cz0flS37.js";
+import { n as loadConfig } from "./config-v975gxv4.js";
+import { c as NPM_PACKAGE, i as cliCommand, n as assertMasterKeyUsable, t as acquireInstanceLock } from "./instance-Dy2jeyZc.js";
+import { r as loopbackUrl, t as consoleUrls } from "./urls-DmnonkJo.js";
+import { i as renderSkill } from "./skill-WKbeyNct.js";
+import { t as SettingsStore } from "./settings-Dq2ETFsd.js";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { extname, join, resolve, sep } from "node:path";
+import pc from "picocolors";
+import { createHash } from "node:crypto";
+import { serve } from "@hono/node-server";
+import open from "open";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+//#region server/api/util.ts
+/**
+* Console API routers are `(ctx) => Hono<AppEnv>` factories with paths relative to /api
+* (e.g. "/accounts/:id"). server/app.ts mounts them behind the admin auth middleware and turns
+* thrown HttpError / PolicyDenied into ApiError JSON responses.
+*/
+const router = () => new Hono();
+/** Parses and validates a JSON body; throws HttpError(400) with a readable message. */
+async function readBody(c, schema) {
+	let raw;
+	try {
+		const text = await c.req.text();
+		raw = text ? JSON.parse(text) : {};
+	} catch {
+		throw badRequest("Request body must be valid JSON");
+	}
+	const parsed = schema.safeParse(raw);
+	if (!parsed.success) throw badRequest(z.prettifyError(parsed.error));
+	return parsed.data;
+}
+/** Audit fields for console (admin) actions: spread into ctx.audit.record. */
+const ADMIN_ACTOR = {
+	actorType: "admin",
+	actorId: null
+};
+//#endregion
+//#region server/api/accounts.ts
+function accountsApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/agents.ts
+function agentsApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/approvals.ts
+function approvalsApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/audit.ts
+function auditApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/setup.ts
+const ClaimBody = z.object({
+	token: z.string().trim().min(1, "Setup token is required").max(200),
+	password: z.string().max(MAX_PASSWORD_LENGTH, `Password must be at most ${MAX_PASSWORD_LENGTH} characters`)
+});
+/** Unauthenticated: first-run status and the one-time claim. Mounted before the admin guard. */
+function setupPublicApi(ctx) {
+	const auth = adminAuth(ctx);
+	return router().get("/setup/status", (c) => {
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			claimed: isClaimed(ctx),
+			authenticated: hasSession(c, ctx)
+		});
+	}).post("/setup/claim", async (c) => {
+		const ip = clientIp(c, ctx.config.trustProxy);
+		const banned = auth.limiter.bannedMinutes(ip);
+		if (banned) return lockedOut(c, banned);
+		const body = await readBody(c, ClaimBody);
+		if (isClaimed(ctx)) throw conflict("This instance is already claimed", "Sign in with the admin password instead.");
+		const expected = readSetupToken(ctx.config.dataDir);
+		if (!expected) throw new HttpError(403, "invalid_token", "The setup link has expired", `Restart agentinbox or run \`${cliCommand("reset-password")}\` for a new link.`);
+		const check = await checkSecret(ctx, ip, `claim:${body.token}`, () => safeEqual(body.token, expected), { global: false });
+		if (!check.ok) {
+			const rejected = rejection(c, check);
+			if (rejected) return rejected;
+			ctx.audit.record({
+				actorType: "admin",
+				action: "admin.claim",
+				outcome: "denied",
+				reason: check.nowBanned ? "lockout" : "invalid_token",
+				detail: { ip }
+			});
+			throw new HttpError(403, "invalid_token", "Invalid setup token", "Use the exact setup link printed by agentinbox on startup.");
+		}
+		checkPassword(body.password);
+		const hash = await hashPasswordAsync(body.password);
+		if (isClaimed(ctx)) throw conflict("This instance is already claimed", "Sign in with the admin password instead.");
+		ctx.settings.setState("admin.passwordHash", hash);
+		deleteSetupToken(ctx.config.dataDir);
+		auth.limiter.reset();
+		startSession(c, ctx);
+		ctx.audit.record({
+			actorType: "admin",
+			action: "admin.claim",
+			outcome: "ok",
+			detail: { ip }
+		});
+		return c.body(null, 204);
+	});
+}
+/** Authenticated: the setup checklist. */
+function setupApi(ctx) {
+	return router().get("/setup/state", (c) => c.json(setupState(ctx)));
+}
+function checkPassword(password) {
+	if (password.length < 10) throw badRequest(`Password must be at least 10 characters`);
+	if (password.length > 1024) throw badRequest(`Password must be at most ${MAX_PASSWORD_LENGTH} characters`);
+}
+/** Composes the setup checklist. Reads the stored state directly if a service is unavailable. */
+function setupState(ctx) {
+	const claimed = isClaimed(ctx);
+	const client = attempt(ctx, () => ctx.google.clientView()) ?? storedClientView(ctx);
+	const pubsub = attempt(ctx, () => ctx.google.pubsubState()) ?? storedPubsub(ctx);
+	const count = (table) => ctx.db.get(`SELECT COUNT(*) AS n FROM ${table}`)?.n ?? 0;
+	const accountsConnected = count("accounts");
+	const googleClientConfigured = !!client.clientId && client.hasSecret;
+	return {
+		claimed,
+		googleClientConfigured,
+		gcpProjectId: client.projectId,
+		googleAppType: client.appType,
+		pubsub,
+		accountsConnected,
+		agentsCreated: count("agents"),
+		complete: claimed && googleClientConfigured && accountsConnected > 0
+	};
+}
+function attempt(ctx, fn) {
+	try {
+		return fn();
+	} catch (err) {
+		ctx.log.debug("setup state: falling back to stored state", { error: err instanceof Error ? err.message : String(err) });
+		return null;
+	}
+}
+function storedClientView(ctx) {
+	const s = ctx.settings.getState("google.client");
+	return {
+		clientId: s?.clientId || null,
+		hasSecret: !!s?.clientSecretEnc,
+		projectId: s?.projectId || null,
+		appType: s?.appType ?? null
+	};
+}
+function storedPubsub(ctx) {
+	const s = ctx.settings.getState("pubsub");
+	return {
+		mode: ctx.settings.get().ingestMode,
+		topic: s?.topic ?? null,
+		subscription: s?.subscription ?? null,
+		lastError: s?.lastError ?? null,
+		lastMessageAt: s?.lastMessageAt ?? null
+	};
+}
+//#endregion
+//#region server/api/auth.ts
+const password = (what) => z.string().max(MAX_PASSWORD_LENGTH, `${what} must be at most ${MAX_PASSWORD_LENGTH} characters`);
+const LoginBody = z.object({ password: password("Password").min(1, "Password is required") });
+const PasswordBody = z.object({
+	current: password("Current password"),
+	next: password("New password")
+});
+/** Unauthenticated: sign in and out. Mounted before the admin guard. */
+function authPublicApi(ctx) {
+	const auth = adminAuth(ctx);
+	return router().post("/auth/login", async (c) => {
+		const ip = clientIp(c, ctx.config.trustProxy);
+		const banned = auth.limiter.bannedMinutes(ip);
+		if (banned) return lockedOut(c, banned);
+		const body = await readBody(c, LoginBody);
+		const hash = ctx.settings.getState("admin.passwordHash");
+		if (!hash) throw conflict("This instance has not been claimed yet", "Open the setup link printed by agentinbox on startup.");
+		const check = await checkSecret(ctx, ip, body.password, () => verifyPasswordAsync(body.password, hash));
+		if (!check.ok) {
+			const rejected = rejection(c, check);
+			if (rejected) return rejected;
+			ctx.audit.record({
+				...ADMIN_ACTOR,
+				action: "admin.login",
+				outcome: "denied",
+				reason: check.nowBanned ? "lockout" : "bad_password",
+				detail: { ip }
+			});
+			throw new HttpError(401, "invalid_password", "Wrong password");
+		}
+		startSession(c, ctx);
+		ctx.audit.record({
+			...ADMIN_ACTOR,
+			action: "admin.login",
+			outcome: "ok",
+			detail: { ip }
+		});
+		return c.body(null, 204);
+	}).post("/auth/logout", (c) => {
+		endSession(c, ctx);
+		return c.body(null, 204);
+	});
+}
+/** Authenticated: change the admin password. Revokes every other session. */
+function authApi(ctx) {
+	const auth = adminAuth(ctx);
+	return router().post("/auth/password", async (c) => {
+		const ip = clientIp(c, ctx.config.trustProxy);
+		const banned = auth.limiter.bannedMinutes(ip);
+		if (banned) return lockedOut(c, banned);
+		const body = await readBody(c, PasswordBody);
+		const hash = ctx.settings.getState("admin.passwordHash");
+		const check = await checkSecret(ctx, ip, body.current, async () => !!hash && await verifyPasswordAsync(body.current, hash));
+		if (!check.ok) {
+			const rejected = rejection(c, check);
+			if (rejected) return rejected;
+			ctx.audit.record({
+				...ADMIN_ACTOR,
+				action: "admin.password_change",
+				outcome: "denied",
+				reason: check.nowBanned ? "lockout" : "bad_password",
+				detail: { ip }
+			});
+			throw new HttpError(400, "invalid_password", "Current password is wrong");
+		}
+		checkPassword(body.next);
+		ctx.settings.setState("admin.passwordHash", await hashPasswordAsync(body.next));
+		const revoked = auth.sessions.deleteAll(sessionToken(c));
+		auth.limiter.reset();
+		ctx.audit.record({
+			...ADMIN_ACTOR,
+			action: "admin.password_change",
+			outcome: "ok",
+			detail: {
+				ip,
+				revokedSessions: revoked
+			}
+		});
+		return c.body(null, 204);
+	});
+}
+//#endregion
+//#region server/api/events.ts
+function eventsApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/google.ts
+function googleApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/oauth.ts
+function oauthRoutes(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/overview.ts
+function overviewApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/api/settings.ts
+/** Shape check only; ranges and URL rules are enforced by SettingsStore.update. */
+const SettingsPatch = z.object({
+	publicUrl: z.string().trim(),
+	ingestMode: z.enum(["pubsub", "poll"]),
+	pollIntervalSeconds: z.number(),
+	maxBodyChars: z.number(),
+	retentionDays: z.number(),
+	approvalTtlHours: z.number(),
+	webhookAllowlist: z.array(z.string())
+}).partial().strict();
+function settingsApi(ctx) {
+	return router().get("/settings", (c) => c.json(ctx.settings.get())).patch("/settings", async (c) => {
+		const patch = await readBody(c, SettingsPatch);
+		const before = ctx.settings.get();
+		const next = ctx.settings.update(patch);
+		const changed = Object.keys(next).filter((k) => JSON.stringify(before[k]) !== JSON.stringify(next[k]));
+		if (changed.length) ctx.audit.record({
+			...ADMIN_ACTOR,
+			action: "settings.update",
+			outcome: "ok",
+			detail: { changed }
+		});
+		return c.json(next);
+	});
+}
+//#endregion
+//#region server/api/system.ts
+const DEFAULT_HOST = "0.0.0.0";
+const LATEST_TTL_MS = 18e5;
+const LATEST_RETRY_MS = 3e5;
+/**
+* Public health check for uptime monitors: 200 when healthy, 503 when degraded (an account needs
+* re-auth or is erroring, or ingest reports an error). Only states and the version, never secrets.
+*/
+function healthRoutes(ctx) {
+	const handler = (c) => {
+		const body = health(ctx);
+		c.header("Cache-Control", "no-store");
+		return c.json(body, body.status === "ok" ? 200 : 503);
+	};
+	return router().get("/health", handler).get("/health/", handler).get("/api/health", handler).get("/api/health/", handler);
+}
+function health(ctx) {
+	const counts = ctx.db.get("SELECT COUNT(*) AS total, COALESCE(SUM(status IN ('needs_reauth', 'error')), 0) AS attention FROM accounts") ?? {
+		total: 0,
+		attention: 0
+	};
+	let ingestError = false;
+	if (counts.total > 0) try {
+		ingestError = !!ctx.ingest.status().lastError;
+	} catch {}
+	let setupComplete = false;
+	try {
+		setupComplete = setupState(ctx).complete;
+	} catch {}
+	return {
+		status: counts.attention > 0 || ingestError ? "degraded" : "ok",
+		version: ctx.config.version,
+		setupComplete
+	};
+}
+/** Authenticated: instance facts and the update notice. */
+function systemApi(ctx) {
+	return router().get("/system", (c) => {
+		let ingest;
+		try {
+			ingest = ctx.ingest.status();
+		} catch (err) {
+			ingest = {
+				mode: ctx.settings.get().ingestMode,
+				running: false,
+				lastPullAt: null,
+				lastError: errorMessage(err)
+			};
+		}
+		return c.json({
+			version: ctx.config.version,
+			nodeVersion: process.versions.node,
+			dataDir: ctx.config.dataDir,
+			service: ctx.config.service,
+			addresses: consoleUrls(ctx.config.host, ctx.config.port),
+			publicUrl: ctx.settings.publicUrl(),
+			ingest
+		});
+	}).get("/system/latest", async (c) => {
+		const latest = await latestVersion(ctx);
+		const current = ctx.config.version;
+		return c.json({
+			current,
+			latest,
+			updateAvailable: !!latest && compareVersions(latest, current) > 0,
+			command: upgradeCommand(ctx.config)
+		});
+	});
+}
+let latestCache;
+/** The npm `latest` dist-tag, cached for 30 minutes (5 after a failed check). */
+async function latestVersion(ctx) {
+	if (latestCache && Date.now() - latestCache.at < (latestCache.version ? LATEST_TTL_MS : LATEST_RETRY_MS)) return latestCache.version;
+	let version = null;
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, { signal: AbortSignal.timeout(5e3) });
+		if (!res.ok) throw new Error(`HTTP ${res.status}`);
+		version = (await res.json()).version ?? null;
+	} catch (err) {
+		ctx.log.debug("Update check failed", { error: errorMessage(err) });
+	}
+	latestCache = {
+		at: Date.now(),
+		version
+	};
+	return version;
+}
+/**
+* Semver precedence: numeric core, then a pre-release sorts before its release, and pre-release
+* identifiers compare numerically when both are numbers ("nightly.10" > "nightly.9").
+*/
+function compareVersions(a, b) {
+	const parse = (v) => {
+		const clean = v.trim().replace(/^v/, "").split("+")[0];
+		const dash = clean.indexOf("-");
+		return {
+			parts: (dash === -1 ? clean : clean.slice(0, dash)).split(".").map((n) => Number.parseInt(n, 10) || 0),
+			pre: dash === -1 ? null : clean.slice(dash + 1).split(".")
+		};
+	};
+	const x = parse(a);
+	const y = parse(b);
+	for (let i = 0; i < Math.max(x.parts.length, y.parts.length); i++) {
+		const d = (x.parts[i] ?? 0) - (y.parts[i] ?? 0);
+		if (d) return Math.sign(d);
+	}
+	if (!x.pre || !y.pre) return x.pre === y.pre ? 0 : x.pre ? -1 : 1;
+	for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+		const p = x.pre[i];
+		const q = y.pre[i];
+		if (p === void 0) return -1;
+		if (q === void 0) return 1;
+		const pn = /^\d+$/.test(p);
+		const qn = /^\d+$/.test(q);
+		if (pn && qn) {
+			const d = Number(p) - Number(q);
+			if (d) return Math.sign(d);
+		} else if (pn !== qn) return pn ? -1 : 1;
+		else if (p !== q) return p < q ? -1 : 1;
+	}
+	return 0;
+}
+const DEFAULT_DATA_DIR = () => resolve(join(homedir(), ".agentinbox"));
+/** Runs, or reinstalls as a service, the latest version with this instance's options. */
+function upgradeCommand(config) {
+	const args = [
+		...config.trustProxy ? ["TRUST_PROXY=1"] : [],
+		"npx",
+		"-y",
+		NPM_PACKAGE
+	];
+	if (config.service) args.push("service", "install");
+	if (config.dataDir !== DEFAULT_DATA_DIR()) args.push("--data", config.dataDir);
+	if (config.port !== 8425) args.push("--port", String(config.port));
+	if (config.host !== DEFAULT_HOST) args.push("--host", config.host);
+	return args.map(shellQuote).join(" ");
+}
+const shellQuote = (a) => /^[\w@%+=:,./-]+$/.test(a) ? a : `'${a.replace(/'/g, `'\\''`)}'`;
+//#endregion
+//#region server/api/webhooks.ts
+function webhooksApi(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/csp.ts
+/**
+* Content Security Policy. Inline scripts run only when their exact content is known up front:
+* the console's index.html (hashed when the file is read) and scripts registered here by routes
+* that render HTML. Never hash scripts out of a response body: that would bless injected markup.
+*
+* A server-rendered page with an inline script (e.g. the OAuth callback page) must keep that
+* script static, call `registerInlineScript(source)` once at module load with the exact source,
+* and pass per-request data in a `<script type="application/json" id="…">` block, which CSP
+* doesn't execute and the static script reads with JSON.parse.
+*/
+const registered = /* @__PURE__ */ new Set();
+/** "sha256-…" source for a script's exact text (what goes between <script> and <\/script>). */
+const scriptHash = (source) => `sha256-${createHash("sha256").update(source).digest("base64")}`;
+function contentSecurityPolicy(extraHashes = []) {
+	return [
+		"default-src 'self'",
+		`script-src 'self'${[.../* @__PURE__ */ new Set([...registered, ...extraHashes])].map((h) => ` '${h}'`).join("")}`,
+		"style-src 'self' 'unsafe-inline'",
+		"img-src 'self' data:",
+		"connect-src 'self'",
+		"object-src 'none'",
+		"base-uri 'none'",
+		"frame-ancestors 'none'",
+		"form-action 'self'"
+	].join("; ");
+}
+/** Hashes of the executable inline scripts in a trusted document (the built index.html). */
+function inlineScriptHashes(html) {
+	const hashes = /* @__PURE__ */ new Set();
+	for (const m of html.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi)) {
+		const attrs = m[1];
+		if (/\bsrc\s*=/i.test(attrs) || !m[2]) continue;
+		const type = /\btype\s*=\s*["']?([^"'\s>]+)/i.exec(attrs)?.[1]?.toLowerCase();
+		if (type && type !== "module" && type !== "text/javascript" && type !== "application/javascript") continue;
+		hashes.add(scriptHash(m[2]));
+	}
+	return [...hashes];
+}
+//#endregion
+//#region server/mcp/index.ts
+function mcpRoutes(_ctx) {
+	return router();
+}
+//#endregion
+//#region server/app.ts
+/**
+* dist/web relative to the running module: the bundle (dist/cli.js) and source runs
+* (server/app.ts via tsx) both resolve to <package root>/dist/web.
+*/
+const DEFAULT_WEB_DIR = resolve(import.meta.dirname, "..", "dist", "web");
+const API_BODY_LIMIT = 1048576;
+const AUTH_BODY_LIMIT = 16384;
+const AUTH_PATHS = [
+	"/api/setup/claim",
+	"/api/auth/login",
+	"/api/auth/password"
+];
+const MCP_BODY_LIMIT = 4194304;
+const AGENT_BODY_LIMIT = 65536;
+/** Extensions served as files; any other path (even with a dot, e.g. /accounts/me@example.com) is a console route. */
+const ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".css",
+	".map",
+	".json",
+	".webmanifest",
+	".txt",
+	".xml",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".avif",
+	".svg",
+	".ico",
+	".woff",
+	".woff2",
+	".ttf",
+	".otf",
+	".wasm"
+]);
+/** Paths the console's index.html fallback must never answer. */
+const SERVER_PREFIXES = [
+	"/api",
+	"/mcp",
+	"/oauth",
+	"/skill.md",
+	"/health"
+];
+const isServerPath = (path) => SERVER_PREFIXES.some((p) => path === p || path.startsWith(p + "/"));
+function createApp(ctx, opts = {}) {
+	const app = new Hono();
+	currentSetupToken(ctx);
+	let consoleHashes = () => [];
+	app.use("*", async (c, next) => {
+		await next();
+		try {
+			c.res.headers.set("Content-Security-Policy", contentSecurityPolicy(consoleHashes()));
+			c.res.headers.set("X-Frame-Options", "DENY");
+			c.res.headers.set("X-Content-Type-Options", "nosniff");
+			c.res.headers.set("Referrer-Policy", "no-referrer");
+		} catch {}
+	});
+	app.onError((err, c) => errorResponse(ctx, err, c));
+	app.notFound((c) => {
+		if (c.req.path === "/api" || c.req.path.startsWith("/api/")) return apiError(c, 404, "not_found", "No such API route");
+		return c.text("Not found", 404);
+	});
+	const tooLarge = (c) => apiError(c, 413, "payload_too_large", "Request body is too large");
+	const limit = (maxSize) => bodyLimit({
+		maxSize,
+		onError: tooLarge
+	});
+	for (const path of AUTH_PATHS) app.use(path, limit(AUTH_BODY_LIMIT));
+	app.use("/api/*", limit(API_BODY_LIMIT));
+	app.use("/mcp", limit(MCP_BODY_LIMIT));
+	app.use("/mcp/*", limit(MCP_BODY_LIMIT));
+	app.use("/agent/*", limit(AGENT_BODY_LIMIT));
+	app.use("/api/*", csrfGuard());
+	app.route("/", healthRoutes(ctx));
+	app.route("/api", setupPublicApi(ctx));
+	app.route("/api", authPublicApi(ctx));
+	app.get("/skill.md", (c) => {
+		c.header("Content-Type", "text/markdown; charset=utf-8");
+		c.header("Cache-Control", "no-cache");
+		return c.body(renderSkill(ctx.settings.publicUrl()));
+	});
+	app.route("/", oauthRoutes(ctx));
+	app.route("/", mcpRoutes(ctx));
+	app.use("/api/*", requireAdmin(ctx));
+	for (const api of [
+		setupApi,
+		authApi,
+		settingsApi,
+		systemApi,
+		googleApi,
+		accountsApi,
+		agentsApi,
+		approvalsApi,
+		webhooksApi,
+		eventsApi,
+		auditApi,
+		overviewApi
+	]) app.route("/api", api(ctx));
+	if (ctx.config.dev) app.get("*", (c) => isServerPath(c.req.path) ? c.notFound() : devPage(c));
+	else consoleHashes = serveConsole(app, opts.webDir ?? DEFAULT_WEB_DIR);
+	return app;
+}
+/** Serves the built console; returns the CSP hashes of index.html's inline scripts (re-read when the file changes). */
+function serveConsole(app, webDir) {
+	const index = join(webDir, "index.html");
+	if (!existsSync(index)) {
+		app.get("*", (c) => isServerPath(c.req.path) ? c.notFound() : missingBuildPage(c, webDir));
+		return () => [];
+	}
+	let cached = {
+		mtimeMs: -1,
+		hashes: []
+	};
+	const hashes = () => {
+		try {
+			const { mtimeMs } = statSync(index);
+			if (mtimeMs !== cached.mtimeMs) cached = {
+				mtimeMs,
+				hashes: inlineScriptHashes(readFileSync(index, "utf8"))
+			};
+		} catch {}
+		return cached.hashes;
+	};
+	const assets = serveStatic({ root: webDir });
+	const assetsDir = join(webDir, "assets") + sep;
+	app.use("*", async (c, next) => {
+		if (isServerPath(c.req.path)) return next();
+		const res = await assets(c, next);
+		if (res instanceof Response) {
+			const hashed = join(webDir, c.req.path).startsWith(assetsDir);
+			res.headers.set("Cache-Control", hashed ? "public, max-age=31536000, immutable" : "no-cache");
+		}
+		return res;
+	});
+	app.get("*", (c) => {
+		const path = c.req.path;
+		if (isServerPath(path) || path.startsWith("/assets/") || ASSET_EXTENSIONS.has(extname(path).toLowerCase())) return c.notFound();
+		c.header("Cache-Control", "no-cache");
+		return c.html(readFileSync(index, "utf8"));
+	});
+	return hashes;
+}
+function errorResponse(ctx, err, c) {
+	if (err instanceof HttpError) return c.json(err.toJSON(), err.status);
+	if (err instanceof PolicyDenied) return apiError(c, 403, "policy_denied", err.message);
+	if (err instanceof z.ZodError) return apiError(c, 400, "bad_request", z.prettifyError(err));
+	if (err instanceof HTTPException) return err.res ? err.getResponse() : apiError(c, err.status, "http_error", err.message || "Request failed");
+	if (err instanceof SyntaxError && /JSON/i.test(err.message)) return apiError(c, 400, "bad_request", "Request body must be valid JSON");
+	ctx.log.error(`${c.req.method} ${c.req.path} failed`, {
+		error: err.message,
+		stack: err.stack
+	});
+	return apiError(c, 500, "internal", "Something went wrong. Check the agentinbox logs for details.");
+}
+function apiError(c, status, code, message) {
+	return c.json({ error: {
+		code,
+		message
+	} }, status);
+}
+const page = (title, body) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title}</title>
+<style>
+  :root { color-scheme: light dark; font-family: ui-sans-serif, system-ui, sans-serif; }
+  body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: Canvas; color: CanvasText; }
+  main { max-width: 34rem; padding: 2rem; line-height: 1.55; }
+  h1 { font-size: 1.25rem; margin: 0 0 .75rem; }
+  code { font-family: ui-monospace, monospace; padding: .1rem .35rem; border-radius: .3rem; background: color-mix(in srgb, CanvasText 10%, transparent); }
+  p { margin: .5rem 0; opacity: .85; }
+</style></head><body><main>${body}</main></body></html>`;
+const escapeHtml = (s) => s.replace(/[&<>"]/g, (ch) => `&#${ch.charCodeAt(0)};`);
+function missingBuildPage(c, webDir) {
+	c.header("Cache-Control", "no-store");
+	return c.html(page("agentinbox: console not built", `<h1>The web console hasn't been built</h1>
+<p>agentinbox is running, but there is no console build in <code>${escapeHtml(webDir)}</code>.</p>
+<p>From a source checkout, run <code>pnpm build</code> and restart, or use <code>pnpm dev</code> for development.</p>
+<p>The API (<code>/api</code>), MCP endpoint (<code>/mcp</code>) and <code>/health</code> work as usual.</p>`), 503);
+}
+function devPage(c) {
+	const url = new URL(c.req.url);
+	const target = `http://localhost:5173${url.pathname}${url.search}`;
+	return c.html(page("agentinbox (dev)", `<h1>agentinbox is running in dev mode</h1>
+<p>The console is served by Vite: open <a href="${escapeHtml(target)}">${escapeHtml(target)}</a>.</p>`));
+}
+//#endregion
+//#region server/maintenance.ts
+const INTERVAL_MS = 36e5;
+const FIRST_RUN_MS = 6e4;
+/** Prunes data older than Settings.retentionDays and expired admin sessions. Never throws. */
+function runMaintenance(ctx) {
+	const log = ctx.log.child("maintenance");
+	const before = (/* @__PURE__ */ new Date(Date.now() - ctx.settings.get().retentionDays * 864e5)).toISOString();
+	const step = (name, fn) => {
+		try {
+			return fn();
+		} catch (err) {
+			log.warn(`Pruning ${name} failed`, { error: errorMessage(err) });
+			return 0;
+		}
+	};
+	const result = {
+		deliveries: step("deliveries", () => ctx.webhooks.prune(before)),
+		events: step("events", () => ctx.events.prune(before)),
+		audit: step("audit log", () => ctx.audit.prune(before)),
+		sessions: step("sessions", () => adminAuth(ctx).sessions.pruneExpired())
+	};
+	if (Object.values(result).some((n) => n > 0)) log.info("Pruned old data", { ...result });
+	return result;
+}
+/** Runs maintenance shortly after start, then hourly. Timers are unref'd. Returns a stop function. */
+function startMaintenance(ctx) {
+	const run = () => {
+		try {
+			runMaintenance(ctx);
+		} catch (err) {
+			ctx.log.warn("Maintenance failed", { error: errorMessage(err) });
+		}
+	};
+	const first = setTimeout(run, FIRST_RUN_MS).unref();
+	const timer = setInterval(run, INTERVAL_MS).unref();
+	return () => {
+		clearTimeout(first);
+		clearInterval(timer);
+	};
+}
+//#endregion
+//#region server/util/log.ts
+const order = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40
+};
+const min = order[process.env.AGENTINBOX_LOG_LEVEL ?? "info"] ?? 20;
+const color = {
+	debug: pc.gray,
+	info: pc.cyan,
+	warn: pc.yellow,
+	error: pc.red
+};
+function createLogger(scope = "agentinbox") {
+	const emit = (level, msg, meta) => {
+		if (order[level] < min) return;
+		const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+		const extra = meta && Object.keys(meta).length ? " " + pc.gray(JSON.stringify(meta)) : "";
+		const line = `${pc.gray(ts)} ${color[level](level.padEnd(5))} ${pc.bold(scope)} ${msg}${extra}`;
+		(level === "error" || level === "warn" ? process.stderr : process.stdout).write(line + "\n");
+	};
+	return {
+		debug: (m, x) => emit("debug", m, x),
+		info: (m, x) => emit("info", m, x),
+		warn: (m, x) => emit("warn", m, x),
+		error: (m, x) => emit("error", m, x),
+		child: (s) => createLogger(`${scope}:${s}`)
+	};
+}
+//#endregion
+//#region server/context.ts
+/** Start order. Policy and events first (no I/O), ingest last so everything it emits into is running. */
+const SERVICE_ORDER = [
+	"policy",
+	"accounts",
+	"events",
+	"webhooks",
+	"mail",
+	"google",
+	"ingest"
+];
+function createCore(config) {
+	const db = new Db(config.dbPath);
+	const bus = createBus();
+	return {
+		config,
+		db,
+		crypto: Crypto.load(config.masterKeyPath),
+		log: createLogger(),
+		bus,
+		settings: new SettingsStore(db, bus, config),
+		audit: new AuditLog(db, bus)
+	};
+}
+//#endregion
+//#region server/util/stub.ts
+/**
+* TEMPORARY scaffolding: a service whose methods throw "not implemented". Lets every domain compile
+* and run its own tests before the others land. Removed at integration.
+*/
+function stubService(name) {
+	return new Proxy({}, { get(_target, prop) {
+		if (prop === "start" || prop === "stop" || prop === "then" || typeof prop === "symbol") return void 0;
+		return () => {
+			throw new Error(`${name}.${String(prop)} is not implemented yet`);
+		};
+	} });
+}
+//#endregion
+//#region server/events/index.ts
+function createEventsService(_ctx) {
+	return stubService("events");
+}
+//#endregion
+//#region server/google/index.ts
+function createGoogleService(_ctx) {
+	return stubService("google");
+}
+function createAccountsService(_ctx) {
+	return stubService("accounts");
+}
+//#endregion
+//#region server/ingest/index.ts
+function createIngestService(_ctx) {
+	return stubService("ingest");
+}
+//#endregion
+//#region server/mail/index.ts
+function createMailService(_ctx) {
+	return stubService("mail");
+}
+//#endregion
+//#region server/policy/index.ts
+function createPolicyService(_ctx) {
+	return stubService("policy");
+}
+//#endregion
+//#region server/webhooks/index.ts
+function createWebhooksService(_ctx) {
+	return stubService("webhooks");
+}
+//#endregion
+//#region server/wire.ts
+const FACTORIES = {
+	accounts: createAccountsService,
+	google: createGoogleService,
+	ingest: createIngestService,
+	events: createEventsService,
+	policy: createPolicyService,
+	mail: createMailService,
+	webhooks: createWebhooksService
+};
+/** Builds the full context. Nothing runs until `startServices`. */
+function createAppContext(config, overrides = {}) {
+	const ctx = createCore(config);
+	for (const key of SERVICE_ORDER) ctx[key] = (overrides[key] ?? FACTORIES[key])(ctx);
+	return ctx;
+}
+async function startServices(ctx) {
+	for (const key of SERVICE_ORDER) await ctx[key].start?.();
+}
+/** Stops services in reverse order, then closes the database. Errors are logged, not thrown. */
+async function stopServices(ctx) {
+	for (const key of [...SERVICE_ORDER].reverse()) try {
+		await ctx[key].stop?.();
+	} catch (err) {
+		ctx.log.error(`Failed to stop ${key}`, { error: err instanceof Error ? err.message : String(err) });
+	}
+	ctx.db.close();
+}
+//#endregion
+//#region server/server.ts
+const SHUTDOWN_TIMEOUT_MS = 1e4;
+/**
+* Takes the data directory's instance lock, checks the master key against stored secrets, builds
+* the context, binds the port, then starts services (so a second instance never runs ingest
+* against the same data). Use `port: 0` in tests; `config.port` is updated to the bound port.
+*/
+async function startServer(opts) {
+	const { config } = opts;
+	const lock = acquireInstanceLock(config);
+	let ctx;
+	let server;
+	try {
+		assertMasterKeyUsable(config);
+		ctx = createAppContext(config, opts.overrides);
+	} catch (err) {
+		lock.release();
+		throw err;
+	}
+	try {
+		server = await listen(createApp(ctx, { webDir: opts.webDir }).fetch, config.host, config.port);
+	} catch (err) {
+		ctx.db.close();
+		lock.release();
+		throw friendlyListenError(err, config.port);
+	}
+	config.port = server.address().port;
+	lock.update(config.port);
+	let stopMaintenance = () => {};
+	let closing;
+	const close = () => closing ??= (async () => {
+		stopMaintenance();
+		await new Promise((resolve) => {
+			server.close(() => resolve());
+			server.closeAllConnections?.();
+		});
+		await stopServices(ctx);
+		lock.release();
+	})();
+	try {
+		await startServices(ctx);
+	} catch (err) {
+		await close();
+		throw err;
+	}
+	stopMaintenance = startMaintenance(ctx);
+	return {
+		url: loopbackUrl(config.host, config.port),
+		ctx,
+		server,
+		close
+	};
+}
+function listen(fetch, hostname, port) {
+	return new Promise((resolve, reject) => {
+		const server = serve({
+			fetch,
+			hostname,
+			port
+		}, () => {
+			server.off("error", reject);
+			resolve(server);
+		});
+		server.once("error", reject);
+	});
+}
+function friendlyListenError(err, port) {
+	const code = err?.code;
+	if (code === "EADDRINUSE") return /* @__PURE__ */ new Error(`Port ${port} is already in use (is agentinbox already running?). Try --port <port>.`);
+	if (code === "EACCES") return /* @__PURE__ */ new Error(`Not allowed to listen on port ${port}. Use a port above 1024, e.g. --port 8425.`);
+	if (code === "EADDRNOTAVAIL") return /* @__PURE__ */ new Error(`Can't bind to that address. Check --host.`);
+	return err instanceof Error ? err : new Error(String(err));
+}
+/** `agentinbox start`: runs in the foreground until SIGINT/SIGTERM. */
+async function runForeground(opts) {
+	const config = loadConfig(opts, opts.version);
+	const running = await startServer({ config });
+	printBanner(running.ctx);
+	const token = currentSetupToken(running.ctx);
+	if (token && opts.open && process.stdout.isTTY && !config.dev && !config.service) openBrowser(`${consoleUrls(config.host, config.port)[0]}/setup?token=${token}`);
+	for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {
+		console.log(pc.dim(`\n  Stopping agentinbox…`));
+		setTimeout(() => {
+			console.error(`agentinbox did not stop within ${SHUTDOWN_TIMEOUT_MS / 1e3} s; exiting anyway.`);
+			process.exit(1);
+		}, SHUTDOWN_TIMEOUT_MS).unref();
+		running.close().then(() => process.exit(0), (err) => {
+			console.error(errorMessage(err));
+			process.exit(1);
+		});
+	});
+}
+function printBanner(ctx) {
+	const { config } = ctx;
+	const urls = config.dev ? ["http://localhost:5173"] : consoleUrls(config.host, config.port);
+	const token = currentSetupToken(ctx);
+	const out = [
+		"",
+		`  ${pc.bold("agentinbox")} ${pc.dim(`v${config.version} · data in ${config.dataDir}`)}`,
+		""
+	];
+	if (token && config.service) out.push(`  ${pc.yellow("Not claimed yet.")} The setup link is ${urls[0]}/setup?token=<token>, with the token in ${setupTokenPath(config.dataDir)}.`, `  ${pc.dim(`\`${cliCommand("service install")}\` prints the full link.`)}`);
+	else if (token) {
+		out.push(`  ${pc.yellow("First run:")} open this link to claim the instance and finish setup:`, "");
+		for (const url of urls) out.push(`  ${pc.cyan(`${url}/setup?token=${token}`)}`);
+	} else {
+		out.push(`  ${pc.dim("Console")}  ${pc.cyan(urls[0])}`);
+		for (const url of urls.slice(1)) out.push(`           ${pc.cyan(url)}`);
+		out.push(`  ${pc.dim("MCP")}      ${pc.cyan(`${ctx.settings.publicUrl()}/mcp`)}`);
+	}
+	if (config.dev) out.push("", pc.dim(`  Dev mode: API on :${config.port}, console via Vite on :5173.`));
+	console.log(out.join("\n") + "\n");
+}
+function openBrowser(url) {
+	if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return;
+	try {
+		open(url).then((child) => child.on("error", () => {}), () => {});
+	} catch {}
+}
+//#endregion
+export { runForeground };
+
+//# sourceMappingURL=server-CWqKeCGn.js.map