@gibme/asterisk-gateway-interface 1.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016-2022 Brandon Lehmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# Simple [Asterisk Gateway Interface](https://wiki.asterisk.org/wiki/pages/viewpage.action?pageId=32375589) Helper
+
+```typescript
+import AGI, { Channel } from '@gibme/asterisk-gateway-interface';
+
+(async () => {
+    const agi = new AMI({
+        port: 3000
+    });
+    
+    agi.on('channel', async (channel: Channel) => {
+        await channel.answer();
+        await channel.sayNumber(12345);
+        await channel.hangup();
+    });
+    
+    await agi.start();
+})()
+```

package/dist/asterisk-gateway-interface.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import Channel from './channel';
+export { Channel };
+export { ChannelState, DialStatus, PlaybackStatus } from './types';
+/**
+ * Represents an AGI server instance
+ */
+export default class AsteriskGatewayInterface extends EventEmitter {
+    readonly port: number;
+    readonly ip: string;
+    private readonly m_server;
+    /**
+     * Constructs a new instance of the object
+     * @param port
+     * @param ip
+     * @param maximumListeners
+     */
+    constructor(port?: number, ip?: string, maximumListeners?: number);
+    /**
+     * Event that is emitted when a new AGI channel has been established and is ready for interation
+     * @param event
+     * @param listener
+     */
+    on(event: 'channel', listener: (channel: Channel) => void): this;
+    /**
+     * Event that is emitted when the server encounters and error
+     * @param event
+     * @param listener
+     */
+    on(event: 'error', listener: (error: any) => void): this;
+    /**
+     * Event that emitted when the server is closed and stopped
+     * @param event
+     * @param listener
+     */
+    on(event: 'close', listener: () => void): this;
+    /**
+     * Starts the AGI server
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the AGI server
+     */
+    stop(): Promise<void>;
+}

package/dist/asterisk-gateway-interface.js

