@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/cli/app/launch.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { os } from "../../core/modules/os/index.js";
+import { readServerMode } from "../../core/modules/app-paths/index.js";
+import { commandLogs } from "../commands/logs.js";
+import { commandOpen, commandSettings, commandToggle } from "../commands/open.js";
+import { commandProjects } from "../commands/projects.js";
+import { commandRun, commandStop } from "../commands/run.js";
+import { commandSearch } from "../commands/search.js";
+import { commandQuit, commandRestart } from "../commands/server.js";
+import { commandStatus } from "../commands/status.js";
+import { createApi } from "../modules/api/index.js";
+import { helpText, parseArgs } from "../modules/arguments/index.js";
+import { createServerControl } from "../modules/server/index.js";
+const ROOT = fileURLToPath(new URL("../../..", import.meta.url));
+const packaged = existsSync(join(ROOT, "packages/server/app/standalone.js"));
+const launchMode = () => (packaged ? "prod" : readServerMode());
+const APP_URL = (process.env.PROJECTOR_URL || "http://localhost:4177").replace(/\/+$/, "");
+const DATA_DIR = join(os.dataHome(), "projector");
+const api = createApi(APP_URL);
+function parsedArgs() {
+    try {
+        return parseArgs(process.argv.slice(2));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+const { command, target, options } = parsedArgs();
+const out = (line = "") => {
+    if (!options.quiet || options.json)
+        console.log(line);
+};
+const serverControl = createServerControl({
+    root: ROOT,
+    dataDir: DATA_DIR,
+    appUrl: APP_URL,
+    packaged,
+    launchMode,
+    options,
+    out,
+});
+async function version() {
+    try {
+        const manifest = JSON.parse(await readFile(join(ROOT, "package.json"), "utf8"));
+        return manifest.version || "";
+    }
+    catch {
+        return "";
+    }
+}
+async function execute() {
+    if (command === "help") {
+        console.log(helpText(await version()));
+        return;
+    }
+    if (command === "version") {
+        const value = await version();
+        if (options.json)
+            out(JSON.stringify({ version: value }, null, 2));
+        else
+            out(value || "неизвестно");
+        return;
+    }
+    if (command === "mode") {
+        await serverControl.switchMode(target, options);
+        return;
+    }
+    if (options.server) {
+        await serverControl.startForegroundServer();
+        return;
+    }
+    if (command === "start") {
+        const info = await serverControl.ensureServer();
+        if (options.json)
+            out(JSON.stringify(info, null, 2));
+        else
+            out(`Projector запущен: ${info.url ?? APP_URL}`);
+        return;
+    }
+    if (command === "quit") {
+        await commandQuit(api, options, out);
+        return;
+    }
+    if (command === "restart") {
+        if (!(await serverControl.health())) {
+            const info = await serverControl.ensureServer();
+            if (options.json)
+                out(JSON.stringify({ server: info, previousPid: null, started: true }, null, 2));
+            else
+                out(`Projector запущен: ${info.url ?? APP_URL}`);
+            return;
+        }
+        await commandRestart(api, options, out);
+        return;
+    }
+    if (command === "logs") {
+        commandLogs(options, out);
+        return;
+    }
+    // Read-only commands stay useful while the server is stopped.
+    if (command === "projects") {
+        await commandProjects(api, options, out);
+        return;
+    }
+    if (command === "status") {
+        await commandStatus(api, options, target, out);
+        return;
+    }
+    await serverControl.ensureServer();
+    if (command === "open")
+        await commandOpen(api, options, target, out);
+    else if (command === "toggle")
+        await commandToggle(api, options, out);
+    else if (command === "settings")
+        await commandSettings(api, options, out);
+    else if (command === "search")
+        await commandSearch(api, options, target, out);
+    else if (command === "run")
+        await commandRun(api, options, target, out);
+    else if (command === "stop")
+        await commandStop(api, options, target, out);
+    else
+        throw new Error("Неизвестная команда");
+}
+execute().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    serverControl.alertFailure(message);
+    process.exit(1);
+});

package/packages/cli/app/restart.js

