@stagewhisper/stagewhisper 0.51.0 → 0.53.0

package/src/channel.ts

@@ -1,182 +0,0 @@
-import {
-  createChatChannelPlugin,
-  createChannelPluginBase,
-  DEFAULT_ACCOUNT_ID,
-} from "openclaw/plugin-sdk/core";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-
-export type StageWhisperAccount = {
-  accountId: string | null;
-  apiBaseUrl: string;
-  integrationId: string;
-  relayToken: string;
-  label: string;
-  pluginSecretKeyB64?: string;
-  desktopPublicKeyB64?: string;
-};
-
-function getChannelSection(cfg: OpenClawConfig): Record<string, unknown> {
-  const channels = cfg.channels as
-    | Record<string, Record<string, unknown>>
-    | undefined;
-  return channels?.["stagewhisper"] ?? {};
-}
-
-export function resolveAccount(
-  cfg: OpenClawConfig,
-  accountId?: string | null,
-): StageWhisperAccount {
-  const section = getChannelSection(cfg);
-  const pluginCfg = (cfg as Record<string, unknown>)?.["plugins"] as
-    | Record<string, unknown>
-    | undefined;
-  const entries = pluginCfg?.["entries"] as
-    | Record<string, Record<string, unknown>>
-    | undefined;
-  const swConfig = entries?.["stagewhisper"]?.["config"] as
-    | Record<string, unknown>
-    | undefined;
-
-  const apiBaseUrl =
-    (section["apiBaseUrl"] as string) ||
-    (swConfig?.["apiBaseUrl"] as string) ||
-    "https://api.stagewhisper.io";
-  const integrationId =
-    (section["integrationId"] as string) ??
-    (swConfig?.["integrationId"] as string) ??
-    "";
-  const relayToken =
-    (section["relayToken"] as string) ??
-    (swConfig?.["relayToken"] as string) ??
-    "";
-  const label =
-    (section["label"] as string) ??
-    (swConfig?.["label"] as string) ??
-    "StageWhisper";
-
-  if (!apiBaseUrl) throw new Error("stagewhisper: apiBaseUrl is required");
-  if (!integrationId)
-    throw new Error("stagewhisper: integrationId is required");
-  if (!relayToken) throw new Error("stagewhisper: relayToken is required");
-
-  return {
-    accountId: accountId ?? null,
-    apiBaseUrl,
-    integrationId,
-    relayToken,
-    label,
-    pluginSecretKeyB64: (section["pluginSecretKey"] as string) ?? (swConfig?.["pluginSecretKey"] as string) ?? undefined,
-    desktopPublicKeyB64: (section["desktopPublicKey"] as string) ?? (swConfig?.["desktopPublicKey"] as string) ?? undefined,
-  };
-}
-
-const base = createChannelPluginBase<StageWhisperAccount>({
-  id: "stagewhisper",
-  capabilities: {
-    chatTypes: ["direct"],
-  },
-  config: {
-    listAccountIds: (cfg: OpenClawConfig) => {
-      try {
-        resolveAccount(cfg);
-        return [DEFAULT_ACCOUNT_ID];
-      } catch {
-        return [];
-      }
-    },
-    resolveAccount,
-    inspectAccount(cfg: OpenClawConfig) {
-      try {
-        const account = resolveAccount(cfg);
-        return {
-          enabled: true,
-          configured: true,
-          label: account.label,
-          apiBaseUrl: account.apiBaseUrl,
-        };
-      } catch {
-        return {
-          enabled: false,
-          configured: false,
-          tokenStatus: "missing",
-        };
-      }
-    },
-  },
-  setup: {
-    applyAccountConfig({ cfg, input }) {
-      const channels = (cfg.channels ?? {}) as Record<
-        string,
-        Record<string, unknown>
-      >;
-      const section = { ...(channels["stagewhisper"] ?? {}) };
-      const raw = input as unknown as Record<string, string>;
-
-      if (raw["apiBaseUrl"]) section["apiBaseUrl"] = raw["apiBaseUrl"];
-      if (raw["integrationId"])
-        section["integrationId"] = raw["integrationId"];
-      if (raw["relayToken"]) section["relayToken"] = raw["relayToken"];
-      if (raw["label"]) section["label"] = raw["label"];
-
-      return {
-        ...cfg,
-        channels: { ...channels, stagewhisper: section },
-      } as OpenClawConfig;
-    },
-  },
-});
-
-export const stagewhisperPlugin = createChatChannelPlugin<StageWhisperAccount>(
-  {
-    base: base as unknown as Parameters<typeof createChatChannelPlugin<StageWhisperAccount>>[0]["base"],
-
-    security: {
-      dm: {
-        channelKey: "stagewhisper",
-        resolvePolicy: () => "closed",
-        resolveAllowFrom: () => [],
-        defaultPolicy: "closed",
-      },
-    },
-
-    pairing: {
-      text: {
-        idLabel: "StageWhisper pairing code",
-        message: "Run this command to complete pairing:",
-        notify: async () => {},
-      },
-    },
-
-    threading: { topLevelReplyToMode: "reply" },
-
-    outbound: {
-      base: {
-        deliveryMode: "direct",
-        resolveTarget: (params: {
-          cfg?: OpenClawConfig;
-          to?: string;
-          allowFrom?: string[];
-          accountId?: string | null;
-          mode?: string;
-        }) => {
-          if (!params.to) return { ok: false as const, error: new Error("No delivery target") };
-          return { ok: true as const, to: params.to };
-        },
-      },
-      attachedResults: {
-        channel: "stagewhisper",
-        sendText: async (ctx) => {
-          const target = (ctx as Record<string, unknown>).to as string | undefined ?? "";
-          if (target.startsWith("sw-session-")) {
-            return { messageId: `sw-relay-ack-${Date.now()}`, ok: true };
-          }
-          console.warn(
-            `[stagewhisper] sendText called for unrecognised target "${target}"; ` +
-            `StageWhisper channel is inbound-only — task replies are routed by the relay service`,
-          );
-          return { messageId: `sw-dropped-${Date.now()}`, ok: false };
-        },
-      },
-    },
-  },
-);

