loop-task 2.1.4 → 2.1.5

package/dist/core/loop/chain-executor.js

@@ -0,0 +1,67 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { executeCommand } from "../command/command-runner.js";
+import { t } from "../../shared/i18n/index.js";
+import { parseStdout } from "../context/context-parser.js";
+import { interpolate } from "../context/template.js";
+export function executeChain(options) {
+    const { chainTargetId, exitCode, task, chainContext, cwd, signal, runCount, logPath, runHistory, logStream, controller } = options;
+    if (!chainTargetId) {
+        return Promise.resolve({ runHistory, lastExitCode: exitCode, lastDuration: 0 });
+    }
+    const chainGroupId = crypto.randomUUID().slice(0, 8);
+    const mainRecord = runHistory[runHistory.length - 1];
+    if (mainRecord)
+        mainRecord.chainGroupId = chainGroupId;
+    let currentTargetId = chainTargetId;
+    let prevBranch = exitCode === 0 ? "onSuccess" : "onFailure";
+    let prevExit = exitCode;
+    let totalExtraDuration = 0;
+    let finalExitCode = exitCode;
+    return (async () => {
+        while (currentTargetId) {
+            const chainTask = controller.taskResolver(currentTargetId);
+            if (!chainTask)
+                break;
+            if (logStream) {
+                logStream.write(t("loop.chainHeader", { name: chainTask.name, branch: prevBranch, prevExit }));
+            }
+            const chainStartedAt = new Date().toISOString();
+            const chainOffset = fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
+            runHistory.push({
+                runNumber: runCount,
+                startedAt: chainStartedAt,
+                exitCode: -1,
+                duration: 0,
+                logSize: 0,
+                status: "running",
+                logOffset: chainOffset,
+                chainGroupId,
+                chainName: chainTask.name,
+            });
+            const interpolatedCommand = interpolate(chainTask.command, chainContext);
+            const interpolatedArgs = chainTask.commandArgs.map(a => interpolate(a, chainContext));
+            const chainResult = await executeCommand(interpolatedCommand, interpolatedArgs, cwd, logStream, signal, runCount, true, true);
+            if (chainResult.stdout) {
+                const parsed = parseStdout(chainResult.stdout);
+                if (parsed !== null) {
+                    Object.assign(chainContext, parsed);
+                }
+            }
+            const chainLogSize = fs.existsSync(logPath) ? fs.statSync(logPath).size - chainOffset : 0;
+            const chainRecord = runHistory.find(r => r.chainGroupId === chainGroupId && r.status === "running" && r.chainName === chainTask.name);
+            if (chainRecord) {
+                chainRecord.exitCode = chainResult.exitCode;
+                chainRecord.duration = chainResult.duration;
+                chainRecord.logSize = Math.max(0, chainLogSize);
+                chainRecord.status = "completed";
+            }
+            totalExtraDuration += chainResult.duration;
+            finalExitCode = chainResult.exitCode;
+            currentTargetId = (chainResult.exitCode === 0 ? chainTask.onSuccessTaskId : chainTask.onFailureTaskId) ?? null;
+            prevBranch = chainResult.exitCode === 0 ? "onSuccess" : "onFailure";
+            prevExit = chainResult.exitCode;
+        }
+        return { runHistory, lastExitCode: finalExitCode, lastDuration: totalExtraDuration };
+    })();
+}

package/dist/core/loop/delay-utils.js

