feat: add settings config UI

src/server/app.ts

@@ -13,6 +13,7 @@ import { registerSessionProxyRoutes } from "./sessiond/sessionProxyRoutes.js";
 import { registerWorkspaceExplorerRoutes } from "./workspaceExplorerRoutes.js";
 import { registerGitRoutes } from "./gitRoutes.js";
 import { registerTerminalProxyRoutes } from "./terminalProxyRoutes.js";
+import { registerConfigRoutes, type PiWebConfigService } from "./configRoutes.js";
 import { PiWebPluginService } from "./piWebPluginService.js";
 import { getPiWebStatus, getPiWebVersionStatus } from "./piWebStatus.js";
 
@@ -20,6 +21,7 @@ export interface AppDependencies {
   projects?: ProjectService;
   workspaces?: WorkspaceService;
   piWebPlugins?: Pick<PiWebPluginService, "manifest" | "readAsset">;
+  config?: PiWebConfigService;
   clientDist?: string | false;
   logger?: FastifyServerOptions["logger"];
 }
@@ -42,6 +44,7 @@ export async function buildApp(deps: AppDependencies = {}): Promise<FastifyInsta
 
   app.get("/api/pi-web/status", async () => getPiWebStatus());
   app.get("/api/pi-web/version", async () => getPiWebVersionStatus());
+  registerConfigRoutes(app, deps.config);
 
   app.get("/api/projects", async () => projects.list());
 

src/server/configRoutes.test.ts

@@ -0,0 +1,69 @@
+import Fastify, { type FastifyInstance } from "fastify";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { registerConfigRoutes, type PiWebConfigService } from "./configRoutes.js";
+import type { PiWebConfigResponse, PiWebConfigValues } from "../shared/apiTypes.js";
+
+let app: FastifyInstance;
+let savedConfig: PiWebConfigValues;
+let service: PiWebConfigService;
+
+beforeEach(async () => {
+  savedConfig = { host: "127.0.0.1", port: 8504, allowedHosts: [] };
+  service = {
+    read: vi.fn(() => responseFor(savedConfig, true)),
+    write: vi.fn((config: PiWebConfigValues) => {
+      savedConfig = config;
+      return responseFor(savedConfig, true);
+    }),
+  };
+  app = Fastify({ logger: false });
+  registerConfigRoutes(app, service);
+  await app.ready();
+});
+
+afterEach(async () => {
+  await app.close();
+});
+
+describe("config routes", () => {
+  it("returns the PI WEB config contract", async () => {
+    const response = await app.inject({ method: "GET", url: "/api/config" });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json<PiWebConfigResponse>()).toEqual(responseFor(savedConfig, true));
+  });
+
+  it("updates config through the service", async () => {
+    const response = await app.inject({
+      method: "PUT",
+      url: "/api/config",
+      payload: { config: { host: "0.0.0.0", port: 9000, allowedHosts: true } },
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(savedConfig).toEqual({ host: "0.0.0.0", port: 9000, allowedHosts: true });
+    expect(response.json<PiWebConfigResponse>().config).toEqual(savedConfig);
+  });
+
+  it("rejects invalid config payloads before writing", async () => {
+    const response = await app.inject({
+      method: "PUT",
+      url: "/api/config",
+      payload: { config: { host: 42 } },
+    });
+
+    expect(response.statusCode).toBe(400);
+    expect(response.json()).toHaveProperty("error");
+    expect(service.write).not.toHaveBeenCalled();
+  });
+});
+
+function responseFor(config: PiWebConfigValues, exists: boolean): PiWebConfigResponse {
+  return {
+    path: "/tmp/pi-web/config.json",
+    exists,
+    config,
+    effectiveConfig: config,
+    envOverrides: { host: false, port: false, allowedHosts: false },
+  };
+}

src/server/configRoutes.ts

@@ -0,0 +1,100 @@
+import type { FastifyInstance } from "fastify";
+import { effectivePiWebConfig, loadPiWebConfig, savePiWebConfig, type LoadOptions, type PiWebConfig } from "../config.js";
+import type { PiWebConfigEnvOverrides, PiWebConfigResponse, PiWebConfigValues } from "../shared/apiTypes.js";
+
+export interface PiWebConfigService {
+  read: () => PiWebConfigResponse | Promise<PiWebConfigResponse>;
+  write: (config: PiWebConfigValues) => PiWebConfigResponse | Promise<PiWebConfigResponse>;
+}
+
+export function createFilePiWebConfigService(options: LoadOptions = {}): PiWebConfigService {
+  return {
+    read: () => currentPiWebConfigResponse(options),
+    write: (config) => {
+      savePiWebConfig(config, options);
+      return currentPiWebConfigResponse(options);
+    },
+  };
+}
+
+export function currentPiWebConfigResponse(options: LoadOptions = {}): PiWebConfigResponse {
+  const loaded = loadPiWebConfig(options);
+  const effective = effectivePiWebConfig(options);
+  const env = options.env ?? process.env;
+  return {
+    path: loaded.path,
+    exists: loaded.exists,
+    config: loaded.config,
+    effectiveConfig: effective.config,
+    envOverrides: piWebConfigEnvOverrides(env),
+  };
+}
+
+export function registerConfigRoutes(app: FastifyInstance, service: PiWebConfigService = createFilePiWebConfigService()): void {
+  app.get("/api/config", async (_request, reply) => {
+    try {
+      return await service.read();
+    } catch (error) {
+      return reply.code(500).send({ error: errorMessage(error) });
+    }
+  });
+
+  app.put<{ Body: { config?: unknown } | undefined }>("/api/config", async (request, reply) => {
+    try {
+      return await service.write(parseConfigRequest(request.body?.config));
+    } catch (error) {
+      const status = isConfigValidationError(error) ? 400 : 500;
+      return reply.code(status).send({ error: errorMessage(error) });
+    }
+  });
+}
+
+function parseConfigRequest(value: unknown): PiWebConfig {
+  if (!isRecord(value)) throw new Error("PI WEB config update must include a config object");
+  const config: PiWebConfig = {};
+  const host = value["host"];
+  const port = value["port"];
+  const allowedHosts = value["allowedHosts"];
+  if (host !== undefined) {
+    if (typeof host !== "string") throw new Error("PI WEB config host must be a string");
+    config.host = host;
+  }
+  if (port !== undefined) {
+    if (typeof port !== "number") throw new Error("PI WEB config port must be a number");
+    config.port = port;
+  }
+  if (allowedHosts !== undefined) config.allowedHosts = parseAllowedHostsRequest(allowedHosts);
+  return config;
+}
+
+function parseAllowedHostsRequest(value: unknown): string[] | true {
+  if (value === true) return true;
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new Error("PI WEB config allowedHosts must be true or an array of strings");
+  }
+  return value;
+}
+
+function piWebConfigEnvOverrides(env: NodeJS.ProcessEnv): PiWebConfigEnvOverrides {
+  return {
+    host: isEnvSet(env["PI_WEB_HOST"]),
+    port: isEnvSet(env["PI_WEB_PORT"]) || isEnvSet(env["PORT"]),
+    allowedHosts: isEnvSet(env["PI_WEB_ALLOWED_HOSTS"]),
+  };
+}
+
+function isEnvSet(value: string | undefined): boolean {
+  return value !== undefined && value !== "";
+}
+
+function isConfigValidationError(error: unknown): boolean {
+  return error instanceof Error && error.message.startsWith("PI WEB config");
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}