@mpis/client 0.0.1

package/src/channel-client/http.ts

@@ -0,0 +1,33 @@
+import type { IMessageObject } from '@mpis/shared';
+import { AbstractChannelClient } from './abs.js';
+
+/**
+ * HTTP连接的客户端实现
+ */
+export class HttpClient extends AbstractChannelClient {
+	constructor(private readonly remote: string) {
+		super();
+	}
+
+	protected override async _disconnect() {}
+	protected override async _connect() {}
+
+	protected override async _send(message: IMessageObject): Promise<void> {
+		const response = await fetch(this.remote, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(message),
+		});
+
+		if (!response.ok) {
+			throw new Error(`HTTP request failed with status ${response.status}: ${response.statusText}`);
+		}
+
+		const body: any = await response.json();
+		if (!body.success) {
+			throw new Error(body.message);
+		}
+	}
+}

package/src/channel-client/nodejs.ts

@@ -0,0 +1,20 @@
+import type { IMessageObject } from '@mpis/shared';
+import { AbstractChannelClient } from './abs.js';
+
+export class NodejsIpcClient extends AbstractChannelClient {
+	constructor() {
+		super();
+
+		if (typeof process.send !== 'function') {
+			throw new Error('process.send is not a function, this is not a valid child process');
+		}
+	}
+
+	protected override async _disconnect(): Promise<void> {}
+	protected override async _connect(): Promise<void> {}
+
+	protected override _send(message: IMessageObject): void {
+		// biome-ignore lint/style/noNonNullAssertion: checked in constructor
+		process.send!(message);
+	}
+}

package/src/channel-client/tcp.ts

@@ -0,0 +1,47 @@
+import { createConnection, type Socket } from 'node:net';
+import { AbstractChannelClient } from './abs.js';
+import type { IMessageObject } from '@mpis/shared';
+export { make_message, type IMessageObject } from '@mpis/shared';
+
+/**
+ * TCP连接的客户端实现
+ */
+export class TcpClient extends AbstractChannelClient {
+	private declare socket: Socket;
+
+	constructor(private readonly remote: string) {
+		super();
+	}
+
+	protected override async _disconnect() {
+		return new Promise<void>((resolve) => {
+			this.socket.end(resolve);
+		});
+	}
+	protected override async _connect() {
+		let socket: Socket;
+
+		const remote = this.remote.trim();
+		if (remote.includes(':')) {
+			const [host, port] = remote.split(':');
+			socket = createConnection({ port: Number.parseInt(port), host });
+		} else {
+			socket = createConnection({ path: remote });
+		}
+
+		await new Promise<void>((resolve, reject) => {
+			socket.once('connect', () => resolve());
+			socket.once('error', (err) => reject(err));
+		});
+
+		socket.on('error', (err) => {
+			this._onFailure.fireNoError(err);
+		});
+
+		this.socket = socket;
+	}
+
+	protected override _send(message: IMessageObject): void {
+		this.socket.write(`${JSON.stringify(message)}\n`);
+	}
+}

package/src/common/message-channel.ts

@@ -0,0 +1,19 @@
+import { VoidClient, type AbstractChannelClient } from '../channel-client/abs.js';
+import { HttpClient } from '../channel-client/http.js';
+import { NodejsIpcClient } from '../channel-client/nodejs.js';
+
+const server = process.env.BUILD_PROTOCOL_SERVER;
+
+export let channelClient: AbstractChannelClient;
+if (!server) {
+	channelClient = new VoidClient();
+	if (!process.stderr.isTTY) {
+		channelClient.logger.error('BUILD_PROTOCOL_SERVER environment variable is not set, sending messages to void.');
+	}
+} else if (server === 'ipc:nodejs') {
+	channelClient = new NodejsIpcClient();
+} else if (server.startsWith('http://')) {
+	channelClient = new HttpClient(server);
+} else {
+	throw new TypeError(`Unknown BUILD_PROTOCOL_SERVER: ${server}`);
+}

package/src/handlers/stdout.ts

@@ -0,0 +1,85 @@
+import { PassThrough } from 'node:stream';
+import split2 from 'split2';
+import { channelClient } from '../common/message-channel.js';
+
+interface IOptions {
+	title?: string;
+	start?: RegExp;
+	stop: RegExp;
+	isFailed(stop_line: string, full_output: string): boolean;
+}
+
+export function listenOutputStream(stream: NodeJS.ReadableStream, options: IOptions) {
+	if (options.title) channelClient.friendlyTitle = options.title;
+
+	function emit_failed() {
+		channelClient.failed('matching failed output', memory);
+		memory = '';
+	}
+	function emit_success() {
+		channelClient.success('matching success output', memory);
+		memory = '';
+	}
+
+	function emit_start() {
+		channelClient.start();
+		memory = '';
+	}
+
+	const reading_stream = split2();
+
+	let memory = '';
+	let started = false;
+	let lastFailed = false;
+
+	reading_stream.on('end', () => {
+		if (started || lastFailed) {
+			emit_failed();
+			process.exitCode = 1;
+		}
+	});
+
+	reading_stream.on('data', (line: string) => {
+		if (started) {
+			memory += line;
+			memory += '\n';
+			if (!options.stop.test(line)) return;
+
+			lastFailed = options.isFailed(line, memory);
+			if (lastFailed) {
+				emit_failed();
+			} else {
+				emit_success();
+			}
+			return;
+		} else if (options.start) {
+			// 如果有开始signal，尝试匹配，失败继续等
+			// 成功的话设置started，然后返回以确保丢弃当前行
+			started = options.start.test(line);
+			if (!started) return;
+			emit_start();
+		} else {
+			started = true;
+			emit_start();
+		}
+
+		memory += line;
+		memory += '\n';
+	});
+
+	stream.pipe(reading_stream, { end: true });
+}
+export function hookCurrentProcessOutput(options: IOptions) {
+	const pipe = new PassThrough({});
+	listenOutputStream(pipe, options);
+
+	function makePipeFunction(originalWrite: (...args: any[]) => boolean) {
+		return function (this: NodeJS.WriteStream, ...args: any[]) {
+			pipe.write.apply(pipe, args as any);
+			return originalWrite.apply(this, args);
+		};
+	}
+
+	process.stdout.write = makePipeFunction(process.stdout.write);
+	process.stderr.write = makePipeFunction(process.stderr.write);
+}

package/src/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "@internal/local-rig/profiles/default/tsconfig.json",
+	"compilerOptions": {
+		"typeRoots": ["../node_modules/@types", "../node_modules"],
+		"outDir": "../lib",
+		"rootDir": "./",
+		"types": ["node"]
+	}
+}