@@ -0,0 +1,65 @@
+import { sleep } from "../../shared/sleep.js";
+import { SLEEP_CHUNK_MS } from "../../shared/config/constants.js";
+export function waitForResume(ctrl) {
+    const savedStatus = ctrl._status;
+    ctrl._status = savedStatus === "idle" ? "idle" : "paused";
+    return new Promise((resolve) => {
+        ctrl.resumeResolve = resolve;
+    });
+}
+export async function waitForDelay(ctrl, ms, signal) {
+    let remaining = ms;
+    ctrl.remainingDelayMs = remaining;
+    let announced = false;
+    while (remaining > 0) {
+        if (ctrl._forceRun) {
+            ctrl._savedRemainingMs = remaining;
+            ctrl.remainingDelayMs = null;
+            ctrl.nextRunAt = null;
+            return true;
+        }
+        if (ctrl._resetSchedule) {
+            ctrl._resetSchedule = false;
+            remaining = ms;
+            ctrl.remainingDelayMs = remaining;
+            announced = false;
+        }
+        if (ctrl._paused) {
+            if (ctrl._status !== "idle") {
+                ctrl._status = "paused";
+            }
+            ctrl.emit("paused");
+            await waitForResume(ctrl);
+            announced = false;
+            if (signal.aborted) {
+                ctrl.remainingDelayMs = null;
+                return false;
+            }
+            if (ctrl._resetSchedule) {
+                ctrl._resetSchedule = false;
+                remaining = ms;
+                ctrl.remainingDelayMs = remaining;
+            }
+        }
+        if (!announced) {
+            ctrl._status = "waiting";
+            ctrl.nextRunAt = new Date(Date.now() + remaining).toISOString();
+            ctrl.emit("waiting");
+            announced = true;
+        }
+        const chunk = Math.min(remaining, SLEEP_CHUNK_MS);
+        const startedAt = Date.now();
+        try {
+            await sleep(chunk, signal);
+        }
+        catch {
+            ctrl.remainingDelayMs = null;
+            return false;
+        }
+        remaining = Math.max(0, remaining - (Date.now() - startedAt));
+        ctrl.remainingDelayMs = remaining;
+    }
+    ctrl.remainingDelayMs = null;
+    ctrl.nextRunAt = null;
+    return true;
+}

package/dist/core/loop/loop-controller.js

