Method call

worker/model-worker-manager.ts:123–180

(request: WorkerRequest)

  }

  call(request: WorkerRequest): WorkerResponse | null {
    const requestId = request.requestId;
    const requestFile = `agent-ward-request-${requestId}.json`;
    const responseFile = `agent-ward-response-${requestId}.json`;
    
    const requestFilePath = join(this.tmpDir, requestFile);
    const responseFilePath = join(this.tmpDir, responseFile);
    
    try {
      const encryptedRequest = encrypt(JSON.stringify(request), this.aesKey);
      writeFileSync(requestFilePath, encryptedRequest);

      const requestFileEncoded = this.encoder.encode(requestFile);
      if (requestFileEncoded.length > FILENAME_MAX_LENGTH) {
        getLogger().error(`[WorkerManager] Request filename too long: ${requestFileEncoded.length} > ${FILENAME_MAX_LENGTH}`);
        return null;
      }
      this.view[1] = requestFileEncoded.length;
      this.dataBuffer.set(requestFileEncoded, REQUEST_FILENAME_DATA_OFFSET);
      
      const responseFileEncoded = this.encoder.encode(responseFile);
      if (responseFileEncoded.length > FILENAME_MAX_LENGTH) {
        getLogger().error(`[WorkerManager] Response filename too long: ${responseFileEncoded.length} > ${FILENAME_MAX_LENGTH}`);
        return null;
      }
      this.view[RESPONSE_FILENAME_LENGTH_INDEX] = responseFileEncoded.length;
      this.dataBuffer.set(responseFileEncoded, RESPONSE_FILENAME_DATA_OFFSET);
      
      const beforeStatus = Atomics.load(this.view, 0);
      Atomics.and(this.view, 0, ~0b010);
      Atomics.or(this.view, 0, 0b001);
      Atomics.notify(this.view, 0);
      
      const status = Atomics.wait(this.view, 0, 0b001, this.timeout);
      Atomics.and(this.view, 0, ~0b010);
      Atomics.and(this.view, 0, ~0b001);
      
      if (status === 'timed-out') {
        getLogger().error('[WorkerManager] Timeout');
        const currentStatus = Atomics.load(this.view, 0);
        getLogger().error(`[WorkerManager] Current status: ${currentStatus.toString(2)}`);
        getLogger().error(`[WorkerManager] Worker is running: ${this.running}`);
        return null;
      }
      
      const responseBuffer = readFileSync(responseFilePath);
      const responseJson = decrypt(new Uint8Array(responseBuffer), this.aesKey);
      const response = JSON.parse(responseJson) as WorkerResponse;
      
      return response;
    } catch (error) {
      getLogger().error(`[WorkerManager] Call failed: ${error}`);
      return null;
    } finally {
      rmSync(requestFilePath, { force: true });
      rmSync(responseFilePath, { force: true });
    }
  }