import type { IncomingMessage, ServerResponse } from 'node:http';
|
import type { Plugin } from 'vite';
|
|
import { Buffer } from 'node:buffer';
|
import { readFileSync } from 'node:fs';
|
import { isIP } from 'node:net';
|
import { relative, resolve } from 'node:path';
|
import { fileURLToPath } from 'node:url';
|
|
const PRODUCTION_VERSION = '0.1.0' as const;
|
const DEVELOPMENT_RELEASE = `${PRODUCTION_VERSION}-dev` as const;
|
const DEVELOPMENT_BASE_PATH = `/onlyoffice-plugins/${DEVELOPMENT_RELEASE}/eln-template-filler`;
|
const PLUGIN_GUID = 'asc.{7F4E8F35-5D66-47F8-A5B4-6AB3FAACF565}';
|
const PRODUCTION_IFRAME_URL = `index.html?v=${PRODUCTION_VERSION}`;
|
const RELEASE_PATH_PREFIX = '/onlyoffice-plugins/';
|
const SDK_PATH_PREFIX = '/onlyoffice-sdk/';
|
const SDK_PROXY_ERROR = 'ONLYOFFICE SDK 代理失败\n';
|
const SDK_PROXY_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
|
const SDK_PROXY_TIMEOUT_MS = 5_000;
|
const EMPTY_TRANSLATIONS_MANIFEST = '[]\n';
|
const SDK_RESOURCES = new Map([
|
['/onlyoffice-sdk/v1/plugins.css', '/sdkjs-plugins/v1/plugins.css'],
|
['/onlyoffice-sdk/v1/plugins.js', '/sdkjs-plugins/v1/plugins.js'],
|
]);
|
const SDK_REQUEST_HEADERS = ['accept', 'if-none-match', 'if-modified-since'] as const;
|
const SDK_RESPONSE_HEADERS = ['content-type', 'etag', 'last-modified'] as const;
|
const NO_STORE_HEADERS = {
|
'Cache-Control': 'no-store, no-cache, must-revalidate',
|
Expires: '0',
|
Pragma: 'no-cache',
|
} as const;
|
const pluginRoot = fileURLToPath(new URL('..', import.meta.url));
|
|
const environmentNames = {
|
devHost: 'ONLYOFFICE_PLUGIN_DEV_HOST',
|
devPort: 'ONLYOFFICE_PLUGIN_DEV_PORT',
|
docsUrl: 'ONLYOFFICE_DOCS_URL',
|
hmrClientPort: 'ONLYOFFICE_PLUGIN_HMR_CLIENT_PORT',
|
hmrHost: 'ONLYOFFICE_PLUGIN_HMR_HOST',
|
hmrPath: 'ONLYOFFICE_PLUGIN_HMR_PATH',
|
hmrProtocol: 'ONLYOFFICE_PLUGIN_HMR_PROTOCOL',
|
publicHost: 'ONLYOFFICE_PLUGIN_PUBLIC_HOST',
|
} as const;
|
|
export interface OnlyOfficeDevOptions {
|
basePath: string;
|
docsUrl: string;
|
hmrClientPort: number;
|
hmrHost: string;
|
hmrPath?: string;
|
hmrProtocol: 'ws' | 'wss';
|
host: string;
|
manifestUrl: string;
|
port: number;
|
publicHost: string;
|
release: '0.1.0-dev';
|
startupId: string;
|
}
|
|
interface OnlyOfficeSdkProxyOptions {
|
docsUrl: string;
|
onError?: (category: 'network' | 'status' | 'timeout') => void;
|
timeoutMs?: number;
|
}
|
|
type OnlyOfficeSdkProxy = (request: IncomingMessage, response: ServerResponse, next: () => void) => Promise<void>;
|
|
function setNoStoreHeaders(response: ServerResponse): void {
|
for (const [name, value] of Object.entries(NO_STORE_HEADERS)) response.setHeader(name, value);
|
}
|
|
function endSdkProxyError(response: ServerResponse, method: string | undefined): void {
|
if (response.destroyed || response.writableEnded) return;
|
response.statusCode = 502;
|
response.setHeader('Content-Type', 'text/plain; charset=utf-8');
|
response.end(method === 'HEAD' ? undefined : SDK_PROXY_ERROR);
|
}
|
|
async function cancelResponseBody(response: Response): Promise<void> {
|
try {
|
await response.body?.cancel();
|
} catch {
|
// The upstream connection may already be closed or aborted.
|
}
|
}
|
|
async function readBoundedResponseBody(response: Response): Promise<Buffer> {
|
const contentLengthHeader = response.headers.get('content-length');
|
const contentLength =
|
response.headers.has('content-encoding') || contentLengthHeader === null || !/^\d+$/u.test(contentLengthHeader) ? undefined : Number(contentLengthHeader);
|
if (contentLength !== undefined && (!Number.isSafeInteger(contentLength) || contentLength > SDK_PROXY_MAX_RESPONSE_BYTES)) {
|
await cancelResponseBody(response);
|
throw new Error('response-too-large');
|
}
|
|
if (!response.body) return Buffer.alloc(0);
|
|
const buffer = Buffer.allocUnsafe(contentLength ?? SDK_PROXY_MAX_RESPONSE_BYTES);
|
const reader = response.body.getReader();
|
let bytesRead = 0;
|
try {
|
while (true) {
|
const result = await reader.read();
|
if (result.done) break;
|
if (bytesRead + result.value.byteLength > SDK_PROXY_MAX_RESPONSE_BYTES) {
|
await reader.cancel();
|
throw new Error('response-too-large');
|
}
|
buffer.set(result.value, bytesRead);
|
bytesRead += result.value.byteLength;
|
}
|
} finally {
|
reader.releaseLock();
|
}
|
|
if (contentLength !== undefined && bytesRead !== contentLength) {
|
throw new Error('response-truncated');
|
}
|
return buffer.subarray(0, bytesRead);
|
}
|
|
export function createOnlyOfficeSdkProxy({
|
docsUrl,
|
onError = () => undefined,
|
timeoutMs = SDK_PROXY_TIMEOUT_MS,
|
}: OnlyOfficeSdkProxyOptions): OnlyOfficeSdkProxy {
|
return async (request, response, next) => {
|
const requestUrl = request.url ?? '/';
|
const queryIndex = requestUrl.indexOf('?');
|
const pathname = queryIndex === -1 ? requestUrl : requestUrl.slice(0, queryIndex);
|
const upstreamPath = SDK_RESOURCES.get(pathname);
|
if (!upstreamPath) {
|
next();
|
return;
|
}
|
|
setNoStoreHeaders(response);
|
if (request.method !== 'GET' && request.method !== 'HEAD') {
|
response.statusCode = 405;
|
response.setHeader('Allow', 'GET, HEAD');
|
response.end('Method Not Allowed');
|
return;
|
}
|
|
const headers = new Headers();
|
for (const name of SDK_REQUEST_HEADERS) {
|
const value = request.headers[name];
|
if (value !== undefined) headers.set(name, Array.isArray(value) ? value.join(', ') : value);
|
}
|
headers.set('accept-encoding', 'identity');
|
|
// Closing each upstream response lets fetch detect a declared-length truncation immediately.
|
headers.set('connection', 'close');
|
const abortController = new AbortController();
|
let clientDisconnected = false;
|
let timedOut = false;
|
const abortForClientDisconnect = (): void => {
|
clientDisconnected = true;
|
abortController.abort();
|
};
|
const abortForPrematureClose = (): void => {
|
if (!response.writableFinished) abortForClientDisconnect();
|
};
|
request.once('aborted', abortForClientDisconnect);
|
response.once('close', abortForPrematureClose);
|
const timeout = setTimeout(() => {
|
timedOut = true;
|
abortController.abort();
|
}, timeoutMs);
|
timeout.unref();
|
|
try {
|
const upstreamResponse = await fetch(`${docsUrl}${upstreamPath}`, {
|
headers,
|
method: request.method,
|
redirect: 'error',
|
signal: abortController.signal,
|
});
|
if (upstreamResponse.status === 304) {
|
response.statusCode = 304;
|
for (const name of SDK_RESPONSE_HEADERS) {
|
const value = upstreamResponse.headers.get(name);
|
if (value !== null) response.setHeader(name, value);
|
}
|
response.end();
|
return;
|
}
|
if (!upstreamResponse.ok) {
|
await cancelResponseBody(upstreamResponse);
|
onError('status');
|
endSdkProxyError(response, request.method);
|
return;
|
}
|
|
const body = request.method === 'HEAD' ? undefined : await readBoundedResponseBody(upstreamResponse);
|
if (clientDisconnected) return;
|
|
response.statusCode = upstreamResponse.status;
|
for (const name of SDK_RESPONSE_HEADERS) {
|
const value = upstreamResponse.headers.get(name);
|
if (value !== null) response.setHeader(name, value);
|
}
|
if (request.method === 'HEAD') response.end();
|
else response.end(body);
|
} catch {
|
if (clientDisconnected) return;
|
onError(timedOut ? 'timeout' : 'network');
|
endSdkProxyError(response, request.method);
|
} finally {
|
clearTimeout(timeout);
|
request.off('aborted', abortForClientDisconnect);
|
response.off('close', abortForPrematureClose);
|
}
|
};
|
}
|
|
function isRecord(value: unknown): value is Record<string, unknown> {
|
return typeof value === 'object' && value !== null && !Array.isArray(value);
|
}
|
|
function containsWhitespaceOrControl(value: string): boolean {
|
for (const character of value) {
|
const codePoint = character.codePointAt(0);
|
if (character.trim() === '' || (codePoint !== undefined && (codePoint < 32 || codePoint === 127))) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
function parseUrlHost(value: string, environmentName: string): string {
|
if (!value || containsWhitespaceOrControl(value) || /[\\/?#@]/u.test(value)) {
|
throw new Error(`${environmentName} 必须是不含协议、路径、空白或控制字符的 host`);
|
}
|
|
const isBracketed = value.startsWith('[') && value.endsWith(']');
|
if ((!isBracketed && value.includes(':')) || value.startsWith('[') !== value.endsWith(']')) {
|
throw new Error(`${environmentName} 的 IPv6 host 必须使用方括号且不能包含端口`);
|
}
|
|
try {
|
const parsed = new URL(`http://${value}`);
|
if (!parsed.hostname || parsed.port || parsed.pathname !== '/') {
|
throw new Error('invalid host');
|
}
|
} catch {
|
throw new Error(`${environmentName} 不是有效的 host`);
|
}
|
|
return value;
|
}
|
|
function parseListenHost(value: string, environmentName: string): string {
|
if (value.startsWith('[') || value.endsWith(']')) {
|
throw new Error(`${environmentName} 的监听 IPv6 host 必须使用裸地址`);
|
}
|
if (value.includes(':')) {
|
if (isIP(value) !== 6) {
|
throw new Error(`${environmentName} 不是有效的监听 host`);
|
}
|
return value;
|
}
|
|
return parseUrlHost(value, environmentName);
|
}
|
|
function parsePort(value: string | undefined, fallback: number, environmentName: string): number {
|
if (value === undefined) {
|
return fallback;
|
}
|
if (!/^[1-9]\d*$/u.test(value)) {
|
throw new Error(`${environmentName} 必须是 1..65535 的十进制整数`);
|
}
|
|
const port = Number(value);
|
if (port > 65_535) {
|
throw new Error(`${environmentName} 必须是 1..65535 的十进制整数`);
|
}
|
return port;
|
}
|
|
function parseHmrPath(value: string | undefined): string | undefined {
|
if (value === undefined) return undefined;
|
if (!/^\/[A-Za-z0-9/_-]+$/u.test(value) || value === '/') {
|
throw new Error(`${environmentNames.hmrPath} 必须是以 / 开头且不含空白、query 或 fragment 的路径`);
|
}
|
return value;
|
}
|
|
function parseDocsUrl(value: string): string {
|
let parsed: URL;
|
try {
|
if (containsWhitespaceOrControl(value)) {
|
throw new Error('invalid URL');
|
}
|
parsed = new URL(value);
|
} catch {
|
throw new Error(`${environmentNames.docsUrl} 必须是有效的 http(s) URL`);
|
}
|
|
if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) {
|
throw new Error(`${environmentNames.docsUrl} 必须是无 username/password、query 或 hash 的 http(s) URL`);
|
}
|
|
const pathname = parsed.pathname.replace(/\/+$/u, '');
|
return `${parsed.origin}${pathname}`;
|
}
|
|
function createStartupId(now: Date): string {
|
if (!Number.isFinite(now.getTime()) || now.getUTCFullYear() < 0 || now.getUTCFullYear() > 9999) {
|
throw new Error('now 必须是可表示为四位 UTC 年份的有效日期');
|
}
|
|
const pad = (value: number): string => String(value).padStart(2, '0');
|
return `${String(now.getUTCFullYear()).padStart(4, '0')}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}T${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`;
|
}
|
|
export function resolveOnlyOfficeDevOptions(environment: NodeJS.ProcessEnv, now: Date = new Date()): OnlyOfficeDevOptions {
|
const host = parseListenHost(environment[environmentNames.devHost] ?? '0.0.0.0', environmentNames.devHost);
|
const port = parsePort(environment[environmentNames.devPort], 4173, environmentNames.devPort);
|
const publicHost = parseUrlHost(environment[environmentNames.publicHost] ?? 'localhost', environmentNames.publicHost);
|
const hmrHost = parseUrlHost(environment[environmentNames.hmrHost] ?? publicHost, environmentNames.hmrHost);
|
const hmrPath = parseHmrPath(environment[environmentNames.hmrPath]);
|
const hmrProtocol = environment[environmentNames.hmrProtocol] ?? 'ws';
|
if (hmrProtocol !== 'ws' && hmrProtocol !== 'wss') {
|
throw new Error(`${environmentNames.hmrProtocol} 只接受 ws 或 wss`);
|
}
|
const hmrClientPort = parsePort(environment[environmentNames.hmrClientPort], port, environmentNames.hmrClientPort);
|
const docsUrl = parseDocsUrl(environment[environmentNames.docsUrl] ?? 'http://localhost:20000');
|
const startupId = createStartupId(now);
|
const publicProtocol = hmrProtocol === 'wss' ? 'https' : 'http';
|
|
return {
|
basePath: DEVELOPMENT_BASE_PATH,
|
docsUrl,
|
hmrClientPort,
|
hmrHost,
|
...(hmrPath ? { hmrPath } : {}),
|
hmrProtocol,
|
host,
|
manifestUrl: `${publicProtocol}://${publicHost}:${port}${DEVELOPMENT_BASE_PATH}/config.json?v=${startupId}`,
|
port,
|
publicHost,
|
release: DEVELOPMENT_RELEASE,
|
startupId,
|
};
|
}
|
|
export function createDevelopmentManifest(source: unknown, options: OnlyOfficeDevOptions): Record<string, unknown> {
|
if (!isRecord(source) || source.guid !== PLUGIN_GUID) {
|
throw new Error('ONLYOFFICE plugin manifest GUID 必须保持正式身份');
|
}
|
if (source.version !== PRODUCTION_VERSION) {
|
throw new Error(`ONLYOFFICE plugin manifest version 必须为 ${PRODUCTION_VERSION}`);
|
}
|
|
const variations = source.variations;
|
const firstVariation = Array.isArray(variations) ? variations[0] : undefined;
|
if (!isRecord(firstVariation) || firstVariation.url !== PRODUCTION_IFRAME_URL) {
|
throw new Error(`ONLYOFFICE plugin manifest 的首个 variation URL 必须为 ${PRODUCTION_IFRAME_URL}`);
|
}
|
|
const manifest = structuredClone(source);
|
const manifestVariations = manifest.variations as Record<string, unknown>[];
|
manifestVariations[0].url = `index.html?v=${options.startupId}`;
|
return manifest;
|
}
|
|
export function onlyOfficeDevelopmentPlugin(options: OnlyOfficeDevOptions): Plugin {
|
const source = JSON.parse(readFileSync(resolve(pluginRoot, 'config.json'), 'utf8')) as unknown;
|
const manifest = `${JSON.stringify(createDevelopmentManifest(source, options), null, 2)}\n`;
|
const manifestPath = `${options.basePath}/config.json`;
|
const indexPath = `${options.basePath}/index.html`;
|
const translationsPath = `${options.basePath}/translations/langs.json`;
|
const developmentResourcePath = `${options.basePath}/`;
|
const developmentResourcePrefixes = ['@fs/', '@id/', '@vite/', 'node_modules/', 'src/'];
|
const fullReloadFiles = new Set(['src/composables/useTemplateAnnotator.ts', 'src/main.ts']);
|
const iconPaths = new Map([
|
[`${options.basePath}/resources/icon.png`, 'resources/icon.png'],
|
[`${options.basePath}/resources/icon@2x.png`, 'resources/icon@2x.png'],
|
]);
|
const sdkProxy = createOnlyOfficeSdkProxy({
|
docsUrl: options.docsUrl,
|
onError: (category) => console.error(`[onlyoffice-sdk-proxy] ${category}`),
|
});
|
let viteBase = '/';
|
|
return {
|
apply: 'serve',
|
name: 'onlyoffice-development',
|
config() {
|
return {
|
server: {
|
headers: NO_STORE_HEADERS,
|
},
|
};
|
},
|
configResolved(config) {
|
viteBase = config.base;
|
},
|
configureServer(server) {
|
let manifestUrlPrinted = false;
|
const printManifestUrl = (): void => {
|
if (manifestUrlPrinted) return;
|
manifestUrlPrinted = true;
|
server.config.logger.info(options.manifestUrl);
|
};
|
if (server.httpServer?.listening) printManifestUrl();
|
else server.httpServer?.once('listening', printManifestUrl);
|
|
server.middlewares.use((request, response, next) => {
|
setNoStoreHeaders(response);
|
|
const requestUrl = request.url ?? '/';
|
const queryIndex = requestUrl.indexOf('?');
|
const pathname = queryIndex === -1 ? requestUrl : requestUrl.slice(0, queryIndex);
|
const query = queryIndex === -1 ? '' : requestUrl.slice(queryIndex);
|
|
if (pathname.startsWith(SDK_PATH_PREFIX)) {
|
void sdkProxy(request, response, () => {
|
response.statusCode = 404;
|
response.end('Not Found');
|
});
|
return;
|
}
|
|
if (pathname === manifestPath) {
|
if (request.method !== 'GET' && request.method !== 'HEAD') {
|
response.statusCode = 405;
|
response.setHeader('Allow', 'GET, HEAD');
|
response.end('Method Not Allowed');
|
return;
|
}
|
|
response.statusCode = 200;
|
response.setHeader('Content-Type', 'application/json; charset=utf-8');
|
if (request.method === 'HEAD') response.end();
|
else response.end(manifest);
|
return;
|
}
|
|
if (pathname === translationsPath) {
|
if (request.method !== 'GET' && request.method !== 'HEAD') {
|
response.statusCode = 405;
|
response.setHeader('Allow', 'GET, HEAD');
|
response.end('Method Not Allowed');
|
return;
|
}
|
response.statusCode = 200;
|
response.setHeader('Content-Type', 'application/json; charset=utf-8');
|
if (request.method === 'HEAD') response.end();
|
else response.end(EMPTY_TRANSLATIONS_MANIFEST);
|
return;
|
}
|
|
if (pathname === indexPath) {
|
request.url = `${server.config.base}index.html${query}`;
|
next();
|
return;
|
}
|
|
const iconPath = iconPaths.get(pathname);
|
if (iconPath && (request.method === 'GET' || request.method === 'HEAD')) {
|
request.url = `${server.config.base}${iconPath}${query}`;
|
next();
|
return;
|
}
|
|
if (pathname.startsWith(developmentResourcePath)) {
|
const resourcePath = pathname.slice(developmentResourcePath.length);
|
if (developmentResourcePrefixes.some((prefix) => resourcePath.startsWith(prefix))) {
|
next();
|
return;
|
}
|
}
|
|
if (pathname.startsWith(RELEASE_PATH_PREFIX)) {
|
response.statusCode = 404;
|
response.end('Not Found');
|
return;
|
}
|
|
next();
|
});
|
},
|
handleHotUpdate(context) {
|
const file = relative(pluginRoot, resolve(context.file)).replaceAll('\\', '/');
|
if (file === 'config.json') {
|
context.server.config.logger.warn('config.json 已变化，请重启 Dev Server 后重新打开编辑器会话。');
|
context.server.ws.send({ path: '*', type: 'full-reload' });
|
return [];
|
}
|
if (fullReloadFiles.has(file) || file.startsWith('src/onlyoffice/')) {
|
context.server.ws.send({ path: '*', type: 'full-reload' });
|
return [];
|
}
|
},
|
transformIndexHtml: {
|
order: 'post',
|
handler(html) {
|
const sdkScriptPath = new URL('../v1/plugins.js', `http://vite.invalid${viteBase}index.html`).pathname;
|
const sdkStylePath = new URL('../v1/plugins.css', `http://vite.invalid${viteBase}index.html`).pathname;
|
return html.replaceAll(sdkStylePath, '/onlyoffice-sdk/v1/plugins.css').replaceAll(sdkScriptPath, '/onlyoffice-sdk/v1/plugins.js');
|
},
|
},
|
};
|
}
|
