@lousy-agents/cli 4.0.0 → 4.0.2

package/api/copilot-with-fastify/src/app.integration.ts

@@ -0,0 +1,45 @@
+import type { AddressInfo } from "node:net";
+import type { FastifyInstance } from "fastify";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { buildApp } from "./app.js";
+
+describe("API integration", () => {
+    let app: FastifyInstance;
+    let baseUrl: string;
+
+    beforeAll(async () => {
+        app = buildApp();
+        await app.listen({ port: 0, host: "127.0.0.1" });
+        const address = app.server.address() as AddressInfo;
+        baseUrl = `http://127.0.0.1:${address.port}`;
+    });
+
+    afterAll(async () => {
+        await app.close();
+    });
+
+    describe("GET /health", () => {
+        it("should respond with 200 and health status", async () => {
+            const response = await fetch(`${baseUrl}/health`);
+
+            expect(response.status).toBe(200);
+            expect(await response.json()).toEqual({ status: "ok" });
+        });
+
+        it("should return application/json content type", async () => {
+            const response = await fetch(`${baseUrl}/health`);
+
+            expect(response.headers.get("content-type")).toContain(
+                "application/json",
+            );
+        });
+    });
+
+    describe("undefined routes", () => {
+        it("should return 404 for non-existent routes", async () => {
+            const response = await fetch(`${baseUrl}/nonexistent`);
+
+            expect(response.status).toBe(404);
+        });
+    });
+});

package/api/copilot-with-fastify/src/app.test.ts

@@ -0,0 +1,28 @@
+import type { FastifyInstance } from "fastify";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { buildApp } from "./app.js";
+
+describe("Health endpoint", () => {
+    let app: FastifyInstance;
+
+    beforeAll(async () => {
+        app = buildApp();
+        await app.ready();
+    });
+
+    afterAll(async () => {
+        await app.close();
+    });
+
+    describe("GET /health", () => {
+        it("should return 200 with status ok", async () => {
+            const response = await app.inject({
+                method: "GET",
+                url: "/health",
+            });
+
+            expect(response.statusCode).toBe(200);
+            expect(response.json()).toEqual({ status: "ok" });
+        });
+    });
+});

package/api/copilot-with-fastify/src/app.ts

@@ -0,0 +1,11 @@
+import Fastify from "fastify";
+
+export function buildApp() {
+    const app = Fastify({ logger: true });
+
+    app.get("/health", async () => {
+        return { status: "ok" };
+    });
+
+    return app;
+}

package/api/copilot-with-fastify/src/index.ts

@@ -0,0 +1,12 @@
+import { buildApp } from "./app.js";
+import { parsePort } from "./parse-port.js";
+
+const app = buildApp();
+const port = parsePort(process.env.PORT);
+
+try {
+    await app.listen({ port, host: "0.0.0.0" });
+} catch (err) {
+    app.log.error(err);
+    process.exit(1);
+}

package/api/copilot-with-fastify/src/parse-port.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { parsePort } from "./parse-port.js";
+
+describe("parsePort", () => {
+    describe("when value is undefined", () => {
+        it("should return default port 3000", () => {
+            const result = parsePort(undefined);
+
+            expect(result).toBe(3000);
+        });
+    });
+
+    describe("when value is empty string", () => {
+        it("should return default port 3000", () => {
+            const result = parsePort("");
+
+            expect(result).toBe(3000);
+        });
+    });
+
+    describe("when value is a valid unprivileged port", () => {
+        it("should return the parsed port", () => {
+            const result = parsePort("8080");
+
+            expect(result).toBe(8080);
+        });
+    });
+
+    describe("when value is invalid", () => {
+        let warnSpy: ReturnType<typeof vi.spyOn>;
+
+        beforeEach(() => {
+            warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+        });
+
+        afterEach(() => {
+            warnSpy.mockRestore();
+        });
+
+        it("should warn and return default for non-numeric value", () => {
+            const result = parsePort("abc");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "abc", using default 3000',
+            );
+        });
+
+        it("should warn and return default for privileged port", () => {
+            const result = parsePort("80");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "80", using default 3000',
+            );
+        });
+
+        it("should warn and return default for port above max", () => {
+            const result = parsePort("70000");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "70000", using default 3000',
+            );
+        });
+
+        it("should warn and return default for non-integer port", () => {
+            const result = parsePort("3000.5");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "3000.5", using default 3000',
+            );
+        });
+    });
+
+    describe("when value is not provided or empty", () => {
+        let warnSpy: ReturnType<typeof vi.spyOn>;
+
+        beforeEach(() => {
+            warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+        });
+
+        afterEach(() => {
+            warnSpy.mockRestore();
+        });
+
+        it("should not warn when value is undefined", () => {
+            parsePort(undefined);
+
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+
+        it("should not warn when value is empty string", () => {
+            parsePort("");
+
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/api/copilot-with-fastify/src/parse-port.ts

@@ -0,0 +1,20 @@
+const defaultPort = 3000;
+const minUnprivilegedPort = 1024;
+const maxPort = 65535;
+
+export function parsePort(value: string | undefined): number {
+    if (value === undefined || value === "") {
+        return defaultPort;
+    }
+    const parsed = Number(value);
+    if (
+        !Number.isInteger(parsed) ||
+        parsed < minUnprivilegedPort ||
+        parsed > maxPort
+    ) {
+        // biome-ignore lint/suspicious/noConsole: user-facing warning for invalid PORT
+        console.warn(`Invalid PORT "${value}", using default ${defaultPort}`);
+        return defaultPort;
+    }
+    return parsed;
+}

package/dist/index.js

@@ -35198,7 +35198,38 @@ const CLI_TEMPLATE_DIR = (0,external_node_path_.join)(PROJECT_ROOT, "cli", "copi
                 path: "vitest.setup.ts",
                 content: readRestApiTemplateFile("vitest.setup.ts")
             },
-            ...buildCommonNodes(readRestApiTemplateFile)
+            ...buildCommonNodes(readRestApiTemplateFile),
+            // Source code
+            {
+                type: "file",
+                path: "src/app.ts",
+                content: readRestApiTemplateFile("src/app.ts")
+            },
+            {
+                type: "file",
+                path: "src/app.test.ts",
+                content: readRestApiTemplateFile("src/app.test.ts")
+            },
+            {
+                type: "file",
+                path: "src/app.integration.ts",
+                content: readRestApiTemplateFile("src/app.integration.ts")
+            },
+            {
+                type: "file",
+                path: "src/parse-port.ts",
+                content: readRestApiTemplateFile("src/parse-port.ts")
+            },
+            {
+                type: "file",
+                path: "src/parse-port.test.ts",
+                content: readRestApiTemplateFile("src/parse-port.test.ts")
+            },
+            {
+                type: "file",
+                path: "src/index.ts",
+                content: readRestApiTemplateFile("src/index.ts")
+            }
         ]
     };
     return cachedRestApiStructure;