@weibaohui/dsh-git-server 0.1.0

package/server/dist/hook.js

@@ -0,0 +1,53 @@
+// git hook subcommand: pre-receive/update/post-receive, mirroring cmd/gogs/hook.go.
+// Environment carries the auth/repo context (ComposeHookEnvs).
+import * as db from './db/db.js';
+export async function runHook(name) {
+    if (name === 'pre-receive' || name === 'update') {
+        // branch protection enforcement goes here; accept by default
+        process.exit(0);
+    }
+    if (name !== 'post-receive') {
+        process.exit(0);
+    }
+    console.error('[hook:dbg] name=%s owner=%s repo=%s user=%s', name, process.env.GOGS_REPO_OWNER_NAME, process.env.GOGS_REPO_NAME, process.env.GOGS_AUTH_USER_ID);
+    const ownerName = process.env.GOGS_REPO_OWNER_NAME ?? '';
+    const repoName = process.env.GOGS_REPO_NAME ?? '';
+    const userID = Number(process.env.GOGS_AUTH_USER_ID ?? 0);
+    const owner = db.getUserByUsername(ownerName);
+    const repo = owner ? db.getRepoByOwnerAndName(owner, repoName) : null;
+    const doer = db.getUserByID(userID);
+    if (!repo || !doer) {
+        console.error('[hook] missing context: owner=%s repo=%s user=%d repoObj=%s', ownerName, repoName, userID, !!repo);
+        process.exit(0);
+    }
+    console.error('[hook:dbg] context ok, reading stdin');
+    // stdin lines: "<old> <new> <ref>"
+    const input = await new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (d) => (data += d));
+        process.stdin.on('end', () => resolve(data));
+    });
+    const { processPushUpdate } = await import('./gitx/service.js');
+    const { pendingDeliveries } = await import('./webhook.js');
+    for (const line of input.split('\n')) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 3)
+            continue;
+        const [oldSha, newSha, ref] = parts;
+        console.error('[hook:dbg] processing line: %s %s %s', oldSha, newSha, ref);
+        // wiki pushes are handled by their own flows
+        if (repo.RepoPath().includes('.wiki.git'))
+            continue;
+        try {
+            await processPushUpdate({ doer, repo, refName: ref, oldSha, newSha, pusherID: doer.id });
+        }
+        catch (e) {
+            console.error(`[hook] push update failed: ${e?.stack ?? e?.message ?? e}`);
+        }
+    }
+    // let async webhook deliveries flush before the hook process exits
+    await Promise.allSettled(Array.from(pendingDeliveries));
+    process.exit(0);
+}
+//# sourceMappingURL=hook.js.map

package/server/dist/index.js

