agent-loft 0.0.0-stage → 0.2.8

package/src/channels/web/auth.ts

@@ -0,0 +1,204 @@
+// Web 登录鉴权。
+//
+// 这个页面能让 agent 在这台机器上执行命令，等同于一个远程 shell，所以：
+//   - 密码用 scrypt 哈希存，不存明文；
+//   - 首次没有密码时，必须拿终端 / 日志里打印的一次性设置码才能设密码
+//     （否则谁先打开页面谁就成了主人）；
+//   - 登录态是随机 token，服务端只存它的哈希，HttpOnly cookie；
+//   - 同一 IP 连续输错会被锁一段时间。
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { EventEmitter } from "node:events";
+import path from "node:path";
+import { config, saveConfig } from "../../core/config.js";
+import { dataDir, readJson, writeJsonAtomic } from "../../home.js";
+
+const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
+/** 登录态被撤销（退出、改密码、踢设备）时通知 WebSocket 那边立刻断开对应连接 */
+export const authEvents = new EventEmitter<{ revoked: [] }>();
+const sessionsPath = path.join(dataDir, "web-sessions.json");
+const setupTokenPath = path.join(dataDir, "web-setup-token");
+
+export type WebSession = {
+  createdAt: number;
+  expiresAt: number;
+  lastSeen: number;
+  ip: string;
+  userAgent: string;
+};
+
+let sessions: Record<string, WebSession> | null = null;
+let loadedMtime = 0;
+
+function mtimeOf(file: string): number {
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function loadSessions(): Record<string, WebSession> {
+  // 终端里 agent-loft passwd 会清空登录态：文件变了就重新读，让被踢的设备立刻失效
+  const mtime = mtimeOf(sessionsPath);
+  if (!sessions || mtime !== loadedMtime) {
+    sessions = readJson<Record<string, WebSession>>(sessionsPath, {});
+    loadedMtime = mtime;
+  }
+  const now = Date.now();
+  for (const [id, s] of Object.entries(sessions)) if (s.expiresAt < now) delete sessions[id];
+  return sessions;
+}
+
+function saveSessions(): void {
+  writeJsonAtomic(sessionsPath, sessions ?? {});
+  loadedMtime = mtimeOf(sessionsPath);
+}
+
+function sha256(value: string): string {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+// ---------- 密码 ----------
+
+export function hashPassword(password: string): string {
+  const salt = crypto.randomBytes(16);
+  const key = crypto.scryptSync(password, salt, 32, { N: 16384, r: 8, p: 1 });
+  return `scrypt$${salt.toString("hex")}$${key.toString("hex")}`;
+}
+
+export function verifyPassword(password: string, stored: string): boolean {
+  const [scheme, saltHex, keyHex] = stored.split("$");
+  if (scheme !== "scrypt" || !saltHex || !keyHex) return false;
+  const expected = Buffer.from(keyHex, "hex");
+  const actual = crypto.scryptSync(password, Buffer.from(saltHex, "hex"), expected.length, { N: 16384, r: 8, p: 1 });
+  return crypto.timingSafeEqual(expected, actual);
+}
+
+export function hasPassword(): boolean {
+  return !!config().web.passwordHash;
+}
+
+export function setPassword(password: string): void {
+  if (password.length < 8) throw new Error("密码至少 8 位");
+  const cfg = structuredClone(config());
+  cfg.web.passwordHash = hashPassword(password);
+  saveConfig(cfg);
+  // 改密码 = 所有已登录设备下线
+  sessions = {};
+  saveSessions();
+  fs.rmSync(setupTokenPath, { force: true });
+  authEvents.emit("revoked");
+}
+
+// ---------- 首次设置码 ----------
+
+/** 没有密码时生成（或沿用）一次性设置码，打印到日志里。 */
+export function ensureSetupToken(): string | null {
+  if (hasPassword()) return null;
+  try {
+    const existing = fs.readFileSync(setupTokenPath, "utf8").trim();
+    if (existing) return existing;
+  } catch {
+    // 没有就新建
+  }
+  const token = crypto.randomBytes(6).toString("hex").toUpperCase();
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(setupTokenPath, token, { mode: 0o600 });
+  return token;
+}
+
+export function checkSetupToken(token: string): boolean {
+  const expected = ensureSetupToken();
+  if (!expected) return false;
+  const a = Buffer.from(token.trim().toUpperCase());
+  const b = Buffer.from(expected);
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+
+// ---------- 登录态 ----------
+
+export function createSession(ip: string, userAgent: string): string {
+  const token = crypto.randomBytes(32).toString("base64url");
+  const now = Date.now();
+  loadSessions()[sha256(token)] = { createdAt: now, expiresAt: now + SESSION_TTL_MS, lastSeen: now, ip, userAgent };
+  saveSessions();
+  return token;
+}
+
+export function validateSession(token: string | undefined): WebSession | undefined {
+  if (!token || !hasPassword()) return undefined;
+  const s = loadSessions()[sha256(token)];
+  if (!s) return undefined;
+  const now = Date.now();
+  if (now - s.lastSeen > 60_000) {
+    s.lastSeen = now;
+    saveSessions();
+  }
+  return s;
+}
+
+export function destroySession(token: string | undefined): void {
+  if (!token) return;
+  delete loadSessions()[sha256(token)];
+  saveSessions();
+  authEvents.emit("revoked");
+}
+
+export function listSessions(): (WebSession & { id: string })[] {
+  return Object.entries(loadSessions()).map(([id, s]) => ({ id: id.slice(0, 12), ...s }));
+}
+
+export function revokeSession(idPrefix: string): boolean {
+  const all = loadSessions();
+  const hit = Object.keys(all).find((id) => id.startsWith(idPrefix));
+  if (!hit) return false;
+  delete all[hit];
+  saveSessions();
+  authEvents.emit("revoked");
+  return true;
+}
+
+// ---------- 防爆破 ----------
+//
+// 额度在「真要验密码的那一刻」同步扣掉，而不是先查后记：后者中间隔着读请求体的
+// await，攻击者攒一大批请求同时提交，每个都能通过检查。
+
+const MAX_ATTEMPTS = 5;
+const WINDOW_MS = 15 * 60 * 1000;
+/** 全局：就算对方能换 IP，一分钟内总共也只能试这么多次 */
+const GLOBAL_MAX_PER_MIN = 30;
+
+const attempts = new Map<string, { count: number; first: number; until: number }>();
+let globalWindow = { start: 0, count: 0 };
+
+/**
+ * 占用一次尝试额度。返回 0 表示可以验证；否则返回还要等多少毫秒。
+ * 同步执行，并发请求之间不会穿插。
+ */
+export function takeAttempt(ip: string): number {
+  const now = Date.now();
+  if (now - globalWindow.start >= 60_000) globalWindow = { start: now, count: 0 };
+  if (globalWindow.count >= GLOBAL_MAX_PER_MIN) return globalWindow.start + 60_000 - now;
+
+  let a = attempts.get(ip);
+  if (a && a.until > now) return a.until - now;
+  if (!a || now - a.first > WINDOW_MS) {
+    if (attempts.size > 10_000) attempts.clear();
+    a = { count: 0, first: now, until: 0 };
+    attempts.set(ip, a);
+  }
+  if (a.count >= MAX_ATTEMPTS) {
+    a.until = now + WINDOW_MS;
+    return WINDOW_MS;
+  }
+  a.count += 1;
+  globalWindow.count += 1;
+  return 0;
+}
+
+/** 验证成功：这个 IP 的计数清零（全局窗口不退，防止拿一个正确密码洗额度） */
+export function clearAttempts(ip: string): void {
+  attempts.delete(ip);
+}

package/src/channels/web/http.ts

@@ -0,0 +1,118 @@
+// HTTP 小工具：不引框架，几十行就够用。
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { config } from "../../core/config.js";
+
+export class HttpError extends Error {
+  constructor(
+    readonly status: number,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+function normalizeIp(ip: string): string {
+  return ip.trim().replace(/^::ffff:/, "");
+}
+
+function isTrustedProxy(ip: string | undefined): boolean {
+  if (!ip) return false;
+  const list = config().web.trustedProxies.map(normalizeIp);
+  return list.includes(normalizeIp(ip));
+}
+
+/** 这条连接是不是经由可信反代来的。只有这时 X-Forwarded-* 才可信。 */
+export function viaTrustedProxy(req: IncomingMessage): boolean {
+  return isTrustedProxy(req.socket.remoteAddress);
+}
+
+/**
+ * 客户端 IP：从 X-Forwarded-For 的最右边往左剥掉可信代理，第一个不可信的就是客户端。
+ * 不取最左边那个 —— 那一项是客户端自己能随便填的。
+ */
+export function clientIp(req: IncomingMessage): string {
+  const remote = req.socket.remoteAddress ?? "unknown";
+  if (!viaTrustedProxy(req)) return normalizeIp(remote);
+  const fwd = req.headers["x-forwarded-for"];
+  const chain = (Array.isArray(fwd) ? fwd.join(",") : (fwd ?? ""))
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  for (let i = chain.length - 1; i >= 0; i--) {
+    if (!isTrustedProxy(chain[i])) return normalizeIp(chain[i]!);
+  }
+  const real = req.headers["x-real-ip"];
+  return typeof real === "string" && real ? normalizeIp(real) : normalizeIp(remote);
+}
+
+export function isHttps(req: IncomingMessage): boolean {
+  if (viaTrustedProxy(req) && req.headers["x-forwarded-proto"] === "https") return true;
+  return (req.socket as { encrypted?: boolean }).encrypted === true;
+}
+
+export function cookies(req: IncomingMessage): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const part of (req.headers.cookie ?? "").split(";")) {
+    const at = part.indexOf("=");
+    if (at < 0) continue;
+    out[part.slice(0, at).trim()] = decodeURIComponent(part.slice(at + 1).trim());
+  }
+  return out;
+}
+
+/**
+ * 跨站请求防护：浏览器发的写请求和 WebSocket 握手一定带 Origin，它的 host 必须和
+ * 请求的 host 一致。没有 Origin 的（curl 之类）放行 —— 它们本来就带不了别人的 cookie。
+ */
+export function sameOrigin(req: IncomingMessage): boolean {
+  const origin = req.headers.origin;
+  if (!origin) return true;
+  let originHost: string;
+  try {
+    originHost = new URL(origin).host;
+  } catch {
+    return false;
+  }
+  const fwdHost = viaTrustedProxy(req) ? req.headers["x-forwarded-host"] : undefined;
+  const hosts = [req.headers.host, ...(Array.isArray(fwdHost) ? fwdHost : fwdHost ? [fwdHost] : [])];
+  return hosts.some((h) => h?.split(",")[0]?.trim() === originHost);
+}
+
+export async function readBody(req: IncomingMessage, limit: number): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += (chunk as Buffer).length;
+    if (size > limit) throw new HttpError(413, `内容太大（上限 ${Math.round(limit / 1024 / 1024)}MB）`);
+    chunks.push(chunk as Buffer);
+  }
+  return Buffer.concat(chunks);
+}
+
+export async function readJsonBody<T = Record<string, unknown>>(req: IncomingMessage): Promise<T> {
+  const raw = await readBody(req, 1024 * 1024);
+  if (raw.length === 0) return {} as T;
+  try {
+    return JSON.parse(raw.toString("utf8")) as T;
+  } catch {
+    throw new HttpError(400, "请求体不是合法的 JSON");
+  }
+}
+
+export function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  const data = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+    "Content-Length": Buffer.byteLength(data),
+  });
+  res.end(data);
+}
+
+export const SECURITY_HEADERS: Record<string, string> = {
+  "X-Content-Type-Options": "nosniff",
+  "X-Frame-Options": "DENY",
+  "Referrer-Policy": "same-origin",
+  "Content-Security-Policy":
+    "default-src 'self'; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline'; script-src 'self'; connect-src 'self' ws: wss:; frame-ancestors 'none'; base-uri 'self'; form-action 'self'",
+};

