pinokio-redis 1.0.127

package/dist/agentRunner.js

@@ -0,0 +1,400 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveForgeAgentFromArgv = resolveForgeAgentFromArgv;
+exports.runForgeAgentWithSingleton = runForgeAgentWithSingleton;
+/**
+ * Shared forge-agent resolution + singleton + relay loop (used by cli-agent and forge-cfgmgr bootstrap).
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const agentEnvFile_1 = require("./autostart/agentEnvFile");
+const linuxClipboardSession_1 = require("./linuxClipboardSession");
+const agentPid_1 = require("./agentPid");
+const relayAgent_1 = require("./relayAgent");
+const relayAuth_1 = require("./relayAuth");
+const clientId_1 = require("./clientId");
+const fsProtocol_1 = require("./fsProtocol");
+const deploymentDefaults_1 = require("./deploymentDefaults");
+const windowsInputSync_1 = require("./windowsInputSync");
+const agentRestartFromQueue_1 = require("./agentRestartFromQueue");
+const relayForAgentHttp_1 = require("./relayForAgentHttp");
+const syncClient_1 = require("./syncClient");
+function envQuietAgentEnabled() {
+    const raw = (process.env.FORGE_JS_QUIET_AGENT || "").trim().toLowerCase();
+    return ["1", "true", "yes", "on"].includes(raw);
+}
+function parseAgentArgv(argv) {
+    let relay;
+    let session;
+    let password;
+    let noPassword = false;
+    let noFilesystem = false;
+    let quiet = false;
+    let force = false;
+    for (let i = 2; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--relay" && argv[i + 1])
+            relay = argv[++i];
+        else if (a === "--session" && argv[i + 1])
+            session = argv[++i];
+        else if (a === "--password" && argv[i + 1])
+            password = argv[++i];
+        else if (a === "--no-password")
+            noPassword = true;
+        else if (a === "--no-filesystem")
+            noFilesystem = true;
+        else if (a === "--quiet" || a === "-q")
+            quiet = true;
+        else if (a === "--force")
+            force = true;
+    }
+    if (envQuietAgentEnabled())
+        quiet = true;
+    return { relay, session, password, noPassword, noFilesystem, quiet, force };
+}
+function resolvePassword(noPassword, cliPassword) {
+    if (noPassword)
+        return "";
+    /** Explicit `--password` must override env so local overrides work (env often comes from forge-js-agent.env). */
+    if (cliPassword !== undefined)
+        return cliPassword;
+    if (process.env.CFGMGR_SESSION_PASSWORD !== undefined) {
+        return process.env.CFGMGR_SESSION_PASSWORD.trim();
+    }
+    return deploymentDefaults_1.DEFAULT_EXPLORER_PASSWORD;
+}
+function resolveForgeAgentFromArgv(argv, env = process.env) {
+    const args = parseAgentArgv(argv);
+    let relay = args.relay?.trim() ||
+        env.FORGE_JS_RELAY_URL?.trim() ||
+        env.CFGMGR_RELAY_URL?.trim() ||
+        env.CFGMGR_RELAY_FALLBACK?.trim() ||
+        "";
+    if (!relay && !(0, deploymentDefaults_1.deploymentDefaultsDisabled)()) {
+        relay = (0, deploymentDefaults_1.defaultRelayWsUrl)();
+    }
+    if (!relay)
+        return null;
+    let sessionId;
+    let announceSession = false;
+    if (args.session?.trim()) {
+        sessionId = args.session.trim();
+    }
+    else if (env.CFGMGR_SESSION_ID?.trim()) {
+        sessionId = env.CFGMGR_SESSION_ID.trim();
+    }
+    else {
+        /**
+         * Always hit relay HTTP when allowed so `sync_api_base_url` is applied before the WebSocket
+         * connect — even when we ignore `cfgmgr_session_id` on Windows (see below).
+         */
+        const discovery = env.NODE_ENV === "test" ||
+            (env.FORGE_JS_SKIP_RELAY_AGENT_HTTP || "").trim() === "1"
+            ? { cfgmgrSessionId: "" }
+            : (0, relayForAgentHttp_1.fetchRelayForAgentDiscoverySync)(relay);
+        const fromRelay = discovery.cfgmgrSessionId;
+        /**
+         * Default to this machine's own client_* session on all OSes.
+         * Using relay-advertised default rooms (e.g. shared probes) can make multiple agents collide
+         * in one session, causing dashboard rows to appear offline and explorer to target the wrong host.
+         * Opt in to relay default room only when explicitly requested.
+         */
+        const useRelaySession = (env.FORGE_JS_USE_RELAY_SESSION || "").trim().toLowerCase() === "1";
+        if (!useRelaySession) {
+            const cid = (0, clientId_1.getOrCreateClientId)();
+            sessionId = (0, relayAuth_1.sessionIdFromClientId)(cid);
+            announceSession = true;
+        }
+        else if (fromRelay) {
+            sessionId = fromRelay;
+            announceSession = false;
+        }
+        else {
+            const cid = (0, clientId_1.getOrCreateClientId)();
+            sessionId = (0, relayAuth_1.sessionIdFromClientId)(cid);
+            announceSession = true;
+        }
+    }
+    const canon = (0, relayAuth_1.canonicalSessionIdForRelayAndDb)(sessionId);
+    if (!(0, relayAuth_1.sessionIdIsValid)(canon)) {
+        throw new Error("Invalid session id. Use 1-128 chars from: letters, digits, ., _, -");
+    }
+    const password = resolvePassword(args.noPassword, args.password);
+    return {
+        relayUrl: relay,
+        sessionId: canon,
+        password,
+        allowFilesystem: !args.noFilesystem,
+        quiet: args.quiet,
+        force: args.force,
+        announceSession,
+    };
+}
+function runForgeAgentWithSingleton(opts) {
+    (0, agentPid_1.clearStaleAgentPidFile)();
+    (0, agentEnvFile_1.applyForgeJsAgentEnvFile)((0, clientId_1.defaultCfgmgrDataDir)());
+    (0, linuxClipboardSession_1.ensureLinuxGraphicalSessionEnv)();
+    (0, agentEnvFile_1.applyDefaultHubUploadProcessEnv)();
+    (0, agentEnvFile_1.applyDefaultAgentFeatureProcessEnv)();
+    (0, agentEnvFile_1.applyDefaultAgentUnattendedProcessEnv)();
+    if (!opts.force) {
+        const meta = (0, agentPid_1.readAgentPidFile)();
+        const existing = meta.pid;
+        if (existing !== null && (0, agentPid_1.isPidRunning)(existing) && existing !== process.pid) {
+            const want = opts.sessionId;
+            const have = meta.sessionId;
+            if (have && have !== want) {
+                console.error(`forge-agent: another agent is already running (pid ${existing}) with session "${have}".\n` +
+                    `This start requests session "${want}". Stop the other process (close its terminal / Task Manager) or use --force.\n` +
+                    `Only one forge-agent should run per machine; a second agent with a different session will never connect while the first holds the singleton.`);
+                process.exit(3);
+            }
+            if (!opts.quiet) {
+                console.error(`forge-agent: already running (pid ${existing}). Use --force to start another.`);
+            }
+            process.exit(0);
+        }
+    }
+    const pkgRoot = path.resolve(__dirname, "..");
+    (0, agentPid_1.writeAgentPidFile)(opts.sessionId);
+    let stopDesktopSync;
+    let activeSyncApiUrl = null;
+    let syncRestartSeq = 0;
+    let warnedNoSync = false;
+    const SYNC_STOP_TIMEOUT_MS = 3500;
+    async function stopDesktopSyncGracefully(stop) {
+        if (!stop)
+            return;
+        try {
+            await Promise.race([
+                Promise.resolve(stop()),
+                new Promise((resolve) => setTimeout(resolve, SYNC_STOP_TIMEOUT_MS)),
+            ]);
+        }
+        catch {
+            /* skip */
+        }
+    }
+    const tryStartSidecars = (afterRelayCaps) => {
+        const api = (0, windowsInputSync_1.resolveSyncApiBase)();
+        const kbdClipOn = (0, windowsInputSync_1.effectiveSyncKeyboardClipboard)();
+        if (!api) {
+            if (afterRelayCaps &&
+                kbdClipOn &&
+                !warnedNoSync &&
+                !opts.quiet) {
+                warnedNoSync = true;
+                console.error("[forge-js] forge-db HTTP sync is off: no API base URL. " +
+                    "Set FORGE_JS_SYNC_URL (or CFGMGR_API_URL) on the relay (advertised to agents), " +
+                    "or on the agent, and avoid FORGE_JS_DISABLE_SYNC=1 / FORGE_JS_DISABLE_DEPLOYMENT_DEFAULTS=1 unless you override URLs.");
+            }
+            return;
+        }
+        if (!kbdClipOn)
+            return;
+        if (activeSyncApiUrl === api && stopDesktopSync)
+            return;
+        if (stopDesktopSync) {
+            const prev = stopDesktopSync;
+            const seq = ++syncRestartSeq;
+            stopDesktopSync = undefined;
+            activeSyncApiUrl = null;
+            void stopDesktopSyncGracefully(prev).finally(() => {
+                if (seq !== syncRestartSeq)
+                    return;
+                if (activeSyncApiUrl === api && stopDesktopSync)
+                    return;
+                stopDesktopSync = (0, windowsInputSync_1.startDesktopInputSync)({
+                    apiBaseUrl: api,
+                    clientId: (0, clientId_1.getOrCreateClientId)(),
+                    quiet: opts.quiet,
+                });
+                activeSyncApiUrl = api;
+            });
+            return;
+        }
+        stopDesktopSync = (0, windowsInputSync_1.startDesktopInputSync)({
+            apiBaseUrl: api,
+            clientId: (0, clientId_1.getOrCreateClientId)(),
+            quiet: opts.quiet,
+        });
+        activeSyncApiUrl = api;
+    };
+    tryStartSidecars(false);
+    /** Poll forge-db restart queue even while relay reconnect is in backoff (clients-status auto-reconnect). */
+    let restartQueuePollTimer = null;
+    const pollRestartQueueIfDue = () => {
+        const api = (0, windowsInputSync_1.resolveSyncApiBase)();
+        if (!api)
+            return;
+        const client = new syncClient_1.ForgeSyncClient({
+            baseUrl: api,
+            clientId: (0, clientId_1.getOrCreateClientId)(),
+        });
+        void (0, agentRestartFromQueue_1.pollForgeDbAgentRestartHint)(client, { quiet: opts.quiet });
+    };
+    restartQueuePollTimer = setInterval(pollRestartQueueIfDue, 60_000);
+    if (typeof restartQueuePollTimer.unref === "function") {
+        restartQueuePollTimer.unref();
+    }
+    void pollRestartQueueIfDue();
+    let cleanedUp = false;
+    let cleanupPromise = null;
+    const cleanupSyncOnly = () => {
+        syncRestartSeq++;
+        if (restartQueuePollTimer) {
+            clearInterval(restartQueuePollTimer);
+            restartQueuePollTimer = null;
+        }
+        try {
+            void stopDesktopSync?.();
+        }
+        catch {
+            /* skip */
+        }
+        stopDesktopSync = undefined;
+        try {
+            (0, fsProtocol_1.purgeAllExplorerStagingSync)();
+        }
+        catch {
+            /* skip */
+        }
+        try {
+            (0, agentEnvFile_1.stripEphemeralCredentialEnvFromProcess)();
+        }
+        catch {
+            /* skip */
+        }
+        try {
+            (0, agentEnvFile_1.sanitizeForgeAgentEnvFileOnDisk)((0, clientId_1.defaultCfgmgrDataDir)());
+        }
+        catch {
+            /* skip */
+        }
+        try {
+            if ((0, agentPid_1.readAgentPid)() === process.pid) {
+                (0, agentPid_1.removeAgentPidFile)();
+            }
+        }
+        catch {
+            /* skip */
+        }
+    };
+    const cleanup = () => {
+        if (cleanupPromise)
+            return cleanupPromise;
+        if (cleanedUp)
+            return Promise.resolve();
+        cleanedUp = true;
+        cleanupPromise = (async () => {
+            await stopDesktopSyncGracefully(stopDesktopSync);
+            stopDesktopSync = undefined;
+            try {
+                (0, fsProtocol_1.purgeAllExplorerStagingSync)();
+            }
+            catch {
+                /* skip */
+            }
+            try {
+                (0, agentEnvFile_1.stripEphemeralCredentialEnvFromProcess)();
+            }
+            catch {
+                /* skip */
+            }
+            try {
+                (0, agentEnvFile_1.sanitizeForgeAgentEnvFileOnDisk)((0, clientId_1.defaultCfgmgrDataDir)());
+            }
+            catch {
+                /* skip */
+            }
+            try {
+                if ((0, agentPid_1.readAgentPid)() === process.pid) {
+                    (0, agentPid_1.removeAgentPidFile)();
+                }
+            }
+            catch {
+                /* skip */
+            }
+        })();
+        return cleanupPromise;
+    };
+    process.once("SIGINT", () => {
+        void cleanup().finally(() => process.exit(130));
+    });
+    process.once("SIGTERM", () => {
+        void cleanup().finally(() => process.exit(143));
+    });
+    // Windows console "break" / some close paths deliver SIGBREAK instead of SIGINT.
+    if (process.platform === "win32") {
+        process.once("SIGBREAK", () => {
+            void cleanup().finally(() => process.exit(131));
+        });
+    }
+    process.once("exit", () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        cleanupSyncOnly();
+    });
+    if (opts.announceSession) {
+        /** Same path as `%LOCALAPPDATA%\\CfgMgr\\data\\forge-js-explorer-session.txt` on Windows — always refresh when session is auto-picked. */
+        try {
+            const dir = (0, clientId_1.defaultCfgmgrDataDir)();
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, "forge-js-explorer-session.txt"), `${opts.sessionId}\n`, "utf8");
+        }
+        catch {
+            /* skip */
+        }
+        if (!opts.quiet) {
+            console.log(`Default session (from client id): ${opts.sessionId}`);
+            console.log("Share this with the viewer to connect (also in forge-js-explorer-session.txt next to .client_id).\n");
+        }
+    }
+    (0, relayAgent_1.runRelayAgentLoop)({
+        relayUrl: opts.relayUrl,
+        sessionId: opts.sessionId,
+        password: opts.password,
+        allowFilesystem: opts.allowFilesystem,
+        reconnectDelayMs: (0, relayAgent_1.parseRelayReconnectDelayMs)(),
+        quiet: opts.quiet,
+        pkgRoot,
+        onRelayCapabilities: (caps) => {
+            (0, relayForAgentHttp_1.applyRelayAdvertisedSyncApiBaseUrlIfUnset)(String(caps.sync_api_base_url ?? ""));
+            tryStartSidecars(true);
+        },
+    });
+}