@@ -0,0 +1,32 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { os } from "../../core/modules/os/index.js";
+export const waitForProcessExit = (pid, timeoutMs = 15000) => os.processes.waitForExit(pid, timeoutMs);
+export async function restartAfterExit(serverPid, desktopPid, launch) {
+    await Promise.all([
+        waitForProcessExit(serverPid),
+        desktopPid ? waitForProcessExit(desktopPid) : Promise.resolve(),
+    ]);
+    await launch();
+}
+function launchProjector() {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [fileURLToPath(new URL("./launch.js", import.meta.url)), "--tray"], {
+            stdio: "inherit",
+        });
+        child.once("error", reject);
+        child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`Запуск Projector завершился (${code})`)));
+    });
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+    const serverPid = Number(process.argv[2]);
+    const desktopPid = Number(process.argv[3]) || undefined;
+    if (!Number.isInteger(serverPid) || serverPid <= 0)
+        throw new Error("Некорректный PID сервера");
+    process.send?.("READY");
+    process.disconnect?.();
+    restartAfterExit(serverPid, desktopPid, launchProjector).catch((error) => {
+        console.error("Перезапуск Projector:", error instanceof Error ? error.message : error);
+        process.exitCode = 1;
+    });
+}

package/packages/cli/commands/logs.js

@@ -0,0 +1,10 @@
+import { serverLogPath } from "../../core/modules/app-paths/index.js";
+import { writeJson } from "../common/output.js";
+export function commandLogs(options, out) {
+    const path = serverLogPath();
+    if (options.json)
+        writeJson(out, { path });
+    else if (!options.quiet)
+        out(path);
+    return path;
+}

package/packages/cli/commands/open.js

@@ -0,0 +1,49 @@
+import { writeJson } from "../common/output.js";
+import { resolveOpenTarget } from "../modules/projects/index.js";
+export async function commandOpen(api, options, target, out) {
+    if (!target) {
+        if (options.tray) {
+            const result = await api.open({ tray: true });
+            if (options.json)
+                writeJson(out, result);
+            else if (!options.quiet)
+                out("Projector работает в трее");
+            return result;
+        }
+        const result = await api.open({ mode: options.mode });
+        if (options.json)
+            writeJson(out, result);
+        else if (!options.quiet)
+            out(`Projector открыт: ${result.url ?? api.baseUrl}`);
+        return result;
+    }
+    if (options.tray)
+        throw new Error("--tray используется без проекта");
+    const id = await resolveOpenTarget(api, target);
+    const launched = await api.launch({ id, action: "open", inline: true });
+    if (!launched.route)
+        throw new Error("Сервер не вернул маршрут проекта");
+    const opened = await api.open({ route: launched.route, mode: options.mode });
+    const result = { ...launched, ...opened, id };
+    if (options.json)
+        writeJson(out, result);
+    else if (!options.quiet)
+        out(`Открыт проект: ${opened.url}`);
+    return result;
+}
+export async function commandToggle(api, options, out) {
+    const result = await api.open({ toggle: true, mode: options.mode });
+    if (options.json)
+        writeJson(out, result);
+    else if (!options.quiet)
+        out("Палитра переключена");
+    return result;
+}
+export async function commandSettings(api, options, out) {
+    const result = await api.open({ route: "/settings", mode: options.mode });
+    if (options.json)
+        writeJson(out, result);
+    else if (!options.quiet)
+        out(`Открыты настройки: ${result.url}`);
+    return result;
+}

package/packages/cli/commands/projects.js

@@ -0,0 +1,18 @@
+import { writeJson, printTable } from "../common/output.js";
+import { projectState, readStoredProjects } from "../modules/projects/index.js";
+export async function commandProjects(api, options, out) {
+    const online = await api.health();
+    const projects = online ? (await api.projects()).projects : await readStoredProjects();
+    if (options.json) {
+        writeJson(out, { source: online ? "server" : "disk", projects });
+        return projects;
+    }
+    if (!projects.length) {
+        if (!options.quiet)
+            out("Проектов пока нет. Откройте папку: projector open <путь>");
+        return projects;
+    }
+    if (!options.quiet)
+        printTable(["ID", "ИМЯ", "СОСТОЯНИЕ", "ПУТЬ"], projects.map((project) => [project.id, project.name, projectState(project), project.path]), out);
+    return projects;
+}

package/packages/cli/commands/run.js

