@recombine-ai/platform 0.2.6-test.8 → 0.3.0

package/build/call-control/sip.js

@@ -0,0 +1,423 @@
+import { RoomAgentDispatch, RoomConfiguration, SipClient, } from 'livekit-server-sdk';
+import createSipSetupLock from './sip-setup-lock';
+import { IncludeHeaders, MediaEncryption, Transport } from './types';
+import { CallControlError, anyOf, computeObjectHash, getLiveKitConnectionOptions, toTitleCase, } from './utils';
+const DEFAULT_TRUNK_CONFIG = {
+    mediaEncryption: MediaEncryption.ALLOW,
+    includeHeaders: IncludeHeaders.ALL_HEADERS,
+};
+var TrunkMeta;
+(function (TrunkMeta) {
+    TrunkMeta["AgentName"] = "agentName";
+    TrunkMeta["Type"] = "trunkType";
+    TrunkMeta["ConfigHash"] = "_configHash";
+})(TrunkMeta || (TrunkMeta = {}));
+export class SipManager {
+    agentName;
+    client;
+    lock;
+    options;
+    trunksConfigHash;
+    logger;
+    constructor(options, logger = console, debugMode = Boolean(process.env.SIP_DEBUG)) {
+        if (debugMode) {
+            populateOptionsFromEnv(options);
+        }
+        const { agentName, livekit = {} } = options;
+        this.agentName = agentName;
+        this.options = options;
+        this.validateOptions();
+        this.trunksConfigHash = computeObjectHash(options.trunks);
+        const { url, key, secret } = getLiveKitConnectionOptions(livekit);
+        this.client = new SipClient(url, key, secret);
+        this.logger = logger;
+        this.lock = createSipSetupLock(url, key, secret, this.logger);
+    }
+    get trunksConfig() {
+        return this.options.trunks;
+    }
+    get trunksConfigDefaultMeta() {
+        return {
+            [TrunkMeta.AgentName]: this.agentName,
+            [TrunkMeta.ConfigHash]: this.trunksConfigHash,
+        };
+    }
+    validateOptions() {
+        const { in: inbound, out: outbound, transfer } = this.trunksConfig ?? {};
+        if (!anyOf(inbound, outbound, transfer)) {
+            throw new SipError('No trunk configured');
+        }
+        if (inbound && !(inbound.numbers ?? []).filter(Boolean).length) {
+            throw new SipError('No phone numbers set for the inbound trunk');
+        }
+        if (transfer && !transfer.server) {
+            throw new SipError('No SIP server set for transfer trunk');
+        }
+        if (outbound && !outbound.server) {
+            throw new SipError('No SIP server set for outbound trunk');
+        }
+        if (this.options.transferRequired) {
+            if (!anyOf(outbound, transfer))
+                throw new SipError('No configuration for the transfer trunk');
+        }
+    }
+    async setup(withCleanup = true) {
+        const agentName = this.agentName;
+        let resources = { agentName };
+        let inboundTrunk, transferTrunk, outboundTrunk, dispatchRule, error;
+        this.logger.info('SIP resources setup started...', { agentName });
+        await this.lock.acquire();
+        try {
+            const existing = await this.getAllResources();
+            if (this.isResourceSetComplete(existing)) {
+                const ownedInbound = existing.inboundTrunks.find(this.isOwnResource);
+                const ownedOutbound = existing.outboundTrunks.find((trunk) => this.isOwnResource(trunk) &&
+                    getMetaValue(trunk.metadata, TrunkMeta.Type) === 'outbound');
+                const ownedTransfer = existing.outboundTrunks.find((trunk) => this.isOwnResource(trunk) &&
+                    getMetaValue(trunk.metadata, TrunkMeta.Type) === 'transfer');
+                const storedHash = getMetaValue((ownedInbound ?? ownedTransfer ?? ownedOutbound)?.metadata, TrunkMeta.ConfigHash);
+                if (storedHash === this.trunksConfigHash) {
+                    this.logger.info('SIP resources unchanged, reusing existing.', {
+                        agentName,
+                        [TrunkMeta.ConfigHash]: storedHash,
+                    });
+                    inboundTrunk = ownedInbound;
+                    transferTrunk = ownedTransfer;
+                    outboundTrunk = ownedOutbound;
+                    dispatchRule = existing.rules.find(this.isOwnResource);
+                }
+            }
+            if (!anyOf(inboundTrunk, transferTrunk, outboundTrunk)) {
+                if (withCleanup) {
+                    await this.cleanup(existing);
+                }
+                if (this.trunksConfig.in) {
+                    await this.resolveNumberConflicts(existing);
+                    inboundTrunk = await this.createInboundTrunk();
+                    if (inboundTrunk) {
+                        dispatchRule = await this.createDispatchRule(inboundTrunk.sipTrunkId);
+                    }
+                }
+                if (this.trunksConfig.transfer) {
+                    transferTrunk = await this.createOutboundTrunk('transfer');
+                }
+                if (this.trunksConfig.out) {
+                    outboundTrunk = await this.createOutboundTrunk('outbound');
+                }
+            }
+            resources = { ...resources, inboundTrunk, transferTrunk, outboundTrunk, dispatchRule };
+        }
+        catch (_error) {
+            error = _error;
+        }
+        finally {
+            await this.lock.release();
+        }
+        if (error) {
+            this.logger.error('SIP resources setup failed!', { error });
+            throw new SipError('Resources setup error', error);
+        }
+        this.logger.info('SIP resources setup completed.', { resources });
+        return resources;
+    }
+    async getTransferTrunkId() {
+        return (await this.client.listSipOutboundTrunk()).find((trunk) => this.isOwnResource(trunk) &&
+            getMetaValue(trunk.metadata, TrunkMeta.Type) === 'transfer')?.sipTrunkId;
+    }
+    async createInboundTrunk() {
+        const agentName = this.agentName;
+        const config = this.trunksConfig.in;
+        const metadata = {
+            ...(config.metadata ?? {}),
+            ...this.trunksConfigDefaultMeta,
+        };
+        const options = {
+            ...DEFAULT_TRUNK_CONFIG,
+            ...config,
+            metadata: JSON.stringify(metadata),
+        };
+        this.logger.info('Creating inbound trunk...', {
+            agentName,
+            numbers: config.numbers,
+            options,
+        });
+        if (config.allowedAddresses) {
+            options.allowedAddresses = config.allowedAddresses;
+        }
+        const trunk = await this.client.createSipInboundTrunk(agentName, config.numbers, options);
+        this.logger.info('Inbound trunk created.', { agentName, ...trunk });
+        return trunk;
+    }
+    async createOutboundTrunk(type = 'transfer') {
+        const agentName = this.agentName;
+        const config = (type === 'transfer' ? this.trunksConfig.transfer : this.trunksConfig.out);
+        const metadata = {
+            ...(config.metadata ?? {}),
+            ...this.trunksConfigDefaultMeta,
+            [TrunkMeta.Type]: type,
+        };
+        const { numbers = ['*'], server, transport = Transport.TCP } = config;
+        const options = {
+            ...DEFAULT_TRUNK_CONFIG,
+            ...config,
+            transport,
+            metadata: JSON.stringify(metadata),
+        };
+        this.logger.info(`Creating ${type} trunk...`, { agentName, numbers, server, options });
+        const trunk = await this.client.createSipOutboundTrunk(`${toTitleCase(type)} trunk for ${agentName}`, server, numbers, options);
+        this.logger.info(`${toTitleCase(type)} trunk created.`, { agentName, ...trunk });
+        return trunk;
+    }
+    async createDispatchRule(trunkId, type = 'individual') {
+        const agentName = this.agentName;
+        const ruleConfig = {
+            type,
+            roomPrefix: this.options.roomPrefix,
+        };
+        const attributes = {
+            ...(this.trunksConfig.in?.metadata ?? {}),
+            ...this.trunksConfigDefaultMeta,
+        };
+        const metadata = JSON.stringify(attributes);
+        this.logger.info('Creating dispatch rule...', {
+            agentName,
+            inboundTrunkId: trunkId,
+            attributes,
+            ruleConfig,
+        });
+        const roomAgentDispatch = new RoomAgentDispatch({
+            agentName: '',
+            metadata,
+        });
+        const options = {
+            trunkIds: [trunkId],
+            metadata,
+            attributes,
+            roomConfig: new RoomConfiguration({ agents: [roomAgentDispatch] }),
+        };
+        const rule = await this.client.createSipDispatchRule(ruleConfig, options);
+        this.logger.info('Dispatch rule created.', { agentName, ...rule });
+        return rule;
+    }
+    async resolveNumberConflicts(preloaded) {
+        const numbers = this.trunksConfig.in.numbers;
+        const all = preloaded ?? (await this.getAllResources());
+        const conflicting = all.inboundTrunks.filter((trunk) => !this.isOwnResource(trunk) && trunk.numbers?.some((n) => numbers.includes(n)));
+        if (conflicting.length === 0)
+            return;
+        const conflictingTrunkIds = new Set(conflicting.map(({ sipTrunkId: id }) => id));
+        const orphanedRules = all.rules.filter((rule) => rule.trunkIds?.some((id) => conflictingTrunkIds.has(id)));
+        for (const rule of orphanedRules) {
+            this.logger.warn('Deleting dispatch rule associated with conflicting trunk', {
+                ruleId: rule.sipDispatchRuleId,
+                owner: getMetaValue(rule.metadata, TrunkMeta.AgentName),
+            });
+            try {
+                await this.deleteDispatchRule(rule.sipDispatchRuleId);
+            }
+            catch (err) {
+                this.logger.error('Failed to delete conflicting dispatch rule', {
+                    ruleId: rule.sipDispatchRuleId,
+                    err,
+                });
+                throw new SipError('Cannot delete dispatch rule', err);
+            }
+        }
+        for (const trunk of conflicting) {
+            this.logger.warn('Deleting inbound trunk with conflicting phone numbers', {
+                trunkId: trunk.sipTrunkId,
+                owner: getMetaValue(trunk.metadata, TrunkMeta.AgentName),
+                conflictingNumbers: trunk.numbers?.filter((n) => numbers.includes(n)),
+            });
+            try {
+                await this.deleteTrunk(trunk.sipTrunkId);
+            }
+            catch (err) {
+                this.logger.error('Failed to delete conflicting inbound trunk', {
+                    trunkId: trunk.sipTrunkId,
+                    err,
+                });
+                throw new SipError('Cannot delete trunk', err);
+            }
+        }
+    }
+    isOwnResource = (resource) => {
+        return getMetaValue(resource.metadata, TrunkMeta.AgentName) === this.agentName;
+    };
+    isResourceSetComplete(resources) {
+        const ownedInbound = resources.inboundTrunks.filter(this.isOwnResource);
+        const ownedOutbound = resources.outboundTrunks.filter(this.isOwnResource);
+        const ownedRules = resources.rules.filter(this.isOwnResource);
+        if (this.trunksConfig.in && (ownedInbound.length === 0 || ownedRules.length === 0)) {
+            return false;
+        }
+        const neededOutbound = (this.trunksConfig.transfer ? 1 : 0) + (this.trunksConfig.out ? 1 : 0);
+        if (neededOutbound > 0 && ownedOutbound.length < neededOutbound)
+            return false;
+        return true;
+    }
+    async cleanup(preloaded) {
+        await this.deleteAllResources(5, 500, preloaded);
+    }
+    async deleteAllResources(maxAttempts = 5, retryInterval = 500, preloaded) {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const all = attempt === 1 && preloaded ? preloaded : await this.getAllResources();
+            const rules = all.rules.filter(this.isOwnResource);
+            const inboundTrunks = all.inboundTrunks.filter(this.isOwnResource);
+            const outboundTrunks = all.outboundTrunks.filter(this.isOwnResource);
+            const trunkIds = new Set([
+                ...inboundTrunks.map((t) => t.sipTrunkId),
+                ...outboundTrunks.map((t) => t.sipTrunkId),
+            ]);
+            this.logger.info('Cleanup: resources found', {
+                attempt,
+                maxAttempts,
+                dispatchRules: rules.length,
+                inboundTrunks: inboundTrunks.length,
+                outboundTrunks: outboundTrunks.length,
+                uniqueTrunks: trunkIds.size,
+            });
+            if (rules.length === 0 && trunkIds.size === 0) {
+                this.logger.info('Cleanup: nothing to delete');
+                return;
+            }
+            for (const rule of rules) {
+                this.logger.info('Cleanup: deleting dispatch rule', { rule });
+                try {
+                    await this.deleteDispatchRule(rule.sipDispatchRuleId);
+                }
+                catch (err) {
+                    this.logger.error('Cleanup: dispatch rule deletion failed (will retry)', {
+                        ruleId: rule.sipDispatchRuleId,
+                        err,
+                    });
+                }
+            }
+            for (const trunk of inboundTrunks) {
+                this.logger.info('Cleanup: deleting inbound trunk', { trunk });
+                try {
+                    await this.deleteTrunk(trunk.sipTrunkId);
+                }
+                catch (err) {
+                    this.logger.error('Cleanup: inbound trunk deletion failed (will retry)', {
+                        trunkId: trunk.sipTrunkId,
+                        err,
+                    });
+                }
+            }
+            for (const trunk of outboundTrunks) {
+                this.logger.info('Cleanup: deleting outbound trunk', { trunk });
+                try {
+                    await this.deleteTrunk(trunk.sipTrunkId);
+                }
+                catch (err) {
+                    this.logger.error('Cleanup: outbound trunk deletion failed (will retry)', {
+                        trunkId: trunk.sipTrunkId,
+                        err,
+                    });
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, retryInterval));
+        }
+        const all = await this.getAllResources();
+        const remainingRules = all.rules.filter(this.isOwnResource);
+        const remainingInbound = all.inboundTrunks.filter(this.isOwnResource);
+        const remainingOutbound = all.outboundTrunks.filter(this.isOwnResource);
+        const remainingTrunkIds = new Set([
+            ...remainingInbound.map(({ sipTrunkId }) => sipTrunkId),
+            ...remainingOutbound.map(({ sipTrunkId }) => sipTrunkId),
+        ]);
+        this.logger.error('Cleanup: resources still remain after retries', {
+            dispatchRules: remainingRules.length,
+            inboundTrunks: remainingInbound.length,
+            outboundTrunks: remainingOutbound.length,
+            uniqueTrunks: remainingTrunkIds.size,
+        });
+        throw new SipError(`Failed to delete all SIP trunks/dispatch rules after ${maxAttempts} attempts`);
+    }
+    async getAllResources() {
+        const [rules, inboundTrunks, outboundTrunks] = await Promise.all([
+            this.client.listSipDispatchRule(),
+            this.client.listSipInboundTrunk(),
+            this.client.listSipOutboundTrunk(),
+        ]);
+        return { rules, inboundTrunks, outboundTrunks };
+    }
+    async deleteTrunk(trunkId) {
+        try {
+            await this.client.deleteSipTrunk(trunkId);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('not found')) {
+                this.logger.info('Trunk was deleted previously', { trunkId });
+                return;
+            }
+            this.logger.error('Failed to delete trunk', { trunkId, err });
+            throw new SipError('Failed to delete trunk', err);
+        }
+        this.logger.info('Trunk deleted', { trunkId });
+    }
+    async deleteDispatchRule(ruleId) {
+        try {
+            await this.client.deleteSipDispatchRule(ruleId);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('not found')) {
+                this.logger.info('Dispatch rule was deleted previously', { ruleId });
+                return;
+            }
+            this.logger.error('Failed to delete dispatch rule', { ruleId, err });
+            throw new SipError('Failed to delete dispatch rule', err);
+        }
+        this.logger.info('Dispatch rule deleted', { ruleId });
+    }
+}
+function getMetaValue(metadata, key) {
+    if (!metadata) {
+        return undefined;
+    }
+    try {
+        const meta = JSON.parse(metadata);
+        return meta[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export class SipError extends CallControlError {
+    constructor(message, cause) {
+        super(message, cause);
+        this.name = 'SipError';
+    }
+}
+export function populateOptionsFromEnv(options = {}, parse = JSON.parse) {
+    const { SIP_ROOM_PREFIX: roomPrefix, SIP_INBOUND_NUMBERS: inboundNumbers, SIP_INBOUND_ALLOWED_NUMBERS: inboundAllowedNumbers, SIP_INBOUND_ALLOWED_ADDRESSES: inboundAllowedAddresses, SIP_INBOUND_AUTH_USERNAME: inboundAuthUsername, SIP_INBOUND_AUTH_PASSWORD: inboundAuthPassword, SIP_INBOUND_METADATA: inboundMetadata, SIP_INBOUND_MEDIA_ENCRYPTION: inboundMediaEncryption, SIP_INBOUND_HEADERS: inboundHeaders, SIP_INBOUND_HEADERS_TO_ATTRS: inboundHeadersToAttrs, SIP_INBOUND_ATTRS_TO_HEADERS: inboundAttrsToHeaders, } = process.env;
+    if (roomPrefix && !options.roomPrefix) {
+        options.roomPrefix = roomPrefix;
+    }
+    const inbound = (options.trunks?.in ?? {});
+    if (inboundNumbers)
+        inbound.numbers = parse(inboundNumbers);
+    if (inboundAllowedNumbers)
+        inbound.allowedNumbers = parse(inboundAllowedNumbers);
+    if (inboundAllowedAddresses)
+        inbound.allowedAddresses = parse(inboundAllowedAddresses);
+    if (inboundAuthUsername)
+        inbound.authUsername = inboundAuthUsername;
+    if (inboundAuthPassword)
+        inbound.authPassword = inboundAuthPassword;
+    if (inboundMetadata)
+        inbound.metadata = parse(inboundMetadata);
+    if (inboundMediaEncryption)
+        inbound.mediaEncryption = Number(inboundMediaEncryption);
+    if (inboundHeaders)
+        inbound.headers = parse(inboundHeaders);
+    if (inboundHeadersToAttrs)
+        inbound.headersToAttributes = parse(inboundHeadersToAttrs);
+    if (inboundAttrsToHeaders)
+        inbound.attributesToHeaders = parse(inboundAttrsToHeaders);
+    if (Object.keys(inbound).length) {
+        options.trunks = { ...(options.trunks ?? {}), in: inbound };
+    }
+    return options;
+}