@soyeht/soyeht 0.1.1 → 0.1.2

package/README.md

@@ -7,7 +7,7 @@ Channel plugin for connecting the Soyeht Flutter mobile app to an OpenClaw gatew
 After this package is published to npm, install it on the OpenClaw host with:
 
 ```bash
-openclaw plugins install @soyeht/soyeht@0.1.1 --pin
+openclaw plugins install @soyeht/soyeht@0.1.2 --pin
 openclaw plugins enable soyeht
 ```
 

package/openclaw.plugin.json

@@ -5,7 +5,7 @@
   ],
   "name": "Soyeht",
   "description": "Channel plugin for the Soyeht Flutter mobile app",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soyeht/soyeht",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "OpenClaw channel plugin for the Soyeht Flutter mobile app",
   "type": "module",
   "main": "src/index.ts",
@@ -38,9 +38,6 @@
     "prepublishOnly": "npm run validate && npm run pack:check",
     "version": "node scripts/sync-plugin-manifest-version.mjs"
   },
-  "dependencies": {
-    "@sinclair/typebox": "^0.34.0"
-  },
   "devDependencies": {
     "@types/node": "^25.3.5",
     "typescript": "^5.7.0",

package/src/types.ts

@@ -1,190 +1,390 @@
-import { Type, type Static } from "@sinclair/typebox";
+type JsonSchema = Record<string, unknown>;
 
 // ---------------------------------------------------------------------------
 // Account config schema (per-account settings under channels.soyeht.accounts.*)
 // ---------------------------------------------------------------------------
 
-export const SoyehtAccountConfigSchema = Type.Object({
-  enabled: Type.Optional(Type.Boolean()),
-  backendBaseUrl: Type.Optional(Type.String()),
-  pluginAuthToken: Type.Optional(Type.String()),
-  allowProactive: Type.Optional(Type.Boolean()),
-  audio: Type.Optional(
-    Type.Object({
-      transcribeInbound: Type.Optional(Type.Boolean()),
-      ttsOutbound: Type.Optional(Type.Boolean()),
-    }),
-  ),
-  files: Type.Optional(
-    Type.Object({
-      acceptInbound: Type.Optional(Type.Boolean()),
-      maxBytes: Type.Optional(Type.Number()),
-    }, { additionalProperties: false }),
-  ),
-  security: Type.Optional(
-    Type.Object({
-      enabled: Type.Optional(Type.Boolean()),
-      timestampToleranceMs: Type.Optional(Type.Number()),
-      dhRatchetIntervalMessages: Type.Optional(Type.Number()),
-      dhRatchetIntervalMs: Type.Optional(Type.Number()),
-      sessionMaxAgeMs: Type.Optional(Type.Number()),
-      rateLimit: Type.Optional(
-        Type.Object({
-          maxRequests: Type.Optional(Type.Number()),
-          windowMs: Type.Optional(Type.Number()),
-        }, { additionalProperties: false }),
-      ),
-    }, { additionalProperties: false }),
-  ),
-}, { additionalProperties: false });
-
-export type SoyehtAccountConfig = Static<typeof SoyehtAccountConfigSchema>;
-
-export const SoyehtChannelConfigSchema = Type.Object({
-  accounts: Type.Optional(Type.Record(Type.String(), SoyehtAccountConfigSchema)),
-}, { additionalProperties: false });
-
-export type SoyehtChannelConfig = Static<typeof SoyehtChannelConfigSchema>;
+export type SoyehtAccountConfig = {
+  enabled?: boolean;
+  backendBaseUrl?: string;
+  pluginAuthToken?: string;
+  allowProactive?: boolean;
+  audio?: {
+    transcribeInbound?: boolean;
+    ttsOutbound?: boolean;
+  };
+  files?: {
+    acceptInbound?: boolean;
+    maxBytes?: number;
+  };
+  security?: {
+    enabled?: boolean;
+    timestampToleranceMs?: number;
+    dhRatchetIntervalMessages?: number;
+    dhRatchetIntervalMs?: number;
+    sessionMaxAgeMs?: number;
+    rateLimit?: {
+      maxRequests?: number;
+      windowMs?: number;
+    };
+  };
+};
+
+export const SoyehtAccountConfigSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    enabled: { type: "boolean" },
+    backendBaseUrl: { type: "string" },
+    pluginAuthToken: { type: "string" },
+    allowProactive: { type: "boolean" },
+    audio: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        transcribeInbound: { type: "boolean" },
+        ttsOutbound: { type: "boolean" },
+      },
+    },
+    files: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        acceptInbound: { type: "boolean" },
+        maxBytes: { type: "number" },
+      },
+    },
+    security: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        timestampToleranceMs: { type: "number" },
+        dhRatchetIntervalMessages: { type: "number" },
+        dhRatchetIntervalMs: { type: "number" },
+        sessionMaxAgeMs: { type: "number" },
+        rateLimit: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            maxRequests: { type: "number" },
+            windowMs: { type: "number" },
+          },
+        },
+      },
+    },
+  },
+};
+
+export type SoyehtChannelConfig = {
+  accounts?: Record<string, SoyehtAccountConfig>;
+};
+
+export const SoyehtChannelConfigSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    accounts: {
+      type: "object",
+      additionalProperties: SoyehtAccountConfigSchema,
+    },
+  },
+};
 
 // ---------------------------------------------------------------------------
 // Outbound message payloads
 // ---------------------------------------------------------------------------
 
