Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* 独立运行入口(服务器部署与本机调试共用):
*
* relay init --data <目录> --name <中转名> --owner-user <账号ID> --owner-device <设备ID>
* --owner-device-name <设备名> --owner-credential-hash <SHA-256>
* --relay-id <UUID> --owner-public-key <公钥> --owner-cert <证书 JSON 的 base64url>
* relay serve --data <目录> [--host 127.0.0.1] [--port 47820]
* [--tls-cert <PEM> --tls-key <PEM>] [--public-url <https://...>] [--trust-proxy]
* [--acme-identifier <域名或IP> [--acme-http-port 80] [--acme-directory <URL>]]
*
* `--acme-identifier`:自动向 Let's Encrypt 申请并续期证书(http-01 验证走 `--acme-http-port`),
* 拿到证书后才开始提供 HTTPS;申请失败按退避重试,状态写进数据目录的 status.json。
* relay --version
*
* stdout 每行一个 JSON 事件(initialized / listening / error),供部署器解析;
* 日志写 stderr,不含凭证、加入码与签名地址。
*/
import { AcmeNetworkError } from './acme';
import { CertificateManager, startChallengeServer, type TlsMaterial } from './certificates';
import { identifierFor } from './csr';
import { RelayError } from './errors';
import type { RelayLogger } from './logger';
import { readTlsFiles, startRelayServer } from './server';
import { initializeRelay } from './store';
import { RELAY_VERSION } from './version';
import { manageNginx } from './nginx';
import { lookup } from 'node:dns/promises';
import { isIP } from 'node:net';
const BOOLEAN_FLAGS = new Set(['trust-proxy', 'ipv6', 'existing-certificate']);
/** 首次申请证书失败后的重试间隔(Let's Encrypt 对同一名字每小时只允许几次失败验证)。 */
const ACME_RETRY_DELAYS_MS = [60_000, 5 * 60_000, 15 * 60_000, 30 * 60_000, 60 * 60_000];
/** 只是连不上 CA(不算失败验证、不占配额)时更快重试,部署等待的几分钟里能多试几次。 */
const ACME_NETWORK_RETRY_DELAYS_MS = [15_000, 30_000, 60_000, 2 * 60_000, 5 * 60_000];
const RENEWAL_CHECK_MS = 60 * 60 * 1000;
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
function parsePort(value: string | undefined, fallback: number, name: string): number {
const port = value === undefined ? fallback : Number(value);
if (!Number.isInteger(port) || port < 0 || port > 65535) throw new RelayError('BAD_REQUEST', `invalid --${name}`);
return port;
}
/** 自动证书:先在 80 端口提供验证,拿到(或读到)有效证书后返回;之后由调用方定时续期。 */
async function prepareAcme(flags: Map<string, string>, dataDir: string, host: string) {
const identifier = identifierFor(required(flags, 'acme-identifier'));
const manager = new CertificateManager({
dataDir,
identifier,
directoryUrl: flags.get('acme-directory'),
logger: stderrLogger,
});
await startChallengeServer({ host, port: parsePort(flags.get('acme-http-port'), 80, 'acme-http-port'), challenges: manager.challenges });
let material: TlsMaterial | null = await manager.load();
if (material && manager.needsRenewal(material)) material = null;
let failures = 0;
let networkFailures = 0;
while (!material) {
emit({ event: 'certificate', status: 'requesting', identifier: identifier.value });
try {
material = await manager.obtain();
} catch (error) {
const delays = error instanceof AcmeNetworkError ? ACME_NETWORK_RETRY_DELAYS_MS : ACME_RETRY_DELAYS_MS;
const index = error instanceof AcmeNetworkError ? networkFailures++ : failures++;
const delay = delays[Math.min(index, delays.length - 1)];
emit({ event: 'certificate', status: 'failed', retryInMs: delay, message: error instanceof Error ? error.message : 'unknown' });
// 证书还没到手但旧证书仍有效:先用旧的服务,后台继续申请。
const previous = await manager.load();
if (previous) {
material = previous;
break;
}
await sleep(delay);
}
}
await manager.writeStatus('ready', { notAfter: new Date(material.notAfter).toISOString() });
return { manager, material };
}
function parseArgs(argv: string[]): { command: string | undefined; flags: Map<string, string> } {
const flags = new Map<string, string>();
let command: string | undefined;
for (let i = 0; i < argv.length; i++) {
const arg = argv[i];
if (!arg.startsWith('--')) {
if (command) throw new RelayError('BAD_REQUEST', `unexpected argument: ${arg}`);
command = arg;
continue;
}
const name = arg.slice(2);
if (name === 'version' || BOOLEAN_FLAGS.has(name)) {
flags.set(name, 'true');
continue;
}
const value = argv[i + 1];
if (value === undefined || value.startsWith('--')) throw new RelayError('BAD_REQUEST', `missing value for --${name}`);
flags.set(name, value);
i++;
}
return { command, flags };
}
function required(flags: Map<string, string>, name: string): string {
const value = flags.get(name);
if (!value) throw new RelayError('BAD_REQUEST', `--${name} is required`);
return value;
}
/** JSON 参数以 base64url 传入,避免经 SSH 拼命令时的引号转义。 */
function parseJsonArg(value: string, name: string): unknown {
try {
return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')) as unknown;
} catch {
throw new RelayError('BAD_REQUEST', `--${name} must be base64url-encoded JSON`);
}
}
function emit(event: Record<string, unknown>): void {
process.stdout.write(`${JSON.stringify(event)}\n`);
}
const stderrLogger: RelayLogger = {
info: (message, fields) => process.stderr.write(`${JSON.stringify({ level: 'info', message, ...fields })}\n`),
warn: (message, fields) => process.stderr.write(`${JSON.stringify({ level: 'warn', message, ...fields })}\n`),
error: (message, fields) => process.stderr.write(`${JSON.stringify({ level: 'error', message, ...fields })}\n`),
};
async function main(): Promise<void> {
const { command, flags } = parseArgs(process.argv.slice(2));
if (flags.has('version')) {
emit({ event: 'version', relayVersion: RELAY_VERSION });
return;
}
if (command === 'nginx') {
const action = required(flags, 'action');
const address = flags.get('address');
const resolvedAddresses = action === 'prepare' && address
? isIP(address) ? [address] : (await lookup(identifierFor(address).value, { all: true })).map((entry) => entry.address)
: undefined;
const result = manageNginx(action, {
address,
resolvedAddresses,
ipv6: flags.has('ipv6'),
existingCertificate: flags.has('existing-certificate'),
});
emit({ event: 'nginx', ...result });
return;
}
if (command === 'init') {
const { relayId } = await initializeRelay({
dataDir: required(flags, 'data'),
name: required(flags, 'name'),
ownerUserId: required(flags, 'owner-user'),
ownerDeviceId: required(flags, 'owner-device'),
ownerDeviceName: required(flags, 'owner-device-name'),
ownerCredentialHash: required(flags, 'owner-credential-hash'),
relayId: required(flags, 'relay-id'),
ownerPublicKey: required(flags, 'owner-public-key'),
ownerCert: parseJsonArg(required(flags, 'owner-cert'), 'owner-cert'),
});
emit({ event: 'initialized', relayId });
return;
}
if (command === 'serve') {
const certPath = flags.get('tls-cert');
const keyPath = flags.get('tls-key');
if (Boolean(certPath) !== Boolean(keyPath)) {
throw new RelayError('BAD_REQUEST', '--tls-cert and --tls-key must be given together');
}
if (flags.has('acme-identifier') && certPath) {
throw new RelayError('BAD_REQUEST', '--acme-identifier cannot be combined with --tls-cert');
}
const port = parsePort(flags.get('port'), 47820, 'port');
const dataDir = required(flags, 'data');
const host = flags.get('host') ?? '127.0.0.1';
const acme = flags.has('acme-identifier') ? await prepareAcme(flags, dataDir, host) : null;
let material = acme?.material ?? null;
const handle = await startRelayServer({
dataDir,
host,
port,
tls: material ? { cert: material.cert, key: material.key } : certPath && keyPath ? await readTlsFiles(certPath, keyPath) : undefined,
publicUrl: flags.get('public-url'),
trustProxyHeaders: flags.has('trust-proxy'),
logger: stderrLogger,
certificateExpiresAt: () => (material ? new Date(material.notAfter).toISOString() : null),
});
emit({ event: 'listening', relayId: handle.relayId, url: handle.localUrl, port: handle.port });
if (acme) {
let renewing = false;
const timer = setInterval(() => {
if (renewing || !material || !acme.manager.needsRenewal(material)) return;
renewing = true;
void acme.manager
.obtain()
.then((next) => {
material = next;
handle.updateTls({ cert: next.cert, key: next.key });
})
.catch(() => {
// 已记录;旧证书仍有效时下个小时再试。
})
.finally(() => {
renewing = false;
});
}, RENEWAL_CHECK_MS);
timer.unref?.();
}
const shutdown = () => {
void handle.close().then(() => process.exit(0));
};
process.once('SIGINT', shutdown);
process.once('SIGTERM', shutdown);
return;
}
throw new RelayError('BAD_REQUEST', 'usage: relay <init|serve> [options] | relay --version');
}
main().catch((error: unknown) => {
const relayError = error instanceof RelayError ? error : null;
emit({
event: 'error',
code: relayError?.code ?? 'INTERNAL',
message: relayError?.message ?? (error instanceof Error ? error.message : 'unknown error'),
});
process.exitCode = 1;
});