@wingman-ai/gateway 0.4.2 → 0.4.4

package/dist/gateway/sms/commands.js

@@ -0,0 +1,79 @@
+const MINUTE_MS = 60000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+const MAX_PAUSE_DURATION_MS = 30 * DAY_MS;
+function parsePauseDurationMs(raw) {
+    const trimmed = raw.trim();
+    const match = trimmed.match(/^(\d+)\s*([mhd])$/i);
+    if (!match) return null;
+    const amount = Number(match[1]);
+    if (!Number.isInteger(amount) || amount <= 0) return null;
+    const unit = match[2].toLowerCase();
+    const multiplier = "m" === unit ? MINUTE_MS : "h" === unit ? HOUR_MS : DAY_MS;
+    const durationMs = amount * multiplier;
+    if (durationMs <= 0 || durationMs > MAX_PAUSE_DURATION_MS) return null;
+    return durationMs;
+}
+function interpretSmsInboundMessage(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) return {
+        type: "text",
+        content: ""
+    };
+    if (trimmed.startsWith("\\")) return {
+        type: "text",
+        content: trimmed.slice(1).trimStart()
+    };
+    const normalized = trimmed.toLowerCase();
+    if ("help" === normalized) return {
+        type: "command",
+        command: {
+            name: "help"
+        }
+    };
+    if ("status" === normalized) return {
+        type: "command",
+        command: {
+            name: "status"
+        }
+    };
+    if ("resume" === normalized) return {
+        type: "command",
+        command: {
+            name: "resume"
+        }
+    };
+    if ("stop" === normalized) return {
+        type: "command",
+        command: {
+            name: "stop"
+        }
+    };
+    const pauseMatch = trimmed.match(/^pause(?:\s+(.+))?$/i);
+    if (pauseMatch) {
+        const durationRaw = pauseMatch[1]?.trim();
+        if (!durationRaw) return {
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: null
+            }
+        };
+        const durationMs = parsePauseDurationMs(durationRaw);
+        if (null !== durationMs) return {
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs
+            }
+        };
+    }
+    return {
+        type: "text",
+        content: trimmed
+    };
+}
+function buildSmsHelpMessage() {
+    return 'Commands:\n- STATUS\n- PAUSE [15m|2h|1d]\n- RESUME\n- STOP\n- HELP\nUse "\\<command>" to send a command word as normal text.';
+}
+export { buildSmsHelpMessage, interpretSmsInboundMessage };

package/dist/gateway/sms/control.cjs

@@ -0,0 +1,118 @@
+"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__, {
+    applySmsControlCommand: ()=>applySmsControlCommand
+});
+const external_commands_cjs_namespaceObject = require("./commands.cjs");
+function formatPauseRemaining(untilMs, nowMs) {
+    const remaining = Math.max(untilMs - nowMs, 0);
+    const totalMinutes = Math.ceil(remaining / 60000);
+    if (totalMinutes < 60) return `${totalMinutes}m`;
+    const hours = Math.ceil(totalMinutes / 60);
+    if (hours < 24) return `${hours}h`;
+    const days = Math.ceil(hours / 24);
+    return `${days}d`;
+}
+function formatPolicyStatus(policy, nowMs) {
+    const lines = [
+        `SMS status for ${policy.target}:`,
+        `- stop: ${policy.stopEnabled ? "enabled" : "disabled"}`
+    ];
+    if (policy.paused) if (policy.pausedUntil) lines.push(`- proactive alerts: paused (${formatPauseRemaining(policy.pausedUntil, nowMs)} remaining)`);
+    else lines.push("- proactive alerts: paused (until RESUME)");
+    else lines.push("- proactive alerts: active");
+    lines.push(`- alert mode: ${policy.alertMode}`);
+    return lines.join("\n");
+}
+function applySmsControlCommand(params) {
+    const { store, target, text, nowMs = Date.now() } = params;
+    const parsed = (0, external_commands_cjs_namespaceObject.interpretSmsInboundMessage)(text);
+    if ("text" === parsed.type) return {
+        handled: false,
+        passThroughText: parsed.content,
+        policy: store.resolve(target, nowMs)
+    };
+    const command = parsed.command;
+    if ("help" === command.name) {
+        const policy = store.resolve(target, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: (0, external_commands_cjs_namespaceObject.buildSmsHelpMessage)(),
+            policy
+        };
+    }
+    if ("status" === command.name) {
+        const policy = store.resolve(target, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: formatPolicyStatus(policy, nowMs),
+            policy
+        };
+    }
+    if ("pause" === command.name) {
+        const pausedUntil = "number" == typeof command.durationMs ? nowMs + command.durationMs : null;
+        const policy = store.upsert(target, {
+            paused: true,
+            pausedUntil
+        }, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: pausedUntil ? `Proactive SMS alerts paused for ${formatPauseRemaining(pausedUntil, nowMs)}.` : "Proactive SMS alerts paused until you send RESUME.",
+            policy
+        };
+    }
+    if ("resume" === command.name) {
+        const policy = store.upsert(target, {
+            paused: false,
+            pausedUntil: null
+        }, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: "Proactive SMS alerts resumed.",
+            policy
+        };
+    }
+    const policy = store.upsert(target, {
+        stopEnabled: true
+    }, nowMs);
+    return {
+        handled: true,
+        command,
+        responseText: "SMS chat is now stopped for this sender. Re-enable in Wingman settings/API.",
+        policy
+    };
+}
+exports.applySmsControlCommand = __webpack_exports__.applySmsControlCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applySmsControlCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/sms/control.d.ts

