arcane-agents 0.1.0

package/dist/server/server/bootstrapApp.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrap = bootstrap;
+const node_http_1 = __importDefault(require("node:http"));
+const httpApp_1 = require("./bootstrap/httpApp");
+const serverContext_1 = require("./bootstrap/serverContext");
+const shutdown_1 = require("./bootstrap/shutdown");
+const websocketUpgrade_1 = require("./bootstrap/websocketUpgrade");
+const startupBannerLines = [
+    "   ▄████████    ▄████████  ▄████████    ▄████████ ███▄▄▄▄      ▄████████      ",
+    "  ███    ███   ███    ███ ███    ███   ███    ███ ███▀▀▀██▄   ███    ███      ",
+    "  ███    ███   ███    ███ ███    █▀    ███    ███ ███   ███   ███    █▀       ",
+    "  ███    ███  ▄███▄▄▄▄██▀ ███          ███    ███ ███   ███  ▄███▄▄▄          ",
+    "▀███████████ ▀▀███▀▀▀▀▀   ███        ▀███████████ ███   ███ ▀▀███▀▀▀          ",
+    "  ███    ███ ▀███████████ ███    █▄    ███    ███ ███   ███   ███    █▄       ",
+    "  ███    ███   ███    ███ ███    ███   ███    ███ ███   ███   ███    ███      ",
+    "  ███    █▀    ███    ███ ████████▀    ███    █▀   ▀█   █▀    ██████████      ",
+    "               ███    ███                                                      ",
+    "",
+    "   ▄████████    ▄██████▄     ▄████████ ███▄▄▄▄       ███        ▄████████     ",
+    "  ███    ███   ███    ███   ███    ███ ███▀▀▀██▄ ▀█████████▄   ███    ███     ",
+    "  ███    ███   ███    █▀    ███    █▀  ███   ███    ▀███▀▀██   ███    █▀      ",
+    "  ███    ███  ▄███         ▄███▄▄▄     ███   ███     ███   ▀   ███            ",
+    "▀███████████ ▀▀███ ████▄  ▀▀███▀▀▀     ███   ███     ███     ▀███████████     ",
+    "  ███    ███   ███    ███   ███    █▄  ███   ███     ███              ███     ",
+    "  ███    ███   ███    ███   ███    ███ ███   ███     ███        ▄█    ███     ",
+    "  ███    █▀    ████████▀    ██████████  ▀█   █▀     ▄████▀    ▄████████▀      ",
+    "                                                                              "
+];
+const startupBannerColorScale = ["\u001b[38;5;159m", "\u001b[38;5;123m", "\u001b[38;5;87m", "\u001b[38;5;51m"];
+const ansiReset = "\u001b[0m";
+function supportsBannerColor() {
+    if (process.env.NO_COLOR !== undefined) {
+        return false;
+    }
+    const forceColor = process.env.FORCE_COLOR;
+    if (forceColor !== undefined) {
+        return forceColor !== "0";
+    }
+    if (!process.stdout.isTTY) {
+        return false;
+    }
+    return process.env.TERM !== "dumb";
+}
+function renderStartupBanner() {
+    if (!supportsBannerColor()) {
+        return startupBannerLines.join("\n");
+    }
+    const maxIndex = startupBannerColorScale.length - 1;
+    const lineCount = Math.max(1, startupBannerLines.length - 1);
+    return startupBannerLines
+        .map((line, lineIndex) => {
+        if (line.trim().length === 0) {
+            return line;
+        }
+        const paletteIndex = Math.max(0, Math.min(maxIndex, Math.round((lineIndex / lineCount) * maxIndex)));
+        return `${startupBannerColorScale[paletteIndex]}${line}${ansiReset}`;
+    })
+        .join("\n");
+}
+async function bootstrap() {
+    console.log(renderStartupBanner());
+    console.log("[arcane-agents] launching Arcane Agents...");
+    const context = await (0, serverContext_1.createServerContext)();
+    context.statusMonitor.start();
+    const app = (0, httpApp_1.createHttpApp)(context);
+    const server = node_http_1.default.createServer(app);
+    const wsServers = (0, websocketUpgrade_1.createWsServers)(context);
+    (0, websocketUpgrade_1.attachUpgradeHandler)(server, wsServers);
+    const host = process.env.ARCANE_AGENTS_API_HOST ?? context.config.server.host;
+    const port = Number(process.env.ARCANE_AGENTS_API_PORT ?? context.config.server.port);
+    const appUrl = `http://${host}:${port}`;
+    server.listen(port, host, () => {
+        console.log("[arcane-agents] Arcane Agents is ready.");
+        console.log(`[arcane-agents] app: ${appUrl}`);
+        console.log("[arcane-agents] github: https://github.com/thomasrice/arcane-agents");
+        console.log(`[arcane-agents] config: ${context.paths.configPath}`);
+        console.log("[arcane-agents] press Ctrl-C to stop.");
+    });
+    (0, shutdown_1.registerShutdownHandlers)({
+        statusMonitor: context.statusMonitor,
+        server,
+        wsServers,
+        workers: context.workers
+    });
+}

