codexui-android 0.1.92 → 0.1.94

package/node_modules/node-pty-prebuilt-multiarch/scripts/check-prebuild.js

@@ -0,0 +1,15 @@
+const { ptyPath } = require('../lib/prebuild-file-path');
+
+if (ptyPath) {
+  console.log('Prebuild binary exists:', ptyPath);
+  try {
+    require(ptyPath);
+  } catch (e) {
+    console.error('Prebuild binary failed test.');
+    process.exit(1);
+  }
+  process.exit(0);
+} else {
+  console.error('Prebuild binary missing for platform.');
+  process.exit(1);
+}

package/node_modules/node-pty-prebuilt-multiarch/scripts/install.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const os = require('os');
+const path = require('path');
+const spawn = require('child_process').spawn;
+
+const gypArgs = ['rebuild'];
+if (process.env.NODE_PTY_DEBUG) {
+  gypArgs.push('--debug');
+}
+const gypProcess = spawn(os.platform() === 'win32' ? 'node-gyp.cmd' : 'node-gyp', gypArgs, {
+  cwd: path.join(__dirname, '..'),
+  stdio: 'inherit'
+});
+
+gypProcess.on('exit', function (code) {
+  process.exit(code);
+});

package/node_modules/node-pty-prebuilt-multiarch/scripts/post-install.js

@@ -0,0 +1,41 @@
+var fs = require('fs');
+var path = require('path');
+
+var RELEASE_DIR = path.join(__dirname, '..', 'build', 'Release');
+var BUILD_FILES = [
+  path.join(RELEASE_DIR, 'conpty.node'),
+  path.join(RELEASE_DIR, 'conpty.pdb'),
+  path.join(RELEASE_DIR, 'conpty_console_list.node'),
+  path.join(RELEASE_DIR, 'conpty_console_list.pdb'),
+  path.join(RELEASE_DIR, 'pty.node'),
+  path.join(RELEASE_DIR, 'pty.pdb'),
+  path.join(RELEASE_DIR, 'winpty-agent.exe'),
+  path.join(RELEASE_DIR, 'winpty-agent.pdb'),
+  path.join(RELEASE_DIR, 'winpty.dll'),
+  path.join(RELEASE_DIR, 'winpty.pdb')
+];
+
+cleanFolderRecursive = function(folder) {
+  var files = [];
+  if( fs.existsSync(folder) ) {
+    files = fs.readdirSync(folder);
+    files.forEach(function(file,index) {
+      var curPath = path.join(folder, file);
+      if(fs.lstatSync(curPath).isDirectory()) { // recurse
+        cleanFolderRecursive(curPath);
+        fs.rmdirSync(curPath);
+      } else if (BUILD_FILES.indexOf(curPath) < 0){ // delete file
+        fs.unlinkSync(curPath);
+      }
+    });
+  }
+};
+
+try {
+  cleanFolderRecursive(RELEASE_DIR);
+} catch(e) {
+  console.log(e);
+  //process.exit(1);
+} finally {
+  process.exit(0);
+}

