chapterhouse 0.1.1

package/dist/cli.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function printHelp() {
+    const version = getVersion();
+    console.log(`
+chapterhouse v${version} — AI orchestrator powered by Copilot SDK
+
+Usage:
+  chapterhouse <command>
+
+Commands:
+  start       Start the Chapterhouse daemon (web UI at http://localhost:7788)
+  setup       Pick a default model and write ~/.chapterhouse/.env
+  update      Check for updates and install the latest version
+  help        Show this help message
+
+Flags (start):
+  --self-edit Allow Chapterhouse to modify his own source code (off by default)
+  --open      Open the web UI in your default browser once the daemon is ready
+
+Examples:
+  chapterhouse start              Start the daemon, then open http://localhost:7788
+  chapterhouse start --open       Same, but open the browser for you
+  chapterhouse start --self-edit  Start with self-edit enabled
+`.trim());
+}
+const args = process.argv.slice(2);
+const command = args[0] || "help";
+switch (command) {
+    case "start": {
+        const startFlags = args.slice(1);
+        if (startFlags.includes("--self-edit")) {
+            process.env.CHAPTERHOUSE_SELF_EDIT = "1";
+        }
+        if (startFlags.includes("--open")) {
+            process.env.CHAPTERHOUSE_OPEN_BROWSER = "1";
+        }
+        await import("./daemon.js");
+        break;
+    }
+    case "setup":
+        await import("./setup.js");
+        break;
+    case "update": {
+        const { checkForUpdate, performUpdate } = await import("./update.js");
+        const check = await checkForUpdate();
+        if (!check.checkSucceeded) {
+            console.error("⚠ Could not reach GitHub to check for updates. Check your network and try again.");
+            process.exit(1);
+        }
+        if (!check.updateAvailable) {
+            console.log(`chapterhouse v${check.current} is already the latest version.`);
+            console.log("Pulling latest from main...");
+            const result = await performUpdate();
+            if (result.ok) {
+                console.log("✅ Updated to latest main.");
+            }
+            else {
+                console.error(`❌ Update failed: ${result.output}`);
+                process.exit(1);
+            }
+            break;
+        }
+        console.log(`Update available: v${check.current} → v${check.latest}`);
+        console.log("Installing...");
+        const result = await performUpdate(check.latest ? `v${check.latest}` : null);
+        if (result.ok) {
+            console.log(`✅ Updated to v${check.latest}`);
+        }
+        else {
+            console.error(`❌ Update failed: ${result.output}`);
+            process.exit(1);
+        }
+        break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+        printHelp();
+        break;
+    case "--version":
+    case "-v":
+        console.log(getVersion());
+        break;
+    default:
+        console.error(`Unknown command: ${command}\n`);
+        printHelp();
+        process.exit(1);
+}
+//# sourceMappingURL=cli.js.map

package/dist/config.js

@@ -0,0 +1,299 @@
+import { config as loadEnv } from "dotenv";
+import { z } from "zod";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { API_TOKEN_PATH, ENV_PATH, ensureChapterhouseHome } from "./paths.js";
+export const DISABLE_DOTENV_ENV_VAR = "CHAPTERHOUSE_DISABLE_DOTENV";
+const DEFAULT_WORKER_TIMEOUT_MS = 600_000;
+const BOOLEAN_ENV_PATTERN = /^(true|false)$/;
+function loadRuntimeEnv() {
+    if (process.env[DISABLE_DOTENV_ENV_VAR] === "1") {
+        return;
+    }
+    loadEnv({ path: ENV_PATH });
+    if ((process.env.NODE_ENV?.trim() || "development") !== "production") {
+        loadEnv();
+    }
+}
+loadRuntimeEnv();
+const configSchema = z.object({
+    NODE_ENV: z.string().optional(),
+    CHAPTERHOUSE_MODE: z.string().optional(),
+    API_HOST: z.string().optional(),
+    API_PORT: z.string().optional(),
+    STANDUP_TIME: z.string().optional(),
+    ADO_ORG: z.string().optional(),
+    ADO_PROJECT: z.string().optional(),
+    ADO_PAT: z.string().optional(),
+    COPILOT_MODEL: z.string().optional(),
+    WORKER_TIMEOUT: z.string().optional(),
+    ENTRA_TENANT_ID: z.string().optional(),
+    ENTRA_CLIENT_ID: z.string().optional(),
+    ENTRA_REQUIRED_ROLE: z.string().optional(),
+    ENTRA_TEAM_LEAD_ID: z.string().optional(),
+    ENTRA_AUTH_ENABLED: z.string().optional(),
+    CORS_ALLOWED_ORIGINS: z.string().optional(),
+    API_TOKEN: z.string().optional(),
+    TEAM_CHAPTERHOUSE_URL: z.string().optional(),
+    TEAM_CHAPTERHOUSE_TOKEN: z.string().optional(),
+    TEAM_WIKI_CACHE_TTL_MINUTES: z.string().optional(),
+    TEAM_WIKI_PATHS: z.string().optional(),
+    TEAMS_WEBHOOK_URL: z.string().optional(),
+    TEAMS_NOTIFICATIONS_ENABLED: z.string().optional(),
+    COPILOT_TOKEN: z.string().optional(),
+    GITHUB_TOKEN: z.string().optional(),
+    API_RATE_LIMIT_WINDOW_MS: z.string().optional(),
+    API_RATE_LIMIT_GENERAL_MAX: z.string().optional(),
+    API_RATE_LIMIT_AUTH_MAX: z.string().optional(),
+    API_RATE_LIMIT_SSE_MAX_CONNECTIONS: z.string().optional(),
+    ENABLE_SQUAD: z.string().optional(),
+});
+export const DEFAULT_MODEL = "claude-sonnet-4.6";
+export const DEFAULT_TEAM_WIKI_CACHE_TTL_MINUTES = 60;
+export const DEFAULT_TEAM_WIKI_PATHS = ["pages/team", "pages/okrs", "pages/kpis", "pages/shared"];
+export const DEFAULT_STANDUP_TIME = "09:00";
+export const DEFAULT_ADO_ORG = "";
+export const DEFAULT_ADO_PROJECT = "";
+export const DEFAULT_API_RATE_LIMIT_WINDOW_MS = 60_000;
+export const DEFAULT_API_RATE_LIMIT_GENERAL_MAX = 100;
+export const DEFAULT_API_RATE_LIMIT_AUTH_MAX = 10;
+export const DEFAULT_API_RATE_LIMIT_SSE_MAX_CONNECTIONS = 5;
+function parseBooleanEnv(name, rawValue, defaultValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return defaultValue;
+    }
+    if (!BOOLEAN_ENV_PATTERN.test(normalized)) {
+        throw new Error(`${name} must be 'true' or 'false', got: "${rawValue}"`);
+    }
+    return normalized === "true";
+}
+function parseOptionalUrl(name, rawValue) {
+    const normalized = rawValue?.trim() || "";
+    if (!normalized) {
+        return "";
+    }
+    try {
+        const parsed = new URL(normalized);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            throw new Error(`${name} must use http or https, got: "${rawValue}"`);
+        }
+        return parsed.toString().replace(/\/+$/, "");
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith(name)) {
+            throw error;
+        }
+        throw new Error(`${name} must be a valid URL, got: "${rawValue}"`);
+    }
+}
+function parsePositiveIntegerEnv(name, rawValue, defaultValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return defaultValue;
+    }
+    const parsed = Number(normalized);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${name} must be a positive integer, got: "${rawValue}"`);
+    }
+    return parsed;
+}
+function parseCorsAllowedOrigins(rawValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return [];
+    }
+    const origins = normalized
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => {
+        try {
+            const parsed = new URL(value);
+            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+                throw new Error();
+            }
+            return parsed.origin;
+        }
+        catch {
+            throw new Error(`CORS_ALLOWED_ORIGINS must contain valid http(s) origins, got: "${value}"`);
+        }
+    });
+    return [...new Set(origins)];
+}
+function parseTeamWikiPaths(rawValue) {
+    const paths = (rawValue || DEFAULT_TEAM_WIKI_PATHS.join(","))
+        .split(",")
+        .map((value) => value.trim().replace(/\/+$/, ""))
+        .filter(Boolean);
+    return paths.length > 0 ? paths : [...DEFAULT_TEAM_WIKI_PATHS];
+}
+function resolveConfiguredApiToken(envToken, { apiTokenPath = API_TOKEN_PATH, exists = existsSync, readFile = readFileSync, } = {}) {
+    const trimmedEnvToken = envToken?.trim();
+    if (trimmedEnvToken) {
+        return trimmedEnvToken;
+    }
+    if (!exists(apiTokenPath)) {
+        return null;
+    }
+    const persistedToken = readFile(apiTokenPath, "utf-8").trim();
+    return persistedToken.length > 0 ? persistedToken : null;
+}
+export function parseRuntimeConfig(env, options = {}) {
+    const raw = configSchema.parse(env);
+    const nodeEnv = raw.NODE_ENV?.trim() || "development";
+    const isProduction = nodeEnv === "production";
+    const parsedMode = raw.CHAPTERHOUSE_MODE?.trim() || "personal";
+    if (parsedMode !== "personal" && parsedMode !== "team") {
+        throw new Error(`CHAPTERHOUSE_MODE must be 'personal' or 'team', got: "${raw.CHAPTERHOUSE_MODE}"`);
+    }
+    const parsedHost = raw.API_HOST?.trim() || "localhost";
+    const parsedPort = parseInt(raw.API_PORT || "7788", 10);
+    if (Number.isNaN(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
+        throw new Error(`API_PORT must be 1-65535, got: "${raw.API_PORT}"`);
+    }
+    const parsedStandupTime = raw.STANDUP_TIME?.trim() || DEFAULT_STANDUP_TIME;
+    if (!/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(parsedStandupTime)) {
+        throw new Error(`STANDUP_TIME must use HH:MM 24-hour local time, got: "${raw.STANDUP_TIME}"`);
+    }
+    const parsedWorkerTimeout = raw.WORKER_TIMEOUT
+        ? Number(raw.WORKER_TIMEOUT)
+        : DEFAULT_WORKER_TIMEOUT_MS;
+    if (!Number.isInteger(parsedWorkerTimeout) || parsedWorkerTimeout <= 0) {
+        throw new Error(`WORKER_TIMEOUT must be a positive integer (ms), got: "${raw.WORKER_TIMEOUT}"`);
+    }
+    const parsedTeamWikiCacheTtlMinutes = raw.TEAM_WIKI_CACHE_TTL_MINUTES
+        ? Number(raw.TEAM_WIKI_CACHE_TTL_MINUTES)
+        : DEFAULT_TEAM_WIKI_CACHE_TTL_MINUTES;
+    if (!Number.isInteger(parsedTeamWikiCacheTtlMinutes) || parsedTeamWikiCacheTtlMinutes <= 0) {
+        throw new Error(`TEAM_WIKI_CACHE_TTL_MINUTES must be a positive integer (minutes), got: "${raw.TEAM_WIKI_CACHE_TTL_MINUTES}"`);
+    }
+    const entraTenantId = raw.ENTRA_TENANT_ID?.trim() || "";
+    const entraClientId = raw.ENTRA_CLIENT_ID?.trim() || "";
+    const entraRequiredRole = raw.ENTRA_REQUIRED_ROLE?.trim() || "";
+    const entraTeamLeadId = raw.ENTRA_TEAM_LEAD_ID?.trim() || "";
+    const entraAuthEnabled = parseBooleanEnv("ENTRA_AUTH_ENABLED", raw.ENTRA_AUTH_ENABLED, false);
+    const apiToken = resolveConfiguredApiToken(raw.API_TOKEN, options);
+    const standaloneMode = !entraAuthEnabled && !apiToken;
+    const teamsWebhookUrl = parseOptionalUrl("TEAMS_WEBHOOK_URL", raw.TEAMS_WEBHOOK_URL);
+    const teamsNotificationsEnabled = parseBooleanEnv("TEAMS_NOTIFICATIONS_ENABLED", raw.TEAMS_NOTIFICATIONS_ENABLED, false);
+    const apiRateLimitWindowMs = parsePositiveIntegerEnv("API_RATE_LIMIT_WINDOW_MS", raw.API_RATE_LIMIT_WINDOW_MS, DEFAULT_API_RATE_LIMIT_WINDOW_MS);
+    const apiRateLimitGeneralMax = parsePositiveIntegerEnv("API_RATE_LIMIT_GENERAL_MAX", raw.API_RATE_LIMIT_GENERAL_MAX, DEFAULT_API_RATE_LIMIT_GENERAL_MAX);
+    const apiRateLimitAuthMax = parsePositiveIntegerEnv("API_RATE_LIMIT_AUTH_MAX", raw.API_RATE_LIMIT_AUTH_MAX, DEFAULT_API_RATE_LIMIT_AUTH_MAX);
+    const apiRateLimitSseMaxConnections = parsePositiveIntegerEnv("API_RATE_LIMIT_SSE_MAX_CONNECTIONS", raw.API_RATE_LIMIT_SSE_MAX_CONNECTIONS, DEFAULT_API_RATE_LIMIT_SSE_MAX_CONNECTIONS);
+    if (entraAuthEnabled && (!entraTenantId || !entraClientId)) {
+        throw new Error("ENTRA_AUTH_ENABLED=true requires ENTRA_TENANT_ID and ENTRA_CLIENT_ID");
+    }
+    if (teamsNotificationsEnabled && !teamsWebhookUrl) {
+        throw new Error("TEAMS_NOTIFICATIONS_ENABLED=true requires TEAMS_WEBHOOK_URL");
+    }
+    return {
+        nodeEnv,
+        isProduction,
+        chapterhouseMode: parsedMode,
+        apiHost: parsedHost,
+        apiPort: parsedPort,
+        standupTime: parsedStandupTime,
+        // Azure DevOps org/project must be provided explicitly for OKR integrations.
+        adoOrg: raw.ADO_ORG?.trim() || DEFAULT_ADO_ORG,
+        adoProject: raw.ADO_PROJECT?.trim() || DEFAULT_ADO_PROJECT,
+        adoPat: raw.ADO_PAT?.trim() || "",
+        workerTimeoutMs: parsedWorkerTimeout,
+        entraTenantId,
+        entraClientId,
+        entraRequiredRole,
+        entraTeamLeadId,
+        entraAuthEnabled,
+        standaloneMode,
+        corsAllowedOrigins: parseCorsAllowedOrigins(raw.CORS_ALLOWED_ORIGINS),
+        copilotModel: raw.COPILOT_MODEL || DEFAULT_MODEL,
+        copilotAuthToken: raw.COPILOT_TOKEN?.trim() || raw.GITHUB_TOKEN?.trim() || "",
+        selfEditEnabled: env.CHAPTERHOUSE_SELF_EDIT === "1",
+        teamChapterhouseUrl: parseOptionalUrl("TEAM_CHAPTERHOUSE_URL", raw.TEAM_CHAPTERHOUSE_URL),
+        teamChapterhouseToken: raw.TEAM_CHAPTERHOUSE_TOKEN?.trim() || "",
+        teamWikiCacheTtlMinutes: parsedTeamWikiCacheTtlMinutes,
+        teamWikiPaths: parseTeamWikiPaths(raw.TEAM_WIKI_PATHS),
+        teamsWebhookUrl,
+        teamsNotificationsEnabled,
+        apiRateLimitWindowMs,
+        apiRateLimitGeneralMax,
+        apiRateLimitAuthMax,
+        apiRateLimitSseMaxConnections,
+        squadEnabled: raw.ENABLE_SQUAD === "1",
+    };
+}
+const runtimeConfig = parseRuntimeConfig(process.env);
+let _copilotModel = runtimeConfig.copilotModel;
+export const config = {
+    nodeEnv: runtimeConfig.nodeEnv,
+    isProduction: runtimeConfig.isProduction,
+    chapterhouseMode: runtimeConfig.chapterhouseMode,
+    apiHost: runtimeConfig.apiHost,
+    apiPort: runtimeConfig.apiPort,
+    standupTime: runtimeConfig.standupTime,
+    adoOrg: runtimeConfig.adoOrg,
+    adoProject: runtimeConfig.adoProject,
+    adoPat: runtimeConfig.adoPat,
+    get ADO_ORG() {
+        return runtimeConfig.adoOrg;
+    },
+    get ADO_PROJECT() {
+        return runtimeConfig.adoProject;
+    },
+    workerTimeoutMs: runtimeConfig.workerTimeoutMs,
+    entraTenantId: runtimeConfig.entraTenantId,
+    entraClientId: runtimeConfig.entraClientId,
+    entraRequiredRole: runtimeConfig.entraRequiredRole,
+    entraTeamLeadId: runtimeConfig.entraTeamLeadId,
+    entraAuthEnabled: runtimeConfig.entraAuthEnabled,
+    standaloneMode: runtimeConfig.standaloneMode,
+    corsAllowedOrigins: runtimeConfig.corsAllowedOrigins,
+    teamChapterhouseUrl: runtimeConfig.teamChapterhouseUrl,
+    teamChapterhouseToken: runtimeConfig.teamChapterhouseToken,
+    teamWikiCacheTtlMinutes: runtimeConfig.teamWikiCacheTtlMinutes,
+    teamWikiPaths: runtimeConfig.teamWikiPaths,
+    teamsWebhookUrl: runtimeConfig.teamsWebhookUrl,
+    teamsNotificationsEnabled: runtimeConfig.teamsNotificationsEnabled,
+    apiRateLimitWindowMs: runtimeConfig.apiRateLimitWindowMs,
+    apiRateLimitGeneralMax: runtimeConfig.apiRateLimitGeneralMax,
+    apiRateLimitAuthMax: runtimeConfig.apiRateLimitAuthMax,
+    apiRateLimitSseMaxConnections: runtimeConfig.apiRateLimitSseMaxConnections,
+    squadEnabled: runtimeConfig.squadEnabled,
+    copilotAuthToken: runtimeConfig.copilotAuthToken,
+    get copilotModel() {
+        return _copilotModel;
+    },
+    set copilotModel(model) {
+        _copilotModel = model;
+    },
+    get selfEditEnabled() {
+        return runtimeConfig.selfEditEnabled;
+    },
+};
+/** Update or append an env var in ~/.chapterhouse/.env */
+function persistEnvVar(key, value) {
+    ensureChapterhouseHome();
+    try {
+        const content = readFileSync(ENV_PATH, "utf-8");
+        const lines = content.split("\n");
+        let found = false;
+        const updated = lines.map((line) => {
+            if (line.startsWith(`${key}=`)) {
+                found = true;
+                return `${key}=${value}`;
+            }
+            return line;
+        });
+        if (!found)
+            updated.push(`${key}=${value}`);
+        writeFileSync(ENV_PATH, updated.join("\n"));
+    }
+    catch {
+        // File doesn't exist — create it
+        writeFileSync(ENV_PATH, `${key}=${value}\n`);
+    }
+}
+/** Persist the current model choice to ~/.chapterhouse/.env */
+export function persistModel(model) {
+    persistEnvVar("COPILOT_MODEL", model);
+}
+//# sourceMappingURL=config.js.map

package/dist/config.phase3.test.js

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+test("defaults CHAPTERHOUSE_MODE to personal when unset", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        TEAM_CHAPTERHOUSE_URL: "https://team.example.com",
+    });
+    assert.equal(parsed.chapterhouseMode, "personal");
+    assert.equal(parsed.teamChapterhouseUrl, "https://team.example.com");
+});
+test("parses explicit CHAPTERHOUSE_MODE values", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "team",
+    });
+    assert.equal(parsed.chapterhouseMode, "team");
+});
+//# sourceMappingURL=config.phase3.test.js.map

package/dist/config.test.js

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+test("parses API_HOST alongside API_PORT", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        API_HOST: "0.0.0.0",
+        API_PORT: "7788",
+    });
+    assert.equal(parsed.apiHost, "0.0.0.0");
+    assert.equal(parsed.apiPort, 7788);
+});
+test("parses Teams webhook settings", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        TEAMS_WEBHOOK_URL: "https://teams.example.test/webhook",
+        TEAMS_NOTIFICATIONS_ENABLED: "true",
+    });
+    assert.equal(parsed.teamsWebhookUrl, "https://teams.example.test/webhook");
+    assert.equal(parsed.teamsNotificationsEnabled, true);
+});
+test("rejects Teams notifications without a webhook", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    assert.throws(() => configModule.parseRuntimeConfig({
+        TEAMS_NOTIFICATIONS_ENABLED: "true",
+    }), /TEAMS_NOTIFICATIONS_ENABLED=true requires TEAMS_WEBHOOK_URL/);
+});
+test("parses Azure DevOps OKR settings", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        ADO_ORG: "https://dev.azure.com/example-org",
+        ADO_PROJECT: "example-project",
+        ADO_PAT: "test-pat",
+    });
+    assert.equal(parsed.adoOrg, "https://dev.azure.com/example-org");
+    assert.equal(parsed.adoProject, "example-project");
+    assert.equal(parsed.adoPat, "test-pat");
+});
+test("leaves Azure DevOps OKR settings empty when unset", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({});
+    assert.equal(parsed.adoOrg, "");
+    assert.equal(parsed.adoProject, "");
+});
+test("parses STANDUP_TIME and defaults it to 09:00", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsedDefault = configModule.parseRuntimeConfig({});
+    const parsedExplicit = configModule.parseRuntimeConfig({
+        STANDUP_TIME: "08:15",
+    });
+    assert.equal(parsedDefault.standupTime, "09:00");
+    assert.equal(parsedExplicit.standupTime, "08:15");
+});
+test("requires Entra tenant and client when auth is enabled", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    assert.throws(() => configModule.parseRuntimeConfig({
+        ENTRA_AUTH_ENABLED: "true",
+        ENTRA_TENANT_ID: "tenant-id",
+    }), /ENTRA_AUTH_ENABLED=true requires ENTRA_TENANT_ID and ENTRA_CLIENT_ID/);
+});
+test("enables standalone mode when Entra auth and API token are both absent", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({}, {
+        apiTokenPath: ".test-work/missing-token",
+        exists: () => false,
+    });
+    assert.equal(parsed.standaloneMode, true);
+});
+test("disables standalone mode when an API token is configured", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        API_TOKEN: "personal-token",
+    });
+    assert.equal(parsed.standaloneMode, false);
+});
+test("normalizes configured CORS origins", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        CORS_ALLOWED_ORIGINS: "https://app.example.com/path, https://app.example.com, http://localhost:3000",
+    });
+    assert.deepEqual(parsed.corsAllowedOrigins, ["https://app.example.com", "http://localhost:3000"]);
+});
+test("defaults TEAM_WIKI_PATHS to include the shared namespace", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({});
+    assert.deepEqual(parsed.teamWikiPaths, ["pages/team", "pages/okrs", "pages/kpis", "pages/shared"]);
+});
+test("prefers COPILOT_TOKEN over GITHUB_TOKEN for Copilot SDK auth", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        GITHUB_TOKEN: "github-token",
+        COPILOT_TOKEN: "copilot-token",
+    });
+    assert.equal(parsed.copilotAuthToken, "copilot-token");
+});
+test("uses GITHUB_TOKEN when COPILOT_TOKEN is unset", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        GITHUB_TOKEN: "github-token",
+    });
+    assert.equal(parsed.copilotAuthToken, "github-token");
+});
+test("rejects invalid boolean env values", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    assert.throws(() => configModule.parseRuntimeConfig({
+        ENTRA_AUTH_ENABLED: "yes",
+    }), /ENTRA_AUTH_ENABLED must be 'true' or 'false'/);
+});
+test("parses rate limiting settings and defaults", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsedDefault = configModule.parseRuntimeConfig({});
+    const parsedExplicit = configModule.parseRuntimeConfig({
+        API_RATE_LIMIT_WINDOW_MS: "120000",
+        API_RATE_LIMIT_GENERAL_MAX: "150",
+        API_RATE_LIMIT_AUTH_MAX: "12",
+        API_RATE_LIMIT_SSE_MAX_CONNECTIONS: "7",
+    });
+    assert.equal(parsedDefault.apiRateLimitWindowMs, 60000);
+    assert.equal(parsedDefault.apiRateLimitGeneralMax, 100);
+    assert.equal(parsedDefault.apiRateLimitAuthMax, 10);
+    assert.equal(parsedDefault.apiRateLimitSseMaxConnections, 5);
+    assert.equal(parsedExplicit.apiRateLimitWindowMs, 120000);
+    assert.equal(parsedExplicit.apiRateLimitGeneralMax, 150);
+    assert.equal(parsedExplicit.apiRateLimitAuthMax, 12);
+    assert.equal(parsedExplicit.apiRateLimitSseMaxConnections, 7);
+});
+test("rejects invalid rate limiting settings", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    assert.throws(() => configModule.parseRuntimeConfig({
+        API_RATE_LIMIT_GENERAL_MAX: "0",
+    }), /API_RATE_LIMIT_GENERAL_MAX must be a positive integer/);
+});
+//# sourceMappingURL=config.test.js.map