@tothalex/cloud 0.0.40

package/src/os.d.ts

@@ -0,0 +1,293 @@
+declare module "os" {
+  interface CpuInfo {
+    model: string;
+    speed: number;
+    /** The number of milliseconds spent by the CPU in each mode cannot be obtained at this time. */
+    times: {
+      /** The number of milliseconds the CPU has spent in user mode. */
+      user: number;
+      /** The number of milliseconds the CPU has spent in nice mode. */
+      nice: number;
+      /** The number of milliseconds the CPU has spent in sys mode. */
+      sys: number;
+      /** The number of milliseconds the CPU has spent in idle mode. */
+      idle: number;
+      /** The number of milliseconds the CPU has spent in irq mode. */
+      irq: number;
+    };
+  }
+  interface NetworkInterfaceBase {
+    address: string;
+    netmask: string;
+    mac: string;
+    internal: boolean;
+    cidr: string | null;
+  }
+  interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
+    family: "IPv4";
+    scopeid?: undefined;
+  }
+  interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
+    family: "IPv6";
+    scopeid: number;
+  }
+  interface UserInfo<T> {
+    username: T;
+    uid: number;
+    gid: number;
+    shell: T | null;
+    homedir: T;
+  }
+  type NetworkInterfaceInfo =
+    | NetworkInterfaceInfoIPv4
+    | NetworkInterfaceInfoIPv6;
+  /**
+   * Returns an estimate of the default amount of parallelism a program should use.
+   * Always returns a value greater than zero.
+   */
+  function availableParallelism(): number;
+  /**
+   * Returns the operating system CPU architecture for which the LLRT binary was compiled.
+   * Possible values are 'arm64', 'x64'. The return value is equivalent to `process.arch`.
+   */
+  function arch(): string;
+  /**
+   * Returns an array of objects containing information about each logical CPU core.
+   * The array will be empty if no CPU information is available, such as if the `/proc` file system is unavailable.
+   *
+   * The properties included on each object include:
+   *
+   * ```js
+   * [
+   *   {
+   *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+   *     speed: 2926,
+   *     times: {
+   *       user: 252020,
+   *       nice: 0,
+   *       sys: 30340,
+   *       idle: 1070356870,
+   *       irq: 0,
+   *     },
+   *   },
+   *   {
+   *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+   *     speed: 2926,
+   *     times: {
+   *       user: 306960,
+   *       nice: 0,
+   *       sys: 26980,
+   *       idle: 1071569080,
+   *       irq: 0,
+   *     },
+   *   },
+   *   {
+   *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+   *     speed: 2926,
+   *     times: {
+   *       user: 248450,
+   *       nice: 0,
+   *       sys: 21750,
+   *       idle: 1070919370,
+   *       irq: 0,
+   *     },
+   *   },
+   *   {
+   *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+   *     speed: 2926,
+   *     times: {
+   *       user: 256880,
+   *       nice: 0,
+   *       sys: 19430,
+   *       idle: 1070905480,
+   *       irq: 20,
+   *     },
+   *   },
+   * ]
+   * ```
+   *
+   * `nice` values are POSIX-only. On Windows, the `nice` values of all processors
+   * are always 0.
+   *
+   * `os.cpus().length` should not be used to calculate the amount of parallelism
+   * available to an application. Use {@link availableParallelism} for this purpose.
+   */
+  function cpus(): CpuInfo[];
+  const devNull: string;
+  /**
+   * Returns a string identifying the endianness of the CPU for which the Node.js
+   * binary was compiled.
+   *
+   * Possible values are `'BE'` for big endian and `'LE'` for little endian.
+   */
+  function endianness(): "BE" | "LE";
+  /**
+   * The operating system-specific end-of-line marker.
+   * * `\n` on POSIX
+   * * `\r\n` on Windows
+   */
+  const EOL: string;
+  /**
+   * Returns the amount of free system memory in bytes as an integer.
+   */
+  function freemem(): number;
+  /**
+   * Returns the scheduling priority for the process specified by `pid`. If `pid` is
+   * not provided or is `0`, the priority of the current process is returned.
+   * @param [pid=0] The process ID to retrieve scheduling priority for.
+   */
+  function getPriority(pid?: number): number;
+  /**
+   * Returns the string path of the current user's home directory.
+   *
+   * On POSIX, it uses the `$HOME` environment variable if defined. Otherwise it
+   * uses the [effective UID](https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID) to look up the user's home directory.
+   *
+   * On Windows, it uses the `USERPROFILE` environment variable if defined.
+   * Otherwise it uses the path to the profile directory of the current user.
+   */
+  function homedir(): string;
+  /**
+   * Returns the host name of the operating system as a string.
+   */
+  function hostname(): string;
+  /**
+   * Returns an array containing the 1, 5, and 15 minute load averages.
+   *
+   * The load average is a measure of system activity calculated by the operating
+   * system and expressed as a fractional number.
+   *
+   * The load average is a Unix-specific concept. On Windows, the return value is
+   * always `[0, 0, 0]`.
+   */
+  function loadavg(): number[];
+  /**
+   * Returns the machine type as a string, such as `arm64`, `aarch64`, `x86_64`.
+   *
+   * On POSIX systems, the machine type is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used, and if it is not
+   * available, `GetVersionExW()` will be used. See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+   */
+  function machine(): string;
+  /**
+   * Returns an object containing network interfaces that have been assigned a
+   * network address.
+   *
+   * Each key on the returned object identifies a network interface. The associated
+   * value is an array of objects that each describe an assigned network address.
+   *
+   * The properties available on the assigned network address object include:
+   *
+   * ```js
+   * {
+   *   lo: [
+   *     {
+   *       address: '127.0.0.1',
+   *       netmask: '255.0.0.0',
+   *       family: 'IPv4',
+   *       mac: '00:00:00:00:00:00',
+   *       internal: true,
+   *       cidr: '127.0.0.1/8'
+   *     },
+   *     {
+   *       address: '::1',
+   *       netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
+   *       family: 'IPv6',
+   *       mac: '00:00:00:00:00:00',
+   *       scopeid: 0,
+   *       internal: true,
+   *       cidr: '::1/128'
+   *     }
+   *   ],
+   *   eth0: [
+   *     {
+   *       address: '192.168.1.108',
+   *       netmask: '255.255.255.0',
+   *       family: 'IPv4',
+   *       mac: '01:02:03:0a:0b:0c',
+   *       internal: false,
+   *       cidr: '192.168.1.108/24'
+   *     },
+   *     {
+   *       address: 'fe80::a00:27ff:fe4e:66a1',
+   *       netmask: 'ffff:ffff:ffff:ffff::',
+   *       family: 'IPv6',
+   *       mac: '01:02:03:0a:0b:0c',
+   *       scopeid: 1,
+   *       internal: false,
+   *       cidr: 'fe80::a00:27ff:fe4e:66a1/64'
+   *     }
+   *   ]
+   * }
+   * ```
+   */
+  function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
+  /**
+   * Returns a string identifying the operating system platform for which
+   * the Node.js binary was compiled. The value is set at compile time.
+   */
+  function platform(): Platform;
+  function release(): string;
+  /**
+   * Returns the operating system's default directory for temporary files as a
+   * string.
+   */
+  /**
+   * Attempts to set the scheduling priority for the process specified by `pid`. If `pid` is not provided or is `0`, the process ID of the current process is used.
+   *
+   * The `priority` input must be an integer between `-20` (high priority) and `19` (low priority). Due to differences between Unix priority levels and Windows
+   * priority classes, `priority` is mapped to one of six priority constants in `os.constants.priority`. When retrieving a process priority level, this range
+   * mapping may cause the return value to be slightly different on Windows. To avoid
+   * confusion, set `priority` to one of the priority constants.
+   *
+   * On Windows, not currently supported on Windows.
+   *
+   * @param [pid=0] The process ID to set scheduling priority for.
+   * @param priority The scheduling priority to assign to the process.
+   */
+  function setPriority(priority: number): void;
+  function setPriority(pid: number, priority: number): void;
+  /**
+   * Returns the operating system release as a string.
+   *
+   * On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used. See
+   * [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+   */
+  function tmpdir(): string;
+  /**
+   * Returns the total amount of system memory in bytes as an integer.
+   */
+  function totalmem(): number;
+  /**
+   * Returns the operating system name as returned by [`uname(3)`](https://linux.die.net/man/3/uname). For example, it
+   * returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows.
+   *
+   * See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for additional information
+   * about the output of running [`uname(3)`](https://linux.die.net/man/3/uname) on various operating systems.
+   */
+  function type(): string;
+  /**
+   * Returns the system uptime in number of seconds.
+   */
+  function uptime(): number;
+  /**
+   * Returns a string identifying the kernel version.
+   *
+   * On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used.
+   * See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+   */
+  /**
+   * Returns information about the currently effective user. On POSIX platforms,
+   * this is typically a subset of the password file. The returned object includes
+   * the `username`, `uid`, `gid`, `shell`, and `homedir`. On Windows, the `uid` and `gid` fields are `-1`, and `shell` is `null`.
+   *
+   * The value of `homedir` returned by `os.userInfo()` is provided by the operating
+   * system. This differs from the result of `os.homedir()`, which queries
+   * environment variables for the home directory before falling back to the
+   * operating system response.
+   *
+   * Throws a [`SystemError`](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-systemerror) if a user has no `username` or `homedir`.
+   */
+  //function userInfo(options: { encoding: "buffer" }): UserInfo<Buffer>;
+  function userInfo(options?: { encoding: BufferEncoding }): UserInfo<string>;
+  function version(): string;
+}