@@ -0,0 +1,112 @@
+// ts-gogs entry point.
+import * as fs from 'node:fs';
+import { execSync } from 'node:child_process';
+import * as path from 'node:path';
+import * as url from 'node:url';
+import { conf } from './conf.js';
+import { startServer } from './server.js';
+import { db } from './db/db.js';
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+async function main() {
+    const argv = process.argv.slice(2);
+    // work directory = repo root (contains templates/, public/, vendored-conf/)
+    const workDir = path.resolve(__dirname, '..');
+    const customDir = process.env.GOGS_CUSTOM ?? path.join(workDir, 'custom');
+    fs.mkdirSync(customDir, { recursive: true });
+    // --config=<path> (gogs CLI convention, used by authorized_keys serv entries)
+    const configFlag = argv.find((a) => a.startsWith('--config='));
+    const confOverride = configFlag ? configFlag.slice('--config='.length).replace(/^'|'$/g, '') : process.env.GOGS_CUSTOM_CONF;
+    conf.load(workDir, customDir, confOverride);
+    // asset cache-busting version: real commit when serving from a git checkout
+    try {
+        conf.buildCommit = execSync('git rev-parse --short HEAD', { cwd: workDir }).toString().trim();
+    }
+    catch { }
+    // git delegate hook entrypoints (config must be loaded before dispatch)
+    if (argv[0] === 'hook') {
+        const { runHook } = await import('./hook.js');
+        await runHook(argv[1] ?? '');
+        return;
+    }
+    console.log(`${conf.brandName} ${conf.version} (ts-gogs)`);
+    console.log(`Work directory: ${workDir}`);
+    console.log(`Custom path:    ${customDir}`);
+    // git version check (gogs requires >= 1.8.3)
+    const { gitVersion } = await import('./gitx/git.js');
+    try {
+        const v = await gitVersion();
+        console.log(`Git version:    ${v}`);
+    }
+    catch (e) {
+        console.error('FATAL: git binary not found');
+        process.exit(1);
+    }
+    // gogs NewRepoContext: ensure a global git identity exists
+    const { gitOK } = await import('./gitx/git.js');
+    if (!(await gitOK(process.cwd(), 'config', '--global', 'user.email'))) {
+        await gitOK(process.cwd(), 'config', '--global', 'user.email', 'gogs@fake.local');
+        await gitOK(process.cwd(), 'config', '--global', 'user.name', 'Gogs');
+    }
+    db();
+    console.log(`Database:       ${conf.dbPath}`);
+    // dsh-git-server 变体：启动时刷新全部仓库的 delegate hooks
+    // （安装位置迁移/升级后旧路径会失效，upstream gogs 同样在启动时重写）
+    {
+        const rows = db().prepare('SELECT r.lower_name AS repo, u.name AS owner FROM repository r JOIN user u ON u.id = r.owner_id').all();
+        const { createDelegateHooks } = await import('./gitx/service.js');
+        for (const row of rows) {
+            try {
+                createDelegateHooks(path.join(conf.repositoryRoot, row.owner, row.repo + '.git'));
+            }
+            catch { }
+        }
+    }
+    // dsh-git-server 插件模式：
+    //   DSH_BOOTSTRAP_ADMIN=user:pass — 用户库为空时播种管理员
+    //   DSH_ADMIN_PASSWORD — 每次启动把该管理员密码重置为此值（设置页轮换密码的落点）
+    const bootstrap = process.env.DSH_BOOTSTRAP_ADMIN || '';
+    const adminPass = process.env.DSH_ADMIN_PASSWORD || '';
+    const adminName = bootstrap.split(':')[0] || 'root';
+    if (bootstrap.includes(':') || adminPass) {
+        const count = db().prepare('SELECT COUNT(*) AS c FROM user WHERE type = 0').get().c;
+        const { randomSalt, encodePassword } = await import('./authx/password.js');
+        const now = Math.floor(Date.now() / 1000);
+        if (count === 0) {
+            const pass = bootstrap.includes(':') ? bootstrap.slice(bootstrap.indexOf(':') + 1) : (adminPass || 'gogs-admin');
+            const salt = randomSalt();
+            db().prepare('INSERT INTO user (name, lower_name, email, passwd, salt, type, is_admin, created_unix, updated_unix) VALUES (?, ?, ?, ?, ?, 0, 1, ?, ?)')
+                .run(adminName, adminName.toLowerCase(), `${adminName}@dsh.local`, encodePassword(pass, salt), salt, now, now);
+            console.log(`Bootstrap admin created: ${adminName}`);
+        }
+        else if (adminPass) {
+            // 管理员已存在：重置密码为插件配置值（设置页轮换的真实落点）
+            const admin = db().prepare('SELECT id, salt FROM user WHERE type = 0 AND is_admin = 1 ORDER BY id LIMIT 1').get();
+            if (admin) {
+                const { encodePassword: enc } = await import('./authx/password.js');
+                db().prepare('UPDATE user SET passwd = ?, updated_unix = ? WHERE id = ?').run(enc(adminPass, admin.salt), now, admin.id);
+                console.log(`Admin password synced from plugin settings`);
+            }
+        }
+    }
+    const server = await startServer();
+    // periodic mirror synchronization (gogs InitSyncMirrors)
+    const { startMirrorLoop } = await import('./mirror.js');
+    startMirrorLoop();
+    // dsh-git-server 变体：不启动内置 SSH 服务（git 统一走 HTTP）
+    // dsh-git-server 变体减法：不写系统 ~/.ssh/authorized_keys（插件默认
+    // DISABLE_SSH，git 统一走 HTTP），避免与宿主机器的 ssh 配置互相干扰。
+    console.log(`Available on    ${conf.externalURL}`);
+    console.log(`Listening       ${conf.httpAddr}:${conf.httpPort}`);
+    const shutdown = () => {
+        console.log('\nShutting down...');
+        server.close(() => process.exit(0));
+        setTimeout(() => process.exit(0), 3000);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((e) => {
+    console.error('FATAL:', e);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/server/dist/lfsx.js

@@ -0,0 +1,265 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { conf } from './conf.js';
+import * as db from './db/db.js';
+import { verifyPassword } from './authx/password.js';
+const LFS_CONTENT_TYPE = 'application/vnd.git-lfs+json';
+function hmacSign(data) {
+    return crypto.createHmac('sha256', conf.secretKey).update(data).digest('hex');
+}
+export function mintLFSToken(userID, repoID, ttlSeconds = 86400) {
+    const expiry = Math.floor(Date.now() / 1000) + ttlSeconds;
+    const payload = `${userID}.${repoID}.${expiry}`;
+    return { token: `${payload}.${hmacSign(payload)}`, expiresAt: expiry };
+}
+export function verifyLFSToken(token) {
+    const idx = token.lastIndexOf('.');
+    if (idx < 0)
+        return null;
+    const payload = token.slice(0, idx);
+    const sig = token.slice(idx + 1);
+    const expected = hmacSign(payload);
+    const a = Buffer.from(sig, 'hex');
+    const b = Buffer.from(expected, 'hex');
+    if (a.length !== b.length || !crypto.timingSafeEqual(a, b))
+        return null;
+    const [userID, repoID, expiry] = payload.split('.');
+    const p = { userID: Number(userID), repoID: Number(repoID), expiry: Number(expiry) };
+    if (!Number.isFinite(p.expiry) || p.expiry < Date.now() / 1000)
+        return null;
+    return p;
+}
+function validOID(oid) {
+    return /^[a-f0-9]{64}$/.test(oid);
+}
+function sendJSON(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('Content-Type', LFS_CONTENT_TYPE);
+    res.end(JSON.stringify(body ?? {}));
+}
+function askCredentials(res) {
+    res.setHeader('Lfs-Authenticate', 'Basic realm="Git LFS"');
+    sendJSON(res, 401, { message: 'Credentials needed' });
+}
+function lfsObjectPath(oid) {
+    return path.join(conf.appDataPath, 'lfs-objects', oid.slice(0, 2), oid.slice(2, 4), oid);
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (d) => chunks.push(d));
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+/** gogs LFS authenticate: RemoteAuth token (from git-lfs-authenticate over SSH),
+ * basic user/pass (2FA users rejected), or token as username or password. */
+async function authenticate(req) {
+    const header = String(req.headers.authorization ?? '');
+    if (header.startsWith('RemoteAuth ')) {
+        const payload = verifyLFSToken(header.slice('RemoteAuth '.length).trim());
+        if (payload)
+            return db.getUserByID(payload.userID);
+        return null;
+    }
+    if (!header.startsWith('Basic '))
+        return null;
+    const decoded = Buffer.from(header.slice(6), 'base64').toString('utf8');
+    const idx = decoded.indexOf(':');
+    const username = idx >= 0 ? decoded.slice(0, idx) : decoded;
+    const password = idx >= 0 ? decoded.slice(idx + 1) : '';
+    if (!username)
+        return null;
+    const user = db.getUserByUsername(username);
+    if (user && verifyPassword(password, user.salt, user.passwd)) {
+        if (is2FAEnabled(user.id))
+            return null; // password auth disallowed for 2FA users
+        return user;
+    }
+    // username or password may be an access token
+    for (const candidate of [username, password]) {
+        const row = db.getAccessTokenBySHA1(candidate);
+        if (row) {
+            const u = db.getUserByID(row.uid);
+            if (u)
+                return u;
+        }
+    }
+    return null;
+}
+function is2FAEnabled(userID) {
+    return !!db.db().prepare('SELECT 1 FROM two_factor WHERE user_id = ?').get(userID);
+}
+function ensureStorage(oid) {
+    const dst = lfsObjectPath(oid);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    return dst;
+}
+/**
+ * Handle an LFS request; returns true when handled.
+ * subPath is the part after "/{owner}/{repo}.git/info/lfs".
+ */
+export async function handleLFS(req, res, owner, repo, subPath) {
+    const method = (req.method ?? 'GET').toUpperCase();
+    const user = await authenticate(req);
+    // route: /objects/batch, /objects/basic/:oid, /objects/basic/verify
+    const m = /^\/objects\/batch$/.exec(subPath);
+    const mBasic = /^\/objects\/basic\/([a-f0-9]{64})$/.exec(subPath);
+    const mVerify = /^\/objects\/basic\/verify$/.exec(subPath);
+    if (!m && !mBasic && !mVerify) {
+        sendJSON(res, 404, { message: 'Not found' });
+        return true;
+    }
+    if (!user) {
+        askCredentials(res);
+        return true;
+    }
+    const mode = db.accessMode(user.id, repo);
+    const canRead = mode >= db.AccessMode.READ || (!repo.is_private && !conf.requireSigninView);
+    const canWrite = mode >= db.AccessMode.WRITE;
+    // ---- POST /objects/batch
+    if (m && method === 'POST') {
+        if (!canRead) {
+            sendJSON(res, 404, { message: 'Not found' });
+            return true;
+        }
+        if (String(req.headers.accept ?? '') !== LFS_CONTENT_TYPE) {
+            sendJSON(res, 406, { message: 'Bad `Accept` header' });
+            return true;
+        }
+        if (String(req.headers['content-type'] ?? '') !== LFS_CONTENT_TYPE) {
+            sendJSON(res, 400, { message: 'Bad `Content-Type` header' });
+            return true;
+        }
+        let body;
+        try {
+            body = JSON.parse((await readBody(req)).toString('utf8'));
+        }
+        catch (e) {
+            sendJSON(res, 400, { message: String(e?.message ?? e).replace(/^./, (ch) => ch.toUpperCase()) });
+            return true;
+        }
+        const operation = String(body.operation ?? '');
+        const baseHref = `${conf.externalURL}${owner.name}/${repo.name}.git/info/lfs/objects/basic`;
+        const objects = [];
+        if (operation === 'upload') {
+            for (const obj of body.objects ?? []) {
+                if (validOID(String(obj.oid))) {
+                    objects.push({
+                        oid: obj.oid,
+                        size: obj.size,
+                        authenticated: true,
+                        actions: {
+                            upload: { href: `${baseHref}/${obj.oid}`, header: { 'Content-Type': 'application/octet-stream' } },
+                            verify: { href: `${baseHref}/verify` },
+                        },
+                    });
+                }
+                else {
+                    objects.push({ oid: obj.oid, size: obj.size, error: { code: 422, message: 'Object has invalid oid' } });
+                }
+            }
+        }
+        else if (operation === 'download') {
+            for (const obj of body.objects ?? []) {
+                const oid = String(obj.oid);
+                const row = db.db().prepare('SELECT * FROM lfs_object WHERE repo_id = ? AND oid = ?').get(repo.id, oid);
+                if (!row) {
+                    objects.push({ oid, size: obj.size, error: { code: 404, message: 'Object does not exist' } });
+                }
+                else if (row.size !== obj.size) {
+                    objects.push({ oid, size: obj.size, error: { code: 422, message: 'Object size mismatch' } });
+                }
+                else {
+                    objects.push({ oid, size: obj.size, authenticated: true, actions: { download: { href: `${baseHref}/${oid}` } } });
+                }
+            }
+        }
+        else {
+            sendJSON(res, 400, { message: 'Operation not supported' });
+            return true;
+        }
+        sendJSON(res, 200, { transfer: 'basic', authentication: 'basic', objects });
+        return true;
+    }
+    // ---- GET /objects/basic/:oid (download)
+    if (mBasic && method === 'GET') {
+        if (!canRead) {
+            sendJSON(res, 404, { message: 'Not found' });
+            return true;
+        }
+        const oid = mBasic[1];
+        const row = db.db().prepare('SELECT * FROM lfs_object WHERE repo_id = ? AND oid = ?').get(repo.id, oid);
+        if (!row) {
+            sendJSON(res, 404, { message: 'Object does not exist' });
+            return true;
+        }
+        const file = lfsObjectPath(oid);
+        if (!fs.existsSync(file)) {
+            sendJSON(res, 404, { message: 'Object does not exist' });
+            return true;
+        }
+        res.setHeader('Content-Type', 'application/octet-stream');
+        res.setHeader('Content-Length', String(fs.statSync(file).size));
+        fs.createReadStream(file).pipe(res);
+        return true;
+    }
+    // ---- PUT /objects/basic/:oid (upload)
+    if (mBasic && method === 'PUT') {
+        if (!canWrite) {
+            sendJSON(res, 404, { message: 'Not found' });
+            return true;
+        }
+        if (String(req.headers['content-type'] ?? '') !== 'application/octet-stream') {
+            sendJSON(res, 400, { message: 'Bad `Content-Type` header' });
+            return true;
+        }
+        const oid = mBasic[1];
+        const content = await readBody(req);
+        const hash = crypto.createHash('sha256').update(content).digest('hex');
+        if (hash !== oid) {
+            sendJSON(res, 422, { message: 'Content-Length and Oid mismatches' });
+            return true;
+        }
+        const dst = ensureStorage(oid);
+        fs.writeFileSync(dst, content);
+        db.db()
+            .prepare('INSERT OR REPLACE INTO lfs_object (repo_id, oid, size, storage, created_at) VALUES (?,?,?,?,?)')
+            .run(repo.id, oid, content.length, 'local', new Date().toISOString().replace('T', ' ').replace('Z', ''));
+        res.statusCode = 200;
+        res.end();
+        return true;
+    }
+    // ---- POST /objects/basic/verify
+    if (mVerify && method === 'POST') {
+        if (!canWrite) {
+            sendJSON(res, 404, { message: 'Not found' });
+            return true;
+        }
+        let body;
+        try {
+            body = JSON.parse((await readBody(req)).toString('utf8'));
+        }
+        catch (e) {
+            sendJSON(res, 400, { message: String(e?.message ?? e) });
+            return true;
+        }
+        const oid = String(body.oid ?? '');
+        const size = Number(body.size ?? -1);
+        const row = db.db().prepare('SELECT * FROM lfs_object WHERE repo_id = ? AND oid = ?').get(repo.id, oid);
+        if (!row || !validOID(oid)) {
+            sendJSON(res, 404, { message: 'Object does not exist' });
+            return true;
+        }
+        if (row.size !== size) {
+            sendJSON(res, 422, { message: 'Object size mismatch' });
+            return true;
+        }
+        sendJSON(res, 200, {});
+        return true;
+    }
+    sendJSON(res, 405, { message: 'Method not allowed' });
+    return true;
+}
+//# sourceMappingURL=lfsx.js.map

package/server/dist/mailer.js

@@ -0,0 +1,127 @@
+// Minimal SMTP client (implicit TLS on 465, STARTTLS on 587, plain otherwise)
+// powering gogs [mailer] flows: test mail, account activation, password reset.
+import * as net from 'node:net';
+import * as tls from 'node:tls';
+import { conf } from './conf.js';
+function readReply(socket, expect) {
+    return new Promise((resolve, reject) => {
+        let buf = '';
+        const onData = (d) => {
+            buf += d.toString('utf8');
+            // last line fully received and matches expected code
+            const lines = buf.split(/\r?\n/).filter(Boolean);
+            const last = lines[lines.length - 1] ?? '';
+            if (/^\d{3} /.test(last)) {
+                socket.removeListener('data', onData);
+                if (expect.test(last))
+                    resolve(buf);
+                else
+                    reject(new Error(`SMTP unexpected reply: ${last}`));
+            }
+        };
+        socket.on('data', onData);
+        socket.once('error', reject);
+    });
+}
+function sendLine(socket, line) {
+    socket.write(line + '\r\n');
+}
+export async function sendMail(mail) {
+    // HOST may carry an explicit port (gogs semantics: `host:port`)
+    let host = conf.emailHost.split(':')[0];
+    let port = conf.emailPort;
+    if (conf.emailHost.includes(':')) {
+        const p = Number(conf.emailHost.split(':')[1]);
+        if (Number.isFinite(p) && p > 0)
+            port = p;
+    }
+    const from = conf.emailFrom || mail.from;
+    const subject = conf.emailSubjectPrefix + mail.subject;
+    await new Promise((resolve, reject) => {
+        let socket;
+        if (port === 465) {
+            socket = tls.connect({ host, port, rejectUnauthorized: !conf.emailSkipVerify }, () => run());
+        }
+        else {
+            socket = net.connect({ host, port }, () => run());
+        }
+        socket.setTimeout(15000, () => {
+            socket.destroy(new Error('SMTP timeout'));
+        });
+        socket.on('error', reject);
+        let started = false;
+        async function run() {
+            try {
+                if (!started) {
+                    started = true;
+                    await readReply(socket, /^220/);
+                    const ehloHost = conf.domain || 'localhost';
+                    sendLine(socket, `EHLO ${ehloHost}`);
+                    await readReply(socket, /^250/);
+                    if (conf.emailUseTLS && port !== 465) {
+                        sendLine(socket, 'STARTTLS');
+                        await readReply(socket, /^220/);
+                        const secure = tls.connect({ socket, host, port, rejectUnauthorized: !conf.emailSkipVerify }, async () => {
+                            socket.removeAllListeners('data');
+                            try {
+                                await smtpSession(socket);
+                                resolve();
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                        });
+                        secure.on('error', reject);
+                        return;
+                    }
+                    await smtpSession(socket);
+                    resolve();
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        }
+        async function smtpSession(sock) {
+            if (conf.emailUser) {
+                sendLine(sock, 'AUTH LOGIN');
+                await readReply(sock, /^334/);
+                sendLine(sock, Buffer.from(conf.emailUser).toString('base64'));
+                await readReply(sock, /^334/);
+                sendLine(sock, Buffer.from(conf.emailPasswd).toString('base64'));
+                await readReply(sock, /^235/);
+            }
+            sendLine(sock, `MAIL FROM:<${from.replace(/.*</, '').replace(/>.*/, '')}>`);
+            await readReply(sock, /^250/);
+            sendLine(sock, `RCPT TO:<${mail.to}>`);
+            await readReply(sock, /^250/);
+            sendLine(sock, 'DATA');
+            await readReply(sock, /^354/);
+            const headers = `From: ${from}\r\nTo: ${mail.to}\r\nSubject: ${subject}\r\nMIME-Version: 1.0\r\nContent-Type: text/html; charset=UTF-8\r\n\r\n`;
+            sendLine(sock, headers + mail.body.replace(/\r?\n\./g, '\r\n..') + '\r\n.');
+            await readReply(sock, /^250/);
+            sendLine(sock, 'QUIT');
+            sock.end();
+        }
+    });
+}
+/** Activation mail body — mirrors gogs mail/auth/activate.tmpl essentials. */
+export function sendActivateMail(user, code) {
+    const link = `${conf.externalURL}user/activate?code=${encodeURIComponent(code)}`;
+    return sendMail({
+        from: conf.emailFrom,
+        to: user.email,
+        subject: 'Please activate your account',
+        body: `<p>Hi <b>${user.name}</b>, thanks for registering! Please click the following link to activate your account within <b>${conf.activateCodeLives} minutes</b>.</p><p><a href="${link}">${link}</a></p><p>Not working? Paste this code: <code>${code}</code></p>`,
+    });
+}
+export function sendResetPasswordMail(user, code) {
+    const link = `${conf.externalURL}user/reset_password?code=${encodeURIComponent(code)}`;
+    return sendMail({
+        from: conf.emailFrom,
+        to: user.email,
+        subject: 'Reset your password',
+        body: `<p>Hi <b>${user.name}</b>, someone requested a password reset. Click within <b>${conf.resetPwdCodeLives} minutes</b> to continue.</p><p><a href="${link}">${link}</a></p>`,
+    });
+}
+//# sourceMappingURL=mailer.js.map