@@ -0,0 +1,39 @@
+import { writeJson } from "../common/output.js";
+import { resolveProject } from "../modules/projects/index.js";
+export async function commandRun(api, options, target, out) {
+    const project = await resolveProject(api, target);
+    if (options.command && !project.commands.some((command) => command.id === options.command))
+        throw new Error(`Команда не найдена: ${options.command}`);
+    const body = options.command ? { commandId: options.command } : {};
+    const { runtime } = await api.start(project.id, body);
+    const result = {
+        project: { id: project.id, name: project.name, path: project.path },
+        runtime,
+    };
+    if (options.json)
+        writeJson(out, result);
+    else if (!options.quiet) {
+        out(`Запущен ${project.name}: ${runtime.commandName ?? "команда"}`);
+        if (runtime.pid)
+            out(`PID: ${runtime.pid}`);
+        if (runtime.url)
+            out(`Адрес: ${runtime.url}`);
+    }
+    if (runtime.status === "error")
+        throw new Error(`Команда завершилась с ошибкой (код ${runtime.exitCode ?? "?"})`);
+    return result;
+}
+export async function commandStop(api, options, target, out) {
+    const project = await resolveProject(api, target);
+    const result = {
+        project: { id: project.id, name: project.name, path: project.path },
+        runtime: (await api.stop(project.id)).runtime,
+    };
+    if (options.json)
+        writeJson(out, result);
+    else if (!options.quiet)
+        out(result.runtime.status === "idle"
+            ? `${project.name}: уже остановлен`
+            : `${project.name}: остановка запущена`);
+    return result;
+}

package/packages/cli/commands/search.js

@@ -0,0 +1,19 @@
+import { printTable, writeJson } from "../common/output.js";
+export async function commandSearch(api, options, query, out) {
+    if (!query)
+        throw new Error("Укажите запрос: projector search <запрос>");
+    const result = await api.search(query);
+    if (options.json) {
+        writeJson(out, result);
+        return result;
+    }
+    if (!result.items.length) {
+        if (!options.quiet)
+            out("Ничего не найдено");
+        return result;
+    }
+    if (!options.quiet) {
+        printTable(["ТИП", "ИМЯ", "ОПИСАНИЕ", "МАРШРУТ"], result.items.map((item) => [item.kind, item.name, item.description, item.route ?? ""]), out);
+    }
+    return result;
+}

package/packages/cli/commands/server.js

@@ -0,0 +1,32 @@
+import { writeJson } from "../common/output.js";
+import { serverLine, waitForHealth, waitUntilDown } from "../modules/command-runtime/index.js";
+export async function commandRestart(api, options, out) {
+    const info = await api.health();
+    if (!info)
+        throw new Error("Projector не запущен. Запустите: projector start");
+    const oldPid = info.pid;
+    await api.app("restart");
+    const next = await waitForHealth(api, (current) => current.pid !== oldPid, 60_000, "Сервер не перезапустился за 60 секунд. Смотрите: projector logs");
+    if (options.json)
+        writeJson(out, { server: next, previousPid: oldPid });
+    else if (!options.quiet)
+        out(`Projector перезапущен · ${serverLine(next)}`);
+    return next;
+}
+export async function commandQuit(api, options, out) {
+    const info = await api.health();
+    if (!info) {
+        if (options.json)
+            writeJson(out, { ok: true, running: false });
+        else if (!options.quiet)
+            out("Projector не запущен");
+        return { ok: true, running: false };
+    }
+    await api.app("quit");
+    await waitUntilDown(api, 15_000, "Сервер не завершился за 15 секунд");
+    if (options.json)
+        writeJson(out, { ok: true, running: false, pid: info.pid });
+    else if (!options.quiet)
+        out("Projector остановлен");
+    return { ok: true, running: false, pid: info.pid };
+}

package/packages/cli/commands/status.js

@@ -0,0 +1,42 @@
+import { writeJson } from "../common/output.js";
+import { serverLine } from "../modules/command-runtime/index.js";
+import { projectState, projectUrl, readStoredProjects, selectProject, } from "../modules/projects/index.js";
+export async function commandStatus(api, options, target, out) {
+    const info = await api.health();
+    const projects = info ? (await api.projects()).projects : await readStoredProjects();
+    if (target) {
+        const project = selectProject(projects, target, { containing: true });
+        if (!project)
+            throw new Error(`Проект не найден: ${target}`);
+        const result = { server: info, project };
+        if (options.json)
+            writeJson(out, result);
+        else if (!options.quiet) {
+            out(info ? `Сервер: работает · ${serverLine(info)}` : "Сервер: не запущен");
+            out(`Проект: ${project.name}`);
+            out(`Путь: ${project.path}`);
+            out(`Состояние: ${projectState(project)}`);
+            if (project.runtime?.commandName)
+                out(`Команда: ${project.runtime.commandName}`);
+            if (project.runtime?.pid)
+                out(`PID: ${project.runtime.pid}`);
+            const url = projectUrl(project);
+            if (url)
+                out(`Адрес: ${url}`);
+        }
+        return result;
+    }
+    const running = projects.filter((project) => project.runtime?.status === "running");
+    const result = { server: info, projects, running: running.length };
+    if (options.json)
+        writeJson(out, result);
+    else if (!options.quiet) {
+        out(info ? `Сервер: работает · ${serverLine(info)}` : "Сервер: не запущен");
+        out(`Проекты: ${projects.length}; работает: ${running.length}`);
+        for (const project of running) {
+            const url = projectUrl(project);
+            out(`  ${project.name}${project.runtime?.pid ? ` (pid ${project.runtime.pid})` : ""}${url ? ` — ${url}` : ""}`);
+        }
+    }
+    return result;
+}