package/src/client.ts

@@ -1,191 +0,0 @@
-import type { IdentityKeypair } from "./crypto.js";
-
-export type TaskPayload = {
-  id: string;
-  session_id: string;
-  title: string;
-  request_text: string;
-  action_type: string;
-  status: string;
-  evidence_payload: Record<string, unknown> | null;
-  created_at: string;
-  is_byo_encrypted?: boolean;
-  encrypted_title?: string;
-  encrypted_request?: string;
-  encrypted_evidence?: string;
-};
-
-export type PairCompleteResponse = {
-  integration_id: string;
-  relay_token: string;
-  label: string;
-  byo_public_key?: string;
-};
-
-export type HeartbeatResponse = {
-  ok: boolean;
-};
-
-export class StageWhisperClient {
-  private baseUrl: string;
-  private integrationId: string;
-  private relayToken: string;
-  private pluginKeypair_: IdentityKeypair | null = null;
-  private desktopPublicKey_: Uint8Array | null = null;
-
-  constructor(baseUrl: string, integrationId: string, relayToken: string) {
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
-    this.integrationId = integrationId;
-    this.relayToken = relayToken;
-  }
-
-  setPluginKeypair(kp: IdentityKeypair): void {
-    this.pluginKeypair_ = kp;
-  }
-
-  setDesktopPublicKey(key: Uint8Array): void {
-    this.desktopPublicKey_ = key;
-  }
-
-  getPluginKeypair(): IdentityKeypair | null {
-    return this.pluginKeypair_;
-  }
-
-  getDesktopPublicKey(): Uint8Array | null {
-    return this.desktopPublicKey_;
-  }
-
-  get pluginKeypair(): IdentityKeypair | null {
-    return this.pluginKeypair_;
-  }
-
-  get desktopPublicKey(): Uint8Array | null {
-    return this.desktopPublicKey_;
-  }
-
-  private headers(): Record<string, string> {
-    return {
-      Authorization: `Bearer ${this.relayToken}`,
-      "Content-Type": "application/json",
-    };
-  }
-
-  async completePairing(
-    pairingCode: string,
-    hostLabel: string,
-    pluginPublicKey?: string,
-  ): Promise<PairCompleteResponse> {
-    const body: Record<string, unknown> = {
-      pairing_code: pairingCode,
-      host_label: hostLabel,
-    };
-    if (pluginPublicKey) {
-      body.plugin_public_key = pluginPublicKey;
-    }
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/pair/complete`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Pairing failed (${res.status}): ${text}`);
-    }
-    return res.json();
-  }
-
-  async updateTaskStatus(taskId: string, status: string, remoteTaskId?: string): Promise<void> {
-    const body: Record<string, unknown> = { status };
-    if (remoteTaskId) body.remote_task_id = remoteTaskId;
-
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/tasks/${taskId}/status`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Status update failed (${res.status}): ${text}`);
-    }
-  }
-
-  async postReply(
-    taskId: string,
-    content: string,
-    remoteMessageId?: string,
-    encryptedSummary?: string,
-  ): Promise<void> {
-    const body: Record<string, unknown> = { content };
-    if (remoteMessageId) body.remote_message_id = remoteMessageId;
-    if (encryptedSummary) body.encrypted_summary = encryptedSummary;
-
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/tasks/${taskId}/reply`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Reply failed (${res.status}): ${text}`);
-    }
-  }
-
-  async heartbeat(capabilities?: Record<string, unknown>): Promise<HeartbeatResponse> {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/heartbeat`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: capabilities ? JSON.stringify(capabilities) : undefined,
-      },
-    );
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Heartbeat failed (${res.status}): ${text}`);
-    }
-    return res.json();
-  }
-
-  async postReasoningResult(
-    jobId: string,
-    result: Record<string, unknown>,
-    correlationId?: string,
-  ): Promise<void> {
-    const headers = this.headers();
-    if (correlationId) {
-      headers["X-Correlation-ID"] = correlationId;
-    }
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/reasoning-jobs/${jobId}/complete`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(result),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Reasoning result post failed (${res.status}): ${text}`);
-    }
-  }
-
-  streamUrl(): string {
-    return `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/stream`;
-  }
-
-  streamHeaders(): Record<string, string> {
-    return { Authorization: `Bearer ${this.relayToken}` };
-  }
-
-  async testReply(testId: string, content: string): Promise<void> {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/test-reply`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify({ test_id: testId, content }),
-      },
-    );
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Test reply failed (${res.status}): ${text}`);
-    }
-  }
-}