package/node_modules/node-pty-prebuilt-multiarch/scripts/publish.js

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ */
+
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const packageJson = require('../package.json');
+
+// Setup auth
+fs.writeFileSync(`${process.env['HOME']}/.npmrc`, `//registry.npmjs.org/:_authToken=${process.env['NPM_AUTH_TOKEN']}`);
+
+// Determine if this is a stable or beta release
+const publishedVersions = getPublishedVersions();
+const isStableRelease = publishedVersions.indexOf(packageJson.version) === -1;
+
+// Get the next version
+let nextVersion = isStableRelease ? packageJson.version : getNextBetaVersion();
+console.log(`Publishing version: ${nextVersion}`);
+
+// Set the version in package.json
+const packageJsonFile = path.resolve(__dirname, '..', 'package.json');
+packageJson.version = nextVersion;
+fs.writeFileSync(packageJsonFile, JSON.stringify(packageJson, null, 2));
+
+// Publish
+const args = ['publish'];
+if (!isStableRelease) {
+  args.push('--tag', 'beta');
+}
+const result = cp.spawn('npm', args, { stdio: 'inherit' });
+result.on('exit', code => process.exit(code));
+
+function getNextBetaVersion() {
+  if (!/^[0-9]+\.[0-9]+\.[0-9]+$/.exec(packageJson.version)) {
+    console.error('The package.json version must be of the form x.y.z');
+    process.exit(1);
+  }
+  const tag = 'beta';
+  const stableVersion = packageJson.version.split('.');
+  const nextStableVersion = `${stableVersion[0]}.${parseInt(stableVersion[1]) + 1}.0`;
+  const publishedVersions = getPublishedVersions(nextStableVersion, tag);
+  if (publishedVersions.length === 0) {
+    return `${nextStableVersion}-${tag}1`;
+  }
+  const latestPublishedVersion = publishedVersions.sort((a, b) => {
+    const aVersion = parseInt(a.substr(a.search(/[0-9]+$/)));
+    const bVersion = parseInt(b.substr(b.search(/[0-9]+$/)));
+    return aVersion > bVersion ? -1 : 1;
+  })[0];
+  const latestTagVersion = parseInt(latestPublishedVersion.substr(latestPublishedVersion.search(/[0-9]+$/)), 10);
+  return `${nextStableVersion}-${tag}${latestTagVersion + 1}`;
+}
+
+function getPublishedVersions(version, tag) {
+  const versionsProcess = cp.spawnSync('npm', ['view', packageJson.name, 'versions', '--json']);
+  const versionsJson = JSON.parse(versionsProcess.stdout);
+  if (tag) {
+    return versionsJson.filter(v => !v.search(new RegExp(`${version}-${tag}[0-9]+`)));
+  }
+  return versionsJson;
+}

package/node_modules/node-pty-prebuilt-multiarch/src/conpty_console_list_agent.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ *
+ * This module fetches the console process list for a particular PID. It must be
+ * called from a different process (child_process.fork) as there can only be a
+ * single console attached to a process.
+ */
+
+let getConsoleProcessList: any;
+try {
+  getConsoleProcessList = require('../build/Release/conpty_console_list.node').getConsoleProcessList;
+} catch (err) {
+  getConsoleProcessList = require('../build/Debug/conpty_console_list.node').getConsoleProcessList;
+}
+
+const shellPid = parseInt(process.argv[2], 10);
+const consoleProcessList = getConsoleProcessList(shellPid);
+process.send({ consoleProcessList });
+process.exit(0);

package/node_modules/node-pty-prebuilt-multiarch/src/eventEmitter2.test.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ */
+
+import * as assert from 'assert';
+import { EventEmitter2 } from './eventEmitter2';
+
+describe('EventEmitter2', () => {
+  it('should fire listeners multiple times', () => {
+    const order: string[] = [];
+    const emitter = new EventEmitter2<number>();
+    emitter.event(data => order.push(data + 'a'));
+    emitter.event(data => order.push(data + 'b'));
+    emitter.fire(1);
+    emitter.fire(2);
+    assert.deepEqual(order, [ '1a', '1b', '2a', '2b' ]);
+  });
+
+  it('should not fire listeners once disposed', () => {
+    const order: string[] = [];
+    const emitter = new EventEmitter2<number>();
+    emitter.event(data => order.push(data + 'a'));
+    const disposeB = emitter.event(data => order.push(data + 'b'));
+    emitter.event(data => order.push(data + 'c'));
+    emitter.fire(1);
+    disposeB.dispose();
+    emitter.fire(2);
+    assert.deepEqual(order, [ '1a', '1b', '1c', '2a', '2c' ]);
+  });
+});

package/node_modules/node-pty-prebuilt-multiarch/src/eventEmitter2.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ */
+
+import { IDisposable } from './types';
+
+interface IListener<T> {
+  (e: T): void;
+}
+
+export interface IEvent<T> {
+  (listener: (e: T) => any): IDisposable;
+}
+
+export class EventEmitter2<T> {
+  private _listeners: IListener<T>[] = [];
+  private _event?: IEvent<T>;
+
+  public get event(): IEvent<T> {
+    if (!this._event) {
+      this._event = (listener: (e: T) => any) => {
+        this._listeners.push(listener);
+        const disposable = {
+          dispose: () => {
+            for (let i = 0; i < this._listeners.length; i++) {
+              if (this._listeners[i] === listener) {
+                this._listeners.splice(i, 1);
+                return;
+              }
+            }
+          }
+        };
+        return disposable;
+      };
+    }
+    return this._event;
+  }
+
+  public fire(data: T): void {
+    const queue: IListener<T>[] = [];
+    for (let i = 0; i < this._listeners.length; i++) {
+      queue.push(this._listeners[i]);
+    }
+    for (let i = 0; i < queue.length; i++) {
+      queue[i].call(undefined, data);
+    }
+  }
+}

