@wingman-ai/gateway 0.1.0

package/dist/gateway/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/types.d.ts

@@ -0,0 +1,215 @@
+import type { ServerWebSocket } from "bun";
+/**
+ * Message types for gateway communication
+ */
+export type MessageType = "connect" | "res" | "req:agent" | "event:agent" | "session_subscribe" | "session_unsubscribe" | "register" | "registered" | "unregister" | "join_group" | "leave_group" | "broadcast" | "direct" | "ping" | "pong" | "error" | "ack" | "upgrade";
+/**
+ * Gateway message structure
+ */
+export interface GatewayMessage {
+    type: MessageType;
+    id?: string;
+    client?: GatewayClientInfo;
+    auth?: GatewayAuthPayload;
+    ok?: boolean;
+    clientId?: string;
+    nodeId?: string;
+    groupId?: string;
+    roomId?: string;
+    targetNodeId?: string;
+    payload?: unknown;
+    timestamp: number;
+    messageId?: string;
+}
+export interface GatewayClientInfo {
+    instanceId: string;
+    clientType: string;
+    version?: string;
+}
+export interface GatewayAuthPayload {
+    token?: string;
+    password?: string;
+    deviceId?: string;
+}
+export interface ImageAttachment {
+    kind?: "image";
+    dataUrl: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+}
+export interface AudioAttachment {
+    kind: "audio";
+    dataUrl: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+}
+export type MediaAttachment = ImageAttachment | AudioAttachment;
+export interface AgentRequestPayload {
+    agentId?: string;
+    content?: string;
+    attachments?: MediaAttachment[];
+    routing?: RoutingInfo;
+    sessionKey?: string;
+}
+export interface RoutingPeer {
+    kind: "dm" | "group" | "channel";
+    id: string;
+}
+export interface RoutingInfo {
+    channel: string;
+    accountId?: string;
+    guildId?: string;
+    teamId?: string;
+    peer?: RoutingPeer;
+    threadId?: string;
+}
+/**
+ * Node metadata
+ */
+export interface NodeMetadata {
+    id: string;
+    name: string;
+    capabilities?: string[];
+    groups: Set<string>;
+    connectedAt: number;
+    lastPing?: number;
+    messageCount?: number;
+    lastMessageTime?: number;
+    sessionId?: string;
+    agentName?: string;
+}
+/**
+ * Node with WebSocket connection
+ */
+export interface Node extends NodeMetadata {
+    ws: ServerWebSocket<{
+        nodeId: string;
+    }>;
+}
+/**
+ * Broadcast processing strategy
+ */
+export type BroadcastStrategy = "parallel" | "sequential";
+/**
+ * Broadcast group
+ */
+export interface BroadcastGroup {
+    id: string;
+    name: string;
+    description?: string;
+    createdAt: number;
+    createdBy: string;
+    members: Set<string>;
+    strategy: BroadcastStrategy;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Gateway configuration
+ */
+export interface GatewayConfig {
+    port: number;
+    host: string;
+    authToken?: string;
+    requireAuth?: boolean;
+    auth?: GatewayAuthConfig;
+    stateDir?: string;
+    workspace?: string;
+    configDir?: string;
+    fsRoots?: string[];
+    maxNodes?: number;
+    pingInterval?: number;
+    pingTimeout?: number;
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+    discovery?: {
+        enabled: boolean;
+        method: "mdns" | "tailscale";
+        name: string;
+    };
+}
+export interface GatewayAuthConfig {
+    mode: "token" | "password" | "none";
+    token?: string;
+    password?: string;
+    allowTailscale?: boolean;
+}
+/**
+ * Gateway statistics
+ */
+export interface GatewayStats {
+    uptime: number;
+    totalNodes: number;
+    totalGroups: number;
+    messagesProcessed: number;
+    startedAt: number;
+    activeSessions?: number;
+    sessionNodes?: Array<{
+        sessionId: string;
+        agentName?: string;
+        nodeIds: string[];
+    }>;
+}
+/**
+ * Registration request payload
+ */
+export interface RegisterPayload {
+    name: string;
+    capabilities?: string[];
+    token?: string;
+    sessionId?: string;
+    agentName?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SessionSubscriptionPayload {
+    sessionId: string;
+}
+/**
+ * Join group request payload
+ */
+export interface JoinGroupPayload {
+    groupId?: string;
+    groupName?: string;
+    createIfNotExists?: boolean;
+    description?: string;
+}
+/**
+ * Broadcast message payload
+ */
+export interface BroadcastPayload {
+    groupId: string;
+    message: unknown;
+}
+/**
+ * Direct message payload
+ */
+export interface DirectPayload {
+    targetNodeId: string;
+    message: unknown;
+}
+/**
+ * Error payload
+ */
+export interface ErrorPayload {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+/**
+ * Health check response
+ */
+export interface HealthResponse {
+    status: "healthy" | "degraded" | "unhealthy";
+    version: string;
+    stats: GatewayStats;
+    timestamp: number;
+}
+/**
+ * Daemon status
+ */
+export interface DaemonStatus {
+    running: boolean;
+    pid?: number;
+    uptime?: number;
+    config?: GatewayConfig;
+}

package/dist/gateway/validation.cjs

@@ -0,0 +1,225 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DirectPayloadSchema: ()=>DirectPayloadSchema,
+    validateDirectPayload: ()=>validateDirectPayload,
+    validateJoinGroupPayload: ()=>validateJoinGroupPayload,
+    MessageTypeSchema: ()=>MessageTypeSchema,
+    validateBroadcastPayload: ()=>validateBroadcastPayload,
+    validateRegisterPayload: ()=>validateRegisterPayload,
+    GatewayMessageSchema: ()=>GatewayMessageSchema,
+    JoinGroupPayloadSchema: ()=>JoinGroupPayloadSchema,
+    ErrorPayloadSchema: ()=>ErrorPayloadSchema,
+    validateGatewayMessage: ()=>validateGatewayMessage,
+    RegisterPayloadSchema: ()=>RegisterPayloadSchema,
+    BroadcastPayloadSchema: ()=>BroadcastPayloadSchema
+});
+const external_zod_namespaceObject = require("zod");
+const MessageTypeSchema = external_zod_namespaceObject.z["enum"]([
+    "connect",
+    "res",
+    "req:agent",
+    "event:agent",
+    "session_subscribe",
+    "session_unsubscribe",
+    "register",
+    "registered",
+    "unregister",
+    "join_group",
+    "leave_group",
+    "broadcast",
+    "direct",
+    "ping",
+    "pong",
+    "error",
+    "ack"
+]);
+const GatewayMessageSchema = external_zod_namespaceObject.z.object({
+    type: MessageTypeSchema,
+    id: external_zod_namespaceObject.z.string().optional(),
+    client: external_zod_namespaceObject.z.object({
+        instanceId: external_zod_namespaceObject.z.string().min(1),
+        clientType: external_zod_namespaceObject.z.string().min(1),
+        version: external_zod_namespaceObject.z.string().optional()
+    }).optional(),
+    auth: external_zod_namespaceObject.z.object({
+        token: external_zod_namespaceObject.z.string().optional(),
+        password: external_zod_namespaceObject.z.string().optional(),
+        deviceId: external_zod_namespaceObject.z.string().optional()
+    }).optional(),
+    ok: external_zod_namespaceObject.z.boolean().optional(),
+    clientId: external_zod_namespaceObject.z.string().optional(),
+    nodeId: external_zod_namespaceObject.z.string().optional(),
+    groupId: external_zod_namespaceObject.z.string().optional(),
+    roomId: external_zod_namespaceObject.z.string().optional(),
+    targetNodeId: external_zod_namespaceObject.z.string().optional(),
+    payload: external_zod_namespaceObject.z.unknown().optional(),
+    timestamp: external_zod_namespaceObject.z.number(),
+    messageId: external_zod_namespaceObject.z.string().optional()
+});
+const RegisterPayloadSchema = external_zod_namespaceObject.z.object({
+    name: external_zod_namespaceObject.z.string().min(1).max(100),
+    capabilities: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    token: external_zod_namespaceObject.z.string().optional()
+});
+const JoinGroupPayloadSchema = external_zod_namespaceObject.z.object({
+    groupId: external_zod_namespaceObject.z.string().optional(),
+    groupName: external_zod_namespaceObject.z.string().min(1).max(100).optional(),
+    createIfNotExists: external_zod_namespaceObject.z.boolean().optional(),
+    description: external_zod_namespaceObject.z.string().max(500).optional()
+});
+const BroadcastPayloadSchema = external_zod_namespaceObject.z.object({
+    groupId: external_zod_namespaceObject.z.string().min(1),
+    message: external_zod_namespaceObject.z.unknown()
+});
+const DirectPayloadSchema = external_zod_namespaceObject.z.object({
+    targetNodeId: external_zod_namespaceObject.z.string().min(1),
+    message: external_zod_namespaceObject.z.unknown()
+});
+const ErrorPayloadSchema = external_zod_namespaceObject.z.object({
+    code: external_zod_namespaceObject.z.string().min(1),
+    message: external_zod_namespaceObject.z.string().min(1),
+    details: external_zod_namespaceObject.z.unknown().optional()
+});
+function validateGatewayMessage(data) {
+    try {
+        const result = GatewayMessageSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid message format: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateRegisterPayload(data) {
+    try {
+        const result = RegisterPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid register payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateJoinGroupPayload(data) {
+    try {
+        const result = JoinGroupPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid join group payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateBroadcastPayload(data) {
+    try {
+        const result = BroadcastPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid broadcast payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateDirectPayload(data) {
+    try {
+        const result = DirectPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid direct payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+exports.BroadcastPayloadSchema = __webpack_exports__.BroadcastPayloadSchema;
+exports.DirectPayloadSchema = __webpack_exports__.DirectPayloadSchema;
+exports.ErrorPayloadSchema = __webpack_exports__.ErrorPayloadSchema;
+exports.GatewayMessageSchema = __webpack_exports__.GatewayMessageSchema;
+exports.JoinGroupPayloadSchema = __webpack_exports__.JoinGroupPayloadSchema;
+exports.MessageTypeSchema = __webpack_exports__.MessageTypeSchema;
+exports.RegisterPayloadSchema = __webpack_exports__.RegisterPayloadSchema;
+exports.validateBroadcastPayload = __webpack_exports__.validateBroadcastPayload;
+exports.validateDirectPayload = __webpack_exports__.validateDirectPayload;
+exports.validateGatewayMessage = __webpack_exports__.validateGatewayMessage;
+exports.validateJoinGroupPayload = __webpack_exports__.validateJoinGroupPayload;
+exports.validateRegisterPayload = __webpack_exports__.validateRegisterPayload;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BroadcastPayloadSchema",
+    "DirectPayloadSchema",
+    "ErrorPayloadSchema",
+    "GatewayMessageSchema",
+    "JoinGroupPayloadSchema",
+    "MessageTypeSchema",
+    "RegisterPayloadSchema",
+    "validateBroadcastPayload",
+    "validateDirectPayload",
+    "validateGatewayMessage",
+    "validateJoinGroupPayload",
+    "validateRegisterPayload"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/validation.d.ts

@@ -0,0 +1,157 @@
+import { z } from "zod";
+import type { GatewayMessage, RegisterPayload, JoinGroupPayload, BroadcastPayload, DirectPayload } from "./types.js";
+/**
+ * Message type enum for validation
+ */
+export declare const MessageTypeSchema: z.ZodEnum<{
+    error: "error";
+    connect: "connect";
+    res: "res";
+    "req:agent": "req:agent";
+    "event:agent": "event:agent";
+    session_subscribe: "session_subscribe";
+    session_unsubscribe: "session_unsubscribe";
+    register: "register";
+    registered: "registered";
+    unregister: "unregister";
+    join_group: "join_group";
+    leave_group: "leave_group";
+    broadcast: "broadcast";
+    direct: "direct";
+    ping: "ping";
+    pong: "pong";
+    ack: "ack";
+}>;
+/**
+ * Base gateway message schema
+ */
+export declare const GatewayMessageSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        error: "error";
+        connect: "connect";
+        res: "res";
+        "req:agent": "req:agent";
+        "event:agent": "event:agent";
+        session_subscribe: "session_subscribe";
+        session_unsubscribe: "session_unsubscribe";
+        register: "register";
+        registered: "registered";
+        unregister: "unregister";
+        join_group: "join_group";
+        leave_group: "leave_group";
+        broadcast: "broadcast";
+        direct: "direct";
+        ping: "ping";
+        pong: "pong";
+        ack: "ack";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    client: z.ZodOptional<z.ZodObject<{
+        instanceId: z.ZodString;
+        clientType: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        token: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        deviceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ok: z.ZodOptional<z.ZodBoolean>;
+    clientId: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    roomId: z.ZodOptional<z.ZodString>;
+    targetNodeId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    timestamp: z.ZodNumber;
+    messageId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Registration payload schema
+ */
+export declare const RegisterPayloadSchema: z.ZodObject<{
+    name: z.ZodString;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Join group payload schema
+ */
+export declare const JoinGroupPayloadSchema: z.ZodObject<{
+    groupId: z.ZodOptional<z.ZodString>;
+    groupName: z.ZodOptional<z.ZodString>;
+    createIfNotExists: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Broadcast payload schema
+ */
+export declare const BroadcastPayloadSchema: z.ZodObject<{
+    groupId: z.ZodString;
+    message: z.ZodUnknown;
+}, z.core.$strip>;
+/**
+ * Direct message payload schema
+ */
+export declare const DirectPayloadSchema: z.ZodObject<{
+    targetNodeId: z.ZodString;
+    message: z.ZodUnknown;
+}, z.core.$strip>;
+/**
+ * Error payload schema
+ */
+export declare const ErrorPayloadSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Validate a gateway message
+ */
+export declare function validateGatewayMessage(data: unknown): {
+    success: true;
+    data: GatewayMessage;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Validate registration payload
+ */
+export declare function validateRegisterPayload(data: unknown): {
+    success: true;
+    data: RegisterPayload;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Validate join group payload
+ */
+export declare function validateJoinGroupPayload(data: unknown): {
+    success: true;
+    data: JoinGroupPayload;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Validate broadcast payload
+ */
+export declare function validateBroadcastPayload(data: unknown): {
+    success: true;
+    data: BroadcastPayload;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Validate direct message payload
+ */
+export declare function validateDirectPayload(data: unknown): {
+    success: true;
+    data: DirectPayload;
+} | {
+    success: false;
+    error: string;
+};