package/packages/cli/common/output.js

@@ -0,0 +1,13 @@
+export function writeJson(out, value) {
+    out(JSON.stringify(value, null, 2) ?? "null");
+}
+export function printTable(headers, rows, out) {
+    const widths = headers.map((header, index) => Math.max(String(header).length, ...rows.map((row) => String(row[index] ?? "").length)));
+    const line = (row) => row
+        .map((value, index) => String(value ?? "").padEnd(widths[index] ?? 0))
+        .join("  ")
+        .trimEnd();
+    out(line(headers));
+    for (const row of rows)
+        out(line(row));
+}

package/packages/cli/modules/api/index.js

@@ -0,0 +1,60 @@
+/** Minimal client for the local Projector server. No retries: the CLI already starts it. */
+export function createApi(baseUrl) {
+    async function request(path, options = {}) {
+        const { method = "GET", body, timeout = 15_000 } = options;
+        const response = await fetch(baseUrl + path, {
+            method,
+            headers: body === undefined ? undefined : { "Content-Type": "application/json" },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(timeout),
+        });
+        const text = await response.text();
+        let data = {};
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = { error: text };
+            }
+        }
+        if (!response.ok) {
+            const error = data && typeof data === "object" && "error" in data
+                ? data.error
+                : undefined;
+            throw new Error(typeof error === "string" && error ? error : `Ошибка запроса (${response.status})`);
+        }
+        return data;
+    }
+    async function health() {
+        try {
+            const response = await fetch(`${baseUrl}/api/health`, {
+                signal: AbortSignal.timeout(500),
+            });
+            const data = (await response.json());
+            return response.ok && data.ok === true && data.app === "projector"
+                ? data
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return {
+        baseUrl,
+        request,
+        health,
+        projects: () => request("/api/projects"),
+        search: (query) => request(`/api/launcher/search?${new URLSearchParams({ q: query })}`),
+        launch: (body) => request("/api/launcher/launch", { method: "POST", body }),
+        open: (body) => request("/api/app/open", { method: "POST", body }),
+        start: (projectId, body) => request(`/api/projects/${encodeURIComponent(projectId)}/start`, {
+            method: "POST",
+            body,
+        }),
+        stop: (projectId) => request(`/api/projects/${encodeURIComponent(projectId)}/stop`, {
+            method: "POST",
+        }),
+        app: (action, body = {}) => request(`/api/app/${action}`, { method: "POST", body }),
+    };
+}

package/packages/cli/modules/arguments/index.js

@@ -0,0 +1,188 @@
+const COMMANDS = new Set([
+    "open",
+    "projects",
+    "status",
+    "search",
+    "run",
+    "start",
+    "stop",
+    "restart",
+    "quit",
+    "toggle",
+    "mode",
+    "settings",
+    "logs",
+    "version",
+    "help",
+]);
+const ALIASES = {
+    list: "projects",
+    ls: "projects",
+    serve: "start",
+};
+const MODE_FLAGS = new Map([
+    ["--native", "native"],
+    ["--window", "window"],
+    ["--browser", "browser"],
+]);
+const TARGET_COMMANDS = new Set([
+    "open",
+    "run",
+    "stop",
+    "status",
+    "mode",
+    "search",
+    "help",
+]);
+function commandOf(value) {
+    if (Object.hasOwn(ALIASES, value))
+        return ALIASES[value];
+    return COMMANDS.has(value) ? value : undefined;
+}
+function valueAfter(argv, index, flag) {
+    const value = argv[index + 1];
+    if (!value || value.startsWith("-"))
+        throw new Error(`Укажите значение для ${flag}`);
+    return value;
+}
+/**
+ * Parses both the historical launcher flags (`--browser`, `toggle`, `quit`, `mode prod`) and
+ * the project commands (`open`, `projects`, `run`, `stop`, `status`, `search`).
+ */
+export function parseArgs(argv) {
+    const options = {
+        json: false,
+        quiet: false,
+        tray: false,
+        toggle: false,
+        quit: false,
+        lan: false,
+        local: false,
+        server: false,
+        help: false,
+        version: false,
+    };
+    const positional = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--") {
+            positional.push(...argv.slice(index + 1));
+            break;
+        }
+        if (arg === "--json")
+            options.json = true;
+        else if (arg === "--quiet" || arg === "-q")
+            options.quiet = true;
+        else if (MODE_FLAGS.has(arg))
+            options.mode = MODE_FLAGS.get(arg);
+        else if (arg === "--tray")
+            options.tray = true;
+        else if (arg === "--toggle")
+            options.toggle = true;
+        else if (arg === "--quit")
+            options.quit = true;
+        else if (arg === "--lan")
+            options.lan = true;
+        else if (arg === "--local")
+            options.local = true;
+        else if (arg === "--server")
+            options.server = true;
+        else if (arg === "--help" || arg === "-h")
+            options.help = true;
+        else if (arg === "--version" || arg === "-v")
+            options.version = true;
+        else if (arg === "--command") {
+            options.command = valueAfter(argv, index, arg);
+            index += 1;
+        }
+        else if (arg.startsWith("--command=")) {
+            options.command = arg.slice("--command=".length);
+            if (!options.command)
+                throw new Error("Укажите значение для --command");
+        }
+        else if (arg.startsWith("-"))
+            throw new Error(`Неизвестный флаг: ${arg}`);
+        else
+            positional.push(arg);
+    }
+    let command = "open";
+    let target;
+    let rest = [];
+    if (positional.length) {
+        const [first, ...tail] = positional;
+        const known = commandOf(first);
+        if (known) {
+            command = known;
+            [target, ...rest] = tail;
+        }
+        else {
+            target = first;
+            rest = tail;
+        }
+    }
+    if (options.quit)
+        command = "quit";
+    else if (options.toggle)
+        command = "toggle";
+    else if (options.server)
+        command = "start";
+    if (options.version)
+        command = "version";
+    else if (options.help)
+        command = "help";
+    if (command === "search")
+        target = [target, ...rest].filter(Boolean).join(" ");
+    else if (rest.length)
+        throw new Error(`Лишние аргументы: ${rest.join(" ")}`);
+    if (command === "help" && target)
+        rest = [target];
+    if (target && !TARGET_COMMANDS.has(command))
+        throw new Error(`Команда ${command} не принимает аргумент: ${target}`);
+    return { command, target, options, rest };
+}
+export function helpText(version = "") {
+    const title = version ? `Projector CLI ${version}` : "Projector CLI";
+    return `${title}
+
+Использование:
+  projector [options]                         открыть палитру
+  projector open [проект] [options]           открыть проект или палитру
+  projector projects [--json]                 список сохранённых проектов
+  projector status [проект] [--json]          состояние сервера и проекта
+  projector run [проект] [--command <id>]     запустить основную команду проекта
+  projector stop [проект]                     остановить команду проекта
+  projector search <запрос> [--json]          поиск по приложениям и проектам
+  projector start [--server]                  запустить сервер без открытия окна
+  projector restart                           перезапустить сервер
+  projector quit                              завершить Projector и его процессы
+  projector toggle                            показать или скрыть палитру
+  projector mode [dev|prod]                   показать или переключить режим сервера
+  projector settings                          открыть настройки
+  projector logs                              показать путь к журналу сервера
+  projector version                           показать версию
+  projector help                              показать эту справку
+
+Проект:
+  локальный путь (в том числе . и ~/путь), имя или id проекта,
+  gh:/owner/repository, gl:/<instance>/<group>/<project>.
+  Без проекта run и stop используют текущую папку.
+
+Параметры:
+  --browser | --window | --native   режим интерфейса
+  --tray                            запустить только трей
+  --lan | --local                   разовый режим доступа к серверу
+  --server                          сервер в foreground (для start)
+  --command <id>                    команда проекта для run
+  --json                            машиночитаемый вывод
+  --quiet, -q                       без обычных сообщений
+  --help, -h                        справка
+  --version, -v                     версия
+
+Примеры:
+  projector open .
+  projector open ~/code/app --window
+  projector open gh:/owner/repository
+  projector run . --command test
+  projector status --json
+  projector projects --json`;
+}

package/packages/cli/modules/command-runtime/index.js

@@ -0,0 +1,24 @@
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+export function serverLine(info) {
+    const network = info.network?.mode === "lan" ? "lan" : "local";
+    return `pid ${info.pid} · режим ${info.mode ?? "dev"} · сеть ${network}`;
+}
+export async function waitForHealth(api, predicate, timeoutMs, message) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        const info = await api.health();
+        if (info && predicate(info))
+            return info;
+        await sleep(250);
+    }
+    throw new Error(message);
+}
+export async function waitUntilDown(api, timeoutMs, message) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        if (!(await api.health()))
+            return;
+        await sleep(250);
+    }
+    throw new Error(message);
+}