typescript-agi-ipcom 0.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 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,72 @@
+# Welcome to typescript-agi 👋
+![Version](https://img.shields.io/badge/version-0.0.5-blue.svg?cacheSeconds=2592000)
+[![Documentation](https://img.shields.io/badge/documentation-yes-brightgreen.svg)](https://brandonlehmann.github.io/typescript-agi/)
+[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/brandonlehmann/typescript-agi/graphs/commit-activity)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/brandonlehmann/typescript-agi/blob/master/LICENSE)
+
+[![NPM](https://nodei.co/npm/typescript-agi.png?downloads=true&stars=true)](https://nodei.co/npm/typescript-agi/)
+
+> NodeJS TypeScript Library for Asterisk AGI Interfaces
+
+### 🏠 [Homepage](https://brandonlehmann.github.io/typescript-agi/)
+
+## Install
+
+```sh
+npm install typescript-agi
+```
+
+## Run tests
+
+```sh
+npm run test
+```
+
+## Example Usage
+
+```typescript
+import {
+    AGIServer, 
+    Channel
+} from 'typescript-agi';
+
+const agiServer = new AGIServer();
+
+agiServer.on('channel', async(channel: Channel) => {
+    await channel.answer();
+    await channel.sayNumber(12345);
+    await channel.hangup();
+});
+
+agiServer.start();
+````
+
+## Documentation
+
+Library documentation is available at [https://brandonlehmann.github.io/typescript-agi/](https://brandonlehmann.github.io/typescript-agi/)
+
+## Author
+
+👤 **Brandon Lehmann <brandonlehmann@gmail.com>**
+
+* Github: [@brandonlehmann](https://github.com/brandonlehmann)
+
+## 🤝 Contributing
+
+Contributions, issues and feature requests are welcome!
+
+Feel free to check [issues page](https://github.com/brandonlehmann/typescript-agi/issues).
+
+## Show your support
+
+Give a ⭐️ if this project helped you!
+
+
+## 📝 License
+
+Copyright © 2020 [Brandon Lehmann <brandonlehmann@gmail.com>](https://github.com/brandonlehmann).
+
+This project is [MIT](https://github.com/brandonlehmann/typescript-agi/blob/master/LICENSE) licensed.
+
+***
+_This README was generated with ❤️ by [readme-md-generator](https://github.com/kefranabg/readme-md-generator)_

package/dist/AGIServer.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Channel } from './Channel';
+/**
+ * Represents an AGI server instance
+ */
+export declare class AGIServer extends EventEmitter {
+    private readonly m_port;
+    private readonly m_ip;
+    private readonly m_server;
+    /**
+     * Constructs a new instance of the object
+     * @param port
+     * @param ip
+     */
+    constructor(port?: number, ip?: string);
+    /**
+     * 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 AGI server is started and in a listening state
+     * @param event
+     * @param listener
+     */
+    on(event: 'listening', listener: (port: number, ip: string) => 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/AGIServer.js

@@ -0,0 +1,71 @@
+"use strict";
+// Copyright (c) 2020, 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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGIServer = void 0;
+const net = require("net");
+const events_1 = require("events");
+const Channel_1 = require("./Channel");
+const util_1 = require("util");
+/**
+ * Represents an AGI server instance
+ */
+class AGIServer extends events_1.EventEmitter {
+    /**
+     * Constructs a new instance of the object
+     * @param port
+     * @param ip
+     */
+    constructor(port = 3000, ip = '0.0.0.0') {
+        super();
+        this.m_server = net.createServer();
+        this.setMaxListeners(10);
+        this.m_port = port;
+        this.m_ip = ip;
+        this.m_server.on('connection', (socket) => {
+            const channel = new Channel_1.Channel(socket);
+            channel.on('ready', () => this.emit('channel', channel));
+        });
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    /**
+     * Starts the AGI server
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.m_server.on('error', (error) => this.emit('error', new Error(util_1.format('Internal TCP server error: %s', error.toString()))));
+            this.m_server.on('close', () => this.emit('close'));
+            this.m_server.listen(this.m_port, this.m_ip, () => {
+                this.emit('listening', this.m_port, this.m_ip);
+            });
+        });
+    }
+    /**
+     * Stops the AGI server
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.m_server.close((error) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    return resolve();
+                });
+            });
+        });
+    }
+}
+exports.AGIServer = AGIServer;

package/dist/Channel.d.ts

@@ -0,0 +1,498 @@
+/// <reference types="node" />
+import { Socket } from 'net';
+import { EventEmitter } from 'events';
+import { ResponseArguments } from './ResponseArguments';
+/**
+ * Represents the current channel state
+ */
+export declare enum ChannelState {
+    DOWN_AVAILABLE = 0,
+    DOWN_RESERVED = 1,
+    OFF_HOOK = 2,
+    DIGITS_DIALED = 3,
+    RINGING = 4,
+    REMOTE_RINGING = 5,
+    UP = 6,
+    BUSY = 7
+}
+/**
+ * Represents the result of a Dial() attempt
+ */
+export declare enum DialStatus {
+    ANSWER = 0,
+    BUSY = 1,
+    NOANSWER = 2,
+    CANCEL = 3,
+    CONGESTION = 4,
+    CHANUNAVAIL = 5,
+    DONTCALL = 6,
+    TORTURE = 7,
+    INVALIDARGS = 8
+}
+/**
+ * Represents the playback status
+ */
+export declare enum PlaybackStatus {
+    SUCCESS = 0,
+    USER_STOPPED = 1,
+    REMOTE_STOPPED = 2,
+    ERROR = 3
+}
+/** @ignore */
+interface IResponse {
+    code: number;
+    result: number;
+    arguments: ResponseArguments;
+}
+/**
+ * Represents an AGI Channel
+ */
+export declare 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 readVariables;
+    private readResponse;
+    private readResponseLine;
+    private send;
+    private sendCommand;
+}
+export {};