import os from "node:os";

import path from "node:path";

import { describe, expect, it, vi } from "vitest";

import { ensureMatrixCryptoRuntime, ensureMatrixSdkInstalled } from "./deps.js";

import {

ensureMatrixCryptoRuntime,

ensureMatrixSdkInstalled,

MATRIX_COMMAND_OUTPUT_TAIL_BYTES,

runFixedCommandWithTimeout,

} from "./deps.js";

const logStub = vi.fn();

});

});

describe("runFixedCommandWithTimeout", () => {

it("retains bounded tails from noisy bootstrap commands", async () => {

const result = await runFixedCommandWithTimeout({

argv: [

process.execPath,

"-e",

[

`process.stdout.write("a".repeat(${MATRIX_COMMAND_OUTPUT_TAIL_BYTES + 1}));`,

`process.stderr.write("b".repeat(${MATRIX_COMMAND_OUTPUT_TAIL_BYTES + 1}));`,

].join(""),

],

cwd: process.cwd(),

timeoutMs: 10_000,

});

expect(result.code).toBe(0);

expect(Buffer.byteLength(result.stdout, "utf8")).toBe(MATRIX_COMMAND_OUTPUT_TAIL_BYTES);

expect(Buffer.byteLength(result.stderr, "utf8")).toBe(MATRIX_COMMAND_OUTPUT_TAIL_BYTES);

expect(result.stdout).toBe("a".repeat(MATRIX_COMMAND_OUTPUT_TAIL_BYTES));

expect(result.stderr).toBe("b".repeat(MATRIX_COMMAND_OUTPUT_TAIL_BYTES));

});

});

describe("ensureMatrixSdkInstalled", () => {

it("returns without error when all required packages resolve", async () => {

const resolveFn = vi.fn((_id: string) => "/fake/path");

"@matrix-org/matrix-sdk-crypto-wasm",

];

const MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES = 1_000_000;

export const MATRIX_COMMAND_OUTPUT_TAIL_BYTES = 64 * 1024;

type MatrixCryptoRuntimeDeps = {

requireFn?: (id: string) => unknown;

let defaultMatrixCryptoRuntimeEnsurePromise: Promise<void> | null = null;

async function runFixedCommandWithTimeout(params: {

function appendBoundedOutputTail(current: string, chunk: Buffer | string): string {

const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);

if (chunkBuffer.byteLength >= MATRIX_COMMAND_OUTPUT_TAIL_BYTES) {

return chunkBuffer

.subarray(chunkBuffer.byteLength - MATRIX_COMMAND_OUTPUT_TAIL_BYTES)

.toString("utf8");

}

const currentBuffer = Buffer.from(current);

const nextBytes = currentBuffer.byteLength + chunkBuffer.byteLength;

if (nextBytes <= MATRIX_COMMAND_OUTPUT_TAIL_BYTES) {

return `${current}${chunkBuffer.toString("utf8")}`;

}

const currentTailBytes = MATRIX_COMMAND_OUTPUT_TAIL_BYTES - chunkBuffer.byteLength;

const currentTail = currentBuffer.subarray(currentBuffer.byteLength - currentTailBytes);

return Buffer.concat([currentTail, chunkBuffer], MATRIX_COMMAND_OUTPUT_TAIL_BYTES).toString(

"utf8",

);

}

export async function runFixedCommandWithTimeout(params: {

argv: string[];

cwd: string;

timeoutMs: number;

process.once("exit", killChildOnExit);

proc.stdout?.on("data", (chunk: Buffer | string) => {

stdout += chunk.toString();

stdout = appendBoundedOutputTail(stdout, chunk);

});

proc.stderr?.on("data", (chunk: Buffer | string) => {

stderr += chunk.toString();

stderr = appendBoundedOutputTail(stderr, chunk);

});

timer = setTimeout(() => {