@plainconceptsplatform/loop-task 2.6.0

package/dist/client/commands.js

@@ -0,0 +1,162 @@
+import { formatDuration } from "../duration.js";
+import { t } from "../shared/i18n/index.js";
+import { sendRequest, streamRequest } from "./ipc.js";
+import { formatCmd, pad } from "./cli-format.js";
+export async function createBackgroundLoop(options, intervalHuman) {
+    const response = await sendRequest({
+        type: "start",
+        payload: { ...options, intervalHuman },
+    });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data.id;
+}
+export async function startLoop(options, intervalHuman) {
+    const id = await createBackgroundLoop(options, intervalHuman).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    });
+    console.log(t("cli.startedTitle"));
+    console.log(t("cli.startedId", { id }));
+    console.log(t("cli.startedCommand", { command: options.command }));
+    console.log(t("cli.startedInterval", { interval: intervalHuman }));
+    console.log(t("cli.startedStatus"));
+    if (options.interval === 0) {
+        console.log("  Note: manual loop  use 'trigger' to run on demand");
+    }
+    console.log();
+    console.log(t("cli.startedHint"));
+    process.exit(0);
+}
+export async function listLoops() {
+    const response = await sendRequest({ type: "list" });
+    if (response.type !== "ok") {
+        console.error(t("cli.error", { message: response.message }));
+        process.exit(1);
+    }
+    const loops = response.data;
+    if (loops.length === 0) {
+        console.log(t("cli.noLoops"));
+        return;
+    }
+    const idW = Math.max(4, ...loops.map((l) => l.id.length)) + 2;
+    const cmdW = Math.max(7, ...loops.map((l) => formatCmd(l.command, l.commandArgs).length)) + 2;
+    const intW = 10;
+    const statusW = 10;
+    const runsW = 6;
+    const header = pad(t("cli.headerId"), idW) +
+        pad(t("cli.headerCommand"), cmdW) +
+        pad(t("cli.headerInterval"), intW) +
+        pad(t("cli.headerStatus"), statusW) +
+        pad(t("cli.headerRuns"), runsW) +
+        t("cli.headerLastExit");
+    console.log(header);
+    console.log("-".repeat(header.length));
+    for (const loop of loops) {
+        const exit = loop.lastExitCode !== null ? String(loop.lastExitCode) : "-";
+        console.log(pad(loop.id, idW) +
+            pad(formatCmd(loop.command, loop.commandArgs), cmdW) +
+            pad(loop.intervalHuman, intW) +
+            pad(loop.status, statusW) +
+            pad(String(loop.runCount), runsW) +
+            exit);
+    }
+    process.exit(0);
+}
+export async function showStatus(id) {
+    const response = await sendRequest({ type: "status", payload: { id } });
+    if (response.type !== "ok") {
+        console.error(t("cli.error", { message: response.message }));
+        process.exit(1);
+    }
+    const loop = response.data;
+    const cmd = `${loop.command} ${loop.commandArgs.join(" ")}`.trim();
+    const maxRuns = loop.maxRuns !== null ? String(loop.maxRuns) : t("cli.unlimited");
+    console.log(t("cli.statusTitle", { id: loop.id }));
+    console.log(t("cli.statusCommand", { command: cmd }));
+    const intervalDisplay = loop.interval === 0 ? "manual" : formatDuration(loop.interval);
+    console.log(t("cli.statusInterval", { interval: loop.intervalHuman, duration: intervalDisplay }));
+    console.log(t("cli.statusStatus", { status: loop.status }));
+    console.log(t("cli.statusRuns", { runs: loop.runCount, maxRuns }));
+    if ((loop.silentChainCount ?? 0) > 0) {
+        console.log(t("cli.statusSilentChains", { count: loop.silentChainCount.toLocaleString() }));
+    }
+    console.log(t("cli.statusCreated", { created: loop.createdAt }));
+    if (loop.lastRunAt) {
+        const exitInfo = loop.lastExitCode !== null ? t("cli.exitInfo", { code: loop.lastExitCode }) : "";
+        const durInfo = loop.lastDuration !== null ? formatDuration(loop.lastDuration) : "";
+        console.log(t("cli.statusLastRun", { lastRun: loop.lastRunAt, exit: exitInfo, duration: durInfo }).trim());
+    }
+    if (loop.nextRunAt) {
+        console.log(t("cli.statusNextRun", { nextRun: loop.nextRunAt }));
+    }
+    process.exit(0);
+}
+export async function pauseLoop(id) {
+    const response = await sendRequest({ type: "pause", payload: { id } });
+    if (response.type !== "ok") {
+        console.error(t("cli.error", { message: response.message }));
+        process.exit(1);
+    }
+    console.log(t("cli.paused", { id }));
+    process.exit(0);
+}
+export async function resumeLoop(id) {
+    const response = await sendRequest({ type: "resume", payload: { id } });
+    if (response.type !== "ok") {
+        console.error(t("cli.error", { message: response.message }));
+        process.exit(1);
+    }
+    console.log(t("cli.resumed", { id }));
+    process.exit(0);
+}
+export async function deleteLoop(id) {
+    const response = await sendRequest({ type: "delete", payload: { id } });
+    if (response.type !== "ok") {
+        console.error(t("cli.error", { message: response.message }));
+        process.exit(1);
+    }
+    console.log(t("cli.deleted", { id }));
+    process.exit(0);
+}
+export async function viewLogs(id, follow, tail) {
+    if (!follow) {
+        const response = await sendRequest({
+            type: "logs",
+            payload: { id, follow: false, tail },
+        });
+        if (response.type !== "ok") {
+            console.error(t("cli.error", { message: response.message }));
+            process.exit(1);
+        }
+        const content = response.data;
+        if (content) {
+            process.stdout.write(content);
+            if (!content.endsWith("\n"))
+                process.stdout.write("\n");
+        }
+        process.exit(0);
+    }
+    const socket = streamRequest({ type: "logs", payload: { id, follow: true, tail } }, (line) => console.log(line), () => process.exit(0), (err) => {
+        console.error(t("cli.error", { message: err.message }));
+        process.exit(1);
+    });
+    process.on("SIGINT", () => {
+        socket.destroy();
+        process.exit(0);
+    });
+}
+export async function attachLoop(id) {
+    console.log(t("cli.attaching", { id }));
+    const socket = streamRequest({ type: "attach", payload: { id } }, (line) => console.log(line), () => process.exit(0), (err) => {
+        console.error(t("cli.error", { message: err.message }));
+        process.exit(1);
+    });
+    process.on("SIGINT", () => {
+        console.log(t("cli.detached"));
+        socket.destroy();
+        process.exit(0);
+    });
+}

