shadow-claw 1.23.3 → 1.24.0

package/src/subsystems/channels/peerjs.ts

@@ -1102,16 +1102,83 @@ export class PeerJsChannel implements Channel {
 
       return;
     }
+
+    // Control-plane command execution over WebRTC DataChannel
+    if (msg.type === "command:execute") {
+      const payload = (msg.payload || {}) as {
+        commandId?: string;
+        action?: string;
+        args?: any;
+      };
+      const action = payload.action || "";
+      const args = payload.args || {};
+      const commandId = payload.commandId || "";
+
+      import("../../core/utils/initControlPlane.js")
+        .then(({ executeClientControlCommand }) =>
+          executeClientControlCommand(action, args),
+        )
+        .then((result) => {
+          const conn = this.connections.get(remotePeerId);
+          if (conn) {
+            const hasError = Boolean(result?.error);
+            conn.send({
+              id: ulid(),
+              type: "command:result",
+              payload: {
+                commandId,
+                action,
+                success: !hasError,
+                data: result,
+                ...(hasError ? { error: result.error } : {}),
+              },
+            });
+          }
+        })
+        .catch((err) => {
+          const conn = this.connections.get(remotePeerId);
+          if (conn) {
+            conn.send({
+              id: ulid(),
+              type: "command:result",
+              payload: {
+                commandId,
+                action,
+                success: false,
+                error: err?.message || String(err),
+              },
+            });
+          }
+        });
+
+      return;
+    }
+  }
+
+  private _isTrustedPeer(remotePeerId: string): boolean {
+    if (this.trustedPeerIds.size === 0) {
+      return true;
+    }
+    if (this.trustedPeerIds.has(remotePeerId)) {
+      return true;
+    }
+    for (const trusted of this.trustedPeerIds) {
+      const clean = trusted.trim();
+      if (clean.endsWith("*") && remotePeerId.startsWith(clean.slice(0, -1))) {
+        return true;
+      }
+      if (clean === "cli" && remotePeerId.startsWith("cli-")) {
+        return true;
+      }
+    }
+    return false;
   }
 
   private _handleIncomingConnection(conn: DataConnection): void {
     const remotePeerId = conn.peer;
 
     // Reject untrusted peers when a trusted list is configured
-    if (
-      this.trustedPeerIds.size > 0 &&
-      !this.trustedPeerIds.has(remotePeerId)
-    ) {
+    if (!this._isTrustedPeer(remotePeerId)) {
       console.warn(
         `PeerJsChannel: rejecting connection from untrusted peer: ${remotePeerId}`,
       );

package/src/subsystems/channels/telegram.test.ts

@@ -331,4 +331,181 @@ describe("TelegramChannel", () => {
     expect(fetchCalls).toBe(2);
     channel.stop();
   });
+
+  it("handles /ping helper command", async () => {
+    const channel = new TelegramChannel();
+    const apiCall = jest
+      .spyOn(channel, "apiCall")
+      .mockResolvedValue({ ok: true } as any);
+
+    channel.configure("token", ["123"]);
+
+    await channel.handleUpdate({
+      update_id: 20,
+      message: {
+        message_id: 99,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        text: "/ping",
+      },
+    });
+
+    expect(apiCall).toHaveBeenCalledWith("sendMessage", {
+      chat_id: "123",
+      text: "Pong! ShadowClaw is running.",
+    });
+  });
+
+  it("handles voice, video, audio, document, sticker, location, and contact messages", async () => {
+    const channel = new TelegramChannel();
+    jest.spyOn(channel, "apiCall").mockResolvedValue({
+      ok: true,
+      result: { file_id: "fid", file_path: "path/file.dat" },
+    } as any);
+
+    channel.configure("token", ["123"]);
+    const messagesSeen: any[] = [];
+    channel.onMessage((m) => messagesSeen.push(m));
+
+    // Voice
+    await channel.handleUpdate({
+      update_id: 21,
+      message: {
+        message_id: 101,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        voice: { file_id: "voice-1", mime_type: "audio/ogg" },
+      },
+    });
+    expect(messagesSeen[0].content).toBe("[Voice message]");
+
+    // Video
+    await channel.handleUpdate({
+      update_id: 22,
+      message: {
+        message_id: 102,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        video: { file_id: "vid-1", file_name: "movie.mp4" },
+      },
+    });
+    expect(messagesSeen[1].content).toBe("[Video]");
+
+    // Audio
+    await channel.handleUpdate({
+      update_id: 23,
+      message: {
+        message_id: 103,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        audio: { file_id: "aud-1", file_name: "song.mp3" },
+      },
+    });
+    expect(messagesSeen[2].content).toBe("[Audio]");
+
+    // Document
+    await channel.handleUpdate({
+      update_id: 24,
+      message: {
+        message_id: 104,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        document: { file_id: "doc-1", file_name: "report.pdf" },
+      },
+    });
+    expect(messagesSeen[3].content).toBe("[Document: report.pdf]");
+
+    // Sticker
+    await channel.handleUpdate({
+      update_id: 25,
+      message: {
+        message_id: 105,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        sticker: { file_id: "stk-1", emoji: "🚀", is_animated: true },
+      },
+    });
+    expect(messagesSeen[4].content).toBe("[Sticker: 🚀]");
+
+    // Location
+    await channel.handleUpdate({
+      update_id: 26,
+      message: {
+        message_id: 106,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        location: { latitude: 37.7749, longitude: -122.4194 },
+      },
+    });
+    expect(messagesSeen[5].content).toBe("[Location: 37.7749, -122.4194]");
+
+    // Contact
+    await channel.handleUpdate({
+      update_id: 27,
+      message: {
+        message_id: 107,
+        chat: { id: 123, type: "private" },
+        date: 1_700_000_000,
+        contact: { first_name: "Jane" },
+      },
+    });
+    expect(messagesSeen[6].content).toBe("[Contact: Jane]");
+  });
+
+  it("sets typing status via sendChatAction", () => {
+    const channel = new TelegramChannel();
+    channel.configure("token", ["123"]);
+    const apiCall = jest
+      .spyOn(channel, "apiCall")
+      .mockResolvedValue({ ok: true } as any);
+
+    channel.setTyping("tg:123", true);
+    expect(apiCall).toHaveBeenCalledWith("sendChatAction", {
+      chat_id: "123",
+      action: "typing",
+    });
+
+    channel.setTyping("tg:123", false);
+    expect(apiCall).toHaveBeenCalledTimes(1);
+  });
+
+  it("sends photos and documents via sendPhoto / sendDocument when fileReader provides blobs", async () => {
+    const channel = new TelegramChannel();
+    channel.configure("token", ["123"]);
+
+    channel.fileReader = jest
+      .fn<any>()
+      .mockImplementation(async (_gid, path) => {
+        if (path.endsWith(".png")) {
+          return new Blob(["png-data"], { type: "image/png" });
+        }
+        return new Blob(["pdf-data"], { type: "application/pdf" });
+      });
+
+    const fetchSpy = jest.spyOn(globalThis, "fetch").mockResolvedValue({
+      ok: true,
+      json: async () => ({ ok: true }),
+    } as Response);
+
+    await channel.send(
+      "tg:123",
+      "Look at ![photo](images/pic.png) and [doc](docs/file.pdf) please",
+    );
+
+    expect(channel.fileReader).toHaveBeenCalledWith("tg:123", "images/pic.png");
+    expect(channel.fileReader).toHaveBeenCalledWith("tg:123", "docs/file.pdf");
+    expect(
+      fetchSpy.mock.calls.some((c: any) => String(c[0]).includes("sendPhoto")),
+    ).toBe(true);
+    expect(
+      fetchSpy.mock.calls.some((c: any) =>
+        String(c[0]).includes("sendDocument"),
+      ),
+    ).toBe(true);
+    expect(
+      fetchSpy.mock.calls.some((c: any) =>
+        String(c[0]).includes("sendMessage"),
+      ),
+    ).toBe(true);
+  });
 });

package/src/subsystems/email/catalog.test.ts

@@ -11,6 +11,7 @@ describe("email catalog", () => {
 
   it("returns null for unknown manifest id", () => {
     expect(getEmailPluginManifest("does-not-exist")).toBeNull();
+    expect(getEmailPluginManifest("")).toBeNull();
   });
 
   it("returns manifest for known id", () => {

package/src/subsystems/email/connections.test.ts

@@ -171,8 +171,46 @@ describe("email connections", () => {
     ]);
 
     const deleted = await deleteEmailConnection({} as any, "conn-9");
-
     expect(deleted).toBe(true);
     expect(mockSetConfig).toHaveBeenCalledWith({} as any, legacyKeyValue, []);
+
+    expect(await deleteEmailConnection({} as any, "")).toBe(false);
+    expect(await deleteEmailConnection({} as any, "non-existent")).toBe(false);
+  });
+
+  it("updates existing connection on upsert", async () => {
+    mockGetConfig.mockResolvedValue([
+      {
+        id: "conn-existing",
+        label: "Old Label",
+        pluginId: "imap",
+        enabled: true,
+        config: {},
+        credentialRef: null,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    ]);
+
+    const updated = await upsertEmailConnection({} as any, {
+      id: "conn-existing",
+      label: "New Label",
+      pluginId: "imap",
+      enabled: false,
+    });
+
+    expect(updated.label).toBe("New Label");
+    expect(updated.enabled).toBe(false);
+  });
+
+  it("handles edge cases for get and bind connection", async () => {
+    expect(await getEmailConnection({} as any, "")).toBeNull();
+    mockGetConfig.mockResolvedValue([]);
+    expect(await getEmailConnection({} as any, "missing")).toBeNull();
+
+    expect(await bindEmailCredentialRef({} as any, "", null)).toBeNull();
+    expect(
+      await bindEmailCredentialRef({} as any, "missing-conn", null),
+    ).toBeNull();
   });
 });