@@ -0,0 +1,18 @@
+import { type SmsControlCommand } from "./commands.js";
+import type { SmsPolicyRecord, SmsPolicyStore } from "./policyStore.js";
+export type SmsControlResolution = {
+    handled: false;
+    passThroughText: string;
+    policy: SmsPolicyRecord;
+} | {
+    handled: true;
+    command: SmsControlCommand;
+    responseText: string;
+    policy: SmsPolicyRecord;
+};
+export declare function applySmsControlCommand(params: {
+    store: SmsPolicyStore;
+    target: string;
+    text: string;
+    nowMs?: number;
+}): SmsControlResolution;

package/dist/gateway/sms/control.js

@@ -0,0 +1,84 @@
+import { buildSmsHelpMessage, interpretSmsInboundMessage } from "./commands.js";
+function formatPauseRemaining(untilMs, nowMs) {
+    const remaining = Math.max(untilMs - nowMs, 0);
+    const totalMinutes = Math.ceil(remaining / 60000);
+    if (totalMinutes < 60) return `${totalMinutes}m`;
+    const hours = Math.ceil(totalMinutes / 60);
+    if (hours < 24) return `${hours}h`;
+    const days = Math.ceil(hours / 24);
+    return `${days}d`;
+}
+function formatPolicyStatus(policy, nowMs) {
+    const lines = [
+        `SMS status for ${policy.target}:`,
+        `- stop: ${policy.stopEnabled ? "enabled" : "disabled"}`
+    ];
+    if (policy.paused) if (policy.pausedUntil) lines.push(`- proactive alerts: paused (${formatPauseRemaining(policy.pausedUntil, nowMs)} remaining)`);
+    else lines.push("- proactive alerts: paused (until RESUME)");
+    else lines.push("- proactive alerts: active");
+    lines.push(`- alert mode: ${policy.alertMode}`);
+    return lines.join("\n");
+}
+function applySmsControlCommand(params) {
+    const { store, target, text, nowMs = Date.now() } = params;
+    const parsed = interpretSmsInboundMessage(text);
+    if ("text" === parsed.type) return {
+        handled: false,
+        passThroughText: parsed.content,
+        policy: store.resolve(target, nowMs)
+    };
+    const command = parsed.command;
+    if ("help" === command.name) {
+        const policy = store.resolve(target, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: buildSmsHelpMessage(),
+            policy
+        };
+    }
+    if ("status" === command.name) {
+        const policy = store.resolve(target, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: formatPolicyStatus(policy, nowMs),
+            policy
+        };
+    }
+    if ("pause" === command.name) {
+        const pausedUntil = "number" == typeof command.durationMs ? nowMs + command.durationMs : null;
+        const policy = store.upsert(target, {
+            paused: true,
+            pausedUntil
+        }, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: pausedUntil ? `Proactive SMS alerts paused for ${formatPauseRemaining(pausedUntil, nowMs)}.` : "Proactive SMS alerts paused until you send RESUME.",
+            policy
+        };
+    }
+    if ("resume" === command.name) {
+        const policy = store.upsert(target, {
+            paused: false,
+            pausedUntil: null
+        }, nowMs);
+        return {
+            handled: true,
+            command,
+            responseText: "Proactive SMS alerts resumed.",
+            policy
+        };
+    }
+    const policy = store.upsert(target, {
+        stopEnabled: true
+    }, nowMs);
+    return {
+        handled: true,
+        command,
+        responseText: "SMS chat is now stopped for this sender. Re-enable in Wingman settings/API.",
+        policy
+    };
+}
+export { applySmsControlCommand };

