@better-openclaw/core 1.0.30 → 1.0.31

package/src/generators/stack-manifest.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import type { GenerationInput, ResolverOutput } from "../types.js";
+import { generateStackManifest, type StackManifest } from "./stack-manifest.js";
+
+function makeResolved(serviceIds: string[]): ResolverOutput {
+	return {
+		services: serviceIds.map((id) => ({
+			definition: {
+				id,
+				name: id.charAt(0).toUpperCase() + id.slice(1),
+				description: `${id} service`,
+				icon: "📦",
+				category: "test",
+				image: `${id}:latest`,
+				imageTag: "latest",
+				ports: [{ container: 8080, host: 8080, exposed: true, description: `${id} port` }],
+				volumes: [],
+				environment: [],
+				dependencies: [],
+				conflicts: [],
+				skills: [],
+				memoryMB: 256,
+				docsUrl: `https://docs.example.com/${id}`,
+			},
+			addedBy: "user" as const,
+		})),
+		addedDependencies: [],
+		estimatedMemoryMB: 512,
+	} as unknown as ResolverOutput;
+}
+
+const baseInput: GenerationInput = {
+	projectName: "test-stack",
+	services: ["redis"],
+	skillPacks: [],
+	proxy: "caddy",
+	domain: "example.com",
+	gpu: false,
+	platform: "linux/amd64",
+	deployment: "local",
+	generateSecrets: true,
+	openclawVersion: "latest",
+} as unknown as GenerationInput;
+
+describe("generateStackManifest", () => {
+	it("returns a single file: stack-manifest.json", () => {
+		const files = generateStackManifest(makeResolved(["redis"]), baseInput);
+		expect(Object.keys(files)).toEqual(["stack-manifest.json"]);
+	});
+
+	it("produces valid JSON", () => {
+		const files = generateStackManifest(makeResolved(["redis"]), baseInput);
+		const manifest: StackManifest = JSON.parse(files["stack-manifest.json"]!);
+		expect(manifest).toBeDefined();
+	});
+
+	it("includes format version", () => {
+		const files = generateStackManifest(makeResolved(["redis"]), baseInput);
+		const manifest: StackManifest = JSON.parse(files["stack-manifest.json"]!);
+		expect(manifest.formatVersion).toBe("1");
+	});
+
+	it("includes project name from input", () => {
+		const files = generateStackManifest(makeResolved(["redis"]), baseInput);
+		const manifest: StackManifest = JSON.parse(files["stack-manifest.json"]!);
+		expect(manifest.projectName).toBe("test-stack");
+	});
+
+	it("includes deployment configuration", () => {
+		const files = generateStackManifest(makeResolved(["redis"]), baseInput);
+		const manifest: StackManifest = JSON.parse(files["stack-manifest.json"]!);
+		expect(manifest.deployment).toBe("local");
+		expect(manifest.proxy).toBe("caddy");
+		expect(manifest.domain).toBe("example.com");
+	});
+
+	it("lists all services with correct structure", () => {
+		const files = generateStackManifest(makeResolved(["redis", "postgresql"]), baseInput);
+		const manifest: StackManifest = JSON.parse(files["stack-manifest.json"]!);
+		expect(manifest.services).toHaveLength(2);
+		for (const svc of manifest.services) {
+			expect(svc).toHaveProperty("id");
+			expect(svc).toHaveProperty("name");
+			expect(svc).toHaveProperty("category");
+			expect(svc).toHaveProperty("ports");
+			expect(svc).toHaveProperty("docsUrl");
+			expect(svc).toHaveProperty("addedBy");
+		}
+	});
+
+	it("includes metadata with service count", () => {
+		const files = generateStackManifest(makeResolved(["redis", "postgresql"]), baseInput);
+		const manifest: StackManifest = JSON.parse(files["stack-manifest.json"]!);
+		expect(manifest.metadata.serviceCount).toBe(2);
+	});
+
+	it("includes generatedAt timestamp", () => {
+		const files = generateStackManifest(makeResolved(["redis"]), baseInput);
+		const manifest: StackManifest = JSON.parse(files["stack-manifest.json"]!);
+		expect(manifest.generatedAt).toBeDefined();
+		// Should be ISO 8601
+		expect(() => new Date(manifest.generatedAt)).not.toThrow();
+	});
+});

package/src/index.ts

@@ -81,14 +81,15 @@ export type {
 	OperationsLoggerOptions,
 } from "./logger/index.js";
 // ─── Operations Logger ─────────────────────────────────────────────────────
+// Note: FileSink is excluded from the barrel export because it depends on
+// Node.js `fs` and breaks browser/edge bundlers (e.g. Next.js webpack).
+// Import it directly: import { FileSink } from "@better-openclaw/core/logger/sinks/file-sink"
 export {
 	CallbackSink,
 	ConsoleSink,
-	FileSink,
 	OperationsLogger,
 	StepTracker,
 } from "./logger/index.js";