@@ -0,0 +1,191 @@
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import { computePhase, alignToPhase } from "../scheduling/index.js";
+import { runLoop } from "./loop-runner.js";
+export class LoopController extends EventEmitter {
+    constructor(id, options, logPath, taskResolver, state, projectDirectory) {
+        super();
+        this.runAbortController = null;
+        this._paused = false;
+        this._forceRun = false;
+        this._savedRemainingMs = null;
+        this._resetSchedule = false;
+        this._stopAfterRun = false;
+        this._maxRunsReached = false;
+        this._status = "running";
+        this.resumeResolve = null;
+        this.runCount = 0;
+        this.lastRunAt = null;
+        this.lastExitCode = null;
+        this.lastDuration = null;
+        this.nextRunAt = null;
+        this.remainingDelayMs = null;
+        this.logStream = null;
+        this.loopPromise = null;
+        this.sessionStartedAt = null;
+        this.runHistory = [];
+        this.currentRunStartOffset = 0;
+        this.skippedCount = 0;
+        this.id = id;
+        this.options = options;
+        this.logPath = logPath;
+        this.taskResolver = taskResolver;
+        this.projectDirectory = projectDirectory;
+        this.abortController = new AbortController();
+        this.createdAt = state?.createdAt ?? new Date().toISOString();
+        this.runCount = state?.runCount ?? 0;
+        this._maxRunsReached = state?.maxRunsReached ?? false;
+        this.sessionStartedAt = state?.sessionStartedAt ?? null;
+        this.lastRunAt = state?.lastRunAt ?? null;
+        this.lastExitCode = state?.lastExitCode ?? null;
+        this.lastDuration = state?.lastDuration ?? null;
+        this.nextRunAt = state?.nextRunAt ?? null;
+        this.remainingDelayMs = state?.remainingDelayMs ?? null;
+        this._status = state?.status ?? "running";
+        this._paused = state?.status === "paused" || state?.status === "idle";
+        this.runHistory = (state?.runHistory ?? []).map((r) => r.status === "running" ? { ...r, status: "completed" } : r).map((r) => ({ ...r, logOffset: r.logOffset ?? 0 }));
+        this.skippedCount = state?.skippedCount ?? 0;
+    }
+    get status() {
+        return this._status;
+    }
+    start() {
+        this.skippedCount = 0;
+        this.logStream?.end();
+        this.abortController = new AbortController();
+        this.logStream = fs.createWriteStream(this.logPath, { flags: "a" });
+        this.loopPromise = this.run();
+        if (this.sessionStartedAt === null) {
+            this.sessionStartedAt = new Date().toISOString();
+        }
+    }
+    pause(interruptCurrentRun = false) {
+        if (this._status === "running" || this._status === "waiting") {
+            this._paused = true;
+            this._status = "paused";
+            if (interruptCurrentRun && this._status === "paused") {
+                this.runAbortController?.abort();
+            }
+            this.emit("paused");
+        }
+    }
+    stopLoop(interruptCurrentRun = false) {
+        if (this._status === "running" || this._status === "waiting" || this._status === "paused") {
+            this._paused = true;
+            this._status = "idle";
+            this.sessionStartedAt = null;
+            this.remainingDelayMs = null;
+            this.nextRunAt = null;
+            if (interruptCurrentRun) {
+                this.runAbortController?.abort();
+            }
+            this.abortController.abort();
+            if (this.resumeResolve) {
+                this.resumeResolve();
+                this.resumeResolve = null;
+            }
+            this.emit("stopped");
+        }
+    }
+    resume() {
+        if (this._status === "paused" && this._paused && this.resumeResolve) {
+            this._paused = false;
+            if (this.remainingDelayMs !== null) {
+                this._status = "waiting";
+                this.nextRunAt = new Date(Date.now() + this.remainingDelayMs).toISOString();
+            }
+            this.resumeResolve();
+            this.resumeResolve = null;
+            this.emit("resumed");
+        }
+    }
+    playLoop() {
+        if (this._status !== "idle" && this._status !== "stopped")
+            return false;
+        if (this._maxRunsReached)
+            return false;
+        if (this.options.maxRuns !== null && this.runCount >= this.options.maxRuns) {
+            this._maxRunsReached = true;
+            return false;
+        }
+        this.sessionStartedAt = new Date().toISOString();
+        this._resetSchedule = true;
+        this._paused = false;
+        this._status = "waiting";
+        const phase = this.options.offset !== null
+            ? this.options.offset
+            : computePhase(this.id, this.options.interval);
+        const delay = alignToPhase(Date.now(), this.options.interval, phase);
+        this.nextRunAt = new Date(Date.now() + delay).toISOString();
+        if (this.resumeResolve) {
+            this.resumeResolve();
+            this.resumeResolve = null;
+        }
+        this.start();
+        this.emit("resumed");
+        return true;
+    }
+    triggerNow() {
+        if (this._status === "running")
+            return false;
+        if (this._maxRunsReached)
+            return false;
+        const needsStart = this._status === "stopped" || this._status === "idle";
+        this._savedRemainingMs = this.remainingDelayMs;
+        this._forceRun = true;
+        if (needsStart) {
+            this._stopAfterRun = true;
+            this._paused = false;
+            this._status = "running";
+            this.start();
+        }
+        else {
+            if (this._paused)
+                this.resume();
+        }
+        this.emit("triggered");
+        return true;
+    }
+    async stop() {
+        this.abortController.abort();
+        if (this._paused)
+            this.resume();
+        if (this.loopPromise) {
+            await this.loopPromise;
+        }
+        this.logStream?.end();
+        this.logStream = null;
+    }
+    getMeta() {
+        return {
+            id: this.id,
+            taskId: this.options.taskId,
+            status: this._status,
+            createdAt: this.createdAt,
+            maxRunsReached: this._maxRunsReached,
+            sessionStartedAt: this.sessionStartedAt,
+            runCount: this.runCount,
+            lastRunAt: this.lastRunAt,
+            lastExitCode: this.lastExitCode,
+            lastDuration: this.lastDuration,
+            nextRunAt: this.nextRunAt,
+            remainingDelayMs: this.remainingDelayMs,
+            runHistory: this.runHistory,
+            skippedCount: this.skippedCount,
+        };
+    }
+    clearMaxRunsReached() {
+        this._maxRunsReached = false;
+        this._paused = false;
+        this._status = "idle";
+        this.remainingDelayMs = null;
+        this.nextRunAt = null;
+        this.runCount = 0;
+    }
+    isMaxRunsReached() {
+        return this._maxRunsReached;
+    }
+    run() {
+        return runLoop(this);
+    }
+}

