@overdeck/desktop 0.45.11 → 0.45.12

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/src/windowsTerminal.ts

@@ -0,0 +1,208 @@
+/**
+ * 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 { Socket } from 'net';
+import { Terminal, DEFAULT_COLS, DEFAULT_ROWS } from './terminal';
+import { WindowsPtyAgent } from './windowsPtyAgent';
+import { IPtyOpenOptions, IWindowsPtyForkOptions } from './interfaces';
+import { ArgvOrCommandLine } from './types';
+import { assign } from './utils';
+
+const DEFAULT_FILE = 'cmd.exe';
+const DEFAULT_NAME = 'Windows Shell';
+
+export class WindowsTerminal extends Terminal {
+  private _isReady: boolean;
+  private _deferreds: any[];
+  private _agent: WindowsPtyAgent;
+
+  constructor(file?: string, args?: ArgvOrCommandLine, opt?: IWindowsPtyForkOptions) {
+    super(opt);
+
+    this._checkType('args', args, 'string', true);
+
+    // Initialize arguments
+    args = args || [];
+    file = file || DEFAULT_FILE;
+    opt = opt || {};
+    opt.env = opt.env || process.env;
+
+    if (opt.encoding) {
+      console.warn('Setting encoding on Windows is not supported');
+    }
+
+    const env = assign({}, opt.env);
+    this._cols = opt.cols || DEFAULT_COLS;
+    this._rows = opt.rows || DEFAULT_ROWS;
+    const cwd = opt.cwd || process.cwd();
+    const name = opt.name || env.TERM || DEFAULT_NAME;
+    const parsedEnv = this._parseEnv(env);
+
+    // If the terminal is ready
+    this._isReady = false;
+
+    // Functions that need to run after `ready` event is emitted.
+    this._deferreds = [];
+
+    // Create new termal.
+    this._agent = new WindowsPtyAgent(file, args, parsedEnv, cwd, this._cols, this._rows, false, opt.useConpty, opt.useConptyDll, opt.conptyInheritCursor);
+    this._socket = this._agent.outSocket;
+
+    // Not available until `ready` event emitted.
+    this._pid = this._agent.innerPid;
+    this._fd = this._agent.fd;
+    this._pty = this._agent.pty;
+
+    // The forked windows terminal is not available until `ready` event is
+    // emitted.
+    this._socket.on('ready_datapipe', () => {
+
+      // These events needs to be forwarded.
+      ['connect', 'data', 'end', 'timeout', 'drain'].forEach(event => {
+        this._socket.on(event, () => {
+
+          // Wait until the first data event is fired then we can run deferreds.
+          if (!this._isReady && event === 'data') {
+
+            // Terminal is now ready and we can avoid having to defer method
+            // calls.
+            this._isReady = true;
+
+            // Execute all deferred methods
+            this._deferreds.forEach(fn => {
+              // NB! In order to ensure that `this` has all its references
+              // updated any variable that need to be available in `this` before
+              // the deferred is run has to be declared above this forEach
+              // statement.
+              fn.run();
+            });
+
+            // Reset
+            this._deferreds = [];
+
+          }
+        });
+      });
+
+      // Shutdown if `error` event is emitted.
+      this._socket.on('error', err => {
+        // Close terminal session.
+        this._close();
+
+        // EIO, happens when someone closes our child process: the only process
+        // in the terminal.
+        // node < 0.6.14: errno 5
+        // node >= 0.6.14: read EIO
+        if ((<any>err).code) {
+          if (~(<any>err).code.indexOf('errno 5') || ~(<any>err).code.indexOf('EIO')) return;
+        }
+
+        // Throw anything else.
+        if (this.listeners('error').length < 2) {
+          throw err;
+        }
+      });
+
+      // Cleanup after the socket is closed.
+      this._socket.on('close', () => {
+        this.emit('exit', this._agent.exitCode);
+        this._close();
+      });
+
+    });
+
+    this._file = file;
+    this._name = name;
+
+    this._readable = true;
+    this._writable = true;
+
+    this._forwardEvents();
+  }
+
+  protected _write(data: string): void {
+    this._defer(this._doWrite, data);
+  }
+
+  private _doWrite(data: string): void {
+    this._agent.inSocket.write(data);
+  }
+
+  /**
+   * openpty
+   */
+
+  public static open(options?: IPtyOpenOptions): void {
+    throw new Error('open() not supported on windows, use Fork() instead.');
+  }
+
+  /**
+   * TTY
+   */
+
+  public resize(cols: number, rows: number): void {
+    if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) {
+      throw new Error('resizing must be done using positive cols and rows');
+    }
+    this._deferNoArgs(() => {
+      this._agent.resize(cols, rows);
+      this._cols = cols;
+      this._rows = rows;
+    });
+  }
+
+  public clear(): void {
+    this._deferNoArgs(() => {
+      this._agent.clear();
+    });
+  }
+
+  public destroy(): void {
+    this._deferNoArgs(() => {
+      this.kill();
+    });
+  }
+
+  public kill(signal?: string): void {
+    this._deferNoArgs(() => {
+      if (signal) {
+        throw new Error('Signals not supported on windows.');
+      }
+      this._close();
+      this._agent.kill();
+    });
+  }
+
+  private _deferNoArgs<A>(deferredFn: () => void): void {
+    // If the terminal is ready, execute.
+    if (this._isReady) {
+      deferredFn.call(this);
+      return;
+    }
+
+    // Queue until terminal is ready.
+    this._deferreds.push({
+      run: () => deferredFn.call(this)
+    });
+  }
+
+  private _defer<A>(deferredFn: (arg: A) => void, arg: A): void {
+    // If the terminal is ready, execute.
+    if (this._isReady) {
+      deferredFn.call(this, arg);
+      return;
+    }
+
+    // Queue until terminal is ready.
+    this._deferreds.push({
+      run: () => deferredFn.call(this, arg)
+    });
+  }
+
+  public get process(): string { return this._name; }
+  public get master(): Socket { throw new Error('master is not supported on Windows'); }
+  public get slave(): Socket { throw new Error('slave is not supported on Windows'); }
+}

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/src/worker/conoutSocketWorker.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2020, Microsoft Corporation (MIT License).
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import { Socket, createServer } from 'net';
+import { ConoutWorkerMessage, IWorkerData, getWorkerPipeName } from '../shared/conout';
+
+const { conoutPipeName } = (workerData as IWorkerData);
+
+const conoutSocket = new Socket();
+conoutSocket.setEncoding('utf8');
+conoutSocket.connect(conoutPipeName, () => {
+  const server = createServer(workerSocket => {
+    conoutSocket.pipe(workerSocket);
+  });
+  server.listen(getWorkerPipeName(conoutPipeName));
+  if (!parentPort) {
+    throw new Error('worker_threads parentPort is null');
+  }
+  parentPort.postMessage(ConoutWorkerMessage.READY);
+});

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/typings/node-pty.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+declare module '@homebridge/node-pty-prebuilt-multiarch' {
+  /**
+   * 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.
+   * @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: string[] | string, options: IPtyForkOptions | IWindowsPtyForkOptions): IPty;
+
+  export interface IBasePtyForkOptions {
+
+    /**
+     * Name of the terminal to be set in environment ($TERM variable).
+     */
+    name?: string;
+
+    /**
+     * Number of intial cols of the pty.
+     */
+    cols?: number;
+
+    /**
+     * Number of initial rows of the pty.
+     */
+    rows?: number;
+
+    /**
+     * Working directory to be set for the child program.
+     */
+    cwd?: string;
+
+    /**
+     * Environment to be set for the child program.
+     */
+    env?: { [key: string]: string | undefined };
+
+    /**
+     * String encoding of the underlying pty.
+     * If set, incoming data will be decoded to strings and outgoing strings to bytes applying this encoding.
+     * If unset, incoming data will be delivered as raw bytes (Buffer type).
+     * By default 'utf8' is assumed, to unset it explicitly set it to `null`.
+     */
+    encoding?: string | null;
+
+    /**
+     * (EXPERIMENTAL)
+     * Whether to enable flow control handling (false by default). If enabled a message of `flowControlPause`
+     * will pause the socket and thus blocking the child program execution due to buffer back pressure.
+     * A message of `flowControlResume` will resume the socket into flow mode.
+     * For performance reasons only a single message as a whole will match (no message part matching).
+     * If flow control is enabled the `flowControlPause` and `flowControlResume` messages are not forwarded to
+     * the underlying pseudoterminal.
+     */
+    handleFlowControl?: boolean;
+
+    /**
+     * (EXPERIMENTAL)
+     * The string that should pause the pty when `handleFlowControl` is true. Default is XOFF ('\x13').
+     */
+    flowControlPause?: string;
+
+    /**
+     * (EXPERIMENTAL)
+     * The string that should resume the pty when `handleFlowControl` is true. Default is XON ('\x11').
+     */
+    flowControlResume?: string;
+  }
+
+  export interface IPtyForkOptions extends IBasePtyForkOptions {
+    /**
+     * Security warning: use this option with great caution,
+     * as opened file descriptors with higher privileges might leak to the child program.
+     */
+    uid?: number;
+    gid?: number;
+  }
+
+  export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {
+    /**
+     * Whether to use the ConPTY system on Windows. When this is not set, ConPTY will be used when
+     * the Windows build number is >= 18309 (instead of winpty). Note that ConPTY is available from
+     * build 17134 but is too unstable to enable by default.
+     *
+     * This setting does nothing on non-Windows.
+     */
+    useConpty?: boolean;
+
+    /**
+     * (EXPERIMENTAL)
+     *
+     * Whether to use the conpty.dll shipped with the node-pty package instead of the one built into
+     * Windows. Defaults to false.
+     */
+    useConptyDll?: boolean;
+
+    /**
+     * Whether to use PSEUDOCONSOLE_INHERIT_CURSOR in conpty.
+     * @see https://docs.microsoft.com/en-us/windows/console/createpseudoconsole
+     */
+    conptyInheritCursor?: boolean;
+  }
+
+  /**
+   * An interface representing a pseudoterminal, on Windows this is emulated via the winpty library.
+   */
+  export interface IPty {
+    /**
+     * The process ID of the outer process.
+     */
+    readonly pid: number;
+
+    /**
+     * The column size in characters.
+     */
+    readonly cols: number;
+
+    /**
+     * The row size in characters.
+     */
+    readonly rows: number;
+
+    /**
+     * The title of the active process.
+     */
+    readonly process: string;
+
+    /**
+     * (EXPERIMENTAL)
+     * Whether to handle flow control. Useful to disable/re-enable flow control during runtime.
+     * Use this for binary data that is likely to contain the `flowControlPause` string by accident.
+     */
+    handleFlowControl: boolean;
+
+    /**
+     * Adds an event listener for when a data event fires. This happens when data is returned from
+     * the pty.
+     * @returns an `IDisposable` to stop listening.
+     */
+    readonly onData: IEvent<string>;
+
+    /**
+     * Adds an event listener for when an exit event fires. This happens when the pty exits.
+     * @returns an `IDisposable` to stop listening.
+     */
+    readonly onExit: IEvent<{ exitCode: number, signal?: number }>;
+
+    /**
+     * Resizes the dimensions of the pty.
+     * @param columns The number of columns to use.
+     * @param rows The number of rows to use.
+     */
+    resize(columns: number, rows: number): void;
+
+    // Re-added this interface as homebridge-config-ui-x leverages it https://github.com/microsoft/node-pty/issues/282
+
+    /**
+    * Adds a listener to the data event, fired when data is returned from the pty.
+    * @param event The name of the event.
+    * @param listener The callback function.
+    * @deprecated Use IPty.onData
+    */
+    on(event: 'data', listener: (data: string) => void): void;
+
+    /**
+     * Adds a listener to the exit event, fired when the pty exits.
+     * @param event The name of the event.
+     * @param listener The callback function, exitCode is the exit code of the process and signal is
+     * the signal that triggered the exit. signal is not supported on Windows.
+     * @deprecated Use IPty.onExit
+     */
+    on(event: 'exit', listener: (exitCode: number, signal?: number) => void): void;
+
+    /**
+     * Clears the pty's internal representation of its buffer. This is a no-op
+     * unless on Windows/ConPTY. This is useful if the buffer is cleared on the
+     * frontend in order to synchronize state with the backend to avoid ConPTY
+     * possibly reprinting the screen.
+     */
+    clear(): void;
+
+    /**
+     * Writes data to the pty.
+     * @param data The data to write.
+     */
+    write(data: string): void;
+
+    /**
+     * Kills the pty.
+     * @param signal The signal to use, defaults to SIGHUP. This parameter is not supported on
+     * Windows.
+     * @throws Will throw when signal is used on Windows.
+     */
+    kill(signal?: string): void;
+
+    /**
+     * Pauses the pty for customizable flow control.
+     */
+    pause(): void;
+
+    /**
+     * Resumes the pty for customizable flow control.
+     */
+    resume(): void;
+  }
+
+  /**
+   * An object that can be disposed via a dispose function.
+   */
+  export interface IDisposable {
+    dispose(): void;
+  }
+
+  /**
+   * An event that can be listened to.
+   * @returns an `IDisposable` to stop listening.
+   */
+  export interface IEvent<T> {
+    (listener: (e: T) => any): IDisposable;
+  }
+}