package/dist/gateway/sms/policyStore.cjs

@@ -0,0 +1,198 @@
+"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__, {
+    createSmsPolicyStore: ()=>createSmsPolicyStore,
+    normalizeSmsPolicyTarget: ()=>normalizeSmsPolicyTarget
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const MAX_TARGET_LENGTH = 256;
+const MINUTE_LIMIT = 1439;
+function isAlertMode(value) {
+    return "off" === value || "important-only" === value || "all" === value;
+}
+function normalizeQuietHours(value) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    const candidate = value;
+    const startMinute = "number" == typeof candidate.startMinute ? candidate.startMinute : NaN;
+    const endMinute = "number" == typeof candidate.endMinute ? candidate.endMinute : NaN;
+    if (!Number.isInteger(startMinute) || startMinute < 0 || startMinute > MINUTE_LIMIT || !Number.isInteger(endMinute) || endMinute < 0 || endMinute > MINUTE_LIMIT) return null;
+    return {
+        enabled: false !== candidate.enabled,
+        startMinute,
+        endMinute,
+        timezone: "string" == typeof candidate.timezone && candidate.timezone.trim() ? candidate.timezone.trim() : void 0
+    };
+}
+function normalizeTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.length > MAX_TARGET_LENGTH) return null;
+    return trimmed;
+}
+function normalizeSmsPolicyTarget(raw) {
+    return normalizeTarget(raw);
+}
+function createDefaultPolicy(target, nowMs) {
+    return {
+        target,
+        paused: false,
+        pausedUntil: null,
+        stopEnabled: false,
+        alertMode: "important-only",
+        quietHours: null,
+        createdAt: nowMs,
+        updatedAt: nowMs
+    };
+}
+function parsePolicyRecord(entry) {
+    if (!entry || "object" != typeof entry || Array.isArray(entry)) return null;
+    const typed = entry;
+    const target = "string" == typeof typed.target ? normalizeTarget(typed.target) : null;
+    if (!target) return null;
+    const createdAt = "number" == typeof typed.createdAt && Number.isFinite(typed.createdAt) ? typed.createdAt : Date.now();
+    const updatedAt = "number" == typeof typed.updatedAt && Number.isFinite(typed.updatedAt) ? typed.updatedAt : createdAt;
+    const paused = true === typed.paused;
+    const pausedUntil = "number" == typeof typed.pausedUntil && Number.isFinite(typed.pausedUntil) ? Math.trunc(typed.pausedUntil) : null;
+    return {
+        target,
+        paused,
+        pausedUntil: paused ? pausedUntil : null,
+        stopEnabled: true === typed.stopEnabled,
+        alertMode: isAlertMode(typed.alertMode) ? typed.alertMode : "important-only",
+        quietHours: normalizeQuietHours(typed.quietHours),
+        createdAt,
+        updatedAt
+    };
+}
+function resolveExpiredPause(record, nowMs) {
+    if (!record.paused || null === record.pausedUntil || record.pausedUntil > nowMs) return record;
+    return {
+        ...record,
+        paused: false,
+        pausedUntil: null,
+        updatedAt: nowMs
+    };
+}
+const createSmsPolicyStore = (resolveConfigDirPath)=>{
+    const resolvePath = ()=>{
+        const configDir = resolveConfigDirPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)(configDir, {
+            recursive: true
+        });
+        return (0, external_node_path_namespaceObject.join)(configDir, "sms-policies.json");
+    };
+    const readRecords = ()=>{
+        const path = resolvePath();
+        if (!(0, external_node_fs_namespaceObject.existsSync)(path)) return [];
+        try {
+            const raw = (0, external_node_fs_namespaceObject.readFileSync)(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) return [];
+            const records = [];
+            for (const entry of parsed){
+                const record = parsePolicyRecord(entry);
+                if (record) records.push(record);
+            }
+            return records;
+        } catch  {
+            return [];
+        }
+    };
+    const writeRecords = (records)=>{
+        const path = resolvePath();
+        (0, external_node_fs_namespaceObject.writeFileSync)(path, JSON.stringify(records, null, 2));
+    };
+    const replaceRecord = (records, nextRecord)=>{
+        const index = records.findIndex((record)=>record.target === nextRecord.target);
+        if (index >= 0) records[index] = nextRecord;
+        else records.unshift(nextRecord);
+        return records;
+    };
+    const resolveRecord = (target, nowMs = Date.now())=>{
+        const normalizedTarget = normalizeTarget(target);
+        if (!normalizedTarget) return createDefaultPolicy("unknown", nowMs);
+        const records = readRecords();
+        const existing = records.find((record)=>record.target === normalizedTarget);
+        if (!existing) return createDefaultPolicy(normalizedTarget, nowMs);
+        const resolved = resolveExpiredPause(existing, nowMs);
+        if (resolved !== existing) writeRecords(replaceRecord(records, resolved));
+        return resolved;
+    };
+    return {
+        load: ()=>readRecords(),
+        save: (records)=>writeRecords(records),
+        list: ()=>readRecords(),
+        get: (target)=>{
+            const normalizedTarget = normalizeTarget(target);
+            if (!normalizedTarget) return null;
+            return readRecords().find((record)=>record.target === normalizedTarget) || null;
+        },
+        resolve: (target, nowMs = Date.now())=>resolveRecord(target, nowMs),
+        upsert: (target, patch, nowMs = Date.now())=>{
+            const normalizedTarget = normalizeTarget(target);
+            if (!normalizedTarget) throw new Error("Invalid SMS policy target");
+            const records = readRecords();
+            const existing = records.find((record)=>record.target === normalizedTarget);
+            const base = existing || createDefaultPolicy(normalizedTarget, nowMs);
+            const next = {
+                ...base,
+                updatedAt: nowMs
+            };
+            if ("boolean" == typeof patch.paused) next.paused = patch.paused;
+            if (Object.hasOwn(patch, "pausedUntil")) {
+                const value = patch.pausedUntil;
+                if ("number" == typeof value && Number.isFinite(value)) next.pausedUntil = Math.trunc(value);
+                else next.pausedUntil = null;
+            }
+            if ("boolean" == typeof patch.stopEnabled) next.stopEnabled = patch.stopEnabled;
+            if (isAlertMode(patch.alertMode)) next.alertMode = patch.alertMode;
+            if (Object.hasOwn(patch, "quietHours")) next.quietHours = patch.quietHours ? normalizeQuietHours(patch.quietHours) : null;
+            if (!next.paused) next.pausedUntil = null;
+            const resolved = resolveExpiredPause(next, nowMs);
+            writeRecords(replaceRecord(records, resolved));
+            return resolved;
+        },
+        reset: (target)=>{
+            const normalizedTarget = normalizeTarget(target);
+            if (!normalizedTarget) return;
+            const records = readRecords();
+            const filtered = records.filter((record)=>record.target !== normalizedTarget);
+            if (filtered.length === records.length) return;
+            writeRecords(filtered);
+        },
+        isPaused: (target, nowMs = Date.now())=>resolveRecord(target, nowMs).paused,
+        isStopped: (target, nowMs = Date.now())=>resolveRecord(target, nowMs).stopEnabled
+    };
+};
+exports.createSmsPolicyStore = __webpack_exports__.createSmsPolicyStore;
+exports.normalizeSmsPolicyTarget = __webpack_exports__.normalizeSmsPolicyTarget;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSmsPolicyStore",
+    "normalizeSmsPolicyTarget"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/sms/policyStore.d.ts