package/dist/core/loop/loop-runner.js

@@ -0,0 +1,133 @@
+import { computePhase, alignToPhase } from "../scheduling/index.js";
+import { resolveEffectiveCwd } from "../command/resolve-cwd.js";
+import { executeChain } from "./chain-executor.js";
+import { executeRunImpl } from "./run-executor.js";
+import { waitForResume, waitForDelay } from "./delay-utils.js";
+export async function runLoop(ctrl) {
+    const signal = ctrl.abortController.signal;
+    let isFirstRun = true;
+    try {
+        while (!signal.aborted) {
+            if (ctrl.options.maxRuns !== null && ctrl.runCount >= ctrl.options.maxRuns) {
+                ctrl._maxRunsReached = true;
+                ctrl._paused = true;
+                ctrl._status = "paused";
+                ctrl.emit("paused");
+                return;
+            }
+            if (isFirstRun && ctrl._paused) {
+                await waitForResume(ctrl);
+                if (signal.aborted)
+                    break;
+            }
+            if (isFirstRun && ctrl.nextRunAt) {
+                const delay = Math.max(0, new Date(ctrl.nextRunAt).getTime() - Date.now());
+                if (delay > 0) {
+                    const completed = await waitForDelay(ctrl, delay, signal);
+                    if (!completed)
+                        break;
+                }
+            }
+            else if (isFirstRun && !ctrl.options.immediate) {
+                const phase = ctrl.options.offset !== null
+                    ? ctrl.options.offset
+                    : computePhase(ctrl.id, ctrl.options.interval);
+                const delay = alignToPhase(Date.now(), ctrl.options.interval, phase);
+                if (delay > 0) {
+                    ctrl.nextRunAt = new Date(Date.now() + delay).toISOString();
+                }
+                const completed = await waitForDelay(ctrl, delay, signal);
+                if (!completed)
+                    break;
+            }
+            isFirstRun = false;
+            if (ctrl._paused) {
+                await waitForResume(ctrl);
+                if (signal.aborted)
+                    break;
+            }
+            const runStartedAtMs = Date.now();
+            const { exitCode, totalDuration } = await executeRunImpl(ctrl, signal);
+            const chainTargetId = exitCode === 0
+                ? (ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId)?.onSuccessTaskId : undefined)
+                : (ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId)?.onFailureTaskId : undefined);
+            if (chainTargetId) {
+                const task = ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId) : null;
+                const cwd = resolveEffectiveCwd(ctrl.options.cwd, ctrl.projectDirectory);
+                const chainContext = {};
+                const chainResult = await executeChain({
+                    chainTargetId,
+                    exitCode,
+                    task,
+                    chainContext,
+                    cwd,
+                    signal,
+                    runCount: ctrl.runCount,
+                    logPath: ctrl.logPath,
+                    runHistory: ctrl.runHistory,
+                    logStream: ctrl.logStream,
+                    controller: ctrl,
+                });
+                ctrl.runHistory = chainResult.runHistory;
+                ctrl.lastExitCode = chainResult.lastExitCode;
+                ctrl.lastDuration = (ctrl.lastDuration ?? 0) + chainResult.lastDuration;
+            }
+            if (ctrl.runHistory.length > 50) {
+                ctrl.runHistory = ctrl.runHistory.slice(-50);
+            }
+            ctrl.emit("run:end", { exitCode, duration: totalDuration });
+            if (signal.aborted)
+                break;
+            if (ctrl.options.maxRuns !== null && ctrl.runCount >= ctrl.options.maxRuns) {
+                ctrl._maxRunsReached = true;
+                ctrl._paused = true;
+                ctrl._status = "paused";
+                ctrl.remainingDelayMs = null;
+                ctrl.nextRunAt = null;
+                ctrl.emit("paused");
+                return;
+            }
+            if (ctrl._stopAfterRun) {
+                ctrl._stopAfterRun = false;
+                ctrl._paused = true;
+                ctrl._status = "idle";
+                ctrl.remainingDelayMs = null;
+                ctrl.nextRunAt = null;
+                ctrl.emit("stopped");
+                return;
+            }
+            const saved = ctrl._savedRemainingMs;
+            ctrl._savedRemainingMs = null;
+            if (saved !== null) {
+                const remaining = Math.max(0, saved - totalDuration);
+                if (remaining > 0) {
+                    const completed = await waitForDelay(ctrl, remaining, signal);
+                    if (!completed)
+                        break;
+                }
+            }
+            else {
+                const nextSlotMs = runStartedAtMs + ctrl.options.interval;
+                const overrunMs = Date.now() - nextSlotMs;
+                if (overrunMs >= 0) {
+                    const missed = Math.floor(overrunMs / ctrl.options.interval) + 1;
+                    ctrl.skippedCount += missed;
+                    const adjustedDelay = ctrl.options.interval - (overrunMs % ctrl.options.interval);
+                    const completed = await waitForDelay(ctrl, adjustedDelay, signal);
+                    if (!completed)
+                        break;
+                }
+                else {
+                    const completed = await waitForDelay(ctrl, ctrl.options.interval, signal);
+                    if (!completed)
+                        break;
+                }
+            }
+        }
+    }
+    finally {
+        if (ctrl._status !== "stopped" && ctrl._status !== "idle" && ctrl._status !== "paused" && !ctrl._maxRunsReached) {
+            ctrl._status = "stopped";
+        }
+    }
+}