package/server/{supervisor-0oXvLwyC.js → supervisor-D5GC5jUM.js}

@@ -1,10 +1,10 @@
-import { Dr as LOGS_DIR, Ir as TRAEFIK_DIR, Or as OVERDECK_HOME, Tr as CONFIG_FILE, Vr as init_paths, vr as init_errors } from "./config-yaml-DPAieL_G.js";
+import { Dr as LOGS_DIR, Ir as TRAEFIK_DIR, Or as OVERDECK_HOME, Tr as CONFIG_FILE, Vr as init_paths, vr as init_errors } from "./config-yaml-ClpGgrf6.js";
 import { t as require_toml } from "./toml-CeLDATih.js";
+import { join } from "node:path";
 import "effect";
 import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { join as join$1 } from "path";
 import "node:fs";
-import { join as join$1 } from "node:path";
 import "node:child_process";
 import { exec as exec$1 } from "child_process";
 import { promisify } from "util";
@@ -33,7 +33,7 @@ init_paths();
 */
 init_paths();
 promisify(exec$1);
-join(LOGS_DIR, "dashboard.log");
+join$1(LOGS_DIR, "dashboard.log");
 function readPlatformConfigSync() {
 	const defaults = {
 		dashboardPort: 3010,
@@ -50,7 +50,7 @@ function readPlatformConfigSync() {
 			dashboardApiPort: config.dashboard?.api_port || defaults.dashboardApiPort,
 			traefikEnabled: config.traefik?.enabled === true,
 			traefikDomain: config.traefik?.domain || defaults.traefikDomain,
-			traefikDir: join(OVERDECK_HOME, "traefik")
+			traefikDir: join$1(OVERDECK_HOME, "traefik")
 		};
 	} catch {
 		return defaults;
@@ -60,8 +60,8 @@ function readPlatformConfigSync() {
 //#region ../../lib/supervisor.ts
 init_paths();
 init_errors();
-join$1(OVERDECK_HOME, "supervisor.pid");
-join$1(LOGS_DIR, "supervisor.log");
+join(OVERDECK_HOME, "supervisor.pid");
+join(LOGS_DIR, "supervisor.log");
 /** Compute the supervisor's port from the configured dashboard API port. */
 function getSupervisorPortSync() {
 	return readPlatformConfigSync().dashboardApiPort + 1;
@@ -73,4 +73,4 @@ function getSupervisorUrlSync() {
 //#endregion
 export { getSupervisorUrlSync as n, getSupervisorPortSync as t };
 
-//# sourceMappingURL=supervisor-0oXvLwyC.js.map
+//# sourceMappingURL=supervisor-D5GC5jUM.js.map

package/server/supervisor-DQMK2e3I.js

@@ -0,0 +1,2 @@
+import { n as getSupervisorUrlSync } from "./supervisor-D5GC5jUM.js";
+export { getSupervisorUrlSync };

package/server/{swarm-readiness-OBgamRql.js → swarm-readiness-Cf9mommA.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { T as init_specs } from "./io-Wy8YpFeP.js";
-import { c as groupItemsByWave, i as compileGlob, l as hasFileOverlap, s as getDispatchableItems, u as init_dag } from "./dag-jH8ZkewR.js";
+import { T as init_specs } from "./io-A7ZuOBkz.js";
+import { c as groupItemsByWave, i as compileGlob, l as hasFileOverlap, s as getDispatchableItems, u as init_dag } from "./dag-Dv2r5bVD.js";
 import "effect";
 //#region ../../lib/vbrief/swarm-readiness.ts
 function computeIssueFootprint(doc) {
@@ -112,4 +112,4 @@ var init_swarm_readiness = __esmMin((() => {
 //#endregion
 export { computeIssueFootprint as n, init_swarm_readiness as r, analyzeSwarmReadiness as t };
 
-//# sourceMappingURL=swarm-readiness-OBgamRql.js.map
+//# sourceMappingURL=swarm-readiness-Cf9mommA.js.map