package/dist/server/server/cli.js

@@ -0,0 +1,452 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const bootstrapApp_1 = require("./bootstrapApp");
+const loadConfig_1 = require("./config/loadConfig");
+const appRoot_1 = require("./utils/appRoot");
+const path_1 = require("./utils/path");
+async function runCli() {
+    (0, appRoot_1.setAppRoot)((0, appRoot_1.resolveAppRoot)());
+    const args = process.argv.slice(2);
+    const firstArg = args[0];
+    if (firstArg === "--help" || firstArg === "-h") {
+        printHelp();
+        return 0;
+    }
+    if (firstArg === "--version" || firstArg === "-v") {
+        printVersion();
+        return 0;
+    }
+    const [command = "start", ...commandArgs] = args;
+    switch (command) {
+        case "start":
+            return runStart();
+        case "init":
+            return runInit(commandArgs);
+        case "config":
+            return runConfig(commandArgs);
+        case "doctor":
+            return runDoctor();
+        case "help":
+            printHelp();
+            return 0;
+        case "version":
+            printVersion();
+            return 0;
+        default:
+            console.error(`[arcane-agents] unknown command '${command}'.`);
+            printHelp();
+            return 1;
+    }
+}
+async function runStart() {
+    if (!process.env.NODE_ENV) {
+        process.env.NODE_ENV = "production";
+    }
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    let configResult;
+    try {
+        configResult = ensureStarterConfig(paths);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        console.error(`[arcane-agents] failed to prepare config: ${detail}`);
+        return 1;
+    }
+    if (configResult.created) {
+        console.log(`[arcane-agents] no config found; wrote starter config to ${paths.configPath}`);
+        console.log("[arcane-agents] next: edit it with 'arcane-agents config edit'.");
+    }
+    await (0, bootstrapApp_1.bootstrap)();
+    return 0;
+}
+function runInit(args) {
+    const force = hasFlag(args, "--force") || hasFlag(args, "-f");
+    const unknownArgs = args.filter((arg) => arg !== "--force" && arg !== "-f");
+    if (unknownArgs.length > 0) {
+        console.error(`[arcane-agents] unknown init options: ${unknownArgs.join(", ")}`);
+        return 1;
+    }
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    try {
+        const result = writeStarterConfig(paths, { force });
+        if (result.overwritten) {
+            console.log(`[arcane-agents] overwrote ${paths.configPath}`);
+        }
+        else {
+            console.log(`[arcane-agents] wrote ${paths.configPath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "config_exists") {
+            console.error(`[arcane-agents] config already exists: ${paths.configPath}`);
+            console.error("[arcane-agents] rerun with --force to overwrite it.");
+            return 1;
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        console.error(`[arcane-agents] failed to initialize config: ${detail}`);
+        return 1;
+    }
+    console.log("[arcane-agents] next: edit it with 'arcane-agents config edit'.");
+    return 0;
+}
+function runConfig(args) {
+    if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+        printConfigHelp();
+        return 0;
+    }
+    const [subcommand = "path", ...subcommandArgs] = args;
+    switch (subcommand) {
+        case "path":
+            return runConfigPath(subcommandArgs);
+        case "show":
+            return runConfigShow(subcommandArgs);
+        case "edit":
+            return runConfigEdit(subcommandArgs);
+        case "help":
+            printConfigHelp();
+            return 0;
+        default:
+            console.error(`[arcane-agents] unknown config command '${subcommand}'.`);
+            printConfigHelp();
+            return 1;
+    }
+}
+function runConfigPath(args) {
+    if (args.length > 0) {
+        console.error(`[arcane-agents] unknown config path options: ${args.join(", ")}`);
+        return 1;
+    }
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    console.log(`[arcane-agents] config: ${paths.configPath}`);
+    console.log(`[arcane-agents] local override: ${paths.localOverridePath}`);
+    return 0;
+}
+function runConfigShow(args) {
+    if (args.length > 0) {
+        console.error(`[arcane-agents] unknown config show options: ${args.join(", ")}`);
+        return 1;
+    }
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    if (!node_fs_1.default.existsSync(paths.configPath)) {
+        console.error(`[arcane-agents] config file not found: ${paths.configPath}`);
+        console.error("[arcane-agents] run 'arcane-agents start' to auto-create it or 'arcane-agents init'.");
+        return 1;
+    }
+    const raw = node_fs_1.default.readFileSync(paths.configPath, "utf8");
+    process.stdout.write(raw);
+    if (!raw.endsWith("\n")) {
+        process.stdout.write("\n");
+    }
+    return 0;
+}
+function runConfigEdit(args) {
+    if (args.length > 0) {
+        console.error(`[arcane-agents] unknown config edit options: ${args.join(", ")}`);
+        return 1;
+    }
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    let configResult;
+    try {
+        configResult = ensureStarterConfig(paths);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        console.error(`[arcane-agents] failed to prepare config: ${detail}`);
+        return 1;
+    }
+    if (configResult.created) {
+        console.log(`[arcane-agents] wrote starter config: ${paths.configPath}`);
+    }
+    const editor = (process.env.VISUAL ?? process.env.EDITOR ?? "").trim();
+    if (editor.length === 0) {
+        console.error("[arcane-agents] no editor configured.");
+        console.error("[arcane-agents] set $VISUAL or $EDITOR, then rerun 'arcane-agents config edit'.");
+        console.error(`[arcane-agents] config file: ${paths.configPath}`);
+        return 1;
+    }
+    const editCommand = `${editor} ${shellQuote(paths.configPath)}`;
+    const result = (0, node_child_process_1.spawnSync)("sh", ["-lc", editCommand], {
+        stdio: "inherit"
+    });
+    if (result.error) {
+        const detail = result.error.message;
+        console.error(`[arcane-agents] failed to launch editor '${editor}': ${detail}`);
+        return 1;
+    }
+    if (typeof result.status === "number" && result.status !== 0) {
+        return result.status;
+    }
+    return 0;
+}
+function writeStarterConfig(paths, options) {
+    const templatePath = (0, appRoot_1.resolveAppPath)("config.example.yaml");
+    if (!node_fs_1.default.existsSync(templatePath)) {
+        throw new Error(`missing template config at ${templatePath}`);
+    }
+    node_fs_1.default.mkdirSync(paths.configDir, { recursive: true });
+    const hasExistingConfig = node_fs_1.default.existsSync(paths.configPath);
+    if (hasExistingConfig && !options.force) {
+        throw new Error("config_exists");
+    }
+    node_fs_1.default.copyFileSync(templatePath, paths.configPath);
+    return {
+        created: !hasExistingConfig,
+        overwritten: hasExistingConfig
+    };
+}
+function ensureStarterConfig(paths) {
+    try {
+        return writeStarterConfig(paths, { force: false });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "config_exists") {
+            return {
+                created: false,
+                overwritten: false
+            };
+        }
+        throw error;
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function printConfigHelp() {
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    console.log(`Arcane Agents config commands
+
+Usage:
+  arcane-agents config [path]
+  arcane-agents config show
+  arcane-agents config edit
+  arcane-agents config help
+
+Commands:
+  path      Print config file locations
+  show      Print ${paths.configPath}
+  edit      Open ${paths.configPath} in $VISUAL or $EDITOR
+  help      Show this config help message
+`);
+}
+function runDoctor() {
+    const checks = [];
+    const nodeVersion = process.versions.node;
+    const nodeMajor = Number.parseInt(nodeVersion.split(".")[0] ?? "0", 10);
+    if (nodeMajor >= 20) {
+        checks.push({ status: "ok", label: "Node.js", detail: `v${nodeVersion}` });
+    }
+    else {
+        checks.push({ status: "fail", label: "Node.js", detail: `v${nodeVersion} (requires >= 20)` });
+    }
+    const tmuxPath = findExecutable("tmux");
+    if (tmuxPath) {
+        checks.push({ status: "ok", label: "tmux", detail: tmuxPath });
+    }
+    else {
+        checks.push({ status: "fail", label: "tmux", detail: "not found on PATH" });
+    }
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    if (node_fs_1.default.existsSync(paths.configPath)) {
+        checks.push({ status: "ok", label: "Config", detail: paths.configPath });
+    }
+    else {
+        checks.push({
+            status: "warn",
+            label: "Config",
+            detail: `missing at ${paths.configPath} (auto-created on 'arcane-agents start'; use 'arcane-agents config edit')`
+        });
+    }
+    const configResult = safeLoadConfig(paths);
+    checks.push(...configResult.checks);
+    if (process.platform === "linux") {
+        const xdgTerminalExecPath = findExecutable("xdg-terminal-exec");
+        if (xdgTerminalExecPath) {
+            checks.push({ status: "ok", label: "xdg-terminal-exec", detail: xdgTerminalExecPath });
+        }
+        else {
+            checks.push({
+                status: "warn",
+                label: "xdg-terminal-exec",
+                detail: "optional dependency for external terminal button"
+            });
+        }
+    }
+    printDoctorReport(checks);
+    return checks.some((check) => check.status === "fail") ? 1 : 0;
+}
+function safeLoadConfig(paths) {
+    const checks = [];
+    let config;
+    try {
+        config = (0, loadConfig_1.loadResolvedConfig)(paths);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : "unknown config load error";
+        checks.push({ status: "fail", label: "Config parse", detail: `${paths.configPath}: ${detail}` });
+        return { checks };
+    }
+    checks.push({
+        status: "ok",
+        label: "Config parse",
+        detail: `${Object.keys(config.projects).length} projects, ${Object.keys(config.runtimes).length} runtimes`
+    });
+    const runtimeCommandResults = checkRuntimeCommands(config);
+    checks.push(...runtimeCommandResults.checks);
+    return { checks };
+}
+function checkRuntimeCommands(config) {
+    const checks = [];
+    let availableRuntimeCount = 0;
+    for (const [runtimeId, runtime] of Object.entries(config.runtimes)) {
+        const executable = runtime.command[0];
+        const executablePath = findExecutable(executable);
+        if (executablePath) {
+            availableRuntimeCount += 1;
+            checks.push({
+                status: "ok",
+                label: `Runtime ${runtimeId}`,
+                detail: `${executable} -> ${executablePath}`
+            });
+        }
+        else {
+            checks.push({
+                status: "warn",
+                label: `Runtime ${runtimeId}`,
+                detail: `${executable} not found on PATH`
+            });
+        }
+    }
+    if (availableRuntimeCount > 0) {
+        checks.push({
+            status: "ok",
+            label: "Runtime availability",
+            detail: `${availableRuntimeCount} runtime command(s) available`
+        });
+    }
+    else {
+        checks.push({
+            status: "fail",
+            label: "Runtime availability",
+            detail: "no configured runtime commands found on PATH"
+        });
+    }
+    return { checks };
+}
+function printDoctorReport(checks) {
+    console.log("[arcane-agents] doctor report");
+    for (const check of checks) {
+        console.log(`[${check.status}] ${check.label}: ${check.detail}`);
+    }
+    const hasFailure = checks.some((check) => check.status === "fail");
+    if (hasFailure) {
+        console.log("[arcane-agents] doctor found blocking issues.");
+    }
+    else {
+        console.log("[arcane-agents] doctor passed.");
+    }
+}
+function printHelp() {
+    const paths = (0, loadConfig_1.getArcaneAgentsPaths)();
+    console.log(`Arcane Agents CLI
+
+Usage:
+  arcane-agents [start]
+  arcane-agents init [--force]
+  arcane-agents config [path|show|edit]
+  arcane-agents doctor
+  arcane-agents --help
+  arcane-agents --version
+
+Commands:
+  start      Start the Arcane Agents server
+  init       Write ~/.config/arcane-agents/config.yaml from config.example.yaml
+  config     Print, show, or edit config files
+  doctor     Check dependencies and runtime command availability
+  help       Show this help message
+  version    Print CLI version
+
+Config paths:
+  primary: ${paths.configPath}
+  local override: ${paths.localOverridePath}
+`);
+}
+function printVersion() {
+    console.log(readPackageVersion());
+}
+function readPackageVersion() {
+    const packageJsonPath = (0, appRoot_1.resolveAppPath)("package.json");
+    try {
+        const raw = node_fs_1.default.readFileSync(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === "string" && parsed.version.trim().length > 0) {
+            return parsed.version;
+        }
+    }
+    catch {
+        // no-op
+    }
+    return "0.0.0";
+}
+function findExecutable(commandToken) {
+    if (!commandToken || commandToken.trim().length === 0) {
+        return undefined;
+    }
+    const token = commandToken.trim();
+    if (looksLikePathToken(token)) {
+        const resolvedPath = resolvePathToken(token);
+        return isExecutableFile(resolvedPath) ? resolvedPath : undefined;
+    }
+    const pathEntries = (process.env.PATH ?? "")
+        .split(node_path_1.default.delimiter)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    for (const entry of pathEntries) {
+        const candidate = node_path_1.default.join(entry, token);
+        if (isExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function isExecutableFile(filePath) {
+    try {
+        const stats = node_fs_1.default.statSync(filePath);
+        if (!stats.isFile()) {
+            return false;
+        }
+        node_fs_1.default.accessSync(filePath, node_fs_1.default.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikePathToken(token) {
+    return token.includes(node_path_1.default.sep) || token.startsWith(".") || token.startsWith("~");
+}
+function resolvePathToken(token) {
+    if (token.startsWith("~")) {
+        return (0, path_1.resolveUserPath)(token);
+    }
+    return node_path_1.default.resolve(token);
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+void runCli()
+    .then((exitCode) => {
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+})
+    .catch((error) => {
+    console.error("[arcane-agents] fatal startup error", error);
+    process.exitCode = 1;
+});

package/dist/server/server/config/discovery.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryService = void 0;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const windowName_1 = require("../orchestrator/spawn/windowName");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+class DiscoveryService {
+    async discover(config) {
+        const discovered = {};
+        const warnings = [];
+        const knownProjectIds = new Set(Object.keys(config.projects));
+        const knownPaths = new Set(Object.values(config.projects).map((project) => node_path_1.default.resolve(project.path)));
+        for (const rule of config.discovery) {
+            let candidatePaths = [];
+            try {
+                if (rule.type === "worktrees") {
+                    candidatePaths = await discoverWorktrees(rule);
+                }
+                else if (rule.type === "directories") {
+                    candidatePaths = await discoverDirectories(rule);
+                }
+                else if (rule.type === "glob") {
+                    candidatePaths = await discoverGlobs(rule);
+                }
+            }
+            catch (error) {
+                warnings.push(`Discovery rule '${rule.name}' failed: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
+            for (const candidatePath of candidatePaths) {
+                const normalizedPath = node_path_1.default.resolve(candidatePath);
+                if (knownPaths.has(normalizedPath)) {
+                    continue;
+                }
+                const basename = node_path_1.default.basename(normalizedPath);
+                const projectId = nextProjectId(knownProjectIds, basename);
+                const shortName = toShortName(basename, projectId);
+                discovered[projectId] = {
+                    path: normalizedPath,
+                    shortName,
+                    label: basename,
+                    source: "discovered"
+                };
+                knownProjectIds.add(projectId);
+                knownPaths.add(normalizedPath);
+            }
+        }
+        return {
+            projects: discovered,
+            warnings
+        };
+    }
+}
+exports.DiscoveryService = DiscoveryService;
+async function discoverWorktrees(rule) {
+    const { stdout } = await execFileAsync("git", ["-C", rule.path, "worktree", "list", "--porcelain"], {
+        maxBuffer: 1024 * 1024
+    });
+    const paths = [];
+    for (const line of stdout.split("\n")) {
+        if (!line.startsWith("worktree ")) {
+            continue;
+        }
+        const worktreePath = line.slice("worktree ".length).trim();
+        if (worktreePath.length > 0) {
+            paths.push(worktreePath);
+        }
+    }
+    return uniqueSortedPaths(paths);
+}
+async function discoverDirectories(rule) {
+    const rootEntries = await promises_1.default.readdir(rule.path, { withFileTypes: true });
+    const maxDepth = rule.maxDepth ?? 1;
+    const exclude = new Set((rule.exclude ?? []).map((entry) => entry.toLowerCase()));
+    const matchValue = rule.match;
+    const queue = [];
+    for (const entry of rootEntries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        if (exclude.has(entry.name.toLowerCase())) {
+            continue;
+        }
+        queue.push({
+            dirPath: node_path_1.default.join(rule.path, entry.name),
+            depth: 1
+        });
+    }
+    const matches = [];
+    while (queue.length > 0) {
+        const next = queue.shift();
+        if (!next) {
+            continue;
+        }
+        if (!matchValue || (await pathExists(node_path_1.default.join(next.dirPath, matchValue)))) {
+            matches.push(next.dirPath);
+        }
+        if (next.depth >= maxDepth) {
+            continue;
+        }
+        const childEntries = await promises_1.default.readdir(next.dirPath, { withFileTypes: true }).catch(() => []);
+        for (const child of childEntries) {
+            if (!child.isDirectory()) {
+                continue;
+            }
+            if (exclude.has(child.name.toLowerCase())) {
+                continue;
+            }
+            queue.push({
+                dirPath: node_path_1.default.join(next.dirPath, child.name),
+                depth: next.depth + 1
+            });
+        }
+    }
+    return uniqueSortedPaths(matches);
+}
+async function discoverGlobs(rule) {
+    const matches = await (0, fast_glob_1.default)(rule.path, {
+        onlyDirectories: true,
+        absolute: true,
+        unique: true,
+        suppressErrors: true
+    });
+    return uniqueSortedPaths(matches);
+}
+async function pathExists(value) {
+    try {
+        await promises_1.default.access(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function uniqueSortedPaths(paths) {
+    return [...new Set(paths.map((value) => node_path_1.default.resolve(value)))].sort();
+}
+function nextProjectId(knownProjectIds, sourceName) {
+    const base = (0, windowName_1.slugify)(sourceName);
+    if (!knownProjectIds.has(base)) {
+        return base;
+    }
+    let suffix = 2;
+    while (knownProjectIds.has(`${base}-${suffix}`)) {
+        suffix += 1;
+    }
+    return `${base}-${suffix}`;
+}
+function toShortName(sourceName, fallback) {
+    const slug = (0, windowName_1.slugify)(sourceName || fallback);
+    return slug.slice(0, 8) || "proj";
+}