package/node_modules/node-pty-prebuilt-multiarch/src/index.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2012-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+import { ITerminal, IPtyOpenOptions, IPtyForkOptions, IWindowsPtyForkOptions } from './interfaces';
+import { ArgvOrCommandLine } from './types';
+import { ptyPath } from './prebuild-file-path';
+
+let terminalCtor: any;
+if (process.platform === 'win32') {
+  terminalCtor = require('./windowsTerminal').WindowsTerminal;
+} else {
+  terminalCtor = require('./unixTerminal').UnixTerminal;
+}
+
+/**
+ * Forks a process as a pseudoterminal.
+ * @param file The file to launch.
+ * @param args The file's arguments as argv (string[]) or in a pre-escaped
+ * CommandLine format (string). Note that the CommandLine option is only
+ * available on Windows and is expected to be escaped properly.
+ * @param options The options of the terminal.
+ * @throws When the file passed to spawn with does not exists.
+ * @see CommandLineToArgvW https://msdn.microsoft.com/en-us/library/windows/desktop/bb776391(v=vs.85).aspx
+ * @see Parsing C++ Comamnd-Line Arguments https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
+ * @see GetCommandLine https://msdn.microsoft.com/en-us/library/windows/desktop/ms683156.aspx
+ */
+export function spawn(file?: string, args?: ArgvOrCommandLine, opt?: IPtyForkOptions | IWindowsPtyForkOptions): ITerminal {
+  return new terminalCtor(file, args, opt);
+}
+
+/** @deprecated */
+export function fork(file?: string, args?: ArgvOrCommandLine, opt?: IPtyForkOptions | IWindowsPtyForkOptions): ITerminal {
+  return new terminalCtor(file, args, opt);
+}
+
+/** @deprecated */
+export function createTerminal(file?: string, args?: ArgvOrCommandLine, opt?: IPtyForkOptions | IWindowsPtyForkOptions): ITerminal {
+  return new terminalCtor(file, args, opt);
+}
+
+export function open(options: IPtyOpenOptions): ITerminal {
+  return terminalCtor.open(options);
+}
+
+/**
+ * Expose the native API when not Windows, note that this is not public API and
+ * could be removed at any time.
+ */
+export const native = (process.platform !== 'win32' ? require('./prebuild-loader').default : null);

package/node_modules/node-pty-prebuilt-multiarch/src/interfaces.ts

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+import * as net from 'net';
+
+export interface IProcessEnv {
+  [key: string]: string;
+}
+
+export interface ITerminal {
+  /**
+   * Gets the name of the process.
+   */
+  process: string;
+
+  /**
+   * Gets the process ID.
+   */
+  pid: number;
+
+  /**
+   * Writes data to the socket.
+   * @param data The data to write.
+   */
+  write(data: string): void;
+
+  /**
+   * Resize the pty.
+   * @param cols The number of columns.
+   * @param rows The number of rows.
+   */
+  resize(cols: number, rows: number): void;
+
+  /**
+   * Close, kill and destroy the socket.
+   */
+  destroy(): void;
+
+  /**
+   * Kill the pty.
+   * @param signal The signal to send, by default this is SIGHUP. This is not
+   * supported on Windows.
+   */
+  kill(signal?: string): void;
+
+  /**
+   * Set the pty socket encoding.
+   */
+  setEncoding(encoding: string | null): void;
+
+  /**
+   * Resume the pty socket.
+   */
+  resume(): void;
+
+  /**
+   * Pause the pty socket.
+   */
+  pause(): void;
+
+  /**
+   * Alias for ITerminal.on(eventName, listener).
+   */
+  addListener(eventName: string, listener: (...args: any[]) => any): void;
+
+  /**
+   * Adds the listener function to the end of the listeners array for the event
+   * named eventName.
+   * @param eventName The event name.
+   * @param listener The callback function
+   */
+  on(eventName: string, listener: (...args: any[]) => any): void;
+
+  /**
+   * Returns a copy of the array of listeners for the event named eventName.
+   */
+  listeners(eventName: string): Function[];
+
+  /**
+   * Removes the specified listener from the listener array for the event named
+   * eventName.
+   */
+  removeListener(eventName: string, listener: (...args: any[]) => any): void;
+
+  /**
+   * Removes all listeners, or those of the specified eventName.
+   */
+  removeAllListeners(eventName: string): void;
+
+  /**
+   * Adds a one time listener function for the event named eventName. The next
+   * time eventName is triggered, this listener is removed and then invoked.
+   */
+  once(eventName: string, listener: (...args: any[]) => any): void;
+}
+
+interface IBasePtyForkOptions {
+  name?: string;
+  cols?: number;
+  rows?: number;
+  cwd?: string;
+  env?: { [key: string]: string };
+  encoding?: string;
+  handleFlowControl?: boolean;
+  flowControlPause?: string;
+  flowControlResume?: string;
+}
+
+export interface IPtyForkOptions extends IBasePtyForkOptions {
+  uid?: number;
+  gid?: number;
+}
+
+export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {
+  useConpty?: boolean;
+  conptyInheritCursor?: boolean;
+}
+
+export interface IPtyOpenOptions {
+  cols?: number;
+  rows?: number;
+  encoding?: string;
+}