package/src/process.d.ts

@@ -0,0 +1,379 @@
+declare module 'process' {
+  import { EventEmitter } from 'events'
+
+  global {
+    var process: Process
+
+    namespace QuickJS {
+      type Signals =
+        | 'SIGABRT'
+        | 'SIGALRM'
+        | 'SIGFPE'
+        | 'SIGHUP'
+        | 'SIGILL'
+        | 'SIGINT'
+        | 'SIGKILL'
+        | 'SIGPIPE'
+        | 'SIGQUIT'
+        | 'SIGSEGV'
+        | 'SIGTERM'
+    }
+    type Platform = 'darwin' | 'linux' | 'win32'
+    type Architecture = 'arm64' | 'x64'
+  }
+  interface Dict<T> {
+    [key: string]: T | undefined
+  }
+  // Alias for compatibility
+  interface ProcessEnv extends Dict<string> {}
+  interface HRTime {
+    (): [number, number]
+
+    /**
+     * The `bigint` version of the `{@link process.hrtime()}` method returning the current high-resolution real time in nanoseconds as a `bigint`.
+     */
+    bigint(): bigint
+  }
+  interface ProcessRelease {
+    name: string
+  }
+  interface ProcessVersions extends Dict<string> {
+    llrt: string
+  }
+  interface Process extends EventEmitter {
+    hrtime: HRTime
+    /**
+     * The `process.cwd()` method returns the current working directory of the llrt
+     * process.
+     *
+     * ```js
+     * import { cwd } from 'process';
+     *
+     * console.log(`Current directory: ${cwd()}`);
+     * ```
+     */
+    cwd(): string
+    /**
+     * The `process.argv0` property stores a read-only copy of the original value of`argv[0]` passed when llrt starts.
+     *
+     * ```console
+     * $ ./llrt -e 'console.log(process.argv[0])'
+     * ./llrt
+     * $ ./llrt -e 'console.log(process.argv0)'
+     * ./llrt
+     * ```
+     */
+    argv0: string
+    /**
+     * Returns the OS-assigned process identifier associated with this process.
+     */
+    id: number
+    /**
+     * The `process.argv` property returns an array containing the command-line
+     * arguments passed when the llrt process was launched. The first element will
+     * be {@link execPath}. See `process.argv0` if access to the original value
+     * of `argv[0]` is needed. The second element will be the path to the JavaScript
+     * file being executed. The remaining elements will be any additional command-line
+     * arguments.
+     *
+     * For example, assuming the following script for `process-args.js`:
+     *
+     * ```js
+     * import { argv } from 'process';
+     *
+     * // print process.argv
+     * argv.forEach((val, index) => {
+     *   console.log(`${index}: ${val}`);
+     * });
+     * ```
+     * ```
+     */
+    argv: string[]
+    /**
+     * The operating system CPU architecture for which the llrt binary was compiled.
+     * Possible values are: `'arm64'` and `'x64'`.
+     *
+     * ```js
+     * import { arch } from 'process';
+     *
+     * console.log(`This processor architecture is ${arch}`);
+     * ```
+     */
+    readonly arch: Architecture
+    /**
+     * The `process.platform` property returns a string identifying the operating
+     * system platform for which the llrt binary was compiled.
+     *
+     * Currently possible values are:
+     *
+     * * `'darwin'`
+     * * `'linux'`
+     * * `'win32'`
+     *
+     * ```js
+     * import { platform } from 'process';
+     *
+     * console.log(`This platform is ${platform}`);
+     * ```
+     */
+    readonly platform: Platform
+
+    /**
+     * The `process.release` property returns an `Object` containing metadata related
+     * to the current release, including URLs for the source tarball and headers-only
+     * tarball.
+     *
+     * `process.release` contains the following properties:
+     *
+     * ```js
+     * {
+     *   name: 'llrt',
+     * }
+     * ```
+     *
+     * In custom builds from non-release versions of the source tree, only the `name` property may be present. The additional properties should not be
+     * relied upon to exist.
+     */
+    readonly release: ProcessRelease
+    /**
+     * The `process.version` property contains the llrt version string.
+     *
+     * ```js
+     * import { version } from 'process';
+     *
+     * console.log(`Version: ${version}`);
+     * // Version: 0.1.15
+     * ```
+     */
+    readonly version: string
+    /**
+     * The `process.versions` property returns an object listing the version strings of
+     * llrt and its dependencies. `process.versions.modules` indicates the current
+     * ABI version, which is increased whenever a C++ API changes. llrt will refuse
+     * to load modules that were compiled against a different module ABI version.
+     *
+     * ```js
+     * import { versions } from 'process';
+     *
+     * console.log(versions);
+     * ```
+     *
+     * Will generate an object similar to:
+     *
+     * ```console
+     * {
+     *   llrt:'0.1.15'
+     * }
+     * ```
+     */
+    readonly versions: ProcessVersions
+    /**
+     * The `process.exit()` method instructs llrt to terminate the process
+     * synchronously with an exit status of `code`. If `code` is omitted, exit uses
+     * either the 'success' code `0` or the value of `process.exitCode` if it has been
+     * set. llrt will not terminate until all the `'exit'` event listeners are
+     * called.
+     *
+     * To exit with a 'failure' code:
+     *
+     * ```js
+     * import { exit } from 'process';
+     *
+     * exit(1);
+     * ```
+     */
+    exit(code?: number | string | null | undefined): never
+
+    /**
+     * The `process.exitCode` property indicates the exit code that will be used
+     * when the llrt process eventually exits. If it is not specified, the default
+     * exit code is `undefined` and will be 0 on exit.
+     *
+     * ```js
+     * import { exitCode, exit } from 'process';
+     *
+     * exitCode = 42;
+     * exit();
+     * ```
+     *
+     * This will cause the llrt process to exit with the exit code `42`.
+     */
+    exitCode: number | null
+
+    /**
+     * The `process.getgid()` method returns the numerical group identity of the
+     * process. (See [`getgid(2)`](http://man7.org/linux/man-pages/man2/getgid.2.html).)
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.getgid) {
+     *   console.log(`Current gid: ${process.getgid()}`);
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * @since v0.1.31
+     */
+    getgid?: () => number
+    /**
+     * The `process.setgid()` method sets the group identity of the process. (See [`setgid(2)`](http://man7.org/linux/man-pages/man2/setgid.2.html).) The `id` can be passed as either a
+     * numeric ID or a group name
+     * string. If a group name is specified, this method blocks while resolving the
+     * associated numeric ID.
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.getgid &#x26;&#x26; process.setgid) {
+     *   console.log(`Current gid: ${process.getgid()}`);
+     *   try {
+     *     process.setgid(501);
+     *     console.log(`New gid: ${process.getgid()}`);
+     *   } catch (err) {
+     *     console.log(`Failed to set gid: ${err}`);
+     *   }
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * This feature is not available in `Worker` threads.
+     * @since v0.1.31
+     * @param id The group name or ID
+     */
+    setgid?: (id: number) => void
+    /**
+     * The `process.getuid()` method returns the numeric user identity of the process.
+     * (See [`getuid(2)`](http://man7.org/linux/man-pages/man2/getuid.2.html).)
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.getuid) {
+     *   console.log(`Current uid: ${process.getuid()}`);
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * @since v0.1.28
+     */
+    getuid?: () => number
+    /**
+     * The `process.setuid(id)` method sets the user identity of the process. (See [`setuid(2)`](http://man7.org/linux/man-pages/man2/setuid.2.html).) The `id` can be passed as either a
+     * numeric ID or a username string.
+     * If a username is specified, the method blocks while resolving the associated
+     * numeric ID.
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.getuid &#x26;&#x26; process.setuid) {
+     *   console.log(`Current uid: ${process.getuid()}`);
+     *   try {
+     *     process.setuid(501);
+     *     console.log(`New uid: ${process.getuid()}`);
+     *   } catch (err) {
+     *     console.log(`Failed to set uid: ${err}`);
+     *   }
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * This feature is not available in `Worker` threads.
+     * @since v0.1.28
+     */
+    setuid?: (id: number) => void
+    /**
+     * The `process.geteuid()` method returns the numerical effective user identity of
+     * the process. (See [`geteuid(2)`](http://man7.org/linux/man-pages/man2/geteuid.2.html).)
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.geteuid) {
+     *   console.log(`Current uid: ${process.geteuid()}`);
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * @since v2.0.0
+     */
+    geteuid?: () => number
+    /**
+     * The `process.seteuid()` method sets the effective user identity of the process.
+     * (See [`seteuid(2)`](http://man7.org/linux/man-pages/man2/seteuid.2.html).) The `id` can be passed as either a numeric ID or a username
+     * string. If a username is specified, the method blocks while resolving the
+     * associated numeric ID.
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.geteuid &#x26;&#x26; process.seteuid) {
+     *   console.log(`Current uid: ${process.geteuid()}`);
+     *   try {
+     *     process.seteuid(501);
+     *     console.log(`New uid: ${process.geteuid()}`);
+     *   } catch (err) {
+     *     console.log(`Failed to set uid: ${err}`);
+     *   }
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * This feature is not available in `Worker` threads.
+     * @since v2.0.0
+     * @param id A user name or ID
+     */
+    seteuid?: (id: number) => void
+    /**
+     * The `process.getegid()` method returns the numerical effective group identity
+     * of the Node.js process. (See [`getegid(2)`](http://man7.org/linux/man-pages/man2/getegid.2.html).)
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.getegid) {
+     *   console.log(`Current gid: ${process.getegid()}`);
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * @since v2.0.0
+     */
+    getegid?: () => number
+    /**
+     * The `process.setegid()` method sets the effective group identity of the process.
+     * (See [`setegid(2)`](http://man7.org/linux/man-pages/man2/setegid.2.html).) The `id` can be passed as either a numeric ID or a group
+     * name string. If a group name is specified, this method blocks while resolving
+     * the associated a numeric ID.
+     *
+     * ```js
+     * import process from 'process';
+     *
+     * if (process.getegid &#x26;&#x26; process.setegid) {
+     *   console.log(`Current gid: ${process.getegid()}`);
+     *   try {
+     *     process.setegid(501);
+     *     console.log(`New gid: ${process.getegid()}`);
+     *   } catch (err) {
+     *     console.log(`Failed to set gid: ${err}`);
+     *   }
+     * }
+     * ```
+     *
+     * This function is only available on POSIX platforms (i.e. not Windows or
+     * Android).
+     * This feature is not available in `Worker` threads.
+     * @since v2.0.0
+     * @param id A group name or ID
+     */
+    setegid?: (id: number) => void
+  }
+}