-export type { FileSinkOptions } from "./logger/sinks/file-sink.js";
 // ─── Config Migrations ──────────────────────────────────────────────────────
 export {
 	CURRENT_CONFIG_VERSION,

package/src/logger/index.ts

@@ -1,7 +1,8 @@
 export { OperationsLogger, StepTracker } from "./logger.js";
 export { CallbackSink } from "./sinks/callback-sink.js";
 export { ConsoleSink } from "./sinks/console-sink.js";
-export { FileSink } from "./sinks/file-sink.js";
+// FileSink is NOT re-exported here because it depends on Node.js `fs`.
+// Import it directly: import { FileSink } from "@better-openclaw/core/logger/sinks/file-sink"
 export type {
 	LogLevel,
 	LogSink,

package/src/port-scanner.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, it, vi } from "vitest";
+import { formatPortConflicts, scanPortConflicts } from "./port-scanner.js";
+import type { ServiceDefinition } from "./types.js";
+
+/**
+ * Tests for port scanner conflict detection and reassignment.
+ *
+ * We mock isPortAvailable via vi.mock to avoid actual port scanning
+ * during tests. The focus is on the conflict detection logic.
+ */
+
+// Mock the internal isPortAvailable to control port availability
+vi.mock("node:net", () => {
+	const portsInUse = new Set([80, 443, 3000]);
+
+	return {
+		default: {
+			Socket: class MockSocket {
+				connect(port: number) {
+					// Simulate: ports in portsInUse are "in use"
+					setTimeout(() => {
+						if (portsInUse.has(port)) {
+							(this as any).connectCb?.();
+						} else {
+							(this as any).errorCb?.();
+						}
+					}, 1);
+				}
+				once(event: string, cb: () => void) {
+					if (event === "connect") (this as any).connectCb = cb;
+					if (event === "error") (this as any).errorCb = cb;
+					if (event === "timeout") (this as any).timeoutCb = cb;
+				}
+				setTimeout() {}
+				removeAllListeners() {}
+				destroy() {}
+			},
+			createServer() {
+				return {
+					once(event: string, cb: (err?: Error) => void) {
+						if (event === "error") (this as any).errorCb = cb;
+					},
+					listen(_port: number, _host: string, cb: () => void) {
+						cb();
+					},
+					close(cb: () => void) {
+						cb();
+					},
+				};
+			},
+		},
+	};
+});
+
+function makeService(
+	id: string,
+	ports: { host: number; container: number; exposed: boolean; description: string }[],
+): ServiceDefinition {
+	return {
+		id,
+		name: id,
+		description: `${id} service`,
+		icon: "",
+		category: "test",
+		image: `${id}:latest`,
+		ports,
+		volumes: [],
+		environment: [],
+		dependencies: [],
+		conflicts: [],
+		skills: [],
+		memoryMB: 256,
+		docsUrl: "",
+	} as ServiceDefinition;
+}
+
+describe("formatPortConflicts", () => {
+	it("returns empty array when no reassignments", () => {
+		const services = [
+			makeService("redis", [{ host: 6379, container: 6379, exposed: true, description: "Redis" }]),
+		];
+		const reassignments = new Map();
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts).toEqual([]);
+	});
+
+	it("returns conflicts with suggested ports", () => {
+		const services = [
+			makeService("redis", [{ host: 6379, container: 6379, exposed: true, description: "Redis" }]),
+		];
+		const reassignments = new Map([["redis", new Map([[6379, 7379]])]]);
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts).toHaveLength(1);
+		expect(conflicts[0]).toEqual({
+			port: 6379,
+			serviceId: "redis",
+			description: "Redis",
+			suggestedPort: 7379,
+		});
+	});
+
+	it("handles multiple services with multiple port reassignments", () => {
+		const services = [
+			makeService("web", [
+				{ host: 80, container: 80, exposed: true, description: "HTTP" },
+				{ host: 443, container: 443, exposed: true, description: "HTTPS" },
+			]),
+			makeService("api", [{ host: 8080, container: 8080, exposed: true, description: "API" }]),
+		];
+		const reassignments = new Map([
+			[
+				"web",
+				new Map([
+					[80, 1080],
+					[443, 1443],
+				]),
+			],
+		]);
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts).toHaveLength(2);
+		expect(conflicts[0]!.port).toBe(80);
+		expect(conflicts[0]!.suggestedPort).toBe(1080);
+		expect(conflicts[1]!.port).toBe(443);
+		expect(conflicts[1]!.suggestedPort).toBe(1443);
+	});
+
+	it("uses service name as fallback when port has no description", () => {
+		const services = [
+			makeService("myapp", [{ host: 9000, container: 9000, exposed: true, description: "" }]),
+		];
+		const reassignments = new Map([["myapp", new Map([[9000, 10000]])]]);
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts[0]!.description).toBe("myapp port");
+	});
+});
+
+describe("scanPortConflicts", () => {
+	it("returns empty map for services with no ports", async () => {
+		const services = [makeService("redis", [])];
+		const result = await scanPortConflicts(services);
+		expect(result.size).toBe(0);
+	});
+
+	it("returns empty map for services with no exposed ports", async () => {
+		const services = [
+			makeService("redis", [{ host: 6379, container: 6379, exposed: false, description: "Redis" }]),
+		];
+		const result = await scanPortConflicts(services);
+		expect(result.size).toBe(0);
+	});
+
+	it("detects inter-service port conflicts", async () => {
+		// Two services claiming the same host port
+		const services = [
+			makeService("web1", [{ host: 8080, container: 80, exposed: true, description: "HTTP" }]),
+			makeService("web2", [{ host: 8080, container: 80, exposed: true, description: "HTTP" }]),
+		];
+		const result = await scanPortConflicts(services);
+
+		// First service wins, second gets reassigned
+		expect(result.has("web1")).toBe(false); // web1 keeps its port
+		expect(result.has("web2")).toBe(true); // web2 gets reassigned
+		const web2Reassignments = result.get("web2")!;
+		expect(web2Reassignments.has(8080)).toBe(true);
+		expect(web2Reassignments.get(8080)).toBeGreaterThan(8080);
+	});
+});