@@ -0,0 +1,37 @@
+export type SmsAlertMode = "off" | "important-only" | "all";
+export type SmsQuietHours = {
+    enabled: boolean;
+    startMinute: number;
+    endMinute: number;
+    timezone?: string;
+};
+export type SmsPolicyRecord = {
+    target: string;
+    paused: boolean;
+    pausedUntil: number | null;
+    stopEnabled: boolean;
+    alertMode: SmsAlertMode;
+    quietHours: SmsQuietHours | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type SmsPolicyPatch = {
+    paused?: boolean;
+    pausedUntil?: number | null;
+    stopEnabled?: boolean;
+    alertMode?: SmsAlertMode;
+    quietHours?: unknown;
+};
+export type SmsPolicyStore = {
+    load: () => SmsPolicyRecord[];
+    save: (records: SmsPolicyRecord[]) => void;
+    list: () => SmsPolicyRecord[];
+    get: (target: string) => SmsPolicyRecord | null;
+    resolve: (target: string, nowMs?: number) => SmsPolicyRecord;
+    upsert: (target: string, patch: SmsPolicyPatch, nowMs?: number) => SmsPolicyRecord;
+    reset: (target: string) => void;
+    isPaused: (target: string, nowMs?: number) => boolean;
+    isStopped: (target: string, nowMs?: number) => boolean;
+};
+export declare function normalizeSmsPolicyTarget(raw: string): string | null;
+export declare const createSmsPolicyStore: (resolveConfigDirPath: () => string) => SmsPolicyStore;