@yinuo-ngm/server 1.0.14 → 1.0.16

package/lib/app.js

@@ -13,6 +13,7 @@ const static_plugin_1 = __importDefault(require("./plugins/static.plugin"));
 const success_handle_plugin_1 = __importDefault(require("./plugins/success-handle.plugin"));
 const ws_plugin_1 = __importDefault(require("./plugins/ws/ws.plugin"));
 const api_client_plugin_1 = __importDefault(require("./plugins/api-client.plugin"));
+const nginx_plugin_1 = __importDefault(require("./plugins/nginx.plugin"));
 const env_1 = require("./env");
 function normalizeLogLevel(v) {
     const lv = (v ?? "").toLowerCase().trim();
@@ -57,6 +58,7 @@ async function createServer() {
     await fastify.register(error_handler_plugin_1.errorHandlerPlugin);
     await fastify.register(success_handle_plugin_1.default);
     await fastify.register(core_plugin_1.default);
+    await fastify.register(nginx_plugin_1.default);
     await fastify.register(ws_plugin_1.default);
     await fastify.register(api_client_plugin_1.default);
     await fastify.register(routes_plugin_1.default);

package/lib/plugins/error-handler.plugin.js

@@ -89,6 +89,11 @@ exports.ERROR_STATUS = {
     SPRITE_CONFIG_NOT_FOUND: 404,
     SPRITE_ICONS_ROOT_NOT_FOUND: 404,
     SPRITE_GROUP_NOT_FOUND: 404,
+    NO_VERSION_MANAGER: 503,
+    NO_AVAILABLE_VERSIONS: 409,
+    VERSION_REQUIRED: 400,
+    PROJECT_PATH_REQUIRED: 400,
+    SWITCH_VERSION_FAILED: 500,
 };
 function mapStatus(code) {
     return exports.ERROR_STATUS[code] ?? 400;

package/lib/plugins/nginx.binding.store.d.ts

@@ -0,0 +1,4 @@
+export declare function getNginxBindingStorePath(): string;
+export declare function loadPersistedNginxPath(): Promise<string | null>;
+export declare function savePersistedNginxPath(path: string): Promise<void>;
+export declare function clearPersistedNginxPath(): Promise<void>;

package/lib/plugins/nginx.binding.store.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNginxBindingStorePath = getNginxBindingStorePath;
+exports.loadPersistedNginxPath = loadPersistedNginxPath;
+exports.savePersistedNginxPath = savePersistedNginxPath;
+exports.clearPersistedNginxPath = clearPersistedNginxPath;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const env_1 = require("../env");
+const bindingStorePath = (0, path_1.join)(env_1.env.dataDir, 'nginx', 'binding.json');
+function getNginxBindingStorePath() {
+    return bindingStorePath;
+}
+async function loadPersistedNginxPath() {
+    try {
+        const raw = await (0, promises_1.readFile)(bindingStorePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const persistedPath = parsed.path?.trim();
+        return persistedPath || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function savePersistedNginxPath(path) {
+    const normalizedPath = path.trim();
+    if (!normalizedPath) {
+        return;
+    }
+    await (0, promises_1.mkdir)((0, path_1.dirname)(bindingStorePath), { recursive: true });
+    const payload = {
+        path: normalizedPath,
+        updatedAt: new Date().toISOString(),
+    };
+    await (0, promises_1.writeFile)(bindingStorePath, JSON.stringify(payload, null, 2), 'utf-8');
+}
+async function clearPersistedNginxPath() {
+    await (0, promises_1.rm)(bindingStorePath, { force: true });
+}

package/lib/plugins/nginx.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from 'fastify';
+declare const _default: (fastify: FastifyInstance) => Promise<void>;
+export default _default;

package/lib/plugins/nginx.plugin.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nginx_1 = require("@yinuo-ngm/nginx");
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const nginx_binding_store_1 = require("./nginx.binding.store");
+exports.default = (0, fastify_plugin_1.default)(async function nginxPlugin(fastify) {
+    const nginxApp = new nginx_1.NginxApp();
+    fastify.decorate('nginx', nginxApp);
+    const persistedPath = await (0, nginx_binding_store_1.loadPersistedNginxPath)();
+    if (persistedPath) {
+        try {
+            await nginxApp.service.bind(persistedPath);
+            fastify.log.info(`[nginx] restored binding from ${persistedPath}`);
+        }
+        catch (error) {
+            fastify.log.warn(`[nginx] failed to restore binding from ${(0, nginx_binding_store_1.getNginxBindingStorePath)()}: ${error?.message || error}`);
+        }
+    }
+    fastify.log.info('[nginx] nginx module initialized');
+});

package/lib/plugins/ws/topics/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./task.ws";
 export * from "./syslog.ws";
 export * from "./svn.ws";
+export * from "./nginx.ws";

package/lib/plugins/ws/topics/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./task.ws"), exports);
 __exportStar(require("./syslog.ws"), exports);
 __exportStar(require("./svn.ws"), exports);
+__exportStar(require("./nginx.ws"), exports);

package/lib/plugins/ws/topics/nginx.ws.d.ts

@@ -0,0 +1,7 @@
+import type { NginxLogService } from "@yinuo-ngm/nginx";
+import { WsContext } from "../ws.context";
+import type { TopicHandler } from "../ws.router";
+export type NginxWsDeps = {
+    logService: NginxLogService;
+};
+export declare function createNginxTopicHandler(deps: NginxWsDeps, getAllClients: () => Iterable<WsContext>): TopicHandler;

package/lib/plugins/ws/topics/nginx.ws.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNginxTopicHandler = createNginxTopicHandler;
+function createNginxTopicHandler(deps, getAllClients) {
+    const { logService } = deps;
+    const onLog = (entry) => {
+        const msg = {
+            op: "nginx.log.append",
+            logType: entry.type,
+            line: entry.line,
+            ts: entry.timestamp
+        };
+        for (const client of getAllClients()) {
+            if (client.hasSub("nginx", `nginx:${entry.type}`)) {
+                client.send(msg);
+            }
+        }
+    };
+    logService.on("log", onLog);
+    return {
+        topic: "nginx",
+        async sub(ctx, msg) {
+            const logType = msg.logType;
+            if (!logType || (logType !== "error" && logType !== "access")) {
+                ctx.send({
+                    op: "error",
+                    code: "BAD_MSG",
+                    message: "logType must be 'error' or 'access'",
+                    ts: Date.now()
+                });
+                return;
+            }
+            const subKey = `nginx:${logType}`;
+            ctx.addSub("nginx", subKey);
+            logService.startWatching(logType);
+            const tail = Math.max(0, Number(msg.tail ?? 0));
+            if (tail > 0) {
+                const lines = await logService.readLogTail(logType, tail);
+                const response = {
+                    op: "nginx.log.tail",
+                    logType,
+                    lines,
+                    ts: Date.now()
+                };
+                ctx.send(response);
+            }
+        },
+        unsub(ctx, msg) {
+            const logType = msg.logType;
+            if (logType) {
+                ctx.delSub("nginx", `nginx:${logType}`);
+            }
+            else {
+                ctx.delSub("nginx", "nginx:error");
+                ctx.delSub("nginx", "nginx:access");
+            }
+        }
+    };
+}

package/lib/plugins/ws/ws.plugin.js

@@ -28,6 +28,8 @@ exports.default = (0, fastify_plugin_1.default)(async function wsPlugin(fastify)
         getSvnRuntimeByProjectId: (projectId, tail) => fastify.core.svnSync.getRuntimeByProjectId(projectId, tail),
     }, () => clients.values());
     router.register(svnSyncHandler);
+    const nginxHandler = (0, topics_1.createNginxTopicHandler)({ logService: fastify.nginx.log }, () => clients.values());
+    router.register(nginxHandler);
     const offs = [];
     const events = fastify.core.events;
     offs.push(events.on(core_1.Events.TASK_OUTPUT, (e) => {
@@ -76,6 +78,7 @@ exports.default = (0, fastify_plugin_1.default)(async function wsPlugin(fastify)
             }
             catch { }
         });
+        fastify.nginx.log.stopAll();
         clients.clear();
     });
     fastify.get("/ws", { websocket: true }, (ws) => {

package/lib/routes/api-client/hub-cookie-jar.d.ts

@@ -0,0 +1,3 @@
+export declare function getCookieJar(sessionKey: string): string | undefined;
+export declare function clearCookieJar(sessionKey: string): void;
+export declare function mergeCookieJar(sessionKey: string, setCookies: string[]): string | undefined;

package/lib/routes/api-client/hub-cookie-jar.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookieJar = getCookieJar;
+exports.clearCookieJar = clearCookieJar;
+exports.mergeCookieJar = mergeCookieJar;
+const jars = new Map();
+function cookieNameFromSetCookie(setCookie) {
+    const pair = String(setCookie ?? "").split(";")[0]?.trim();
+    if (!pair)
+        return null;
+    const idx = pair.indexOf("=");
+    if (idx <= 0)
+        return null;
+    return pair.slice(0, idx).trim().toLowerCase();
+}
+function mergeCookieString(oldCookie, setCookies) {
+    const next = new Map();
+    for (const token of String(oldCookie ?? "").split(";")) {
+        const pair = token.trim();
+        if (!pair)
+            continue;
+        const idx = pair.indexOf("=");
+        if (idx <= 0)
+            continue;
+        const name = pair.slice(0, idx).trim().toLowerCase();
+        next.set(name, pair);
+    }
+    for (const sc of setCookies ?? []) {
+        const pair = String(sc ?? "").split(";")[0]?.trim();
+        if (!pair)
+            continue;
+        const name = cookieNameFromSetCookie(sc);
+        if (!name)
+            continue;
+        next.set(name, pair);
+    }
+    return Array.from(next.values()).join("; ");
+}
+function getCookieJar(sessionKey) {
+    return jars.get(sessionKey)?.value;
+}
+function clearCookieJar(sessionKey) {
+    jars.delete(sessionKey);
+}
+function mergeCookieJar(sessionKey, setCookies) {
+    if (!Array.isArray(setCookies) || setCookies.length === 0)
+        return jars.get(sessionKey)?.value;
+    const oldCookie = jars.get(sessionKey)?.value ?? "";
+    const merged = mergeCookieString(oldCookie, setCookies);
+    if (!merged)
+        return undefined;
+    jars.set(sessionKey, { value: merged, updatedAt: Date.now() });
+    return merged;
+}

package/lib/routes/api-client/hub-token.routes.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from "fastify";
+export declare function apiClientHubTokenRoutes(fastify: FastifyInstance): Promise<void>;

package/lib/routes/api-client/hub-token.routes.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiClientHubTokenRoutes = apiClientHubTokenRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const api_1 = require("@yinuo-ngm/api");
+const node_stream_1 = require("node:stream");
+function normalizeNonEmptyString(value, field) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new core_1.AppError("BAD_REQUEST", `${field} is required`);
+    }
+    return value.trim();
+}
+function readHubTokenConfigFromProject(project) {
+    const env = (project?.env ?? {});
+    const baseUrl = env.NGM_HUB_V2_BASE_URL ?? env.HUB_V2_BASE_URL;
+    const token = env.NGM_HUB_V2_TOKEN ?? env.HUB_V2_TOKEN;
+    const personalToken = env.NGM_HUB_V2_PERSONAL_TOKEN ?? env.HUB_V2_PERSONAL_TOKEN;
+    const projectKey = env.NGM_HUB_V2_PROJECT_KEY ?? env.HUB_V2_PROJECT_KEY;
+    return {
+        baseUrl: baseUrl?.trim() || "",
+        token: token?.trim() || "",
+        personalToken: personalToken?.trim() || "",
+        projectKey: projectKey?.trim() || undefined,
+    };
+}
+async function resolveHubTokenConfig(app, body, tokenType) {
+    const inlineBaseUrl = body.baseUrl?.trim();
+    const inlineToken = tokenType === "personal"
+        ? body.personalToken?.trim() || body.token?.trim()
+        : body.token?.trim();
+    if (inlineBaseUrl && inlineToken) {
+        return { baseUrl: inlineBaseUrl, token: inlineToken };
+    }
+    if (!body.projectId) {
+        throw new core_1.AppError("BAD_REQUEST", "projectId is required when baseUrl/token are not provided");
+    }
+    const project = await app.core.project.get(body.projectId);
+    const config = readHubTokenConfigFromProject(project);
+    const resolvedToken = tokenType === "personal" ? body.personalToken?.trim() || config.personalToken : config.token;
+    if (!config.baseUrl || !resolvedToken) {
+        throw new core_1.AppError("BAD_REQUEST", tokenType === "personal"
+            ? "project hub-v2 config missing (NGM_HUB_V2_BASE_URL/NGM_HUB_V2_PERSONAL_TOKEN)"
+            : "project hub-v2 config missing (NGM_HUB_V2_BASE_URL/NGM_HUB_V2_TOKEN)");
+    }
+    return {
+        baseUrl: config.baseUrl,
+        token: resolvedToken,
+        projectKey: config.projectKey,
+    };
+}
+async function apiClientHubTokenRoutes(fastify) {
+    fastify.get("/projects/:projectId/issues/:issueId/attachments/:attachmentId/raw", async (req, reply) => {
+        const params = (req.params ?? {});
+        const projectId = normalizeNonEmptyString(params.projectId, "projectId");
+        const issueId = normalizeNonEmptyString(params.issueId, "issueId");
+        const attachmentId = normalizeNonEmptyString(params.attachmentId, "attachmentId");
+        const { baseUrl, token, projectKey } = await resolveHubTokenConfig(fastify, { projectId }, "project");
+        const normalizedPath = normalizeHubTokenPath(`/issues/${issueId}/attachments/${attachmentId}/raw`, projectKey);
+        const response = await requestHubApiRaw(baseUrl, "/api/token", token, "GET", normalizedPath);
+        if (!response.ok) {
+            const payload = await parseJson(response);
+            throw new core_1.AppError("BAD_REQUEST", payload?.message || `hub-v2 request failed (${response.status})`, {
+                status: response.status,
+                response: payload,
+            });
+        }
+        copyRawResponseHeaders(response, reply);
+        const body = response.body;
+        if (!body) {
+            return reply.status(response.status).send();
+        }
+        return reply.status(response.status).send(node_stream_1.Readable.fromWeb(body));
+    });
+    fastify.get("/projects/:projectId/issues/:issueId/uploads/:uploadId/raw", async (req, reply) => {
+        const params = (req.params ?? {});
+        const projectId = normalizeNonEmptyString(params.projectId, "projectId");
+        const issueId = normalizeNonEmptyString(params.issueId, "issueId");
+        const uploadId = normalizeNonEmptyString(params.uploadId, "uploadId");
+        const { baseUrl, token, projectKey } = await resolveHubTokenConfig(fastify, { projectId }, "project");
+        const normalizedPath = normalizeHubTokenPath(`/issues/${issueId}/uploads/${uploadId}/raw`, projectKey);
+        const response = await requestHubApiRaw(baseUrl, "/api/token", token, "GET", normalizedPath);
+        if (!response.ok) {
+            const payload = await parseJson(response);
+            throw new core_1.AppError("BAD_REQUEST", payload?.message || `hub-v2 request failed (${response.status})`, {
+                status: response.status,
+                response: payload,
+            });
+        }
+        copyRawResponseHeaders(response, reply);
+        const body = response.body;
+        if (!body) {
+            return reply.status(response.status).send();
+        }
+        return reply.status(response.status).send(node_stream_1.Readable.fromWeb(body));
+    });
+    fastify.get("/projects/:projectId/rd-items/:itemId/uploads/:uploadId/raw", async (req, reply) => {
+        const params = (req.params ?? {});
+        const projectId = normalizeNonEmptyString(params.projectId, "projectId");
+        const itemId = normalizeNonEmptyString(params.itemId, "itemId");
+        const uploadId = normalizeNonEmptyString(params.uploadId, "uploadId");
+        const { baseUrl, token, projectKey } = await resolveHubTokenConfig(fastify, { projectId }, "project");
+        const normalizedPath = normalizeHubTokenPath(`/rd-items/${itemId}/uploads/${uploadId}/raw`, projectKey);
+        const response = await requestHubApiRaw(baseUrl, "/api/token", token, "GET", normalizedPath);
+        if (!response.ok) {
+            const payload = await parseJson(response);
+            throw new core_1.AppError("BAD_REQUEST", payload?.message || `hub-v2 request failed (${response.status})`, {
+                status: response.status,
+                response: payload,
+            });
+        }
+        copyRawResponseHeaders(response, reply);
+        const body = response.body;
+        if (!body) {
+            return reply.status(response.status).send();
+        }
+        return reply.status(response.status).send(node_stream_1.Readable.fromWeb(body));
+    });
+    fastify.post("/request", async (req) => {
+        const body = (req.body ?? {});
+        const path = normalizeNonEmptyString(body.path, "path");
+        assertPathProjectSegmentNotLocalProjectId(path, body.projectId);
+        const method = (body.method ?? "GET").toUpperCase();
+        const tokenType = body.tokenType === "personal" ? "personal" : "project";
+        const { baseUrl, token, projectKey } = await resolveHubTokenConfig(fastify, body, tokenType);
+        const query = { ...(body.query ?? {}) };
+        if (query.projectKey === undefined && projectKey) {
+            query.projectKey = projectKey;
+        }
+        else if (typeof query.projectKey === "string") {
+            query.projectKey = String(query.projectKey).trim();
+        }
+        const normalizedPath = tokenType === "personal"
+            ? normalizeHubPersonalPath(path, projectKey)
+            : normalizeHubTokenPath(path, projectKey);
+        const data = tokenType === "project"
+            ? await requestByProjectTokenClient(baseUrl, token, method, normalizedPath, query, body.body, body.headers)
+            : await requestHubApi(baseUrl, "/api/personal", token, method, normalizedPath, query, body.body, body.headers);
+        return data;
+    });
+    fastify.post("/resolve", async (req) => {
+        const body = (req.body ?? {});
+        const resolvedProject = await resolveHubTokenConfig(fastify, body, "project");
+        let personalTokenConfigured = false;
+        try {
+            await resolveHubTokenConfig(fastify, body, "personal");
+            personalTokenConfigured = true;
+        }
+        catch {
+            personalTokenConfigured = false;
+        }
+        return {
+            baseUrl: resolvedProject.baseUrl,
+            tokenConfigured: !!resolvedProject.token,
+            personalTokenConfigured,
+            projectKey: resolvedProject.projectKey ?? null,
+        };
+    });
+}
+function copyRawResponseHeaders(response, reply) {
+    const passthroughHeaders = [
+        "content-type",
+        "content-disposition",
+        "content-length",
+        "cache-control",
+        "etag",
+        "last-modified",
+    ];
+    for (const key of passthroughHeaders) {
+        const value = response.headers.get(key);
+        if (!value) {
+            continue;
+        }
+        reply.header(key, value);
+    }
+}
+async function requestByProjectTokenClient(baseUrl, token, method, path, query, body, headers) {
+    const client = new api_1.ProjectTokenApiClient({ baseUrl, apiToken: token });
+    return client.request({
+        method,
+        path,
+        query,
+        body,
+        headers,
+    });
+}
+async function requestHubApi(baseUrl, apiPrefix, token, method, path, query, body, headers) {
+    const root = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${root}${apiPrefix}${path}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if (value === undefined || value === null || value === "") {
+            continue;
+        }
+        url.searchParams.set(key, String(value));
+    }
+    const requestHeaders = {
+        authorization: `Bearer ${token}`,
+        ...(headers ?? {}),
+    };
+    if (body !== undefined) {
+        requestHeaders["content-type"] = "application/json";
+    }
+    const response = await fetch(url.toString(), {
+        method,
+        headers: requestHeaders,
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    const payload = await parseJson(response);
+    if (!response.ok) {
+        throw new core_1.AppError("BAD_REQUEST", payload?.message || `hub-v2 request failed (${response.status})`, {
+            status: response.status,
+            response: payload,
+        });
+    }
+    if (payload && typeof payload === "object" && "code" in payload) {
+        if (payload.code !== "OK") {
+            throw new core_1.AppError("BAD_REQUEST", payload.message || "hub-v2 response error", {
+                response: payload,
+            });
+        }
+        return payload.data;
+    }
+    return payload;
+}
+async function requestHubApiRaw(baseUrl, apiPrefix, token, method, path, query, headers) {
+    const root = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${root}${apiPrefix}${path}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if (value === undefined || value === null || value === "") {
+            continue;
+        }
+        url.searchParams.set(key, String(value));
+    }
+    const requestHeaders = {
+        authorization: `Bearer ${token}`,
+        ...(headers ?? {}),
+    };
+    return fetch(url.toString(), {
+        method,
+        headers: requestHeaders,
+    });
+}
+async function parseJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+function assertPathProjectSegmentNotLocalProjectId(path, projectId) {
+    const localProjectId = projectId?.trim();
+    if (!localProjectId) {
+        return;
+    }
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const matched = normalizedPath.match(/^\/projects\/([^\/]+)(?:\/|$)/i);
+    if (!matched) {
+        return;
+    }
+    const projectSegment = (matched[1] ?? "").trim();
+    if (projectSegment && projectSegment === localProjectId) {
+        throw new core_1.AppError("BAD_REQUEST", "path must use projectKey (or business relative path), not local projectId");
+    }
+}
+function normalizeHubTokenPath(path, projectKey) {
+    const p = path.startsWith("/") ? path : `/${path}`;
+    const m = p.match(/^\/projects\/([^\/]+)(\/.*)?$/i);
+    if (m) {
+        const key = (m[1] ?? "").trim();
+        const rest = m[2] ?? "";
+        return `/projects/${key}${rest}`;
+    }
+    if (!projectKey) {
+        throw new core_1.AppError("BAD_REQUEST", "projectKey is required when path does not include /projects/:projectKey");
+    }
+    return `/projects/${projectKey}${p}`;
+}
+function normalizeHubPersonalPath(path, projectKey) {
+    const p = path.startsWith("/") ? path : `/${path}`;
+    if (/^\/me(?:\/|$)/i.test(p)) {
+        return p;
+    }
+    return normalizeHubTokenPath(p, projectKey);
+}

package/lib/routes/api-client/index.d.ts

@@ -3,3 +3,4 @@ export * from './request.routes';
 export * from './history.routes';
 export * from './send.routes';
 export * from './collection.routes';
+export * from './hub-token.routes';

package/lib/routes/api-client/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./request.routes"), exports);
 __exportStar(require("./history.routes"), exports);
 __exportStar(require("./send.routes"), exports);
 __exportStar(require("./collection.routes"), exports);
+__exportStar(require("./hub-token.routes"), exports);

package/lib/routes/api-client/send.routes.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiClientSendRoutes = apiClientSendRoutes;
+const hub_cookie_jar_1 = require("./hub-cookie-jar");
 async function apiClientSendRoutes(fastify) {
     const api = fastify.api;
     fastify.post("/", async (req) => {
@@ -10,13 +11,71 @@ async function apiClientSendRoutes(fastify) {
             throw new Error("projectId is required when scope=project");
         if (!body.request && !body.requestId)
             throw new Error("request or requestId is required");
-        return await api.send({
+        const useCookieJar = body.useCookieJar !== false;
+        const sessionKey = body.sessionKey ?? `${scope}:${body.projectId ?? "global"}:${body.envId ?? "default"}`;
+        if (body.clearCookieJar) {
+            (0, hub_cookie_jar_1.clearCookieJar)(sessionKey);
+        }
+        const cookieFromJar = useCookieJar ? (0, hub_cookie_jar_1.getCookieJar)(sessionKey) : undefined;
+        const nextRequest = await buildRequestWithCookie(api, {
             scope,
             projectId: body.projectId,
             requestId: body.requestId,
             request: body.request,
+            cookie: cookieFromJar,
+        });
+        const result = await api.send({
+            scope,
+            projectId: body.projectId,
+            requestId: nextRequest ? undefined : body.requestId,
+            request: nextRequest ?? body.request,
             envId: body.envId,
             projectRoot: body.projectRoot,
         });
+        if (useCookieJar) {
+            const setCookies = extractSetCookieHeader(result?.response?.headers?.["set-cookie"]);
+            if (setCookies.length > 0) {
+                (0, hub_cookie_jar_1.mergeCookieJar)(sessionKey, setCookies);
+            }
+        }
+        return result;
     });
 }
+async function buildRequestWithCookie(api, params) {
+    if (!params.cookie)
+        return params.request;
+    const requestEntity = params.request
+        ?? (params.requestId
+            ? await api.getRequest(params.requestId, params.scope, params.projectId)
+            : undefined);
+    if (!requestEntity)
+        return params.request;
+    const next = {
+        ...requestEntity,
+        headers: Array.isArray(requestEntity.headers) ? [...requestEntity.headers] : [],
+        auth: requestEntity.auth ? { ...requestEntity.auth } : undefined,
+    };
+    if (next.auth?.type === "cookie" && next.auth?.cookie?.value) {
+        return next;
+    }
+    const cookieHeader = next.headers.find((h) => String(h?.key ?? "").toLowerCase() === "cookie");
+    if (cookieHeader && cookieHeader.value) {
+        return next;
+    }
+    if (cookieHeader) {
+        cookieHeader.value = params.cookie;
+        cookieHeader.enabled = true;
+        return next;
+    }
+    next.headers.push({
+        key: "cookie",
+        value: params.cookie,
+        enabled: true,
+    });
+    return next;
+}
+function extractSetCookieHeader(raw) {
+    if (!raw)
+        return [];
+    return [raw];
+}

package/lib/routes/hub.routes.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from "fastify";
+export default function hubRoutes(app: FastifyInstance): Promise<void>;