@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/core/modules/agent-widgets/steps/index.js

@@ -0,0 +1,14 @@
+import { defineWidget } from "../../widget-catalog/index.js";
+export const stepsWidget = defineWidget({
+    name: "Steps",
+    group: "data",
+    summary: "этапы с отметкой готовности",
+    props: {
+        items: {
+            type: "array",
+            description: "массив объектов: title обязателен, text и done необязательны",
+            required: true,
+        },
+    },
+    example: "<Steps :items=\"[{title:'Собрать',done:true},{title:'Проверить'}]\" />",
+});

package/packages/core/modules/agent-widgets/tab/index.js

@@ -0,0 +1,12 @@
+import { defineWidget } from "../../widget-catalog/index.js";
+export const tabWidget = defineWidget({
+    name: "Tab",
+    group: "layout",
+    summary: "одна вкладка внутри <Tabs>",
+    props: {
+        title: { type: "string", description: "название вкладки", required: true },
+        hint: { type: "string", description: "подсказка при наведении" },
+    },
+    slot: "содержимое вкладки",
+    example: '<Tab title="Данные">Значения за месяц</Tab>',
+});

package/packages/core/modules/agent-widgets/tabs/index.js

@@ -0,0 +1,24 @@
+import { defineWidget } from "../../widget-catalog/index.js";
+export const tabsWidget = defineWidget({
+    name: "Tabs",
+    group: "layout",
+    summary: "вкладки с содержимым в компонентах Tab",
+    props: {
+        options: {
+            type: "array",
+            description: "массив строк или объектов: value обязателен, label и hint необязательны; без дочерних Tab это устаревший переключатель",
+        },
+        name: { type: "string", description: "имя поля в <Form> (устаревший переключатель)" },
+        initial: { type: "string", description: "начальное значение (устаревший переключатель)" },
+    },
+    model: { type: "string", description: "выбранная вкладка или значение" },
+    slot: "дочерний компонент Tab с названием title и содержимым для каждой вкладки",
+    notes: [
+        "Скрытая вкладка сохраняет введённое. Для переключателя значения используй Field с type=segmented или radio.",
+    ],
+    guide: [
+        "Дочерние Tab с title; скрытая вкладка сохраняет введённое.",
+        "Для выбора значения используй Field type=segmented или radio.",
+    ].join("\n"),
+    example: '<Tabs><Tab title="Данные">Значения за месяц</Tab><Tab title="Итоги">Всего 100</Tab></Tabs>',
+});

package/packages/core/modules/agents-integration/claude/index.js

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

package/packages/core/modules/agents-integration/codex/index.js

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

package/packages/core/modules/agents-integration/cursor/index.js

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

package/packages/core/modules/agents-integration/kimi/index.js

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

package/packages/core/modules/agents-integration/opencode/index.js

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

package/packages/core/modules/app-paths/index.js

@@ -0,0 +1,14 @@
+export { dataDir } from "./paths.js";
+export { appUrl } from "./paths.js";
+export { projectAppUrl } from "./paths.js";
+export { APP_PORT } from "./paths.js";
+export { instancePath } from "./paths.js";
+export { providersPath } from "./paths.js";
+export { APP_CLASS } from "./paths.js";
+export { chromeProfileDir } from "./paths.js";
+export { serverModePath } from "./paths.js";
+export { networkModePath } from "./paths.js";
+export { lanPasswordPath } from "./paths.js";
+export { readServerMode, writeServerMode } from "./server-mode.js";
+export { readNetworkMode, writeNetworkMode } from "./network-mode.js";
+export { DEFAULT_LOG_CHECK_MS, DEFAULT_LOG_MAX_BYTES, DEFAULT_LOG_MAX_FILES, SERVER_LOG, logRotationSettings, openLog, rotateLog, rotateStandardStreams, serverLogPath, startLogRotation, startServerLogRotation, } from "./logs.js";

package/packages/core/modules/app-paths/logs.js