package/src/crypto.test.ts

@@ -1,181 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  IdentityKeypair,
-  seal,
-  open,
-  sealJson,
-  openJson,
-  openChecked,
-  ReplayGuard,
-  ENVELOPE_VERSION,
-  type BYOEnvelope,
-} from "./crypto";
-
-function makeTestKey(): { key: Uint8Array; alice: IdentityKeypair; bob: IdentityKeypair } {
-  const alice = IdentityKeypair.generate();
-  const bob = IdentityKeypair.generate();
-  const key = alice.deriveEnvelopeKey(bob.publicKey);
-  return { key, alice, bob };
-}
-
-describe("crypto envelope", () => {
-  it("seal and open roundtrip", () => {
-    const { key } = makeTestKey();
-    const plaintext = new TextEncoder().encode("hello world");
-
-    const envelope = seal(key, "desktop", "session-1", "corr-1", "reasoning_input", plaintext);
-
-    expect(envelope.version).toBe(ENVELOPE_VERSION);
-    expect(envelope.sender_role).toBe("desktop");
-
-    const decrypted = open(key, envelope);
-    expect(decrypted).toEqual(plaintext);
-  });
-
-  it("wrong key fails", () => {
-    const { key: key1 } = makeTestKey();
-    const { key: key2 } = makeTestKey();
-
-    const envelope = seal(key1, "plugin", "s", "c", "reasoning_output", new TextEncoder().encode("secret"));
-
-    expect(() => open(key2, envelope)).toThrow();
-  });
-
-  it("tampered ciphertext fails", () => {
-    const { key } = makeTestKey();
-    const envelope = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("data"));
-
-    const bytes = Uint8Array.from(atob(envelope.ciphertext), (c) => c.codePointAt(0)!);
-    bytes[0] ^= 0xff;
-    const tampered: BYOEnvelope = {
-      ...envelope,
-      ciphertext: btoa(Array.from(bytes, (b) => String.fromCodePoint(b)).join("")),
-    };
-
-    expect(() => open(key, tampered)).toThrow();
-  });
-
-  it("tampered session_id fails", () => {
-    const { key } = makeTestKey();
-    const envelope = seal(key, "desktop", "session-1", "corr-1", "reasoning_input", new TextEncoder().encode("data"));
-
-    const tampered: BYOEnvelope = { ...envelope, session_id: "TAMPERED" };
-    expect(() => open(key, tampered)).toThrow();
-  });
-
-  it("tampered sender_role fails", () => {
-    const { key } = makeTestKey();
-    const envelope = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("data"));
-
-    const tampered: BYOEnvelope = { ...envelope, sender_role: "plugin" };
-    expect(() => open(key, tampered)).toThrow();
-  });
-
-  it("tampered content_type fails", () => {
-    const { key } = makeTestKey();
-    const envelope = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("data"));
-
-    const tampered: BYOEnvelope = { ...envelope, content_type: "task_content" };
-    expect(() => open(key, tampered)).toThrow();
-  });
-
-  it("unique message_ids", () => {
-    const { key } = makeTestKey();
-    const e1 = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("a"));
-    const e2 = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("a"));
-    expect(e1.message_id).not.toBe(e2.message_id);
-  });
-
-  it("unique nonces", () => {
-    const { key } = makeTestKey();
-    const e1 = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("a"));
-    const e2 = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("a"));
-    expect(e1.nonce).not.toBe(e2.nonce);
-  });
-
-  it("json roundtrip", () => {
-    const { key } = makeTestKey();
-    const payload = {
-      system_instruction: "You are an analyst",
-      user_prompt: "Analyze the transcript",
-      response_schema: { type: "object" },
-    };
-
-    const envelope = sealJson(key, "desktop", "session-1", "corr-1", "reasoning_input", payload);
-    const decrypted = openJson(key, envelope);
-    expect(decrypted).toEqual(payload);
-  });
-
-  it("serialization roundtrip", () => {
-    const { key } = makeTestKey();
-    const envelope = seal(key, "desktop", "session-1", "corr-1", "reasoning_input", new TextEncoder().encode("test payload"));
-
-    const json = JSON.stringify(envelope);
-    const restored: BYOEnvelope = JSON.parse(json);
-
-    const decrypted = open(key, restored);
-    expect(new TextDecoder().decode(decrypted)).toBe("test payload");
-  });
-
-  it("unsupported version rejected", () => {
-    const { key } = makeTestKey();
-    const envelope = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("data"));
-    const bad: BYOEnvelope = { ...envelope, version: "static_v99" };
-
-    expect(() => open(key, bad)).toThrow(/Unsupported envelope version/);
-  });
-});
-
-describe("replay guard", () => {
-  it("detects duplicate message", () => {
-    const { key } = makeTestKey();
-    const envelope = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("data"));
-
-    const guard = new ReplayGuard();
-    expect(() => openChecked(key, envelope, guard)).not.toThrow();
-    expect(() => openChecked(key, envelope, guard)).toThrow(/Replay detected/);
-  });
-
-  it("allows different messages", () => {
-    const { key } = makeTestKey();
-    const e1 = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("a"));
-    const e2 = seal(key, "desktop", "s", "c", "reasoning_input", new TextEncoder().encode("b"));
-
-    const guard = new ReplayGuard();
-    expect(() => openChecked(key, e1, guard)).not.toThrow();
-    expect(() => openChecked(key, e2, guard)).not.toThrow();
-  });
-});
-
-describe("identity keypair", () => {
-  it("generate and DH agreement", () => {
-    const alice = IdentityKeypair.generate();
-    const bob = IdentityKeypair.generate();
-
-    const sharedA = alice.diffieHellman(bob.publicKey);
-    const sharedB = bob.diffieHellman(alice.publicKey);
-    expect(sharedA).toEqual(sharedB);
-  });
-
-  it("derived envelope keys match", () => {
-    const alice = IdentityKeypair.generate();
-    const bob = IdentityKeypair.generate();
-
-    const keyA = alice.deriveEnvelopeKey(bob.publicKey);
-    const keyB = bob.deriveEnvelopeKey(alice.publicKey);
-    expect(keyA).toEqual(keyB);
-  });
-
-  it("base64 roundtrip", () => {
-    const kp = IdentityKeypair.generate();
-    const b64 = kp.publicKeyBase64();
-    const restored = IdentityKeypair.publicKeyFromBase64(b64);
-    expect(restored).toEqual(kp.publicKey);
-  });
-
-  it("from secret bytes roundtrip", () => {
-    const original = IdentityKeypair.generate();
-    const restored = IdentityKeypair.fromSecretBytes(original.secretBytes());
-    expect(restored.publicKey).toEqual(original.publicKey);
-  });
-});