package/dist/core/loop/run-executor.js

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import { executeCommand } from "../command/command-runner.js";
+import { rotateLogIfNeeded } from "../logging/log-rotator.js";
+import { parseStdout } from "../context/context-parser.js";
+import { interpolate } from "../context/template.js";
+import { resolveEffectiveCwd } from "../command/resolve-cwd.js";
+export async function executeRunImpl(ctrl, signal) {
+    ctrl._status = "running";
+    ctrl._forceRun = false;
+    ctrl.runCount++;
+    ctrl.lastRunAt = new Date().toISOString();
+    if (ctrl.sessionStartedAt === null) {
+        ctrl.sessionStartedAt = ctrl.lastRunAt;
+    }
+    ctrl.nextRunAt = null;
+    ctrl.emit("run:start", ctrl.runCount);
+    ctrl.logStream = rotateLogIfNeeded(ctrl.logPath, ctrl.logStream);
+    ctrl.currentRunStartOffset = fs.existsSync(ctrl.logPath) ? fs.statSync(ctrl.logPath).size : 0;
+    ctrl.runHistory.push({
+        runNumber: ctrl.runCount,
+        startedAt: ctrl.lastRunAt,
+        exitCode: -1,
+        duration: 0,
+        logSize: 0,
+        status: "running",
+        logOffset: ctrl.currentRunStartOffset,
+    });
+    ctrl.runAbortController = new AbortController();
+    const task = ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId) : null;
+    const cwd = resolveEffectiveCwd(ctrl.options.cwd, ctrl.projectDirectory);
+    const chainContext = {};
+    const hasChainTasks = !!(task?.onSuccessTaskId || task?.onFailureTaskId);
+    const singleCommandFallback = {
+        command: task?.command ?? ctrl.options.command,
+        commandArgs: task?.commandArgs ?? ctrl.options.commandArgs,
+        commandRaw: task?.commandRaw ?? ctrl.options.commandRaw,
+    };
+    const taskSteps = task?.steps?.length
+        ? task.steps
+        : [{ commands: [singleCommandFallback] }];
+    const shouldCaptureStdout = hasChainTasks || taskSteps.length > 1 || taskSteps[0].commands.length > 1;
+    let exitCode = 0;
+    let totalDuration = 0;
+    for (const step of taskSteps) {
+        const stepResults = await Promise.allSettled(step.commands.map((cmd) => executeCommand(interpolate(cmd.command, chainContext), cmd.commandArgs.map(a => interpolate(a, chainContext)), cwd, ctrl.logStream, AbortSignal.any([signal, ctrl.runAbortController.signal]), ctrl.runCount, shouldCaptureStdout)));
+        let stepStdout = "";
+        for (const r of stepResults) {
+            if (r.status === "fulfilled") {
+                totalDuration += r.value.duration;
+                if (r.value.stdout)
+                    stepStdout += (stepStdout ? "\n" : "") + r.value.stdout;
+            }
+        }
+        if (shouldCaptureStdout && stepStdout) {
+            const parsed = parseStdout(stepStdout);
+            if (parsed !== null) {
+                Object.assign(chainContext, parsed);
+            }
+        }
+        const stepFailure = stepResults.some((r) => r.status === "rejected" || (r.status === "fulfilled" && r.value.exitCode !== 0));
+        if (stepFailure) {
+            const failed = stepResults.find((r) => r.status === "fulfilled" && r.value.exitCode !== 0);
+            exitCode = failed ? failed.value.exitCode : 1;
+            break;
+        }
+    }
+    ctrl.runAbortController = null;
+    ctrl.lastExitCode = exitCode;
+    ctrl.lastDuration = totalDuration;
+    const logSize = fs.existsSync(ctrl.logPath) ? fs.statSync(ctrl.logPath).size - ctrl.currentRunStartOffset : 0;
+    const runningRecord = ctrl.runHistory.find((r) => r.runNumber === ctrl.runCount);
+    if (runningRecord) {
+        runningRecord.exitCode = exitCode;
+        runningRecord.duration = totalDuration;
+        runningRecord.logSize = Math.max(0, logSize);
+        runningRecord.status = "completed";
+    }
+    else {
+        ctrl.runHistory.push({
+            runNumber: ctrl.runCount,
+            startedAt: ctrl.lastRunAt,
+            exitCode,
+            duration: totalDuration,
+            logSize: Math.max(0, logSize),
+            status: "completed",
+            logOffset: ctrl.currentRunStartOffset,
+        });
+    }
+    return { exitCode, totalDuration };
+}