package/src/channels/web/push.ts

@@ -0,0 +1,218 @@
+// Web Push：回复完成、需要授权时给手机 / 电脑推系统通知。
+//
+// 不依赖第三方库，按标准自己实现：
+//   - VAPID（RFC 8292）：用一对 P-256 密钥给推送服务签 JWT，证明推送来自我们；
+//   - 消息加密（RFC 8291，aes128gcm）：推送服务（Apple / Google / Mozilla）看不到内容。
+// iPhone 上只有「添加到主屏幕」的 PWA 才能收到（iOS 16.4+），macOS Safari / Chrome 直接可用。
+// 订阅接口要求页面是 HTTPS（localhost 除外）。
+import crypto from "node:crypto";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../../home.js";
+
+export type PushSubscriptionRecord = {
+  endpoint: string;
+  keys: { p256dh: string; auth: string };
+  /** 设备描述（User-Agent 摘要），设置页里认设备用 */
+  label: string;
+  createdAt: number;
+  lastOkAt?: number;
+};
+
+export type PushPayload = {
+  title: string;
+  body: string;
+  /** 同一 tag 的通知会互相替换，不在通知中心堆一串 */
+  tag?: string;
+  /** 点开通知后打开的地址 */
+  url?: string;
+};
+
+type Store = {
+  vapid?: { publicKey: string; privateJwk: crypto.JsonWebKey };
+  subscriptions: PushSubscriptionRecord[];
+};
+
+const FILE = () => path.join(dataDir, "push.json");
+/** VAPID 的 sub 声明：Apple 要求是 mailto: 或 https: 地址 */
+const VAPID_SUBJECT = "https://github.com/qijieinnet/agent-loft";
+
+let store: Store | null = null;
+
+function load(): Store {
+  if (!store) {
+    store = readJson<Store>(FILE(), { subscriptions: [] });
+    if (!Array.isArray(store.subscriptions)) store.subscriptions = [];
+  }
+  return store;
+}
+
+function persist(): void {
+  writeJsonAtomic(FILE(), load());
+}
+
+/** 测试用：换了 AGENT_LOFT_HOME 之后重新读 */
+export function resetPushStoreForTest(): void {
+  store = null;
+}
+
+export const b64url = (buf: Buffer | Uint8Array): string => Buffer.from(buf).toString("base64url");
+export const fromB64url = (s: string): Buffer => Buffer.from(s, "base64url");
+
+/** 未压缩格式的 P-256 公钥（0x04 || x || y，65 字节） */
+function rawPublicKey(jwk: crypto.JsonWebKey): Buffer {
+  return Buffer.concat([Buffer.from([4]), fromB64url(jwk.x!), fromB64url(jwk.y!)]);
+}
+
+function vapid(): { publicKey: string; privateKey: crypto.KeyObject } {
+  const s = load();
+  if (!s.vapid) {
+    const { privateKey } = crypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+    const privateJwk = privateKey.export({ format: "jwk" });
+    s.vapid = { publicKey: b64url(rawPublicKey(privateJwk)), privateJwk };
+    persist();
+  }
+  return { publicKey: s.vapid.publicKey, privateKey: crypto.createPrivateKey({ key: s.vapid.privateJwk, format: "jwk" }) };
+}
+
+/** 浏览器订阅时要的 applicationServerKey */
+export function vapidPublicKey(): string {
+  return vapid().publicKey;
+}
+
+export function vapidHeader(endpoint: string): string {
+  const { publicKey, privateKey } = vapid();
+  const header = b64url(Buffer.from(JSON.stringify({ typ: "JWT", alg: "ES256" })));
+  const claims = b64url(
+    Buffer.from(
+      JSON.stringify({ aud: new URL(endpoint).origin, exp: Math.floor(Date.now() / 1000) + 12 * 3600, sub: VAPID_SUBJECT }),
+    ),
+  );
+  const signature = crypto.sign("sha256", Buffer.from(`${header}.${claims}`), { key: privateKey, dsaEncoding: "ieee-p1363" });
+  return `vapid t=${header}.${claims}.${b64url(signature)}, k=${publicKey}`;
+}
+
+const hkdf = (ikm: Buffer, salt: Buffer, info: Buffer, len: number): Buffer =>
+  Buffer.from(crypto.hkdfSync("sha256", ikm, salt, info, len));
+
+/** RFC 8291 加密：单条记录，内容后加 0x02 分隔符，不填充 */
+export function encryptPayload(plaintext: Buffer, p256dh: string, auth: string): Buffer {
+  const uaPublic = fromB64url(p256dh);
+  const authSecret = fromB64url(auth);
+  const ecdh = crypto.createECDH("prime256v1");
+  const asPublic = ecdh.generateKeys();
+  const shared = ecdh.computeSecret(uaPublic);
+  const keyInfo = Buffer.concat([Buffer.from("WebPush: info\0"), uaPublic, asPublic]);
+  const ikm = hkdf(shared, authSecret, keyInfo, 32);
+  const salt = crypto.randomBytes(16);
+  const cek = hkdf(ikm, salt, Buffer.from("Content-Encoding: aes128gcm\0"), 16);
+  const nonce = hkdf(ikm, salt, Buffer.from("Content-Encoding: nonce\0"), 12);
+  const cipher = crypto.createCipheriv("aes-128-gcm", cek, nonce);
+  const body = Buffer.concat([cipher.update(Buffer.concat([plaintext, Buffer.from([2])])), cipher.final(), cipher.getAuthTag()]);
+  const rs = Buffer.alloc(4);
+  rs.writeUInt32BE(4096);
+  return Buffer.concat([salt, rs, Buffer.from([asPublic.length]), asPublic, body]);
+}
+
+// ---------- 订阅管理 ----------
+
+function validSubscription(sub: unknown): sub is { endpoint: string; keys: { p256dh: string; auth: string } } {
+  const s = sub as { endpoint?: unknown; keys?: { p256dh?: unknown; auth?: unknown } };
+  if (typeof s?.endpoint !== "string" || typeof s.keys?.p256dh !== "string" || typeof s.keys?.auth !== "string") return false;
+  try {
+    const url = new URL(s.endpoint);
+    // 只往 https 推：不然这个接口能被拿来让服务器去请求内网任意地址
+    if (url.protocol !== "https:") return false;
+  } catch {
+    return false;
+  }
+  return fromB64url(s.keys.p256dh).length === 65 && fromB64url(s.keys.auth).length >= 16;
+}
+
+function describeUa(ua: string): string {
+  const device = /iPhone/.test(ua) ? "iPhone" : /iPad/.test(ua) ? "iPad" : /Mac OS X/.test(ua) ? "Mac" : /Android/.test(ua) ? "Android" : /Windows/.test(ua) ? "Windows" : "设备";
+  const browser = /Edg\//.test(ua) ? "Edge" : /Chrome\//.test(ua) ? "Chrome" : /Firefox\//.test(ua) ? "Firefox" : /Safari\//.test(ua) ? "Safari" : "";
+  return browser ? `${device} · ${browser}` : device;
+}
+
+export function addSubscription(sub: unknown, userAgent: string): PushSubscriptionRecord {
+  if (!validSubscription(sub)) throw new Error("订阅信息不完整");
+  const s = load();
+  const record: PushSubscriptionRecord = {
+    endpoint: sub.endpoint,
+    keys: { p256dh: sub.keys.p256dh, auth: sub.keys.auth },
+    label: describeUa(userAgent),
+    createdAt: Date.now(),
+  };
+  s.subscriptions = [...s.subscriptions.filter((x) => x.endpoint !== sub.endpoint), record];
+  persist();
+  return record;
+}
+
+export function removeSubscription(endpoint: string): boolean {
+  const s = load();
+  const before = s.subscriptions.length;
+  s.subscriptions = s.subscriptions.filter((x) => x.endpoint !== endpoint);
+  if (s.subscriptions.length === before) return false;
+  persist();
+  return true;
+}
+
+/** 给设置页看的：不带密钥 */
+export function listSubscriptions(): { endpoint: string; label: string; createdAt: number; lastOkAt?: number }[] {
+  return load().subscriptions.map(({ endpoint, label, createdAt, lastOkAt }) => ({
+    endpoint,
+    label,
+    createdAt,
+    ...(lastOkAt ? { lastOkAt } : {}),
+  }));
+}
+
+export function hasSubscriptions(): boolean {
+  return load().subscriptions.length > 0;
+}
+
+// ---------- 发送 ----------
+
+async function sendOne(sub: PushSubscriptionRecord, payload: PushPayload): Promise<boolean> {
+  const body = encryptPayload(Buffer.from(JSON.stringify(payload)), sub.keys.p256dh, sub.keys.auth);
+  const res = await fetch(sub.endpoint, {
+    method: "POST",
+    headers: {
+      Authorization: vapidHeader(sub.endpoint),
+      "Content-Encoding": "aes128gcm",
+      "Content-Type": "application/octet-stream",
+      TTL: String(24 * 3600),
+      Urgency: "high",
+    },
+    body,
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (res.status === 404 || res.status === 410) {
+    // 订阅失效了（用户关了通知、删了 PWA）：清掉，别一直推
+    removeSubscription(sub.endpoint);
+    console.warn(`[push] 订阅已失效，已移除：${sub.label}`);
+    return false;
+  }
+  if (!res.ok) {
+    console.error(`[push] 推送失败（${sub.label}）：${res.status} ${await res.text().catch(() => "")}`);
+    return false;
+  }
+  sub.lastOkAt = Date.now();
+  return true;
+}
+
+/** 推给所有订阅的设备，返回成功的数量。单个设备失败不影响别的 */
+export async function pushToAll(payload: PushPayload): Promise<number> {
+  const subs = [...load().subscriptions];
+  if (subs.length === 0) return 0;
+  const results = await Promise.all(
+    subs.map((sub) =>
+      sendOne(sub, payload).catch((err) => {
+        console.error(`[push] 推送出错（${sub.label}）：`, err instanceof Error ? err.message : err);
+        return false;
+      }),
+    ),
+  );
+  if (results.some(Boolean)) persist();
+  return results.filter(Boolean).length;
+}