@@ -0,0 +1,88 @@
+"use strict";
+// Copyright (c) 2016-2022 Brandon Lehmann
+//
+// Please see the included LICENSE file for more information.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaybackStatus = exports.DialStatus = exports.ChannelState = exports.Channel = void 0;
+const net_1 = require("net");
+const events_1 = require("events");
+const channel_1 = __importDefault(require("./channel"));
+exports.Channel = channel_1.default;
+var types_1 = require("./types");
+Object.defineProperty(exports, "ChannelState", { enumerable: true, get: function () { return types_1.ChannelState; } });
+Object.defineProperty(exports, "DialStatus", { enumerable: true, get: function () { return types_1.DialStatus; } });
+Object.defineProperty(exports, "PlaybackStatus", { enumerable: true, get: function () { return types_1.PlaybackStatus; } });
+/**
+ * Represents an AGI server instance
+ */
+class AsteriskGatewayInterface extends events_1.EventEmitter {
+    /**
+     * Constructs a new instance of the object
+     * @param port
+     * @param ip
+     * @param maximumListeners
+     */
+    constructor(port = 3000, ip = '0.0.0.0', maximumListeners = 20) {
+        super();
+        this.port = port;
+        this.ip = ip;
+        this.m_server = (0, net_1.createServer)();
+        this.setMaxListeners(maximumListeners);
+        this.m_server.on('connection', (socket) => {
+            const channel = new channel_1.default(socket);
+            channel.on('ready', () => this.emit('channel', channel));
+        });
+        this.m_server.on('close', () => this.emit('close'));
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    /**
+     * Starts the AGI server
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.m_server.once('error', error => {
+                    return reject(error);
+                });
+                this.m_server.listen(this.port, this.ip, () => {
+                    this.m_server.removeAllListeners('error');
+                    this.m_server.on('error', error => this.emit('error', error));
+                    return resolve();
+                });
+            });
+        });
+    }
+    /**
+     * Stops the AGI server
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.m_server.listening) {
+                return;
+            }
+            return new Promise((resolve, reject) => {
+                this.m_server.close((error) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    return resolve();
+                });
+            });
+        });
+    }
+}
+exports.default = AsteriskGatewayInterface;

package/dist/channel.d.ts

@@ -0,0 +1,457 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Socket } from 'net';
+import { EventEmitter } from 'events';
+import { IResponse, DialStatus, PlaybackStatus, ChannelState } from './types';
+/**
+ * Represents an AGI Channel
+ */
+export default class Channel extends EventEmitter {
+    private readonly m_connection;
+    private m_state;
+    private m_message;
+    private m_network;
+    private m_network_script;
+    private m_request;
+    private m_channel;
+    private m_language;
+    private m_type;
+    private m_uniqueid;
+    private m_version;
+    private m_callerid;
+    private m_calleridname;
+    private m_callingpres;
+    private m_callingani2;
+    private m_callington;
+    private m_callingtns;
+    private m_dnid;
+    private m_rdnis;
+    private m_context;
+    private m_extension;
+    private m_priority;
+    private m_enhanced;
+    private m_accountcode;
+    private m_threadid;
+    /**
+     * Creates a new instance of a channel object
+     * @param connection the AGI socket connection
+     */
+    constructor(connection: Socket);
+    /**
+     * Event that is emitted when the underlying socket encounters an error
+     * @param event
+     * @param listener
+     */
+    on(event: 'error', listener: (error: any) => void): this;
+    /**
+     * Event that is emitted when the underlying socket is closed
+     * @param event
+     * @param listener
+     */
+    on(event: 'close', listener: () => void): this;
+    /**
+     * Event that emitted when the underlying socket times out
+     * @param event
+     * @param listener
+     */
+    on(event: 'timeout', listener: () => void): this;
+    /**
+     * Event that is emitted when the channel is ready
+     * @param event
+     * @param listener
+     */
+    on(event: 'ready', listener: () => void): this;
+    /**
+     * Event that is emitted when a response is received from the Asterisk server
+     * @param event
+     * @param listener
+     */
+    on(event: 'recv', listener: (response: string) => void): this;
+    /**
+     * Event that emitted when the channel is hung up
+     * @param event
+     * @param listener
+     */
+    on(event: 'hangup', listener: () => void): this;
+    /**
+     * Event that emitted when the response from the Asterisk server is processed into a structured response
+     * @param event
+     * @param listener
+     */
+    on(event: 'response', listener: (response: IResponse) => void): this;
+    /**
+     * Event that is emitted when data is sent to the Asterisk server
+     * @param event
+     * @param listener
+     */
+    on(event: 'send', listener: (data: string) => void): this;
+    /**
+     * Whether this AGI request is over the network
+     */
+    get network(): boolean;
+    /**
+     * The network path included in the AGI request
+     * ie. agi://127.0.0.1:3000/test
+     * This value would return 'test'
+     */
+    get network_script(): string;
+    /**
+     * The version of Asterisk
+     */
+    get version(): string;
+    /**
+     * The filename of your script
+     * ie. agi
+     */
+    get request(): string;
+    /**
+     * The originating channel (your phone)
+     */
+    get channel(): string;
+    /**
+     * The language code (e.g. “en”)
+     */
+    get language(): string;
+    /**
+     * The originating channel type (e.g. “SIP” or “ZAP”)
+     */
+    get type(): string;
+    /**
+     * A unique ID for the call
+     */
+    get uniqueid(): string;
+    /**
+     * The caller ID number (or “unknown”)
+     */
+    get callerid(): string;
+    /**
+     * The caller ID name (or “unknown”)
+     */
+    get calleridname(): string;
+    /**
+     * The presentation for the callerid in a ZAP channel
+     */
+    get callingpres(): string;
+    /**
+     * The number which is defined in ANI2 see Asterisk Detailed Variable List (only for PRI Channels)
+     */
+    get callingani2(): string;
+    /**
+     *  The type of number used in PRI Channels see Asterisk Detailed Variable List
+     */
+    get callington(): string;
+    /**
+     * An optional 4 digit number (Transit Network Selector) used in PRI Channels see Asterisk Detailed Variable List
+     */
+    get callingtns(): string;
+    /**
+     * The dialed number id (or “unknown”)
+     */
+    get dnid(): string;
+    /**
+     * The referring DNIS number (or “unknown”)
+     */
+    get rdnis(): string;
+    /**
+     * Origin context in extensions.conf
+     */
+    get context(): string;
+    /**
+     * The called number
+     */
+    get extension(): string;
+    /**
+     * The priority it was executed as in the dial plan
+     */
+    get priority(): string;
+    /**
+     * The flag value is 1.0 if started as an EAGI script, 0.0 otherwise
+     */
+    get enhanced(): string;
+    /**
+     * Account code of the origin channel
+     */
+    get accountcode(): string;
+    /**
+     * Thread ID of the AGI script
+     */
+    get threadid(): string;
+    /**
+     * Answers channel if not already in answer state.
+     */
+    answer(): Promise<void>;
+    /**
+     * Interrupts expected flow of Async AGI commands and returns control to
+     * previous source (typically, the PBX dialplan).
+     */
+    break(): Promise<void>;
+    /**
+     * Returns status of the connected channel.
+     * @param channel
+     */
+    channelStatus(channel?: string): Promise<ChannelState>;
+    /**
+     * Sends audio file on channel and allows the listener to control the stream.
+     * @param filename
+     * @param escapeDigits
+     * @param skipms
+     * @param fastForwardCharacter
+     * @param rewindCharacter
+     * @param pauseCharacter
+     */
+    controlStreamFile(filename: string, escapeDigits?: string, skipms?: number, fastForwardCharacter?: string, rewindCharacter?: string, pauseCharacter?: string): Promise<{
+        digit: string;
+        playbackStatus: PlaybackStatus;
+        playbackOffset: number;
+    }>;
+    /**
+     * Attempts to establish a new outgoing connection on a channel, and then link it to the calling input channel.
+     * @param target
+     * @param timeout
+     * @param params
+     */
+    dial(target: string, timeout?: number, params?: string): Promise<DialStatus>;
+    /**
+     * Deletes an entry in the Asterisk database for a given family and key.
+     * @param family
+     * @param key
+     */
+    databaseDel(family: string, key: string): Promise<void>;
+    /**
+     * Deletes a family or specific keytree within a family in the Asterisk database.
+     * @param family
+     * @param keyTree
+     */
+    databaseDelTree(family: string, keyTree?: string): Promise<boolean>;
+    /**
+     * Retrieves an entry in the Asterisk database for a given family and key.
+     * @param family
+     * @param key
+     */
+    databaseGet(family: string, key: string): Promise<string>;
+    /**
+     * Adds or updates an entry in the Asterisk database for a given family, key, and value.
+     * @param family
+     * @param key
+     * @param value
+     */
+    databasePut(family: string, key: string, value: string): Promise<string>;
+    /**
+     * Executes application with given options
+     * @param application.
+     * @param args
+     */
+    exec(application: string, ...args: string[]): Promise<number>;
+    /**
+     * Stream the given file, and receive DTMF data.
+     * @param soundFile
+     * @param timeout
+     * @param maxDigits
+     */
+    getData(soundFile: string, timeout?: number, maxDigits?: number): Promise<{
+        digits: string;
+        timeout: boolean;
+    }>;
+    /**
+     * Evaluates a channel expression
+     * Understands complex variable names and builtin variables, unlike GET VARIABLE.
+     * @param key
+     * @param channel
+     */
+    getFullVariable(key: string, channel?: string): Promise<string>;
+    /**
+     * Stream file, prompt for DTMF, with timeout.
+     * Behaves similar to STREAM FILE but used with a timeout option.
+     * @param soundFile
+     * @param escapeDigits
+     * @param timeout
+     */
+    getOption(soundFile: string, escapeDigits?: string, timeout?: number): Promise<{
+        digit: string;
+        endpos: number;
+    }>;
+    /**
+     * Gets a channel variable.
+     * @param key
+     */
+    getVariable(key: string): Promise<string>;
+    /**
+     * Cause the channel to execute the specified dialplan subroutine.
+     * @param context
+     * @param extension
+     * @param priority
+     * @param argument
+     */
+    goSub(context: string, extension: string, priority: number, argument?: string): Promise<void>;
+    /**
+     * Hangs up the specified channel. If no channel name is given, hangs up the current channel
+     * @param channel
+     */
+    hangup(channel?: string): Promise<void>;
+    /**
+     * Does nothing
+     */
+    noop(): Promise<void>;
+    /**
+     * Receives one character from channels supporting it.
+     * @param timeout
+     */
+    receiveChar(timeout?: number): Promise<{
+        char: string;
+        timeout: boolean;
+    }>;
+    /**
+     * Receives text from channels supporting it.
+     * @param timeout
+     */
+    receiveText(timeout?: number): Promise<string>;
+    /**
+     * Records to a given file.
+     * @param filename
+     * @param fileFormat
+     * @param escapeDigits
+     * @param timeout
+     * @param beep
+     * @param silence
+     * @param offsetSamples
+     */
+    recordFile(filename: string, fileFormat?: string, escapeDigits?: string, timeout?: number, beep?: boolean, silence?: number, offsetSamples?: number): Promise<{
+        digit: string;
+        endpos: number;
+        timeout: boolean;
+    }>;
+    /**
+     * Says a given character string.
+     * @param value
+     * @param escapeDigits
+     */
+    sayAlpha(value: string, escapeDigits?: string): Promise<string>;
+    /**
+     * Says a given date.
+     * @param value
+     * @param escapeDigits
+     */
+    sayDate(value: Date | number, escapeDigits?: string): Promise<string>;
+    /**
+     * Says a given time as specified by the format given.
+     * @param value
+     * @param escapeDigits
+     * @param dateFormat
+     * @param timezone
+     */
+    sayDateTime(value: Date | number, escapeDigits?: string, dateFormat?: string, timezone?: string): Promise<string>;
+    /**
+     * Says a given digit string.
+     * @param value
+     * @param escapeDigits
+     */
+    sayDigits(value: string, escapeDigits?: string): Promise<string>;
+    /**
+     * Says a given number.
+     * @param value
+     * @param escapeDigits
+     */
+    sayNumber(value: number, escapeDigits?: string): Promise<string>;
+    /**
+     * Says a given character string with phonetics.
+     * @param value
+     * @param escapeDigits
+     */
+    sayPhonetic(value: string, escapeDigits?: string): Promise<string>;
+    /**
+     * Says a given time.
+     * @param value
+     * @param escapeDigits
+     */
+    sayTime(value: Date | number, escapeDigits?: string): Promise<string>;
+    /**
+     * Sends images to channels supporting it.
+     * @param image
+     */
+    sendImage(image: string): Promise<void>;
+    /**
+     * Sends text to channels supporting it.
+     * @param text
+     */
+    sendText(text: string): Promise<void>;
+    /**
+     * Autohangup channel in some time.
+     * @param timeout
+     */
+    setAutoHangup(timeout?: number): Promise<void>;
+    /**
+     * Sets callerid for the current channel.
+     * @param callerNumber
+     * @param callerName
+     */
+    setCallerID(callerNumber: number, callerName?: string): Promise<void>;
+    /**
+     * Sets channel context.
+     * @param context
+     */
+    setContext(context: string): Promise<void>;
+    /**
+     * Changes channel extension.
+     * @param extension
+     */
+    setExtension(extension: string): Promise<void>;
+    /**
+     * Enable/Disable Music on hold generator
+     * @param status
+     * @param musicClass
+     */
+    setMusic(status?: boolean, musicClass?: string): Promise<void>;
+    /**
+     * Set channel dialplan priority.
+     * @param priority
+     */
+    setPriority(priority: number): Promise<void>;
+    /**
+     * Set channel dialplan priority.
+     * @param key
+     * @param value
+     */
+    setVariable(key: string, value: string): Promise<void>;
+    speechActivateGrammar(grammar: string): Promise<IResponse>;
+    speechCreate(engine: string): Promise<IResponse>;
+    speechDeactivateGrammar(grammar: string): Promise<IResponse>;
+    speechDestroy(): Promise<IResponse>;
+    speechLoadGrammar(grammar: string, path: string): Promise<IResponse>;
+    speechRecognize(soundFile: string, timeout: number | undefined, offset: number): Promise<IResponse>;
+    speechSet(key: string, value: string): Promise<IResponse>;
+    speedUnloadGrammar(grammar: string): Promise<IResponse>;
+    /**
+     * Sends audio file on channel.
+     * @param filename
+     * @param escapeDigits
+     * @param offset
+     */
+    streamFile(filename: string, escapeDigits?: string, offset?: number): Promise<{
+        digit: string;
+        endpos: number;
+    }>;
+    /**
+     * Toggles TDD mode (for the deaf).
+     * @param status
+     */
+    tddMode(status: boolean): Promise<void>;
+    /**
+     * Logs a message to the asterisk verbose log.
+     * @param message
+     * @param level
+     */
+    verbose(message: string, level?: number): Promise<void>;
+    /**
+     * Waits for a digit to be pressed.
+     * @param timeout
+     */
+    waitForDigit(timeout?: number): Promise<string>;
+    private close;
+    private read;
+    private handleVariable;
+    private readVariables;
+    private readResponse;
+    private readResponseLine;
+    private send;
+    private sendCommand;
+}