package/dist/client/ipc.js

@@ -0,0 +1,96 @@
+import net from "node:net";
+import { ensureDaemon, getSocket } from "../daemon/spawner/index.js";
+import { t } from "../shared/i18n/index.js";
+import { IPC_TIMEOUT_MS } from "../shared/config/constants.js";
+export async function sendRequest(request) {
+    ensureDaemon();
+    const socketPath = getSocket();
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        const socket = net.createConnection(socketPath, () => {
+            socket.write(JSON.stringify(request) + "\n");
+        });
+        let buffer = "";
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.trim() && !resolved) {
+                    try {
+                        const response = JSON.parse(line);
+                        resolved = true;
+                        socket.destroy();
+                        resolve(response);
+                    }
+                    catch {
+                        resolved = true;
+                        socket.destroy();
+                        reject(new Error(t("errors.invalidResponse")));
+                    }
+                }
+            }
+        });
+        socket.on("close", () => {
+            if (!resolved) {
+                resolved = true;
+                reject(new Error(t("errors.connectionClosed")));
+            }
+        });
+        socket.on("error", (err) => {
+            if (!resolved) {
+                resolved = true;
+                reject(new Error(t("errors.cannotConnect", { message: err.message })));
+            }
+        });
+        socket.setTimeout(IPC_TIMEOUT_MS, () => {
+            if (!resolved) {
+                resolved = true;
+                socket.destroy();
+                reject(new Error(t("errors.requestTimedOut")));
+            }
+        });
+    });
+}
+export function streamRequest(request, onLine, onEnd, onError) {
+    ensureDaemon();
+    const socketPath = getSocket();
+    const socket = net.createConnection(socketPath, () => {
+        socket.write(JSON.stringify(request) + "\n");
+    });
+    let buffer = "";
+    socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line.trim()) {
+                try {
+                    const response = JSON.parse(line);
+                    if (response.type === "data") {
+                        onLine(response.line);
+                    }
+                    else if (response.type === "error") {
+                        onError(new Error(response.message));
+                        socket.destroy();
+                    }
+                    else if (response.type === "end") {
+                        onEnd();
+                        socket.destroy();
+                    }
+                }
+                catch {
+                    onError(new Error(t("errors.invalidResponse")));
+                    socket.destroy();
+                }
+            }
+        }
+    });
+    socket.on("error", (err) => {
+        onError(new Error(t("errors.cannotConnect", { message: err.message })));
+    });
+    socket.on("close", () => {
+        onEnd();
+    });
+    return socket;
+}

package/dist/client/project-commands.js

