id: string;

url?: string;

mode?: string;

outputCommand: { command: string; args: string[] };

input?: ChildProcess;

output?: ChildProcess;

chunks: Buffer[];

createdAt: string;

lastInputAt?: string;

lastOutputAt?: string;

lastClearAt?: string;

lastInputBytes: number;

lastOutputBytes: number;

closedAt?: string;

clearCount: number;

};

const sessions = new Map<string, NodeBridgeSession>();

wake(session);

}

function attachOutputProcessHandlers(session: NodeBridgeSession, outputProcess: ChildProcess) {

outputProcess.on("exit", () => {

if (session.output === outputProcess) {

stopSession(session);

}

});

outputProcess.on("error", () => {

if (session.output === outputProcess) {

stopSession(session);

}

});

}

function startOutputProcess(command: { command: string; args: string[] }) {

return spawn(command.command, command.args, {

stdio: ["pipe", "ignore", "pipe"],

});

}

function startCommandPair(params: {

inputCommand: string[];

outputCommand: string[];

id: `meet_node_${randomUUID()}`,

url: params.url,

mode: params.mode,

outputCommand: output,

chunks: [],

waiters: [],

closed: false,

createdAt: new Date().toISOString(),

lastInputBytes: 0,

lastOutputBytes: 0,

clearCount: 0,

};

const outputProcess = spawn(output.command, output.args, {

stdio: ["pipe", "ignore", "pipe"],

});

const outputProcess = startOutputProcess(output);

const inputProcess = spawn(input.command, input.args, {

stdio: ["ignore", "pipe", "pipe"],

});

wake(session);

});

inputProcess.on("exit", () => stopSession(session));

outputProcess.on("exit", () => stopSession(session));

attachOutputProcessHandlers(session, outputProcess);

inputProcess.on("error", () => stopSession(session));

outputProcess.on("error", () => stopSession(session));

sessions.set(session.id, session);

return session;

}

return { bridgeId, ok: true };

}

function clearAudio(params: Record<string, unknown>) {

const bridgeId = readString(params.bridgeId);

if (!bridgeId) {

throw new Error("bridgeId required");

}

const session = sessions.get(bridgeId);

if (!session || session.closed) {

throw new Error(`bridge is not open: ${bridgeId}`);

}

const previousOutput = session.output;

const outputProcess = startOutputProcess(session.outputCommand);

session.output = outputProcess;

attachOutputProcessHandlers(session, outputProcess);

session.clearCount += 1;

session.lastClearAt = new Date().toISOString();

terminateChild(previousOutput);

return { bridgeId, ok: true, clearCount: session.clearCount };

}

function startChrome(params: Record<string, unknown>) {

const url = readString(params.url);

if (!url) {

createdAt: session.createdAt,

lastInputAt: session.lastInputAt,

lastOutputAt: session.lastOutputAt,

lastClearAt: session.lastClearAt,

lastInputBytes: session.lastInputBytes,

lastOutputBytes: session.lastOutputBytes,

clearCount: session.clearCount,

queuedInputChunks: session.chunks.length,

}

: bridgeId

? { bridgeId, closed: true }

case "pushAudio":

result = pushAudio(params);

break;

case "clearAudio":

result = clearAudio(params);

break;

case "stop":

result = stopChrome(params);

break;