commandmate 0.10.3 → 0.11.0

package/dist/cli/utils/daemon.js

@@ -12,6 +12,7 @@ const dotenv_1 = require("dotenv");
 const pid_manager_1 = require("./pid-manager");
 const paths_1 = require("./paths");
 const env_setup_1 = require("./env-setup");
+const package_info_1 = require("./package-info");
 const security_messages_1 = require("../config/security-messages");
 const logger_1 = require("./logger");
 const server_url_1 = require("./server-url");
@@ -116,9 +117,23 @@ class DaemonManager {
         // Unref to allow parent to exit
         child.unref();
         const pid = child.pid;
-        // Write PID file atomically
-        if (!this.pidManager.writePid(pid)) {
-            // Failed to write PID - another process may have started
+        // Issue #1354/#1355/#1358: persist the daemon's version, effective settings, and a
+        // process-identity signature so status/stop/start can report and verify the actual server,
+        // not re-derive it from a possibly-diverged .env. The port/protocol/auth recorded here are
+        // exactly what start() handed the child above.
+        const state = {
+            pid,
+            version: (0, package_info_1.readPackageVersion)(),
+            port: parseInt(port, 10),
+            bind: bindAddress,
+            protocol,
+            auth: !!env.CM_AUTH_TOKEN_HASH,
+            startedAt: new Date().toISOString(),
+            startTime: this.pidManager.getStartTime(pid) ?? undefined,
+        };
+        // Write state file atomically
+        if (!this.pidManager.writeState(state)) {
+            // Failed to write state - another process may have started
             try {
                 process.kill(pid, 'SIGTERM');
             }
@@ -162,24 +177,44 @@ class DaemonManager {
      * @returns Status object or null if no PID file
      */
     async getStatus() {
-        const pid = this.pidManager.readPid();
-        if (pid === null) {
+        const state = this.pidManager.readState();
+        if (state === null) {
             return null;
         }
         const running = this.pidManager.isProcessRunning();
         if (!running) {
             return { running: false };
         }
-        // Issue #1266: resolve with the same precedence start() hands the child. Reading
-        // process.env directly reported the shell's CM_PORT, not the port the server is on.
-        const { port, url } = (0, server_url_1.resolveServerEndpoint)(this.getEffectiveEnv());
+        let port;
+        let url;
+        if (state.port !== undefined) {
+            // Issue #1355: report the effective settings the server was started with, recorded in the
+            // state file, rather than re-deriving them from a .env that may have changed since.
+            port = state.port;
+            const protocol = state.protocol ?? 'http';
+            const bind = state.bind ?? '127.0.0.1';
+            const host = bind === '0.0.0.0' ? '127.0.0.1' : bind;
+            url = `${protocol}://${host}:${port}`;
+        }
+        else {
+            // Legacy state file (PID only, e.g. a daemon started before this change): fall back to
+            // Issue #1266's .env resolution, which gives .env precedence exactly as start() does.
+            const resolved = (0, server_url_1.resolveServerEndpoint)(this.getEffectiveEnv());
+            port = resolved.port;
+            url = resolved.url;
+        }
         // Note: Getting accurate uptime would require storing start time
         // For now, we don't track uptime
         return {
             running: true,
-            pid,
+            pid: state.pid,
             port,
             url,
+            // Issue #1354: surface the version the daemon actually runs, so status can flag a stale
+            // daemon of a different version than the installed CLI.
+            version: state.version,
+            protocol: state.protocol,
+            auth: state.auth,
         };
     }
     /**

package/dist/cli/utils/npx-runner.d.ts

@@ -0,0 +1,88 @@
+/**
+ * npx Execution Wrapper
+ * Issue #1395: GUI one-click self-update for npx-launched servers.
+ *
+ * The npx self-update fetches a fresh npx cache and relaunches the daemon from
+ * it (design §2.1), rather than mutating a global install (rejected Alt C). This
+ * module owns the two npx spawns and the env hygiene they need:
+ *
+ * - `warmNpxLatest`  — force-download the latest and read back its version, so
+ *   staleness can be caught *before* the old daemon is stopped (design §4.2).
+ * - `spawnNpxDaemon` — relaunch the server from the freshly-cached version.
+ * - `sanitizeNpxEnv` — strip the `npm_*` env a `npm run start` parent leaks, so
+ *   it cannot skew npx's registry/cache/prefix resolution (design §7.3).
+ *
+ * MF-SEC-1 (mirrors npm-runner): every command uses spawnSync with array args,
+ * never a shell string. `packageName` is always a literal constant supplied by
+ * the caller (update.ts PACKAGE_NAME) — never built from request input (§5).
+ *
+ * @module npx-runner
+ */
+/**
+ * Upper bound for the warmup download.
+ *
+ * The warmup runs *before* the old daemon is stopped, so hitting this bound
+ * aborts with zero downtime (design §4.2). Kept comfortably under the banner's
+ * UPDATE_TIMEOUT_MS (5 min, UpdateNotificationBanner.tsx) so a stalled download
+ * aborts and logs before the GUI gives up (design §8.2 / §9-8).
+ */
+export declare const NPX_WARMUP_TIMEOUT_MS: number;
+/** Result of the warmup + version query */
+export interface NpxWarmResult {
+    /** Whether the warmup succeeded and a version was read */
+    success: boolean;
+    /** Version reported by `<pkg> --version` (only when success) */
+    version?: string;
+    /** Human readable failure reason (only when !success) */
+    error?: string;
+}
+/** Result of the daemon relaunch */
+export interface NpxDaemonResult {
+    /** Whether the relaunch exited 0 */
+    success: boolean;
+    /** Exit status of the npx process (null when it never ran) */
+    status: number | null;
+    /** Human readable failure reason (only when !success) */
+    error?: string;
+}
+/**
+ * Build an env for an npx spawn with the leaked `npm_*` variables removed.
+ *
+ * A server started by `npm run start` carries `npm_config_*` / `npm_lifecycle_*`
+ * / `npm_package_*` in its env; those flow down the inherit chain into the npx
+ * call and npx reads `npm_config_*` as configuration, which would silently
+ * redirect its registry/cache/prefix (design §7.3). Everything else — notably
+ * `CM_*` (config continuity) and `PATH` (needed to locate npx) — passes through.
+ *
+ * @param env - Source env (defaults to the current process env)
+ * @returns A fresh env object with all `npm_*` keys removed
+ */
+export declare function sanitizeNpxEnv(env?: Record<string, string | undefined>): NodeJS.ProcessEnv;
+/**
+ * Force-fetch the latest published version via npx and read back its version.
+ *
+ * `npx --yes <pkg>@latest --version` downloads the latest into the npx cache
+ * (`--yes` suppresses the install prompt) and prints the package version;
+ * commander's `.version()` short-circuits before any command runs, so this has
+ * no side effects and starts no server (design §2.1). Running it before the
+ * stop lets a stale/failed fetch abort with zero downtime (design §4.2).
+ *
+ * @param packageName - Package name (a literal constant, e.g. `commandmate`)
+ * @returns The fetched version, or a classified failure
+ */
+export declare function warmNpxLatest(packageName: string): NpxWarmResult;
+/**
+ * Relaunch the server as a daemon from the freshly-cached npx version.
+ *
+ * `npx --yes <pkg>@latest start --daemon` runs the just-warmed package (so no
+ * new download) and spawns `npm run start` from the new cache dir; the npx
+ * process exits once the daemon is detached. `start --daemon` is used rather
+ * than the bare quickstart, which bails in a non-interactive process (design
+ * §2.1). The call blocks until npx exits, so the exit status is the relaunch
+ * outcome. Output is echoed so it lands in the update log.
+ *
+ * @param packageName - Package name (a literal constant, e.g. `commandmate`)
+ * @returns Success, or a classified failure carrying the exit status
+ */
+export declare function spawnNpxDaemon(packageName: string): NpxDaemonResult;
+//# sourceMappingURL=npx-runner.d.ts.map

package/dist/cli/utils/npx-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npx-runner.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/npx-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,QAAgB,CAAC;AAEnD,2CAA2C;AAC3C,MAAM,WAAW,aAAa;IAC5B,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;IACjB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAAC,UAAU,CAWnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAoChE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe,CAyCnE"}

package/dist/cli/utils/npx-runner.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * npx Execution Wrapper
+ * Issue #1395: GUI one-click self-update for npx-launched servers.
+ *
+ * The npx self-update fetches a fresh npx cache and relaunches the daemon from
+ * it (design §2.1), rather than mutating a global install (rejected Alt C). This
+ * module owns the two npx spawns and the env hygiene they need:
+ *
+ * - `warmNpxLatest`  — force-download the latest and read back its version, so
+ *   staleness can be caught *before* the old daemon is stopped (design §4.2).
+ * - `spawnNpxDaemon` — relaunch the server from the freshly-cached version.
+ * - `sanitizeNpxEnv` — strip the `npm_*` env a `npm run start` parent leaks, so
+ *   it cannot skew npx's registry/cache/prefix resolution (design §7.3).
+ *
+ * MF-SEC-1 (mirrors npm-runner): every command uses spawnSync with array args,
+ * never a shell string. `packageName` is always a literal constant supplied by
+ * the caller (update.ts PACKAGE_NAME) — never built from request input (§5).
+ *
+ * @module npx-runner
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NPX_WARMUP_TIMEOUT_MS = void 0;
+exports.sanitizeNpxEnv = sanitizeNpxEnv;
+exports.warmNpxLatest = warmNpxLatest;
+exports.spawnNpxDaemon = spawnNpxDaemon;
+const child_process_1 = require("child_process");
+/**
+ * Upper bound for the warmup download.
+ *
+ * The warmup runs *before* the old daemon is stopped, so hitting this bound
+ * aborts with zero downtime (design §4.2). Kept comfortably under the banner's
+ * UPDATE_TIMEOUT_MS (5 min, UpdateNotificationBanner.tsx) so a stalled download
+ * aborts and logs before the GUI gives up (design §8.2 / §9-8).
+ */
+exports.NPX_WARMUP_TIMEOUT_MS = 3 * 60 * 1000;
+/**
+ * Build an env for an npx spawn with the leaked `npm_*` variables removed.
+ *
+ * A server started by `npm run start` carries `npm_config_*` / `npm_lifecycle_*`
+ * / `npm_package_*` in its env; those flow down the inherit chain into the npx
+ * call and npx reads `npm_config_*` as configuration, which would silently
+ * redirect its registry/cache/prefix (design §7.3). Everything else — notably
+ * `CM_*` (config continuity) and `PATH` (needed to locate npx) — passes through.
+ *
+ * @param env - Source env (defaults to the current process env)
+ * @returns A fresh env object with all `npm_*` keys removed
+ */
+function sanitizeNpxEnv(env = process.env) {
+    // Built as a plain record: the project augments ProcessEnv with a required
+    // NODE_ENV, so an empty ProcessEnv literal would not typecheck.
+    const clean = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (/^npm_/i.test(key)) {
+            continue;
+        }
+        clean[key] = value;
+    }
+    return clean;
+}
+/**
+ * Force-fetch the latest published version via npx and read back its version.
+ *
+ * `npx --yes <pkg>@latest --version` downloads the latest into the npx cache
+ * (`--yes` suppresses the install prompt) and prints the package version;
+ * commander's `.version()` short-circuits before any command runs, so this has
+ * no side effects and starts no server (design §2.1). Running it before the
+ * stop lets a stale/failed fetch abort with zero downtime (design §4.2).
+ *
+ * @param packageName - Package name (a literal constant, e.g. `commandmate`)
+ * @returns The fetched version, or a classified failure
+ */
+function warmNpxLatest(packageName) {
+    const result = (0, child_process_1.spawnSync)('npx', ['--yes', `${packageName}@latest`, '--version'], {
+        encoding: 'utf-8',
+        timeout: exports.NPX_WARMUP_TIMEOUT_MS,
+        env: sanitizeNpxEnv(),
+    });
+    if (result.error) {
+        const errnoError = result.error;
+        if (errnoError.code === 'ENOENT') {
+            return {
+                success: false,
+                error: 'npx command not found. Install Node.js/npm and try again.',
+            };
+        }
+        return { success: false, error: errnoError.message };
+    }
+    if (result.status !== 0) {
+        const stderr = readStream(result.stderr);
+        return {
+            success: false,
+            error: stderr || `npx exited with status ${String(result.status)}`,
+        };
+    }
+    const version = parseVersion(readStream(result.stdout));
+    if (!version) {
+        return { success: false, error: 'npx did not report a version' };
+    }
+    return { success: true, version };
+}
+/**
+ * Relaunch the server as a daemon from the freshly-cached npx version.
+ *
+ * `npx --yes <pkg>@latest start --daemon` runs the just-warmed package (so no
+ * new download) and spawns `npm run start` from the new cache dir; the npx
+ * process exits once the daemon is detached. `start --daemon` is used rather
+ * than the bare quickstart, which bails in a non-interactive process (design
+ * §2.1). The call blocks until npx exits, so the exit status is the relaunch
+ * outcome. Output is echoed so it lands in the update log.
+ *
+ * @param packageName - Package name (a literal constant, e.g. `commandmate`)
+ * @returns Success, or a classified failure carrying the exit status
+ */
+function spawnNpxDaemon(packageName) {
+    const result = (0, child_process_1.spawnSync)('npx', ['--yes', `${packageName}@latest`, 'start', '--daemon'], {
+        encoding: 'utf-8',
+        env: sanitizeNpxEnv(),
+    });
+    const stdout = readStream(result.stdout);
+    const stderr = readStream(result.stderr);
+    if (stdout) {
+        console.log(stdout);
+    }
+    if (stderr) {
+        console.error(stderr);
+    }
+    if (result.error) {
+        const errnoError = result.error;
+        if (errnoError.code === 'ENOENT') {
+            return {
+                success: false,
+                status: null,
+                error: 'npx command not found. Install Node.js/npm and try again.',
+            };
+        }
+        return { success: false, status: result.status, error: errnoError.message };
+    }
+    if (result.status !== 0) {
+        return {
+            success: false,
+            status: result.status,
+            error: stderr || `npx start exited with status ${String(result.status)}`,
+        };
+    }
+    return { success: true, status: 0 };
+}
+/**
+ * Extract the first semver-looking token from `--version` output.
+ * Robust against npx warning noise that may share the stream.
+ */
+function parseVersion(output) {
+    const match = output.match(/\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)\b/);
+    return match ? match[1] : null;
+}
+/**
+ * Read a spawnSync stream as a trimmed string.
+ * `encoding: 'utf-8'` yields strings, but mocks/edge cases may yield null.
+ */
+function readStream(stream) {
+    if (typeof stream === 'string') {
+        return stream.trim();
+    }
+    return '';
+}

package/dist/cli/utils/package-info.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Package Info
+ * Issue #1354: record and report the version the daemon was started with
+ *
+ * The daemon records this at launch (into the state file) and `status` reads the currently
+ * installed version to warn when a stale daemon of a different version is still running.
+ */
+/**
+ * Read the version from the installed package.json.
+ *
+ * Reads from disk rather than `require('../../package.json')` so a fresh `npm i -g` is observed
+ * without the module cache pinning the version that was current when this process started.
+ *
+ * @returns The version string, or undefined when package.json cannot be read or has no version
+ */
+export declare function readPackageVersion(): string | undefined;
+//# sourceMappingURL=package-info.d.ts.map

package/dist/cli/utils/package-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-info.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/package-info.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,SAAS,CASvD"}

package/dist/cli/utils/package-info.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Package Info
+ * Issue #1354: record and report the version the daemon was started with
+ *
+ * The daemon records this at launch (into the state file) and `status` reads the currently
+ * installed version to warn when a stale daemon of a different version is still running.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageVersion = readPackageVersion;
+const fs_1 = require("fs");
+const paths_1 = require("./paths");
+/**
+ * Read the version from the installed package.json.
+ *
+ * Reads from disk rather than `require('../../package.json')` so a fresh `npm i -g` is observed
+ * without the module cache pinning the version that was current when this process started.
+ *
+ * @returns The version string, or undefined when package.json cannot be read or has no version
+ */
+function readPackageVersion() {
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)((0, paths_1.getPackageJsonPath)(), 'utf-8'));
+        return typeof parsed.version === 'string' && parsed.version.length > 0
+            ? parsed.version
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cli/utils/pid-manager.d.ts

@@ -1,42 +1,98 @@
 /**
- * PID File Manager
+ * PID / Daemon State File Manager
  * Issue #96: npm install CLI support
  * Issue #136: Phase 2 - Task 2.4 - Added factory functions for Issue number support
+ * Issue #1354/#1355/#1358: the file now records the daemon's version, effective settings, and
+ *   a process-identity signature, not just the PID. See DaemonState.
  * SF-1: SRP - Separated from daemon.ts for single responsibility
  * MF-SEC-2: TOCTOU protection with O_EXCL atomic writes
  */
+import { ProcessStartTimeReader } from './process-inspector';
+/**
+ * The daemon state persisted alongside the PID.
+ *
+ * Only `pid` is guaranteed: files written by older versions held just the PID as a bare integer,
+ * so every other field is optional and readState() tolerates their absence (backward compat).
+ */
+export interface DaemonState {
+    /** Process ID of the daemon */
+    pid: number;
+    /** Package version the daemon was started with (Issue #1354) */
+    version?: string;
+    /** Effective port the server listens on (Issue #1355) */
+    port?: number;
+    /** Effective bind address, as configured (Issue #1355) */
+    bind?: string;
+    /** Effective protocol the server speaks (Issue #1355) */
+    protocol?: 'http' | 'https';
+    /** Whether token authentication was enabled at startup (Issue #1355) */
+    auth?: boolean;
+    /** ISO timestamp of when this record was written */
+    startedAt?: string;
+    /** OS-reported process start time, used to detect PID reuse (Issue #1358) */
+    startTime?: string;
+}
 /**
  * PID file manager for daemon process tracking
  */
 export declare class PidManager {
     private readonly pidFilePath;
-    constructor(pidFilePath: string);
+    private readonly readStartTime;
     /**
-     * Check if PID file exists
+     * @param pidFilePath - Path to the state file for this server
+     * @param readStartTime - Injectable process-identity reader (Issue #1358); defaults to `ps`.
+     *   Overridden in tests to avoid spawning a real process.
+     */
+    constructor(pidFilePath: string, readStartTime?: ProcessStartTimeReader);
+    /**
+     * Check if the state file exists
      */
     exists(): boolean;
     /**
-     * Read PID from file
+     * Read the daemon state from file.
+     *
+     * Tolerates the legacy format (a bare integer PID) by returning `{ pid }`, so a state file
+     * written by an older running daemon is still understood after a CLI upgrade (Issue #1354).
+     *
+     * @returns The daemon state, or null when the file is missing or invalid
+     */
+    readState(): DaemonState | null;
+    /**
+     * Read PID from the state file
      * @returns PID number or null if file doesn't exist or is invalid
      */
     readPid(): number | null;
     /**
-     * Write PID to file atomically
+     * Write the daemon state to file atomically
      * MF-SEC-2: Uses O_EXCL to prevent TOCTOU race conditions
      *
      * @returns true if successful, false if file already exists
      * @throws Error for other filesystem errors
      */
-    writePid(pid: number): boolean;
+    writeState(state: DaemonState): boolean;
     /**
-     * Remove PID file
+     * Read a live process's start-time signature via the injected reader.
+     * Used by start() to record the daemon's identity at launch (Issue #1358).
+     *
+     * @param pid - Process ID to inspect
+     * @returns The start-time signature, or null when it cannot be read
+     */
+    getStartTime(pid: number): string | null;
+    /**
+     * Remove the state file
      */
     removePid(): void;
     /**
-     * Check if the process recorded in PID file is running
+     * Check if the process recorded in the state file is the daemon we started.
      * NTH-1: ISP - Lightweight process check API
      *
-     * @returns true if process is running, false otherwise
+     * Issue #1358: `process.kill(pid, 0)` alone only proves the PID is in use. When the state
+     * records a start-time signature, the live process's is compared to catch PID reuse; a
+     * mismatch is treated as not-running so stop() never kills, and start() never defers to, an
+     * unrelated process. EPERM (the PID was reused by a process we don't own) is likewise treated
+     * as stale rather than thrown, so a reused PID no longer crashes the command.
+     *
+     * @returns true if the daemon is running, false otherwise
      */
     isProcessRunning(): boolean;
 }

package/dist/cli/utils/pid-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pid-manager.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/pid-manager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAaH;;GAEG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,MAAM;IAEhD;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;;OAGG;IACH,OAAO,IAAI,MAAM,GAAG,IAAI;IAmBxB;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAwB9B;;OAEG;IACH,SAAS,IAAI,IAAI;IAUjB;;;;;OAKG;IACH,gBAAgB,IAAI,OAAO;CAmB5B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAI7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAEjE"}
+{"version":3,"file":"pid-manager.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/pid-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,EAAuB,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElF;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B,wEAAwE;IACxE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,UAAU;IAOnB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAPhC;;;;OAIG;gBAEgB,WAAW,EAAE,MAAM,EACnB,aAAa,GAAE,sBAA4C;IAG9E;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;;;;;;OAOG;IACH,SAAS,IAAI,WAAW,GAAG,IAAI;IA2B/B;;;OAGG;IACH,OAAO,IAAI,MAAM,GAAG,IAAI;IAIxB;;;;;;OAMG;IACH,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAwBvC;;;;;;OAMG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIxC;;OAEG;IACH,SAAS,IAAI,IAAI;IAUjB;;;;;;;;;;;OAWG;IACH,gBAAgB,IAAI,OAAO;CAoC5B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAI7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAEjE"}