-export const TextMessagePayloadSchema = Type.Object({
-  contentType: Type.Literal("text"),
-  text: Type.String({ minLength: 1 }),
-});
-
-export type TextMessagePayload = Static<typeof TextMessagePayloadSchema>;
-
-export const AudioMessagePayloadSchema = Type.Object({
-  contentType: Type.Literal("audio"),
-  renderStyle: Type.Literal("voice_note"),
-  mimeType: Type.String(),
-  filename: Type.String(),
-  durationMs: Type.Optional(Type.Number()),
-  url: Type.String(),
-  transcript: Type.Optional(Type.String()),
-});
-
-export type AudioMessagePayload = Static<typeof AudioMessagePayloadSchema>;
-
-export const FileMessagePayloadSchema = Type.Object({
-  contentType: Type.Literal("file"),
-  mimeType: Type.String(),
-  filename: Type.String(),
-  sizeBytes: Type.Optional(Type.Number()),
-  url: Type.String(),
-});
-
-export type FileMessagePayload = Static<typeof FileMessagePayloadSchema>;
+export type TextMessagePayload = {
+  contentType: "text";
+  text: string;
+};
+
+export const TextMessagePayloadSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["contentType", "text"],
+  properties: {
+    contentType: { const: "text" },
+    text: { type: "string", minLength: 1 },
+  },
+};
+
+export type AudioMessagePayload = {
+  contentType: "audio";
+  renderStyle: "voice_note";
+  mimeType: string;
+  filename: string;
+  durationMs?: number;
+  url: string;
+  transcript?: string;
+};
+
+export const AudioMessagePayloadSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["contentType", "renderStyle", "mimeType", "filename", "url"],
+  properties: {
+    contentType: { const: "audio" },
+    renderStyle: { const: "voice_note" },
+    mimeType: { type: "string" },
+    filename: { type: "string" },
+    durationMs: { type: "number" },
+    url: { type: "string" },
+    transcript: { type: "string" },
+  },
+};
+
+export type FileMessagePayload = {
+  contentType: "file";
+  mimeType: string;
+  filename: string;
+  sizeBytes?: number;
+  url: string;
+};
+
+export const FileMessagePayloadSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["contentType", "mimeType", "filename", "url"],
+  properties: {
+    contentType: { const: "file" },
+    mimeType: { type: "string" },
+    filename: { type: "string" },
+    sizeBytes: { type: "number" },
+    url: { type: "string" },
+  },
+};
 
 // ---------------------------------------------------------------------------
 // Outbound envelope (wraps any payload for backend delivery)
 // ---------------------------------------------------------------------------
 
-export const OutboundEnvelopeSchema = Type.Object({
-  accountId: Type.String(),
-  sessionId: Type.String(),
-  deliveryId: Type.String(),
-  timestamp: Type.Number(),
-  message: Type.Union([
-    TextMessagePayloadSchema,
-    AudioMessagePayloadSchema,
-    FileMessagePayloadSchema,
-  ]),
-});
-
-export type OutboundEnvelope = Static<typeof OutboundEnvelopeSchema>;
+export type OutboundEnvelope = {
+  accountId: string;
+  sessionId: string;
+  deliveryId: string;
+  timestamp: number;
+  message: TextMessagePayload | AudioMessagePayload | FileMessagePayload;
+};
+
+export const OutboundEnvelopeSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["accountId", "sessionId", "deliveryId", "timestamp", "message"],
+  properties: {
+    accountId: { type: "string" },
+    sessionId: { type: "string" },
+    deliveryId: { type: "string" },
+    timestamp: { type: "number" },
+    message: {
+      oneOf: [
+        TextMessagePayloadSchema,
+        AudioMessagePayloadSchema,
+        FileMessagePayloadSchema,
+      ],
+    },
+  },
+};
 
 // ---------------------------------------------------------------------------
 // Delivery ack (webhook response from backend)
 // ---------------------------------------------------------------------------
 