@@ -0,0 +1,164 @@
+import { PROJECT_COLORS } from "../shared/config/constants.js";
+import { t } from "../shared/i18n/index.js";
+import { sendRequest } from "./ipc.js";
+import { pad } from "./cli-format.js";
+async function fetchProjects() {
+    const response = await sendRequest({ type: "project-list" });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data;
+}
+export function resolveColor(input) {
+    if (PROJECT_COLORS[input])
+        return PROJECT_COLORS[input];
+    if (/^#[0-9a-fA-F]{6}$/.test(input))
+        return input;
+    throw new Error(t("cli.projectInvalidColor", {
+        color: input,
+        valid: Object.keys(PROJECT_COLORS).join(", "),
+    }));
+}
+export async function resolveProjectId(idOrName) {
+    const projects = await fetchProjects();
+    const byId = projects.find((p) => p.id === idOrName);
+    if (byId)
+        return byId.id;
+    const matches = projects.filter((p) => p.name.toLowerCase() === idOrName.toLowerCase());
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length === 0)
+        throw new Error(t("cli.projectNotFound", { name: idOrName }));
+    throw new Error(t("cli.projectAmbiguous", { name: idOrName }));
+}
+export async function listProjectsCli() {
+    try {
+        const projects = await fetchProjects();
+        if (projects.length === 0) {
+            console.log(t("cli.noProjects"));
+            process.exit(0);
+        }
+        const loopResponse = await sendRequest({ type: "list" });
+        const loops = loopResponse.type === "ok" ? loopResponse.data : [];
+        const counts = new Map();
+        for (const loop of loops) {
+            counts.set(loop.projectId, (counts.get(loop.projectId) ?? 0) + 1);
+        }
+        const nameW = Math.max(t("cli.projectHeaderName").length, ...projects.map((p) => p.name.length)) + 2;
+        const idW = Math.max(t("cli.projectHeaderId").length, ...projects.map((p) => p.id.length)) + 2;
+        const colorW = Math.max(t("cli.projectHeaderColor").length, ...projects.map((p) => p.color.length)) + 2;
+        const loopsW = t("cli.projectHeaderLoops").length + 2;
+        const header = pad(t("cli.projectHeaderName"), nameW) +
+            pad(t("cli.projectHeaderId"), idW) +
+            pad(t("cli.projectHeaderColor"), colorW) +
+            pad(t("cli.projectHeaderLoops"), loopsW) +
+            t("cli.projectHeaderSystem");
+        console.log(header);
+        console.log("-".repeat(header.length));
+        for (const project of projects) {
+            console.log(pad(project.name, nameW) +
+                pad(project.id, idW) +
+                pad(project.color, colorW) +
+                pad(String(counts.get(project.id) ?? 0), loopsW) +
+                (project.isSystem ? "yes" : ""));
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function createProjectCli(name, colorInput, directory, githubSource) {
+    try {
+        if (githubSource !== undefined && githubSource !== "") {
+            if (!/^[a-zA-Z0-9_.\-]+\/[a-zA-Z0-9_.\-]+$/.test(githubSource)) {
+                throw new Error(`Invalid github-source format: "${githubSource}". Expected owner/repo (e.g. CKGrafico/loop-task)`);
+            }
+        }
+        const color = colorInput ? resolveColor(colorInput) : PROJECT_COLORS.cyan;
+        const response = await sendRequest({
+            type: "project-create",
+            payload: { name, color, directory, githubSource },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        const id = response.data.id;
+        console.log(t("cli.projectCreated", { name, id }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function renameProjectCli(idOrName, newName) {
+    try {
+        const id = await resolveProjectId(idOrName);
+        const response = await sendRequest({
+            type: "project-update",
+            payload: { id, name: newName },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        console.log(t("cli.projectRenamed", { name: newName }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function setProjectColorCli(idOrName, colorInput) {
+    try {
+        const projects = await fetchProjects();
+        const byId = projects.find((p) => p.id === idOrName);
+        const matches = byId
+            ? [byId]
+            : projects.filter((p) => p.name.toLowerCase() === idOrName.toLowerCase());
+        if (matches.length === 0)
+            throw new Error(t("cli.projectNotFound", { name: idOrName }));
+        if (matches.length > 1)
+            throw new Error(t("cli.projectAmbiguous", { name: idOrName }));
+        const project = matches[0];
+        const color = resolveColor(colorInput);
+        const response = await sendRequest({
+            type: "project-update",
+            payload: { id: project.id, name: project.name, color },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        console.log(t("cli.projectColorSet", { name: project.name, color }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function deleteProjectCli(idOrName) {
+    try {
+        const id = await resolveProjectId(idOrName);
+        const response = await sendRequest({
+            type: "project-delete",
+            payload: { id },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        console.log(t("cli.projectDeleted", { name: idOrName }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}