package/dist/core/loop/types.js

@@ -0,0 +1 @@
+export {};

package/dist/daemon/daemon-log.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { getDataDir, getDaemonLogFile } from "../config/paths.js";
+import { getDataDir, getDaemonLogFile } from "../shared/config/paths.js";
 export function daemonLog(message) {
     try {
         fs.mkdirSync(getDataDir(), { recursive: true });

package/dist/daemon/http/helpers.js

@@ -0,0 +1,81 @@
+// --- Response helpers ---
+export function sendJson(res, status, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body),
+    });
+    res.end(body);
+}
+export function sendOk(res, data, status = 200) {
+    sendJson(res, status, { ok: true, data: data ?? null });
+}
+export function sendError(res, status, message) {
+    sendJson(res, status, { ok: false, error: { message } });
+}
+export function sendNotFound(res, id) {
+    sendError(res, 404, `Not found: ${id}`);
+}
+export function matchRoute(routes, method, pathSegments) {
+    for (const route of routes) {
+        if (route.method !== method)
+            continue;
+        if (route.segments.length !== pathSegments.length)
+            continue;
+        const params = {};
+        let matched = true;
+        for (let i = 0; i < route.segments.length; i++) {
+            const routeSeg = route.segments[i];
+            const pathSeg = pathSegments[i];
+            if (routeSeg.startsWith(":")) {
+                params[routeSeg.slice(1)] = decodeURIComponent(pathSeg);
+            }
+            else if (routeSeg !== pathSeg) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            return { params, handler: route.handler };
+        }
+    }
+    return null;
+}
+// --- Request parsing ---
+export function parsePath(url) {
+    if (!url)
+        return [];
+    const pathname = url.split("?")[0] ?? "";
+    return pathname.split("/").filter((s) => s.length > 0);
+}
+export function parseQuery(url) {
+    if (!url)
+        return new URLSearchParams();
+    const qs = url.split("?")[1] ?? "";
+    return new URLSearchParams(qs);
+}
+export async function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+            if (body.length > 1024 * 1024) {
+                reject(new Error("Body too large"));
+                req.destroy();
+            }
+        });
+        req.on("end", () => {
+            if (!body.trim()) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(body));
+            }
+            catch {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}