package/node_modules/node-pty-prebuilt-multiarch/src/native.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+interface IConptyNative {
+  startProcess(file: string, cols: number, rows: number, debug: boolean, pipeName: string, conptyInheritCursor: boolean): IConptyProcess;
+  connect(ptyId: number, commandLine: string, cwd: string, env: string[], onExitCallback: (exitCode: number) => void): { pid: number };
+  resize(ptyId: number, cols: number, rows: number): void;
+  kill(ptyId: number): void;
+}
+
+interface IWinptyNative {
+  startProcess(file: string, commandLine: string, env: string[], cwd: string, cols: number, rows: number, debug: boolean): IWinptyProcess;
+  resize(processHandle: number, cols: number, rows: number): void;
+  kill(pid: number, innerPidHandle: number): void;
+  getProcessList(pid: number): number[];
+  getExitCode(innerPidHandle: number): number;
+}
+
+interface IUnixNative {
+  fork(file: string, args: string[], parsedEnv: string[], cwd: string, cols: number, rows: number, uid: number, gid: number, useUtf8: boolean, onExitCallback: (code: number, signal: number) => void): IUnixProcess;
+  open(cols: number, rows: number): IUnixOpenProcess;
+  process(fd: number, pty: string): string;
+  resize(fd: number, cols: number, rows: number): void;
+}
+
+interface IConptyProcess {
+  pty: number;
+  fd: number;
+  conin: string;
+  conout: string;
+}
+
+interface IWinptyProcess {
+  pty: number;
+  fd: number;
+  conin: string;
+  conout: string;
+  pid: number;
+  innerPid: number;
+  innerPidHandle: number;
+}
+
+interface IUnixProcess {
+  fd: number;
+  pid: number;
+  pty: string;
+}
+
+interface IUnixOpenProcess {
+  master: number;
+  slave: number;
+  pty: string;
+}

package/node_modules/node-pty-prebuilt-multiarch/src/prebuild-file-path.ts

@@ -0,0 +1,21 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+function prebuildName(): string {
+  const tags = [];
+
+  tags.push(process.versions.hasOwnProperty('electron') ? 'electron' : 'node');
+
+  tags.push('abi' + process.versions.modules);
+
+  if (os.platform() === 'linux' && fs.existsSync('/etc/alpine-release')) {
+    tags.push('musl');
+  }
+
+  return tags.join('.') + '.node';
+}
+
+const pathToBuild = path.resolve(__dirname, `../prebuilds/${os.platform()}-${os.arch()}/${prebuildName()}`);
+
+export const ptyPath: string | null = fs.existsSync(pathToBuild) ? pathToBuild : null;

package/node_modules/node-pty-prebuilt-multiarch/src/prebuild-loader.ts

@@ -0,0 +1,17 @@
+import { ptyPath } from './prebuild-file-path';
+
+let pty: IUnixNative;
+
+try {
+  pty = require(ptyPath || '../build/Release/pty.node');
+} catch (outerError) {
+  try {
+    pty = require(ptyPath ? '../build/Release/pty.node' : '../build/Debug/pty.node');
+  } catch (innerError) {
+    console.error('innerError', innerError);
+    // Re-throw the exception from the Release require if the Debug require fails as well
+    throw outerError;
+  }
+}
+
+export default pty;