@syllm/brickly-test-host 0.11.0 → 0.12.0

package/dist/index.cjs

@@ -24214,14 +24214,14 @@ var require_varint = __commonJS({
   "../../node_modules/@bufbuild/protobuf/dist/commonjs/wire/varint.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.varint64read = varint64read;
+    exports2.varint64read = varint64read2;
     exports2.varint64write = varint64write;
     exports2.int64FromString = int64FromString2;
     exports2.int64ToString = int64ToString2;
     exports2.uInt64ToString = uInt64ToString2;
     exports2.varint32write = varint32write;
-    exports2.varint32read = varint32read;
-    function varint64read() {
+    exports2.varint32read = varint32read2;
+    function varint64read2() {
       const buf = this.buf;
       let pos = this.pos;
       let lo = 0;
@@ -24380,7 +24380,7 @@ var require_varint = __commonJS({
         bytes.push(1);
       }
     }
-    function varint32read() {
+    function varint32read2() {
       let b = this.buf[this.pos++];
       if ((b & 128) === 0) {
         this.assertBounds();
@@ -34648,7 +34648,9 @@ var require_brick_storage = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  HostDriver: () => HostDriver,
   HostTestControl: () => HostTestControl,
+  createHostDriver: () => createHostDriver,
   spawnTestHost: () => spawnTestHost,
   startTestHost: () => startTestHost
 });
@@ -36422,6 +36424,45 @@ var import_grpc_js2 = __toESM(require_src3());
 var import_grpc_js = __toESM(require_src3());
 
 // ../../node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
+function varint64read() {
+  const buf = this.buf;
+  let pos = this.pos;
+  let lo = 0;
+  let hi = 0;
+  for (let shift = 0; shift < 28; shift += 7) {
+    const b = buf[pos++];
+    lo |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.pos = pos;
+      this.assertBounds();
+      this.varint64Lo = lo;
+      this.varint64Hi = hi;
+      return;
+    }
+  }
+  const middleByte = buf[pos++];
+  lo |= (middleByte & 15) << 28;
+  hi = (middleByte & 112) >> 4;
+  if ((middleByte & 128) == 0) {
+    this.pos = pos;
+    this.assertBounds();
+    this.varint64Lo = lo;
+    this.varint64Hi = hi;
+    return;
+  }
+  for (let shift = 3; shift <= 31; shift += 7) {
+    const b = buf[pos++];
+    hi |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.pos = pos;
+      this.assertBounds();
+      this.varint64Lo = lo;
+      this.varint64Hi = hi;
+      return;
+    }
+  }
+  throw new Error("invalid varint");
+}
 var TWO_PWR_32_DBL = 4294967296;
 function int64FromString(dec) {
   const minus = dec[0] === "-";
@@ -36496,6 +36537,40 @@ var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
   const partial = String(digit1e7);
   return "0000000".slice(partial.length) + partial;
 };
+function varint32read() {
+  let b = this.buf[this.pos++];
+  if ((b & 128) === 0) {
+    this.assertBounds();
+    return b;
+  }
+  let result = b & 127;
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 7;
+  if ((b & 128) === 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 14;
+  if ((b & 128) === 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 21;
+  if ((b & 128) === 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 15) << 28;
+  for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
+    b = this.buf[this.pos++];
+  if ((b & 128) !== 0)
+    throw new Error("invalid varint");
+  this.assertBounds();
+  return result >>> 0;
+}
 
 // ../../node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js
 var protoInt64 = /* @__PURE__ */ makeInt64Support();
@@ -36998,6 +37073,206 @@ function varint32Size(value) {
     return 4;
   return 5;
 }
+var BinaryReader = class {
+  constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
+    this.decodeUtf8 = decodeUtf8;
+    this.varint64Lo = 0;
+    this.varint64Hi = 0;
+    this.varint64 = varint64read;
+    this.uint32 = varint32read;
+    this.buf = buf;
+    this.len = buf.length;
+    this.pos = 0;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  /**
+   * Reads a tag - field number and wire type. Tags are uint32 varints; values
+   * that do not fit in uint32 are rejected.
+   */
+  tag() {
+    const start = this.pos;
+    const tag = this.uint32();
+    const bytesRead = this.pos - start;
+    if (bytesRead > 5 || bytesRead == 5 && this.buf[this.pos - 1] > 15) {
+      throw new Error("illegal tag: varint overflows uint32");
+    }
+    const fieldNo = tag >>> 3;
+    const wireType = tag & 7;
+    if (fieldNo <= 0 || wireType > 5) {
+      throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+    }
+    return [fieldNo, wireType];
+  }
+  /**
+   * Skip one element and return the skipped data.
+   *
+   * When skipping StartGroup, provide the tags field number to check for
+   * matching field number in the EndGroup tag. Recursion into nested groups
+   * is guarded by the `recursionLimit` argument: When the limit is reached,
+   * this method throws.
+   */
+  skip(wireType, fieldNo, recursionLimit = 100) {
+    let start = this.pos;
+    switch (wireType) {
+      case WireType.Varint:
+        while (this.buf[this.pos++] & 128) {
+        }
+        break;
+      // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
+      case WireType.Bit64:
+        this.pos += 4;
+      case WireType.Bit32:
+        this.pos += 4;
+        break;
+      case WireType.LengthDelimited:
+        let len = this.uint32();
+        this.pos += len;
+        break;
+      case WireType.StartGroup:
+        if (recursionLimit <= 0) {
+          throw new Error("maximum recursion depth reached");
+        }
+        for (; ; ) {
+          const [fn, wt] = this.tag();
+          if (wt === WireType.EndGroup) {
+            if (fieldNo !== void 0 && fn !== fieldNo) {
+              throw new Error("invalid end group tag");
+            }
+            break;
+          }
+          this.skip(wt, fn, recursionLimit - 1);
+        }
+        break;
+      default:
+        throw new Error("cant skip wire type " + wireType);
+    }
+    this.assertBounds();
+    return this.buf.subarray(start, this.pos);
+  }
+  /**
+   * Throws error if position in byte array is out of range.
+   */
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  int32() {
+    return this.uint32() | 0;
+  }
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32() {
+    let zze = this.uint32();
+    return zze >>> 1 ^ -(zze & 1);
+  }
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64() {
+    this.varint64();
+    return protoInt64.dec(this.varint64Lo, this.varint64Hi);
+  }
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64() {
+    this.varint64();
+    return protoInt64.uDec(this.varint64Lo, this.varint64Hi);
+  }
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64() {
+    this.varint64();
+    let lo = this.varint64Lo;
+    let hi = this.varint64Hi;
+    let s = -(lo & 1);
+    lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
+    hi = hi >>> 1 ^ s;
+    return protoInt64.dec(lo, hi);
+  }
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool() {
+    const b = this.buf[this.pos];
+    if (b < 128) {
+      this.pos++;
+      return b !== 0;
+    }
+    this.varint64();
+    return this.varint64Lo !== 0 || this.varint64Hi !== 0;
+  }
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64() {
+    return protoInt64.uDec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64() {
+    return protoInt64.dec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, true);
+  }
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes() {
+    let len = this.uint32(), start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text. If
+   * `strict` is true, throw on invalid UTF-8 instead of substituting U+FFFD.
+   */
+  string(strict) {
+    const bytes = this.bytes();
+    const len = bytes.length;
+    if (len <= ASCII_MAX_LENGTH) {
+      const codes = new Array(len);
+      for (let i = 0; i < len; i++) {
+        const byte = bytes[i];
+        if (byte > 127) {
+          return this.decodeUtf8(bytes, strict);
+        }
+        codes[i] = byte;
+      }
+      return String.fromCharCode.apply(String, codes);
+    }
+    return this.decodeUtf8(bytes, strict);
+  }
+};
 function assertInt32(arg) {
   if (typeof arg == "string") {
     arg = Number(arg);
@@ -37096,6 +37371,17 @@ function toBrickGrpcStatus(error) {
     metadata
   };
 }
+function unpackBrickError(error) {
+  const bin = error.metadata?.get("grpc-status-details-bin")[0];
+  if (!bin) return void 0;
+  const bytes = typeof bin === "string" ? Buffer.from(bin, "utf8") : bin;
+  for (const item of decodeRpcStatus(bytes)) {
+    if (item.typeUrl === BRICK_ERROR_TYPE_URL || item.typeUrl.endsWith("BrickError")) {
+      return import_error.BrickError.decode(item.value);
+    }
+  }
+  return void 0;
+}
 function registeredDetail(code, error) {
   const extra = error && typeof error === "object" && "detail" in error && error.detail && typeof error.detail === "object" ? error.detail : {};
   const text = (key, fallback) => typeof extra[key] === "string" ? extra[key] : fallback;
@@ -37266,6 +37552,19 @@ function encodeRpcStatus(code, message, details) {
   }
   return Buffer.from(writer.finish());
 }
+function decodeRpcStatus(bytes) {
+  const reader = new BinaryReader(bytes);
+  const details = [];
+  while (reader.pos < reader.len) {
+    const tag = reader.uint32();
+    const field = tag >>> 3;
+    if (field === 3) details.push(import_any.Any.decode(reader, reader.uint32()));
+    else if (field === 1) reader.int32();
+    else if (field === 2) reader.string();
+    else reader.skip(tag & 7);
+  }
+  return details;
+}
 
 // ../../src/main/runtime/transport/connector-interact-relay.ts
 function relayConnectorInteract(call, openInteract) {
@@ -40413,19 +40712,30 @@ var HostGrpcServer = class {
     });
     this.server.addService(
       import_resource.ResourceServiceService,
-      createResourceServiceImplementation(this.resources, this.spawns, this.resourceContext, this.helperAccess)
+      createResourceServiceImplementation(
+        this.resources,
+        this.spawns,
+        this.resourceContext,
+        this.helperAccess
+      )
     );
     this.server.addService(
       import_event.EventServiceService,
       createEventServiceImplementation(this.events, this.spawns, () => this.eventRouter)
     );
-    this.server.addService(import_storage.StorageServiceService, createStorageServiceImplementation(this.storage, this.spawns));
+    this.server.addService(
+      import_storage.StorageServiceService,
+      createStorageServiceImplementation(this.storage, this.spawns)
+    );
     this.server.addService(
       import_brick_storage.BrickStorageServiceService,
       createBrickStorageServiceImplementation(() => this.brickStorageService, this.spawns)
     );
     this.server.addService(import_system.SystemServiceService, createSystemServiceImplementation(this.spawns));
-    this.server.addService(import_window.WindowServiceService, createWindowServiceImplementation(this.windows, this.spawns));
+    this.server.addService(
+      import_window.WindowServiceService,
+      createWindowServiceImplementation(this.windows, this.spawns)
+    );
     this.server.addService(
       import_connector.BrickConnectorServiceService,
       createConnectorServiceImplementation(this.connector, this.spawns)
@@ -40483,6 +40793,10 @@ var HostGrpcServer = class {
   getHandle(runtimeHandleId) {
     return this.handles.get(runtimeHandleId);
   }
+  /** 已注册 runtime 句柄快照（测试驱动面用，只读）。 */
+  listHandles() {
+    return [...this.handles.values()];
+  }
   async listen(host = "127.0.0.1", port = 0) {
     assertLoopbackHost(host);
     if (this.started) {
@@ -40490,13 +40804,17 @@ var HostGrpcServer = class {
       return this.endpoint;
     }
     const bound = await new Promise((resolve2, reject) => {
-      this.server.bindAsync(`${host}:${port}`, import_grpc_js12.ServerCredentials.createInsecure(), (error, boundPort) => {
-        if (error) {
-          reject(error);
-          return;
+      this.server.bindAsync(
+        `${host}:${port}`,
+        import_grpc_js12.ServerCredentials.createInsecure(),
+        (error, boundPort) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve2(`${host}:${boundPort}`);
         }
-        resolve2(`${host}:${boundPort}`);
-      });
+      );
     });
     this.endpoint = bound;
     this.started = true;
@@ -40701,6 +41019,157 @@ async function startTestHost(options = {}) {
   };
 }
 
+// ../../src/main/runtime/transport/test-host/drive.ts
+var CANNED_UI_METHODS = [
+  "createBrowserWindow",
+  "callWindow",
+  "closeWindow",
+  "forceCloseWindow",
+  "listWindows",
+  "sendToChild",
+  "replyToChild",
+  "emitToChild"
+];
+var HostDriver = class {
+  constructor(testHost) {
+    this.testHost = testHost;
+  }
+  cannedUi = /* @__PURE__ */ new Map();
+  uiCallLog = [];
+  uiHandlerInstalled = false;
+  /** 再铸一套 spawn 凭据（依赖 invoke 等需要多个 runtime 的用例）。 */
+  spawn(input) {
+    const credentials2 = this.testHost.host.createSpawn({
+      brickId: input.brickId,
+      instanceId: input.instanceId,
+      origin: input.origin ?? "development",
+      version: input.version ?? "0.0.0"
+    });
+    const record = this.testHost.host.spawns.get(credentials2.spawnId);
+    return {
+      ...credentials2,
+      brickId: record?.brickId ?? input.brickId,
+      instanceId: record?.instanceId ?? credentials2.spawnId
+    };
+  }
+  /** 已注册 runtime 句柄快照（测试等待/断言用）。 */
+  runtimes() {
+    return this.testHost.host.listHandles().map((handle) => ({
+      spawnId: handle.runtimeHandleId,
+      brickId: handle.brickId,
+      instanceId: handle.instanceId
+    }));
+  }
+  /** 等待 runtime 完成注册，拿到 host→runtime 通道句柄。 */
+  async waitHandle(spawnId, timeoutMs = 1e4) {
+    const id = spawnId ?? this.testHost.spawnCredentials.spawnId;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const handle = this.testHost.host.getHandle(id);
+      if (handle) return handle;
+      await sleep(40);
+    }
+    throw new Error(`\u7B49\u5F85 runtime \u6CE8\u518C\u8D85\u65F6\uFF1AspawnId=${id}`);
+  }
+  /** host→runtime 单向 invoke；错误按 brick 码结构化返回而不抛出。 */
+  async invoke(input) {
+    try {
+      const handle = await this.waitHandle(input.spawnId, input.timeoutMs);
+      const result = await handle.channel.invoke(
+        { commandId: input.commandId, input: jsToBrickValue(input.input ?? null) },
+        { deadlineMs: input.timeoutMs }
+      );
+      return { ok: true, result: brickValueToJs(result.result) };
+    } catch (error) {
+      return { ok: false, error: serializeError(error) };
+    }
+  }
+  /** host→runtime interact 批量模式：open → closeInput → 收 events 与 final。 */
+  async interact(input) {
+    try {
+      const handle = await this.waitHandle(input.spawnId, input.timeoutMs);
+      const signal = input.timeoutMs ? AbortSignal.timeout(input.timeoutMs) : void 0;
+      const { events, result } = await handle.channel.stream(
+        input.commandId,
+        jsToBrickValue(input.input ?? null),
+        { signal }
+      );
+      return { ok: true, events: events.map(brickValueToJs), result: brickValueToJs(result) };
+    } catch (error) {
+      return { ok: false, error: serializeError(error) };
+    }
+  }
+  /** 往指定 runtime 推 domain event（经真 HostEventBus 投递到订阅流）。 */
+  async pushEvent(input) {
+    const spawnId = input.spawnId ?? this.testHost.spawnCredentials.spawnId;
+    const record = this.testHost.host.spawns.get(spawnId);
+    const instanceId = record?.instanceId ?? spawnId;
+    this.testHost.host.events.publishTo(
+      instanceId,
+      input.topic,
+      jsToBrickValue(input.payload ?? null)
+    );
+  }
+  /**
+   * 注册 UI 方法罐头响应（重复注册后者覆盖前者）。
+   * method 取 HostUiHandler 方法名，如 createBrowserWindow / callWindow。
+   */
+  setUiResponse(method, result) {
+    if (!CANNED_UI_METHODS.includes(method)) {
+      throw new Error(`\u672A\u77E5 UI \u65B9\u6CD5\uFF1A${method}\uFF08\u53EF\u9009\uFF1A${CANNED_UI_METHODS.join(", ")}\uFF09`);
+    }
+    this.cannedUi.set(method, result);
+    if (!this.uiHandlerInstalled) {
+      this.installUiHandler();
+      this.uiHandlerInstalled = true;
+    }
+  }
+  /** UI handler 被调记录（按序），/reset 清空。 */
+  uiCalls() {
+    return [...this.uiCallLog];
+  }
+  /** 清驱动面状态：罐头响应与 UI 调用记录（不动 storage/故障规则，那些归 control）。 */
+  reset() {
+    this.cannedUi.clear();
+    this.uiCallLog.length = 0;
+  }
+  installUiHandler() {
+    const dispatch = (method, args) => {
+      this.uiCallLog.push({ method, args, at: Date.now() });
+      if (!this.cannedUi.has(method)) {
+        throw new Error(`UI \u65B9\u6CD5 ${method} \u672A\u6CE8\u518C\u7F50\u5934\u54CD\u5E94`);
+      }
+      return this.cannedUi.get(method);
+    };
+    const handler = {
+      createBrowserWindow: (...args) => dispatch("createBrowserWindow", args),
+      callWindow: (...args) => dispatch("callWindow", args),
+      closeWindow: (...args) => dispatch("closeWindow", args),
+      forceCloseWindow: (...args) => dispatch("forceCloseWindow", args),
+      listWindows: (...args) => dispatch("listWindows", args),
+      sendToChild: (...args) => dispatch("sendToChild", args),
+      replyToChild: (...args) => dispatch("replyToChild", args),
+      emitToChild: (...args) => dispatch("emitToChild", args)
+    };
+    this.testHost.host.setUiHandler(handler);
+  }
+};
+function createHostDriver(testHost) {
+  return new HostDriver(testHost);
+}
+function serializeError(error) {
+  const serviceError = error;
+  const brick = unpackBrickError(serviceError);
+  return {
+    brickCode: brick?.code,
+    message: serviceError?.message ?? String(error),
+    grpcStatus: serviceError?.code
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
 // src/spawn.ts
 var import_node_child_process = require("node:child_process");
 var import_node_path7 = require("node:path");
@@ -40799,7 +41268,9 @@ function waitForExit(child, timeoutMs) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HostDriver,
   HostTestControl,
+  createHostDriver,
   spawnTestHost,
   startTestHost
 });

package/dist/sources.lst

@@ -207,6 +207,7 @@
 ..\..\src\main\runtime\transport\runtime-channel.ts
 ..\..\src\main\runtime\transport\spawn-registry.ts
 ..\..\src\main\runtime\transport\test-host\control.ts
+..\..\src\main\runtime\transport\test-host\drive.ts
 ..\..\src\main\runtime\transport\test-host\main.ts
 ..\..\src\main\runtime\transport\test-host\start.ts
 ..\..\src\main\runtime\transport\tokens.ts