-export const DeliveryAckSchema = Type.Object({
-  deliveryId: Type.String(),
-  status: Type.Union([Type.Literal("delivered"), Type.Literal("failed")]),
-  error: Type.Optional(Type.String()),
-});
-
-export type DeliveryAck = Static<typeof DeliveryAckSchema>;
+export type DeliveryAck = {
+  deliveryId: string;
+  status: "delivered" | "failed";
+  error?: string;
+};
+
+export const DeliveryAckSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["deliveryId", "status"],
+  properties: {
+    deliveryId: { type: "string" },
+    status: { enum: ["delivered", "failed"] },
+    error: { type: "string" },
+  },
+};
 
 // ---------------------------------------------------------------------------
 // Security schemas
 // ---------------------------------------------------------------------------
 
-export const HandshakeInitV2Schema = Type.Object({
-  version: Type.Literal(2),
-  accountId: Type.String(),
-  appEphemeralKey: Type.String(),   // X25519 pub raw b64url
-  nonce: Type.String(),
-  timestamp: Type.Number(),
-});
-
-export type HandshakeInitV2 = Static<typeof HandshakeInitV2Schema>;
-
-export const HandshakeResponseV2Schema = Type.Object({
-  version: Type.Literal(2),
-  phase: Type.Literal("init"),
-  complete: Type.Boolean(),
-  pluginEphemeralKey: Type.String(), // X25519 pub raw b64url
-  nonce: Type.String(),
-  timestamp: Type.Number(),
-  serverTimestamp: Type.Number(),
-  challengeExpiresAt: Type.Number(),
-  expiresAt: Type.Number(),
-  pluginSignature: Type.String(),    // Ed25519 sig over transcript, b64url
-});
-
-export type HandshakeResponseV2 = Static<typeof HandshakeResponseV2Schema>;
-
-export const EnvelopeV2Schema = Type.Object({
-  v: Type.Literal(2),
-  accountId: Type.String(),
-  direction: Type.Union([Type.Literal("plugin_to_app"), Type.Literal("app_to_plugin")]),
-  counter: Type.Number(),
-  timestamp: Type.Number(),
-  dhRatchetKey: Type.Optional(Type.String()),
-  ciphertext: Type.String(),
-  iv: Type.String(),
-  tag: Type.String(),
-});
-
-export type EnvelopeV2Type = Static<typeof EnvelopeV2Schema>;
-
-export const PairRequestSchema = Type.Object({
-  accountId: Type.String(),
-  pairingToken: Type.String(),
-  appIdentityKey: Type.String(), // Ed25519 pub raw b64url
-  appDhKey: Type.String(),       // X25519 pub raw b64url
-  appSignature: Type.String(),   // Ed25519 signature over pairing proof transcript
-});
-
-export type PairRequest = Static<typeof PairRequestSchema>;
-
-export const PairingQrPayloadSchema = Type.Object({
-  version: Type.Literal(1),
-  type: Type.Literal("soyeht_pairing_qr"),
-  accountId: Type.String(),
-  pairingToken: Type.String(),
-  expiresAt: Type.Number(),
-  allowOverwrite: Type.Boolean(),
-  pluginIdentityKey: Type.String(),
-  pluginDhKey: Type.String(),
-  fingerprint: Type.String(),
-  signature: Type.String(),
-});
-
-export type PairingQrPayload = Static<typeof PairingQrPayloadSchema>;
-
-export const HandshakeFinishV2Schema = Type.Object({
-  version: Type.Literal(2),
-  accountId: Type.String(),
-  nonce: Type.String(),
-  appSignature: Type.String(),
-});
-
-export type HandshakeFinishV2 = Static<typeof HandshakeFinishV2Schema>;
+export type HandshakeInitV2 = {
+  version: 2;
+  accountId: string;
+  appEphemeralKey: string;
+  nonce: string;
+  timestamp: number;
+};
+
+export const HandshakeInitV2Schema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["version", "accountId", "appEphemeralKey", "nonce", "timestamp"],
+  properties: {
+    version: { const: 2 },
+    accountId: { type: "string" },
+    appEphemeralKey: { type: "string" },
+    nonce: { type: "string" },
+    timestamp: { type: "number" },
+  },
+};
+
+export type HandshakeResponseV2 = {
+  version: 2;
+  phase: "init";
+  complete: boolean;
+  pluginEphemeralKey: string;
+  nonce: string;
+  timestamp: number;
+  serverTimestamp: number;
+  challengeExpiresAt: number;
+  expiresAt: number;
+  pluginSignature: string;
+};
+
+export const HandshakeResponseV2Schema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "version",
+    "phase",
+    "complete",
+    "pluginEphemeralKey",
+    "nonce",
+    "timestamp",
+    "serverTimestamp",
+    "challengeExpiresAt",
+    "expiresAt",
+    "pluginSignature",
+  ],
+  properties: {
+    version: { const: 2 },
+    phase: { const: "init" },
+    complete: { type: "boolean" },
+    pluginEphemeralKey: { type: "string" },
+    nonce: { type: "string" },
+    timestamp: { type: "number" },
+    serverTimestamp: { type: "number" },
+    challengeExpiresAt: { type: "number" },
+    expiresAt: { type: "number" },
+    pluginSignature: { type: "string" },
+  },
+};
+
+export type EnvelopeV2Type = {
+  v: 2;
+  accountId: string;
+  direction: "plugin_to_app" | "app_to_plugin";
+  counter: number;
+  timestamp: number;
+  dhRatchetKey?: string;
+  ciphertext: string;
+  iv: string;
+  tag: string;
+};
+
+export const EnvelopeV2Schema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["v", "accountId", "direction", "counter", "timestamp", "ciphertext", "iv", "tag"],
+  properties: {
+    v: { const: 2 },
+    accountId: { type: "string" },
+    direction: { enum: ["plugin_to_app", "app_to_plugin"] },
+    counter: { type: "number" },
+    timestamp: { type: "number" },
+    dhRatchetKey: { type: "string" },
+    ciphertext: { type: "string" },
+    iv: { type: "string" },
+    tag: { type: "string" },
+  },
+};
+
+export type PairRequest = {
+  accountId: string;
+  pairingToken: string;
+  appIdentityKey: string;
+  appDhKey: string;
+  appSignature: string;
+};
+
+export const PairRequestSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["accountId", "pairingToken", "appIdentityKey", "appDhKey", "appSignature"],
+  properties: {
+    accountId: { type: "string" },
+    pairingToken: { type: "string" },
+    appIdentityKey: { type: "string" },
+    appDhKey: { type: "string" },
+    appSignature: { type: "string" },
+  },
+};
+
+export type PairingQrPayload = {
+  version: 1;
+  type: "soyeht_pairing_qr";
+  accountId: string;
+  pairingToken: string;
+  expiresAt: number;
+  allowOverwrite: boolean;
+  pluginIdentityKey: string;
+  pluginDhKey: string;
+  fingerprint: string;
+  signature: string;
+};
+
+export const PairingQrPayloadSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "version",
+    "type",
+    "accountId",
+    "pairingToken",
+    "expiresAt",
+    "allowOverwrite",
+    "pluginIdentityKey",
+    "pluginDhKey",
+    "fingerprint",
+    "signature",
+  ],
+  properties: {
+    version: { const: 1 },
+    type: { const: "soyeht_pairing_qr" },
+    accountId: { type: "string" },
+    pairingToken: { type: "string" },
+    expiresAt: { type: "number" },
+    allowOverwrite: { type: "boolean" },
+    pluginIdentityKey: { type: "string" },
+    pluginDhKey: { type: "string" },
+    fingerprint: { type: "string" },
+    signature: { type: "string" },
+  },
+};
+
+export type HandshakeFinishV2 = {
+  version: 2;
+  accountId: string;
+  nonce: string;
+  appSignature: string;
+};
+
+export const HandshakeFinishV2Schema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["version", "accountId", "nonce", "appSignature"],
+  properties: {
+    version: { const: 2 },
+    accountId: { type: "string" },
+    nonce: { type: "string" },
+    appSignature: { type: "string" },
+  },
+};
 
 // ---------------------------------------------------------------------------
 // Channel capabilities

package/src/version.ts

@@ -1 +1 @@
-export const PLUGIN_VERSION = "0.1.1";
+export const PLUGIN_VERSION = "0.1.2";