Route command replies through MeshService.respond() — same channel, threaded quote (v0.18.1)

src/commands/command.service.spec.ts

@@ -4,6 +4,7 @@ import {
   startBridge,
   textPacketFrame,
   waitFor,
+  outboundPackets,
   KAMIL_NUM,
 } from '../mesh/fake-bridge.js';
 import type { MeshService } from '../mesh/mesh.service.js';
@@ -12,8 +13,12 @@ import { CommandService } from './command.service.js';
 
 function makeService(
   sendText?: ReturnType<typeof vi.fn>,
+  respond?: ReturnType<typeof vi.fn>,
 ): [CommandService, MeshService] {
-  const mesh = { sendText: sendText ?? vi.fn() } as unknown as MeshService;
+  const mesh = {
+    sendText: sendText ?? vi.fn(),
+    respond: respond ?? vi.fn().mockResolvedValue({ id: 1 }),
+  } as unknown as MeshService;
   return [new CommandService(mesh), mesh];
 }
 
@@ -22,15 +27,24 @@ beforeEach(() => {
 });
 
 describe('CommandService.onRx', () => {
-  it('answers #ping on the command channel with a directed DM back to the sender', async () => {
+  it('replies #ping via respond() — threaded quote of the trigger packet, no direct sendText', async () => {
     const [svc, mesh] = makeService();
     await svc.onRx(2, '#ping', 42, 7);
+    expect(mesh.respond).toHaveBeenCalledWith(7, '#pong!');
+    expect(mesh.sendText).not.toHaveBeenCalled();
+  });
+
+  it('falls back to a directed sendText on COMMAND_CHANNEL when the trigger has no packet id (DM)', async () => {
+    const [svc, mesh] = makeService();
+    await svc.onRx(2, '#ping', 42); // from present but no id — defensive path
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).toHaveBeenCalledWith(42, '#pong!', undefined, 2);
   });
 
-  it('broadcasts the reply when there is no sender', async () => {
+  it('falls back to a broadcast sendText on COMMAND_CHANNEL when the trigger has no packet id (no sender)', async () => {
     const [svc, mesh] = makeService();
-    await svc.onRx(2, '#ping');
+    await svc.onRx(2, '#ping'); // no from, no id — defensive path
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).toHaveBeenCalledWith(
       BROADCAST_ADDR,
       '#pong!',
@@ -43,6 +57,7 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     await svc.onRx(0, '#ping', 42);
     await svc.onRx(3, '#ping', 42);
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
@@ -50,6 +65,7 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     await svc.onRx(2, 'hello there', 42);
     await svc.onRx(2, 'ping', 42); // no leading # — not a command trigger
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
@@ -57,28 +73,31 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     await svc.onRx(2, '#Ping', 42);
     await svc.onRx(2, '#ping!', 42); // extra char — no partial matches
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
   it('trims surrounding whitespace before matching', async () => {
     const [svc, mesh] = makeService();
-    await svc.onRx(2, '  #ping  ', 42);
-    expect(mesh.sendText).toHaveBeenCalledWith(42, '#pong!', undefined, 2);
+    await svc.onRx(2, '  #ping  ', 42, 9);
+    expect(mesh.respond).toHaveBeenCalledWith(9, '#pong!');
   });
 
   it('honors the COMMAND_CHANNEL env override', async () => {
     process.env.COMMAND_CHANNEL = '5';
     const [svc, mesh] = makeService();
     await svc.onRx(2, '#ping', 42); // old default no longer triggers
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
-    await svc.onRx(5, '#ping', 42);
-    expect(mesh.sendText).toHaveBeenCalledWith(42, '#pong!', undefined, 5);
+    await svc.onRx(5, '#ping', 42, 8);
+    expect(mesh.respond).toHaveBeenCalledWith(8, '#pong!');
   });
 
   it('sends nothing when a handler returns void', async () => {
     const [svc, mesh] = makeService();
     svc.register('silent', () => undefined);
     await svc.onRx(2, '#silent', 42);
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
@@ -86,7 +105,7 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     svc.register('status', (ctx) => `up from ${ctx.from ?? 'broadcast'}`);
     await svc.onRx(2, '#status', 99, 5);
-    expect(mesh.sendText).toHaveBeenCalledWith(99, 'up from 99', undefined, 2);
+    expect(mesh.respond).toHaveBeenCalledWith(5, 'up from 99');
   });
 
   it('swallows a failing handler (a bad command must not crash the app)', async () => {
@@ -95,19 +114,28 @@ describe('CommandService.onRx', () => {
       throw new Error('kaboom');
     });
     await expect(svc.onRx(2, '#boom', 42)).resolves.toBeUndefined();
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
+  it('swallows a failing respond (unknown id / bridge down) without throwing', async () => {
+    const [svc] = makeService(
+      undefined,
+      vi.fn().mockRejectedValue(new Error('no message with id 7')),
+    );
+    await expect(svc.onRx(2, '#ping', 42, 7)).resolves.toBeUndefined();
+  });
+
   it('swallows a failing send (mesh down) without throwing', async () => {
     const [svc] = makeService(
       vi.fn().mockRejectedValue(new Error('no bridge')),
     );
-    await expect(svc.onRx(2, '#ping', 42)).resolves.toBeUndefined();
+    await expect(svc.onRx(2, '#ping', 42)).resolves.toBeUndefined(); // no id → legacy path
   });
 });
 
 describe('MeshService wiring (event-driven trigger)', () => {
-  it('calls onRx for decoded rx text and answers #ping over the wire', async () => {
+  it('answers a #ping DM on ch2 with a directed #pong! back to the sender, same channel, threaded quote', async () => {
     const bridge = await startBridge();
     process.env.MESH_HOST = '127.0.0.1';
     process.env.MESH_PORT = String(bridge.port);
@@ -120,6 +148,10 @@ describe('MeshService wiring (event-driven trigger)', () => {
         () => bridge.sockets.length === 1 && svc.status().connected,
       );
 
+      const out: Uint8Array[] = [];
+      bridge.sockets[0].on('data', (c) => out.push(c));
+
+      // rx DM from KAMIL to node 42 on channel 2 (packet id 1)
       bridge.sockets[0].write(textPacketFrame(KAMIL_NUM, 42, '#ping', 2));
 
       // rx record + the directed #pong! reply on channel 2 (newest first — the reply is [0])
@@ -130,6 +162,60 @@ describe('MeshService wiring (event-driven trigger)', () => {
         text: '#pong!',
         channel: 2,
       });
+
+      // wire-level: DM back to the sender on ch2 with replyId = the ping packet id (threaded quote)
+      await waitFor(() => outboundPackets(out).length >= 1);
+      const pkt = outboundPackets(out)[0]!;
+      expect(pkt.to).toBe(KAMIL_NUM);
+      expect(pkt.channel).toBe(2);
+      const data =
+        pkt.payloadVariant?.case === 'decoded'
+          ? pkt.payloadVariant.value
+          : undefined;
+      expect(data?.replyId).toBe(1);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('answers a #ping broadcast on ch2 with a #pong! broadcast, same channel, threaded quote', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new RealMeshService();
+    try {
+      svc.attachCommands(new CommandService(svc));
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      const out: Uint8Array[] = [];
+      bridge.sockets[0].on('data', (c) => out.push(c));
+
+      // rx broadcast from KAMIL on channel 2 (packet id 1)
+      bridge.sockets[0].write(
+        textPacketFrame(KAMIL_NUM, BROADCAST_ADDR, '#ping', 2),
+      );
+
+      await waitFor(() => svc.messages().length === 2);
+      expect(svc.messages()[0]).toMatchObject({
+        dir: 'tx',
+        to: BROADCAST_ADDR, // broadcast original → broadcast reply
+        text: '#pong!',
+        channel: 2,
+      });
+
+      await waitFor(() => outboundPackets(out).length >= 1);
+      const pkt = outboundPackets(out)[0]!;
+      expect(pkt.to).toBe(BROADCAST_ADDR);
+      expect(pkt.channel).toBe(2);
+      const data =
+        pkt.payloadVariant?.case === 'decoded'
+          ? pkt.payloadVariant.value
+          : undefined;
+      expect(data?.replyId).toBe(1); // threaded quote of the ping packet (id 1)
     } finally {
       svc.onModuleDestroy();
       bridge.close();