oorja 2.1.8 → 2.2.0

package/dist/commands/signout.js

@@ -1,10 +1,10 @@
 import { Command } from '@oclif/core';
-import { determineENV, setENVAccessToken } from '../lib/config.js';
+import { Config } from '../lib/config.js';
 export class SignOut extends Command {
     static description = `Sign-out of oorja. Clears saved auth-token`;
     async run() {
-        const env = determineENV();
-        setENVAccessToken(env, '');
+        const config = new Config(this.config.configDir);
+        config.setAccessToken('');
         console.log('Sign-out complete');
     }
 }

package/dist/commands/teletype/index.d.ts

@@ -11,10 +11,10 @@ export default class TeleTypeCommand extends Command {
         new_space: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static args: {
-        space: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        streamKey: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     run(): Promise<void>;
-    private streamToLink;
+    private streamUsingStreamKey;
     private createRoomAndStream;
     private clearstdin;
 }

package/dist/commands/teletype/index.js

@@ -1,27 +1,29 @@
 import inquirer from 'inquirer';
 import { Command, Flags, Args } from '@oclif/core';
 import ora from 'ora';
-import * as os from 'os';
+import { hostname } from 'os';
 import chalk from 'chalk';
-import { ROOM_LINK_SAMPLE } from '../../lib/config.js';
-import { getApp } from '../../lib/oorja/index.js';
-import { printExitMessage, promptRoomLink } from '../../lib/utils.js';
-const DEFAULT_SHELL = os.platform() === 'win32' ? 'powershell.exe' : process.env.SHELL || 'bash';
+import { Config, STREAM_KEY_SAMPLE } from '../../lib/config.js';
+import { App, parseStreamKey } from '../../lib/oorja/index.js';
+import { printExitMessage, promptStreamKey } from '../../lib/utils.js';
+import { Unauthorized } from '../../lib/connect/errors.js';
+import { exit } from '../../lib/exit.js';
 export default class TeleTypeCommand extends Command {
     static order = 1;
     static aliases = ['tty'];
     static description = `Launch a terminal streaming session in oorja.`;
     static examples = [
         `${chalk.blueBright('$ teletype')}
-Will prompt to choose streaming destination - existing space or create a new one.
+Will prompt to choose streaming destination - either enter a stream key for an existing space or create a new space.
 
 `,
-        `${chalk.blueBright(`$ teletype '${ROOM_LINK_SAMPLE}'`)}
-Will stream to the space specified by secret link, you must have joined the space before streaming.
+        `${chalk.blueBright(`$ teletype '${STREAM_KEY_SAMPLE}'`)}
+Will stream to the space using the secret stream-key. NOTE: stream-keys are personal (generated for you in the teletype app at oorja.io), do not accept them from other people, nor should
+you share your stream-keys with others.
 
 `,
         `${chalk.blueBright('$ teletype -m')}
-Will also allow participants to write to your terminal!
+Will also allow participants to write to your terminal! Collaboration mode must be explicitly enabled.
 
 `,
     ];
@@ -30,7 +32,7 @@ Will also allow participants to write to your terminal!
         shell: Flags.string({
             char: 's',
             description: 'shell to use. e.g. bash, fish',
-            default: DEFAULT_SHELL,
+            default: 'bash',
         }),
         multiplex: Flags.boolean({
             char: 'm',
@@ -44,61 +46,64 @@ Will also allow participants to write to your terminal!
         }),
     };
     static args = {
-        space: Args.string({}),
+        streamKey: Args.string({}),
     };
     async run() {
         const { args, flags: { shell, multiplex, new_space }, } = await this.parse(TeleTypeCommand);
-        if (args.space) {
-            await this.streamToLink({ shell, multiplex, roomLink: args.space });
-            process.exit(0);
+        const config = new Config(this.config.configDir);
+        const app = new App(config);
+        if (args.streamKey) {
+            await this.streamUsingStreamKey(app, { shell, multiplex, streamKey: args.streamKey });
+            exit(0);
         }
         if (new_space) {
-            await this.createRoomAndStream({ shell, multiplex });
-            process.exit(0);
+            await this.createRoomAndStream(app, { shell, multiplex });
+            exit(0);
         }
         console.log('(use -h for description and options) \n');
         // room not known, prompt
-        const SPACE = 'To an existing space (you have the link)';
-        const NEW = 'New space';
+        const STREAM_USING_STREAM_KEY = 'Stream using stream-key (You can acquire your stream key from teletype app within the space)';
+        const STREAM_TO_NEW_SPACE = 'New space';
         const { answer } = await inquirer.prompt([
             {
                 type: 'list',
                 name: 'answer',
                 message: 'Choose streaming destination',
-                choices: [NEW, SPACE],
+                choices: [STREAM_TO_NEW_SPACE, STREAM_USING_STREAM_KEY],
             },
         ]);
         switch (answer) {
-            case SPACE:
-                await this.streamToLink({ shell, multiplex });
+            case STREAM_USING_STREAM_KEY:
+                await this.streamUsingStreamKey(app, { shell, multiplex });
                 break;
-            case NEW:
-                await this.createRoomAndStream({ shell, multiplex });
+            case STREAM_TO_NEW_SPACE:
+                await this.createRoomAndStream(app, { shell, multiplex });
                 break;
         }
-        process.exit(0);
+        exit(0);
     }
-    async streamToLink(options) {
-        const roomLink = options.roomLink || (await promptRoomLink());
-        if (!roomLink) {
-            printExitMessage(chalk.redBright('Space link not provided :('));
-            process.exit();
+    async streamUsingStreamKey(app, options) {
+        const streamKey = options.streamKey || (await promptStreamKey());
+        if (!streamKey) {
+            printExitMessage(chalk.redBright('stream-key not provided :('));
+            exit();
         }
-        const app = await getApp({ roomLink });
-        const roomKey = app.getRoomKey(roomLink);
+        const streamKeyStruct = parseStreamKey(streamKey);
+        const oorja = await app.init(streamKeyStruct);
+        const roomKey = oorja.getRoomKey(streamKeyStruct);
         this.clearstdin();
-        await app.teletype({ roomKey, ...options, process });
+        await oorja.teletype({ roomKey, ...options, process });
     }
-    async createRoomAndStream({ shell, multiplex }) {
-        const app = await getApp();
+    async createRoomAndStream(app, { shell, multiplex }) {
+        const oorja = await app.init();
         const spinner = ora({
             text: chalk.bold('Creating space with TeleType app'),
             discardStdin: false,
         }).start();
         const now = new Date();
-        const { roomKey } = await app
+        const { roomKey } = await oorja
             .createRoom({
-            roomName: `Teletype session - ${os.hostname()} @ ${now.getHours()}:${now.getMinutes().toString().padStart(2, '0')}`,
+            roomName: `Teletype session - ${hostname()} @ ${now.getHours()}:${now.getMinutes().toString().padStart(2, '0')}`,
             apps: {
                 defaultFocus: '39',
                 appList: [
@@ -111,15 +116,21 @@ Will also allow participants to write to your terminal!
             },
         })
             .catch((e) => {
-            printExitMessage('Failed to create space.');
-            process.exit(9);
+            if (e instanceof Unauthorized) {
+                printExitMessage('Failed to create space. Are you sure your access-token is valid?');
+            }
+            else {
+                printExitMessage('Failed to create space. Try again later or try updating your oorja-cli');
+            }
+            exit(9);
+            return Promise.reject();
         });
         spinner.succeed(chalk.bold('Space created')).clear();
-        const link = app.linkForRoom(roomKey);
+        const link = oorja.linkForRoom(roomKey);
         console.log(`\n${chalk.bold(chalk.blueBright(link))}\n`);
         console.log(chalk.bold("^^ You'll be streaming here ^^"));
         this.clearstdin();
-        return await app.teletype({ roomKey, shell, multiplex, process });
+        return await oorja.teletype({ roomKey, shell, multiplex, process });
     }
     clearstdin() {
         process.stdin.read();

package/dist/lib/config.d.ts

@@ -1,18 +1,23 @@
-import { URL } from 'url';
-export declare const CLI_VERSION = 2.6;
-import Conf from 'conf';
-export declare const config: Conf<string>;
+export declare const CLI_VERSION = 2.7;
 export type env = 'local' | 'prod';
+export declare class Config {
+    streamKeyAuth: boolean;
+    private configPath;
+    private config;
+    constructor(configDir: string);
+    private loadConfig;
+    private saveConfig;
+    getEnv: () => env;
+    getAccessToken: () => string;
+    setAccessToken: (token: string) => void;
+}
 export type ConnectConfig = {
+    useHttps: boolean;
     host: string;
-    token: string;
 };
 export declare const getConnectConfig: (env: env, region: string) => ConnectConfig;
-export declare const ROOM_LINK_SAMPLE = "https://oorja.io/spaces?id=foo#key";
-export declare const INVALID_ROOM_LINK_MESSAGE: string;
-export declare const determineENV: (roomURL?: URL) => env;
-export declare const getENVAccessToken: (env: env) => string;
-export declare const setENVAccessToken: (env: env, token: string) => void;
+export declare const STREAM_KEY_SAMPLE = "sk-xxxx:space-id#encryption-secret";
+export declare const INVALID_STREAM_KEY_MESSAGE: string;
 export type oorjaConfig = {
     host: string;
 };

package/dist/lib/config.js

@@ -1,57 +1,70 @@
 import chalk from 'chalk';
-export const CLI_VERSION = 2.6;
-import Conf from 'conf';
-import { printExitMessage } from './utils.js';
-export const config = new Conf({
-    projectName: 'oorja',
-    schema: {
-        env: {
-            type: 'string',
-        },
-        'staging-access-token': {
-            type: 'string',
-        },
-        'prod-access-token': {
-            type: 'string',
-        },
-    },
-});
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+export const CLI_VERSION = 2.7;
+export class Config {
+    streamKeyAuth = false;
+    configPath;
+    config = {};
+    constructor(configDir) {
+        this.configPath = path.join(configDir, 'config.json');
+        this.loadConfig();
+    }
+    loadConfig() {
+        try {
+            const data = readFileSync(this.configPath, 'utf8');
+            this.config = JSON.parse(data);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Config file doesn't exist, create it with default values
+                const dir = path.dirname(this.configPath);
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+                this.saveConfig();
+            }
+            else {
+                console.error(chalk.redBright('Error loading config:'), error.message, this.configPath);
+            }
+        }
+    }
+    async saveConfig() {
+        try {
+            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf8');
+        }
+        catch (error) {
+            console.error(chalk.redBright('Error saving config:'), error.message);
+        }
+    }
+    getEnv = () => {
+        return this.config['env'] ?? 'prod';
+    };
+    getAccessToken = () => {
+        return this.config[`${this.getEnv()}-access-token`] || '';
+    };
+    setAccessToken = (token) => {
+        this.config[`${this.getEnv()}-access-token`] = token;
+        this.saveConfig();
+    };
+}
 export const getConnectConfig = (env, region) => {
     const getHost = (env) => {
         switch (env) {
             case 'local':
-                return 'connect-staging.oorja.io';
+                return 'localhost:4000';
             case 'prod':
                 return region ? `${region}.connect.oorja.io` : 'connect.oorja.io';
         }
     };
+    const host = getHost(env);
     return {
-        host: getHost(env),
-        token: getENVAccessToken(env),
+        useHttps: host.includes('oorja.io'),
+        host,
     };
 };
-export const ROOM_LINK_SAMPLE = 'https://oorja.io/spaces?id=foo#key';
-export const INVALID_ROOM_LINK_MESSAGE = `${chalk.redBright('invalid url ')}🤔. It should look like: ${chalk.blue(ROOM_LINK_SAMPLE)}`;
-export const determineENV = (roomURL) => {
-    if (!roomURL)
-        return config.get('env') || 'prod';
-    switch (roomURL.host) {
-        case 'oorja.io':
-        case 'teletype.oorja.io':
-            return 'prod';
-        case 'localhost:3000':
-            return 'local';
-        default:
-            printExitMessage(INVALID_ROOM_LINK_MESSAGE);
-            process.exit(1);
-    }
-};
-export const getENVAccessToken = (env) => {
-    return config.get(`${env}-access-token`) || '';
-};
-export const setENVAccessToken = (env, token) => {
-    config.set(`${env}-access-token`, token);
-};
+export const STREAM_KEY_SAMPLE = 'sk-xxxx:space-id#encryption-secret';
+export const INVALID_STREAM_KEY_MESSAGE = `${chalk.redBright('invalid stream-key ')}🤔. It should look like: ${chalk.blue(STREAM_KEY_SAMPLE)}`;
 export const getoorjaConfig = (env) => {
     let host;
     switch (env) {

package/dist/lib/connect/index.d.ts

@@ -9,29 +9,30 @@ export declare class ConnectClient {
     private headers;
     private timeout;
     private socket?;
-    constructor(env: env, region: string);
+    private accessToken;
+    constructor(env: env, region: string, token: string);
+    setAccessToken: (token: string) => void;
     private _fetch;
     fetchCliManifest: () => Promise<CliManifest>;
-    fetchSessionUser: () => Promise<User>;
+    fetchSessionUser: (v2?: boolean) => Promise<User>;
     createRoom: ({ roomName, apps }: CreateRoomOptions) => Promise<Room>;
     createAnonymousUser: () => Promise<string>;
-    accessTokenFromRoomParticipantOTP: (roomId: string, otp: string) => Promise<string>;
     fetchRoom: (roomId: string) => Promise<Room>;
     establishSocket: () => Promise<void>;
-    joinChannel: ({ channel, params, onJoin, onClose, onError, onMessage, handleSessionJoin, handleSessionLeave, }: JoinChannelOptions<any>) => Channel;
+    joinChannel: ({ channel, params, onJoin, onClose, onError, onMessage, handleSessionJoin, handleSessionLeave, }: JoinChannelOptions<unknown, unknown>) => Channel;
     destroy: () => Promise<unknown>;
 }
 export type CreateRoomOptions = {
     roomName: string;
     apps: RoomApps;
 };
-export type JoinChannelOptions<T> = {
+export type JoinChannelOptions<Params, Metas> = {
     channel: string;
-    params: T;
+    params: Params;
     onJoin?: () => void;
     onError?: (reason: any) => void;
     onClose?: (payload: any, ref: any, joinRef: any) => void;
     onMessage: (payload: any) => void;
-    handleSessionJoin: (session: string | undefined, _ignore: any, metas: any) => void;
-    handleSessionLeave: (session: string | undefined) => void;
+    handleSessionJoin: (session: string, currentMetas: undefined | Metas, newMetas: Metas) => void;
+    handleSessionLeave: (session: string, currentMetas: undefined | Metas, leftMetas: Metas) => void;
 };

package/dist/lib/connect/index.js

@@ -8,6 +8,7 @@ import { Unauthorized, BadRequest } from './errors.js';
 import { Socket, Presence } from 'phoenix';
 import camelcaseKeys from 'camelcase-keys';
 import { printExitMessage } from '../utils.js';
+import { exit } from '../exit.js';
 export class ApiClientError extends Error {
 }
 export class ConnectClient {
@@ -16,16 +17,22 @@ export class ConnectClient {
     headers;
     timeout;
     socket;
-    constructor(env, region) {
+    accessToken;
+    constructor(env, region, token) {
         const config = getConnectConfig(env, region);
-        this.baseURL = connectBaseURL(config.host);
+        this.baseURL = connectBaseURL(config.host, config.useHttps);
         this.headers = {
-            'x-access-token': config.token || '',
+            'x-access-token': token || '',
             'Content-Type': 'application/json',
         };
+        this.accessToken = token || '';
         this.timeout = 5000;
         this.config = config;
     }
+    setAccessToken = (token) => {
+        this.accessToken = token;
+        this.headers['x-access-token'] = token;
+    };
     // Private helper to encapsulate fetch with timeout and consistent error handling.
     async _fetch(path, options = {}) {
         const controller = new AbortController();
@@ -54,7 +61,7 @@ export class ConnectClient {
     }
     fetchCliManifest = async () => {
         try {
-            const response = await this._fetch('/cli');
+            const response = await this._fetch('/v1/cli');
             const data = await response.json();
             return camelcaseKeys(data);
         }
@@ -62,9 +69,10 @@ export class ConnectClient {
             return handleError(error);
         }
     };
-    fetchSessionUser = async () => {
+    fetchSessionUser = async (v2 = false) => {
+        const path = v2 ? '/v2/session/user_profile' : '/v1/session/user';
         try {
-            const response = await this._fetch('/session/user');
+            const response = await this._fetch(path);
             const data = await response.json();
             return defaultParser(data.data);
         }
@@ -81,7 +89,7 @@ export class ConnectClient {
             },
         };
         try {
-            const response = await this._fetch('/rooms', {
+            const response = await this._fetch('/v1/rooms', {
                 method: 'POST',
                 body: JSON.stringify(body),
             });
@@ -94,7 +102,7 @@ export class ConnectClient {
     };
     createAnonymousUser = async () => {
         try {
-            const response = await this._fetch('/session/anon', { method: 'POST' });
+            const response = await this._fetch('/v1/session/anon', { method: 'POST' });
             const data = await response.json();
             return data.access_token;
         }
@@ -102,25 +110,9 @@ export class ConnectClient {
             return handleError(error);
         }
     };
-    accessTokenFromRoomParticipantOTP = async (roomId, otp) => {
-        try {
-            const response = await this._fetch('/access_tokens/from_room_participant_otp', {
-                method: 'POST',
-                body: JSON.stringify({
-                    room_id: roomId,
-                    otp: otp,
-                }),
-            });
-            const data = await response.json();
-            return data.data.token;
-        }
-        catch (error) {
-            return handleError(error);
-        }
-    };
     fetchRoom = async (roomId) => {
         try {
-            const response = await this._fetch(`/rooms/${roomId}`);
+            const response = await this._fetch(`/v1/rooms/${roomId}`);
             const data = await response.json();
             return defaultParser(data.data);
         }
@@ -129,7 +121,7 @@ export class ConnectClient {
         }
     };
     establishSocket = async () => {
-        const protocolPrefix = `wss://`;
+        const protocolPrefix = this.config.useHttps ? 'wss://' : 'ws://';
         const host = this.config.host;
         const encodeMessage = function (rawdata, callback) {
             return callback(encoder.encode(rawdata));
@@ -141,7 +133,7 @@ export class ConnectClient {
             let initialConnection = false;
             this.socket = new Socket(`${protocolPrefix}${host}/socket`, {
                 params: {
-                    access_token: this.config.token,
+                    access_token: this.accessToken,
                 },
                 transport: WebSocket,
                 heartbeatIntervalMs: 7500,
@@ -159,9 +151,8 @@ export class ConnectClient {
                     return;
                 }
                 printExitMessage('connection error');
-                process.exit(2);
+                exit(2);
             });
-            // @ts-ignore
             this.socket.connect();
         });
     };
@@ -173,16 +164,20 @@ export class ConnectClient {
             chan.onError(onError);
         if (onClose)
             chan.onClose(onClose);
-        let presences = [];
         chan.on('new_msg', (msg) => {
             onMessage(msg);
         });
-        chan.on('presence_state', (response) => {
-            Presence.syncState(presences, response, handleSessionJoin, undefined);
-            presences = response;
+        const presence = new Presence(chan);
+        // https://hexdocs.pm/phoenix/js/index.html#handling-individual-presence-join-and-leave-events
+        presence.onJoin((key, current, newPres) => {
+            if (!current) {
+                handleSessionJoin(key, current, newPres);
+            }
         });
-        chan.on('presence_diff', (newPresence) => {
-            presences = Presence.syncDiff(presences, newPresence, handleSessionJoin, handleSessionLeave);
+        presence.onLeave((key, current, leftPres) => {
+            if (current.metas.length === 0) {
+                handleSessionLeave(key, current, leftPres);
+            }
         });
         chan
             .join()
@@ -197,7 +192,7 @@ export class ConnectClient {
                 return;
             }
             printExitMessage('error on channel');
-            process.exit(3);
+            exit(3);
         });
         return chan;
     };
@@ -214,7 +209,7 @@ export class ConnectClient {
         });
     };
 }
-const connectBaseURL = (host) => `https://${host}/api/v1`;
+const connectBaseURL = (host, useHttps) => `http${useHttps ? 's' : ''}://${host}/api`;
 const handleError = (error) => {
     // This function was originally designed for AxiosError.
     // The custom _fetch method now throws an object with a `response` key

package/dist/lib/exit.d.ts

@@ -0,0 +1 @@
+export declare function exit(exitCode?: number, streams?: any): void;

package/dist/lib/exit.js

@@ -0,0 +1,44 @@
+// because flushing stdout / graceful exit doesn't seem possible in nodejs?
+// without this error-codes/logs just before exit is called won't show up..
+/*
+ * exit
+ * https://github.com/cowboy/node-exit
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ */
+'use strict';
+export function exit(exitCode = 0, streams) {
+    if (!streams) {
+        streams = [process.stdout, process.stderr];
+    }
+    var drainCount = 0;
+    // Actually exit if all streams are drained.
+    function tryToExit() {
+        if (drainCount === streams.length) {
+            process.exit(exitCode);
+        }
+    }
+    streams.forEach(function (stream) {
+        // Count drained streams now, but monitor non-drained streams.
+        if (stream.bufferSize === 0) {
+            drainCount++;
+        }
+        else {
+            stream.write('', 'utf-8', function () {
+                drainCount++;
+                tryToExit();
+            });
+        }
+        // Prevent further writing.
+        stream.write = function () { };
+    });
+    // If all streams were already drained, exit now.
+    tryToExit();
+    // In Windows, when run as a Node.js child process, a script utilizing
+    // this library might just exit with a 0 exit code, regardless. This code,
+    // despite the fact that it looks a bit crazy, appears to fix that.
+    process.on('exit', function () {
+        process.exit(exitCode);
+    });
+}

package/dist/lib/oorja/client.js

@@ -1,5 +1,7 @@
 import haversine from 'haversine-distance';
 import { printExitMessage } from '../utils.js';
+import { exit } from '../exit.js';
+import { geoMap } from './geoMap.js';
 export class OorjaClientError extends Error {
 }
 const _maybeError = (response) => {
@@ -24,18 +26,21 @@ class Client {
 }
 const _client = new Client();
 export const getRegion = async () => {
-    const response = await _client.get('https://static.oorja.io/nudge', {
+    const response = await _client.get('https://oorja.io/nudge', {
         method: 'GET',
     });
     if (response.status !== 200) {
         printExitMessage('There seems to be an issue with the network');
-        process.exit(1);
+        exit(1);
+        return Promise.reject();
     }
     const settings = (await response.json());
+    const country = (response.headers.get('cdn-requestcountrycode') || 'us').toUpperCase().trim();
+    const info = geoMap[country] || geoMap['US'];
     try {
         const clientLocation = {
-            lat: parseFloat(response.headers.get('oorja-lat')),
-            lng: parseFloat(response.headers.get('oorja-lon')),
+            lat: parseFloat(info[0]),
+            lng: parseFloat(info[1]),
         };
         const distances = settings.regions.map((region) => {
             return {
@@ -48,6 +53,7 @@ export const getRegion = async () => {
     }
     catch {
         printExitMessage('error determining region');
-        process.exit(1);
+        exit(1);
+        return Promise.reject();
     }
 };