@@ -0,0 +1,194 @@
+import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, renameSync, rmSync, statSync, truncateSync, writeSync, } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { dataDir } from "./paths.js";
+/** Диагностический лог запуска: `stdout` и `stderr` сервера дописываются сюда. */
+export const SERVER_LOG = "server.log";
+/** Размер активного файла, после которого он уступает место новому. */
+export const DEFAULT_LOG_MAX_BYTES = 10 * 1024 * 1024;
+/** Сколько архивов `server.log.1…N` хранится рядом с активным файлом. */
+export const DEFAULT_LOG_MAX_FILES = 5;
+/** Как часто работающий сервер проверяет размер собственного лога. */
+export const DEFAULT_LOG_CHECK_MS = 15_000;
+function envNumber(name, fallback) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+export function logRotationSettings(options = {}) {
+    return {
+        maxBytes: Math.max(1024, Math.floor(options.maxBytes ?? envNumber("PROJECTOR_LOG_MAX_BYTES", DEFAULT_LOG_MAX_BYTES))),
+        maxFiles: Math.max(1, Math.floor(options.maxFiles ?? envNumber("PROJECTOR_LOG_MAX_FILES", DEFAULT_LOG_MAX_FILES))),
+        intervalMs: Math.max(100, Math.floor(options.intervalMs ?? envNumber("PROJECTOR_LOG_CHECK_MS", DEFAULT_LOG_CHECK_MS))),
+    };
+}
+export function serverLogPath() {
+    return join(dataDir(), SERVER_LOG);
+}
+function fileSize(file) {
+    try {
+        return statSync(file).size;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Сдвигает `file` → `file.1`, `file.1` → `file.2` и удаляет самый старый архив.
+ * Возвращает `false`, если активный файл ещё не дорос до порога.
+ */
+export function rotateLog(file, options = {}) {
+    const { maxBytes, maxFiles } = logRotationSettings(options);
+    const size = fileSize(file);
+    if (size === undefined || size < maxBytes)
+        return false;
+    mkdirSync(dirname(file), { recursive: true });
+    rmSync(`${file}.${maxFiles}`, { force: true });
+    for (let index = maxFiles - 1; index >= 1; index -= 1) {
+        const source = `${file}.${index}`;
+        if (existsSync(source))
+            renameSync(source, `${file}.${index + 1}`);
+    }
+    rmSync(`${file}.1`, { force: true });
+    renameSync(file, `${file}.1`);
+    return true;
+}
+/** Ротирует файл (если нужно) и открывает его на дозапись. */
+export function openLog(file, options = {}) {
+    const { rotate = true } = options;
+    mkdirSync(dirname(file), { recursive: true });
+    if (rotate)
+        rotateLog(file, options);
+    return openSync(file, "a");
+}
+function closeStandardStreams() {
+    for (const fd of [1, 2]) {
+        try {
+            closeSync(fd);
+        }
+        catch {
+            /* already closed */
+        }
+    }
+}
+function reopenStandardStreams(file) {
+    const out = openSync(file, "a");
+    const err = openSync(file, "a");
+    if (out !== 1 || err !== 2) {
+        throw new Error(`не удалось вернуть stdout/stderr на server.log (fd ${out}, ${err})`);
+    }
+}
+/**
+ * Ротирует открытый файл без закрытия стандартных потоков: копирует его в
+ * архив и обнуляет активный. Так `console.log` продолжает писать в тот же
+ * дескриптор, что и на Windows, где переименовать открытый файл нельзя.
+ */
+function rotateOpenLog(file, settings) {
+    const size = fileSize(file);
+    if (size === undefined || size < settings.maxBytes)
+        return false;
+    mkdirSync(dirname(file), { recursive: true });
+    rmSync(`${file}.${settings.maxFiles}`, { force: true });
+    for (let index = settings.maxFiles - 1; index >= 1; index -= 1) {
+        const source = `${file}.${index}`;
+        if (existsSync(source))
+            renameSync(source, `${file}.${index + 1}`);
+    }
+    rmSync(`${file}.1`, { force: true });
+    copyFileSync(file, `${file}.1`);
+    truncateSync(file, 0);
+    return true;
+}
+/**
+ * Ротирует файл, в который перенаправлены `stdout` и `stderr` самого процесса.
+ * На POSIX файл можно переименовать открытым, а затем вернуть дескрипторы;
+ * на Windows открытый файл остаётся на месте, а его содержимое уходит в архив.
+ */
+export function rotateStandardStreams(file, options = {}) {
+    const settings = logRotationSettings(options);
+    const size = fileSize(file);
+    if (size === undefined || size < settings.maxBytes)
+        return false;
+    let rotated = false;
+    if (process.platform === "win32") {
+        try {
+            rotated = rotateOpenLog(file, settings);
+        }
+        catch {
+            rotated = false;
+        }
+    }
+    else {
+        // Close first: POSIX reopens the same descriptor numbers after the rename.
+        closeStandardStreams();
+        try {
+            rotated = rotateLog(file, settings);
+        }
+        catch {
+            rotated = false;
+        }
+        reopenStandardStreams(file);
+    }
+    if (rotated) {
+        try {
+            writeSync(1, `[projector] rotated ${basename(file)}: ${size} bytes -> ${basename(file)}.1 at ${new Date().toISOString()}\n`);
+        }
+        catch {
+            /* the new stream is still usable */
+        }
+    }
+    return rotated;
+}
+/**
+ * Проверяет размер `PROJECTOR_SERVER_LOG` и ротирует его на ходу.
+ * Без переменной (сервер запущен вручную в терминале) ничего не делает.
+ */
+export function startServerLogRotation() {
+    const file = process.env.PROJECTOR_SERVER_LOG;
+    if (!file)
+        return () => undefined;
+    // The marker is for this process only: terminals and agents must not inherit it.
+    delete process.env.PROJECTOR_SERVER_LOG;
+    return startLogRotation(file);
+}
+/**
+ * Фоновый watcher для файла, в который пишет сам процесс. Повторный вызов
+ * для того же файла возвращает существующую остановку: Vite перезагружает модули.
+ */
+export function startLogRotation(file, options = {}) {
+    const host = globalThis;
+    const active = (host.projectorLogRotation ??= new Map());
+    const existing = active.get(file);
+    if (existing)
+        return existing;
+    const settings = logRotationSettings(options);
+    let stopped = false;
+    let reported = false;
+    const check = () => {
+        if (stopped)
+            return;
+        try {
+            rotateStandardStreams(file, settings);
+            reported = false;
+        }
+        catch (error) {
+            if (reported)
+                return;
+            reported = true;
+            try {
+                writeSync(2, `[projector] log rotation failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+            catch {
+                /* stderr is the file being rotated */
+            }
+        }
+    };
+    const timer = setInterval(check, settings.intervalMs);
+    timer.unref();
+    const stop = () => {
+        stopped = true;
+        clearInterval(timer);
+        active.delete(file);
+    };
+    active.set(file, stop);
+    check();
+    return stop;
+}

package/packages/core/modules/app-paths/network-mode.js

@@ -0,0 +1,24 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { isNetworkMode } from "../network-mode/index.js";
+import { networkModePath } from "./paths.js";
+/**
+ * Режим доступа к серверу; по умолчанию local. `PROJECTOR_NETWORK` задаёт
+ * одноразовый запуск (флаг `--lan`/`--local`) и имеет приоритет над файлом.
+ */
+export function readNetworkMode() {
+    const env = process.env.PROJECTOR_NETWORK;
+    if (env === "local" || env === "lan")
+        return env;
+    try {
+        const value = readFileSync(networkModePath(), "utf8").trim();
+        return isNetworkMode(value) ? value : "local";
+    }
+    catch {
+        return "local";
+    }
+}
+export function writeNetworkMode(mode) {
+    mkdirSync(dirname(networkModePath()), { recursive: true });
+    writeFileSync(networkModePath(), `${mode}\n`, "utf8");
+}

package/packages/core/modules/app-paths/paths.js

@@ -0,0 +1,40 @@
+import { os } from "../os/index.js";
+import { join } from "node:path";
+export const APP_PORT = 4177;
+export const APP_HOST = "localhost";
+export const APP_CLASS = "Projector";
+export const APP_NAME = "projector";
+export function appUrl() {
+    return `http://${APP_HOST}:${APP_PORT}`;
+}
+export function projectAppUrl(id) {
+    return `${appUrl()}/api/projects/${encodeURIComponent(id)}/app`;
+}
+export function dataDir() {
+    const root = os.dataHome();
+    return join(root, APP_NAME);
+}
+export function instancePath() {
+    return join(dataDir(), "instance.json");
+}
+export function chromeProfileDir() {
+    return join(dataDir(), "chrome-profile");
+}
+export function launchLockPath() {
+    return join(dataDir(), "launch.lock");
+}
+export function providersPath() {
+    return join(dataDir(), "providers.json");
+}
+/** Режим следующего запуска сервера: `dev` или `prod`. */
+export function serverModePath() {
+    return join(dataDir(), "server-mode");
+}
+/** Режим доступа к серверу: `local` или `lan`. */
+export function networkModePath() {
+    return join(dataDir(), "network-mode");
+}
+/** Хеш пароля доступа по локальной сети (scrypt `salt:hash`). */
+export function lanPasswordPath() {
+    return join(dataDir(), "lan-password");
+}

package/packages/core/modules/app-paths/server-mode.js

@@ -0,0 +1,18 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { isServerMode } from "../server-mode/index.js";
+import { serverModePath } from "./paths.js";
+/** Режим следующего запуска сервера; по умолчанию dev. */
+export function readServerMode() {
+    try {
+        const value = readFileSync(serverModePath(), "utf8").trim();
+        return isServerMode(value) ? value : "dev";
+    }
+    catch {
+        return "dev";
+    }
+}
+export function writeServerMode(mode) {
+    mkdirSync(dirname(serverModePath()), { recursive: true });
+    writeFileSync(serverModePath(), `${mode}\n`, "utf8");
+}

package/packages/core/modules/appearance/index.js

@@ -0,0 +1,35 @@
+export const appearanceFile = "appearance.json";
+export const appearanceOptions = [
+    {
+        id: "dark",
+        title: "Тёмная",
+        description: "Спокойная тёплая тёмная схема Projector.",
+    },
+    {
+        id: "light",
+        title: "Светлая",
+        description: "Тёплая светлая схема для яркого окружения.",
+    },
+    {
+        id: "contrast",
+        title: "Высокий контраст",
+        description: "Чёрный фон и яркие акценты для максимальной читаемости.",
+    },
+    {
+        id: "auto",
+        title: "Как в системе",
+        description: "Следует за светлой или тёмной темой операционной системы.",
+    },
+];
+export const defaultAppearance = "dark";
+export function isAppearanceChoice(value) {
+    return appearanceOptions.some((option) => option.id === value);
+}
+export function resolveScheme(choice, prefersLight) {
+    if (choice === "auto")
+        return prefersLight ? "light" : "dark";
+    return choice;
+}
+export function schemeMode(scheme) {
+    return scheme === "light" ? "light" : "dark";
+}

package/packages/core/modules/browser/index.js

@@ -0,0 +1,86 @@
+/**
+ * Адреса псевдобраузера. Страница из интернета открывается с собственного origin
+ * `<хост>.<тег>.<nonce>.proxy.localhost:<порт>`: у неё настоящие относительные ссылки,
+ * fetch и хранилище, а API Projector остаётся на другом origin.
+ */
+export const PROXY_DOMAIN = "proxy.localhost";
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "0.0.0.0"]);
+const PRIVATE_HOST = /^(?:10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.|169\.254\.)|\.(?:localhost|local)$/;
+const PROXY_HOST = /^(.+)\.([sh])(\d{0,5})\.([0-9a-f]{16})\.proxy\.localhost(?::(\d{1,5}))?$/i;
+/** Доводит ввод адресной строки до URL: без схемы это localhost-порт, домен или поисковый запрос. */
+export function normalizeBrowserInput(input) {
+    const text = input.trim();
+    if (!text)
+        return "";
+    if (/^https?:\/\//i.test(text))
+        return new URL(text).href;
+    if (/^(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?(?:[/?#]|$)/i.test(text))
+        return new URL(`http://${text}`).href;
+    if (/^:\d{2,5}(?:[/?#]|$)/.test(text))
+        return new URL(`http://localhost${text}`).href;
+    if (!/\s/.test(text) && /^[^\s/]+\.[a-z]{2,}(?::\d+)?(?:[/?#]|$)/i.test(text))
+        return new URL(`https://${text}`).href;
+    return `https://duckduckgo.com/?q=${encodeURIComponent(text)}`;
+}
+/** Страницы машины и локальной сети (dev-серверы) открываются напрямую, без прокси. */
+export function isLocalBrowserTarget(url) {
+    try {
+        const host = new URL(url).hostname.toLowerCase();
+        return LOCAL_HOSTS.has(host) || PRIVATE_HOST.test(host);
+    }
+    catch {
+        return false;
+    }
+}
+/** Прокси доступен, когда Projector открыт на этом компьютере: `*.localhost` указывает на него. */
+export function proxyAvailableFor(hostname) {
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+/** Окончание хоста прокси: `<nonce>.proxy.localhost[:порт]`. */
+export function proxySuffix(nonce, port = "") {
+    return `${nonce}.${PROXY_DOMAIN}${port ? `:${port}` : ""}`;
+}
+/** Адрес на origin прокси; `undefined` для не-http(s), IPv6 и слишком длинных имён. */
+export function proxyUrl(url, suffix) {
+    let target;
+    try {
+        target = new URL(url);
+    }
+    catch {
+        return;
+    }
+    if (target.protocol !== "http:" && target.protocol !== "https:")
+        return;
+    if (target.hostname.includes(":"))
+        return;
+    const tag = (target.protocol === "https:" ? "s" : "h") + target.port;
+    const host = `${target.hostname}.${tag}.${suffix}`;
+    if (host.length > 253)
+        return;
+    return `http://${host}${target.pathname}${target.search}${target.hash}`;
+}
+/** Разбирает заголовок Host запроса к прокси; `undefined`, если это не хост прокси. */
+export function parseProxyHost(host) {
+    const match = host.toLowerCase().match(PROXY_HOST);
+    if (!match)
+        return;
+    const [, hostname, scheme, targetPort, nonce, port] = match;
+    return {
+        origin: `${scheme === "s" ? "https" : "http"}://${hostname}${targetPort ? `:${targetPort}` : ""}`,
+        nonce,
+        suffix: proxySuffix(nonce, port),
+    };
+}
+/** Адрес настоящего сайта по адресу на origin прокси. */
+export function fromProxyUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const host = parseProxyHost(parsed.host);
+        if (!host)
+            return;
+        return `${host.origin}${parsed.pathname}${parsed.search}${parsed.hash}`;
+    }
+    catch {
+        return;
+    }
+}

package/packages/core/modules/devcontainer/classify.js

@@ -0,0 +1,101 @@
+const nonEmpty = (value) => Array.isArray(value)
+    ? value.length > 0
+    : value !== null && typeof value === "object"
+        ? Object.keys(value).length > 0
+        : Boolean(value);
+const LIFECYCLE = [
+    "onCreateCommand",
+    "updateContentCommand",
+    "postCreateCommand",
+    "postStartCommand",
+    "postAttachCommand",
+];
+/**
+ * Lists what a devcontainer.json asks for beyond the restricted model
+ * (image, ports, environment, non-root user). An empty list means the
+ * configuration needs no trust decision.
+ */
+export function classifyDevcontainer(config) {
+    if (!config || typeof config !== "object" || Array.isArray(config))
+        return [];
+    const input = config;
+    const findings = [];
+    const add = (finding) => findings.push(finding);
+    if (nonEmpty(input.initializeCommand))
+        add({
+            id: "initialize-command",
+            risk: "host",
+            title: "Команда на вашем компьютере",
+            detail: "initializeCommand выполняется на хосте, вне контейнера, с вашими правами и доступом к файлам.",
+            keys: ["initializeCommand"],
+        });
+    const privileged = ["privileged", "capAdd", "securityOpt"].filter((key) => nonEmpty(input[key]));
+    if (privileged.length)
+        add({
+            id: "privileges",
+            risk: "host",
+            title: "Расширенные права контейнера",
+            detail: "Снимает ограничения изоляции: привилегированный режим, capabilities или security-опции.",
+            keys: privileged,
+        });
+    if (nonEmpty(input.runArgs))
+        add({
+            id: "run-args",
+            risk: "host",
+            title: "Произвольные аргументы docker run",
+            detail: "runArgs передаются Docker как есть и могут менять сеть, устройства и доступ к хосту.",
+            keys: ["runArgs"],
+        });
+    const mounts = ["mounts", "workspaceMount"].filter((key) => nonEmpty(input[key]));
+    if (mounts.length)
+        add({
+            id: "mounts",
+            risk: "host",
+            title: "Монтирование путей хоста",
+            detail: "Контейнер получает доступ к дополнительным папкам или сокетам хоста.",
+            keys: mounts,
+        });
+    if (nonEmpty(input.dockerComposeFile))
+        add({
+            id: "compose",
+            risk: "host",
+            title: "Docker Compose",
+            detail: "Запускает сервисы из Compose-файла репозитория со всеми их настройками.",
+            keys: ["dockerComposeFile"],
+        });
+    const build = nonEmpty(input.build) ? ["build"] : [];
+    if (build.length)
+        add({
+            id: "build",
+            risk: "root",
+            title: "Сборка образа из Dockerfile",
+            detail: "Команды Dockerfile выполняются при сборке от root, обычно с доступом к сети.",
+            keys: build,
+        });
+    if (nonEmpty(input.features))
+        add({
+            id: "features",
+            risk: "root",
+            title: "Dev Container Features",
+            detail: "Скрипты установки загружаются из реестров и выполняются при сборке от root.",
+            keys: ["features"],
+        });
+    const lifecycle = LIFECYCLE.filter((key) => nonEmpty(input[key]));
+    if (lifecycle.length)
+        add({
+            id: "lifecycle",
+            risk: "container",
+            title: "Команды при создании и запуске",
+            detail: "Выполняются в контейнере автоматически, с доступом к вашему проекту.",
+            keys: [...lifecycle],
+        });
+    if (input.remoteUser === "root" || input.containerUser === "root")
+        add({
+            id: "root-user",
+            risk: "root",
+            title: "Работа от root",
+            detail: "Процессы в контейнере запускаются от имени root.",
+            keys: ["remoteUser", "containerUser"].filter((key) => input[key] === "root"),
+        });
+    return findings;
+}

package/packages/core/modules/devcontainer/contract.js

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

package/packages/core/modules/devcontainer/index.js

@@ -0,0 +1 @@
+export { classifyDevcontainer } from "./classify.js";

package/packages/core/modules/directories/contract.js

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

package/packages/core/modules/directories/index.js

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

package/packages/core/modules/docker/contract.js

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

package/packages/core/modules/docker/index.js

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

package/packages/core/modules/editor-themes/index.js

@@ -0,0 +1,17 @@
+export const editorThemes = [
+    {
+        id: "projector-soft",
+        title: "Projector · Gruvbox Material",
+        description: "Приглушённые тёплые цвета на фоне Projector. Рекомендуемая тема.",
+    },
+    {
+        id: "projector",
+        title: "Projector · классическая",
+        description: "Прежняя подсветка на тёмном фоне Projector.",
+    },
+    { id: "one-dark", title: "One Dark", description: "Классическая тёмная тема One Dark." },
+];
+export const defaultEditorTheme = "projector-soft";
+export function isEditorTheme(value) {
+    return editorThemes.some((theme) => theme.id === value);
+}

package/packages/core/modules/environment/index.js

@@ -0,0 +1 @@
+export const DEFAULT_ENVIRONMENT_IMAGE = "node:24-bookworm";