Host Communication

import { HostClient } from "@scramjet/runner/src/host-client";

/**
 * Connects to Host and exposes streams per channel (stdin, monitor etc.)
 */
class HostClient implements IHostClient {
  constructor(instancesServerPort: number, instancesServerHost: string);
  
  /** Logger instance for host communication */
  logger: IObjectLogger;
  
  /** BPMux multiplexer for HTTP connections */
  bpmux: any;
  
  /** HTTP agent for API connections */
  agent?: Agent;
}

import { HostClient } from "@scramjet/runner/src/host-client";

// Create connection to host
const hostClient = new HostClient(3000, "localhost");

// Initialize connection with instance ID
await hostClient.init("instance-123");

// Use streams for communication
hostClient.inputStream.pipe(someProcessor);
someOutput.pipe(hostClient.outputStream);

// Clean disconnect
await hostClient.disconnect(false);

/**
 * Initialize connection to host with multiple streams
 * @param id - Instance identifier (36 bytes)
 * @returns Promise that resolves when all connections are established
 */
init(id: string): Promise<void>;

/**
 * Disconnect from host and clean up all streams
 * @param hard - Whether to force close streams without graceful shutdown
 * @returns Promise that resolves when disconnection is complete
 */
disconnect(hard: boolean): Promise<void>;

/**
 * Get HTTP agent for making API calls to host
 * @returns HTTP agent configured for host communication
 * @throws Error if agent is not initialized
 */
getAgent(): Agent;

/**
 * Standard input stream from host to sequence
 */
readonly stdinStream: Readable;

/**
 * Standard output stream from sequence to host
 */
readonly stdoutStream: Writable;

/**
 * Standard error stream from sequence to host
 */
readonly stderrStream: Writable;

/**
 * Control message stream from host (JSON messages)
 */
readonly controlStream: Readable;

/**
 * Monitoring message stream to host (health, status updates)
 */
readonly monitorStream: Writable;

/**
 * Sequence input data stream from host
 */
readonly inputStream: Readable;

/**
 * Sequence output data stream to host
 */
readonly outputStream: Writable;

/**
 * Logging stream to host for structured logs
 */
readonly logStream: Writable;

/**
 * Package communication stream for API multiplexing
 */
readonly packageStream: Readable;

// Read control messages
StringStream
  .from(hostClient.controlStream)
  .JSONParse()
  .each(([code, data]) => {
    console.log("Control message:", code, data);
  });

// Send monitoring data
const monitoringData = [RunnerMessageCode.MONITORING, { healthy: true }];
hostClient.monitorStream.write(JSON.stringify(monitoringData) + "\r\n");

// Process input data
hostClient.inputStream
  .pipe(new PassThrough())
  .on('data', (chunk) => {
    console.log("Received data:", chunk.toString());
  });

interface IHostClient {
  logger: IObjectLogger;
  
  init(id: string): Promise<void>;
  disconnect(hard: boolean): Promise<void>;
  getAgent(): Agent;
  
  readonly stdinStream: Readable;
  readonly stdoutStream: Writable;
  readonly stderrStream: Writable;
  readonly controlStream: Readable;
  readonly monitorStream: Writable;
  readonly inputStream: Readable;
  readonly outputStream: Writable;
  readonly logStream: Writable;
  readonly packageStream: Readable;
}

interface UpstreamStreamsConfig extends Array<Socket> {
  [index: number]: Socket;
}

enum CommunicationChannel {
  IN = 0,
  OUT = 1,
  CONTROL = 2,
  MONITORING = 3,
  STDIN = 4,
  STDOUT = 5,
  STDERR = 6,
  LOG = 7,
  PACKAGE = 8
}