@agent-team-foundation/first-tree-hub 0.3.0 → 0.3.2

package/dist/bootstrap-B9JsJR3Z.mjs

@@ -0,0 +1,583 @@
+import { t as __exportAll } from "./rolldown-runtime-twds-ZHy.mjs";
+import { z } from "zod";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse, stringify } from "yaml";
+import { randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+//#region ../shared/dist/config/index.mjs
+/** Declare a config field with a Zod schema and optional metadata. */
+function field(schema, options) {
+	return {
+		_tag: "field",
+		_type: void 0,
+		schema,
+		options: options ?? {}
+	};
+}
+/** Mark a config group as optional — present only when at least one field has an explicit value. */
+function optional(shape) {
+	return {
+		_tag: "optional",
+		shape
+	};
+}
+/** Define a config shape. Identity function used for type inference. */
+function defineConfig(shape) {
+	return shape;
+}
+const agentConfigSchema = defineConfig({
+	token: field(z.string(), { secret: true }),
+	type: field(z.string().default("claude-code")),
+	concurrency: field(z.number().int().positive().default(5)),
+	session: {
+		idle_timeout: field(z.number().int().positive().default(300)),
+		max_sessions: field(z.number().int().positive().default(10))
+	}
+});
+let _config;
+/** Store the resolved config as a singleton. Called by initConfig(). */
+function setConfig(config) {
+	_config = config;
+}
+/**
+* Get the resolved config singleton.
+* Must be called after initConfig().
+*/
+function getConfig() {
+	if (_config === void 0) throw new Error("Config not initialized. Call initConfig() first.");
+	return _config;
+}
+/** Reset the config singleton. For testing only. */
+function resetConfig() {
+	_config = void 0;
+}
+const clientConfigSchema = defineConfig({
+	server: { url: field(z.string(), {
+		env: "FIRST_TREE_HUB_SERVER_URL",
+		prompt: {
+			message: "Server URL:",
+			default: "http://localhost:8000"
+		}
+	}) },
+	logLevel: field(z.enum([
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]).default("info"), { env: "FIRST_TREE_HUB_LOG_LEVEL" })
+});
+/** Typed accessor for client configuration singleton. */
+function getClientConfig() {
+	return getConfig();
+}
+const DEFAULT_HOME_DIR = join(homedir(), ".first-tree-hub");
+const DEFAULT_CONFIG_DIR = join(DEFAULT_HOME_DIR, "config");
+const DEFAULT_DATA_DIR = join(DEFAULT_HOME_DIR, "data");
+function isFieldDef(value) {
+	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "field";
+}
+function isOptionalGroup(value) {
+	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "optional";
+}
+function getByPath(obj, path) {
+	let current = obj;
+	for (const key of path) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[key];
+	}
+	return current;
+}
+function setByPath(obj, path, value) {
+	let current = obj;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		if (key === void 0) continue;
+		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) current[key] = {};
+		current = current[key];
+	}
+	const lastKey = path.at(-1);
+	if (lastKey !== void 0) current[lastKey] = value;
+}
+/** Unwrap ZodDefault / ZodOptional to get the inner type for coercion. */
+function unwrapZodType(schema) {
+	if (schema instanceof z.ZodDefault) return unwrapZodType(schema._def.innerType);
+	if (schema instanceof z.ZodOptional) return unwrapZodType(schema._def.innerType);
+	return schema;
+}
+/** Coerce a string env var to the JS type expected by the Zod schema. */
+function coerceEnvValue(value, schema) {
+	const inner = unwrapZodType(schema);
+	if (inner instanceof z.ZodNumber) {
+		const num = Number(value);
+		return Number.isNaN(num) ? value : num;
+	}
+	if (inner instanceof z.ZodBoolean) {
+		if (value === "true" || value === "1") return true;
+		if (value === "false" || value === "0") return false;
+		return value;
+	}
+	return value;
+}
+function builtinAutoGenerate(strategy) {
+	const match = /^random:(\w+):(\d+)$/.exec(strategy);
+	if (!match) throw new Error(`Unknown auto-generation strategy: ${strategy}`);
+	const encoding = match[1];
+	const bytes = Number(match[2]);
+	if (!encoding) throw new Error(`Invalid auto-generation strategy: ${strategy}`);
+	if (encoding === "base64url") return randomBytes(bytes).toString("base64url");
+	if (encoding === "hex") return randomBytes(bytes).toString("hex");
+	throw new Error(`Unknown random encoding: ${encoding}`);
+}
+function ensureDir(dir) {
+	if (!existsSync(dir)) mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const [key, value] of Object.entries(source)) if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) result[key] = deepMerge(result[key], value);
+	else result[key] = value;
+	return result;
+}
+function deepFreeze(obj) {
+	if (typeof obj !== "object" || obj === null) return obj;
+	Object.freeze(obj);
+	for (const value of Object.values(obj)) deepFreeze(value);
+	return obj;
+}
+function collectFields(shape, path = [], optionalGroupPath = null) {
+	const fields = [];
+	for (const [key, value] of Object.entries(shape)) {
+		const currentPath = [...path, key];
+		if (isFieldDef(value)) fields.push({
+			path: currentPath,
+			fieldDef: value,
+			optionalGroupPath
+		});
+		else if (isOptionalGroup(value)) fields.push(...collectFields(value.shape, currentPath, currentPath));
+		else if (typeof value === "object" && value !== null) fields.push(...collectFields(value, currentPath, optionalGroupPath));
+	}
+	return fields;
+}
+/** Build a Zod object schema from the config shape for validation. */
+function buildZodSchema(shape) {
+	const zodShape = {};
+	for (const [key, value] of Object.entries(shape)) if (isFieldDef(value)) zodShape[key] = value.schema;
+	else if (isOptionalGroup(value)) zodShape[key] = buildZodSchema(value.shape).optional();
+	else if (typeof value === "object" && value !== null) zodShape[key] = buildZodSchema(value).default({});
+	return z.object(zodShape);
+}
+function resetConfigMeta() {}
+const CONFIG_HEADER = "# Generated by first-tree-hub. Edit as needed.\n# https://github.com/agent-team-foundation/first-tree-hub\n\n";
+/**
+* Initialize config from the priority chain:
+*   CLI args > env vars > YAML file > auto-generated > Zod defaults
+*
+* Auto-generated values are written back to the YAML file.
+* Result is frozen and stored as a singleton accessible via getConfig().
+*/
+async function initConfig(options) {
+	const { schema, role, cliArgs = {}, autoGenerators = {} } = options;
+	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${role}.yaml`);
+	let fileValues = {};
+	if (existsSync(configPath)) {
+		const raw = parse(readFileSync(configPath, "utf-8"));
+		if (typeof raw === "object" && raw !== null) fileValues = raw;
+	}
+	const fields = collectFields(schema);
+	const resolved = {};
+	const meta = /* @__PURE__ */ new Map();
+	const autoGenerated = {};
+	const activeOptionalGroups = /* @__PURE__ */ new Set();
+	for (const { path, fieldDef, optionalGroupPath } of fields) {
+		if (!optionalGroupPath) continue;
+		const groupKey = optionalGroupPath.join(".");
+		if (activeOptionalGroups.has(groupKey)) continue;
+		if (getByPath(cliArgs, path) !== void 0) {
+			activeOptionalGroups.add(groupKey);
+			continue;
+		}
+		if (fieldDef.options.env) {
+			const envValue = process.env[fieldDef.options.env];
+			if (envValue !== void 0 && envValue !== "") {
+				activeOptionalGroups.add(groupKey);
+				continue;
+			}
+		}
+		if (getByPath(fileValues, path) !== void 0) activeOptionalGroups.add(groupKey);
+	}
+	for (const { path, fieldDef, optionalGroupPath } of fields) {
+		const dotPath = path.join(".");
+		if (optionalGroupPath && !activeOptionalGroups.has(optionalGroupPath.join("."))) continue;
+		const cliValue = getByPath(cliArgs, path);
+		if (cliValue !== void 0) {
+			setByPath(resolved, path, cliValue);
+			meta.set(dotPath, {
+				value: cliValue,
+				source: "cli",
+				secret: fieldDef.options.secret ?? false
+			});
+			continue;
+		}
+		if (fieldDef.options.env) {
+			const envValue = process.env[fieldDef.options.env];
+			if (envValue !== void 0 && envValue !== "") {
+				const coerced = coerceEnvValue(envValue, fieldDef.schema);
+				setByPath(resolved, path, coerced);
+				meta.set(dotPath, {
+					value: coerced,
+					source: "env",
+					secret: fieldDef.options.secret ?? false
+				});
+				continue;
+			}
+		}
+		const fileValue = getByPath(fileValues, path);
+		if (fileValue !== void 0) {
+			setByPath(resolved, path, fileValue);
+			meta.set(dotPath, {
+				value: fileValue,
+				source: "file",
+				secret: fieldDef.options.secret ?? false
+			});
+			continue;
+		}
+		if (fieldDef.options.auto) {
+			const strategy = fieldDef.options.auto;
+			const customGen = autoGenerators[strategy];
+			let generated;
+			if (customGen) generated = await customGen();
+			else generated = builtinAutoGenerate(strategy);
+			setByPath(resolved, path, generated);
+			setByPath(autoGenerated, path, generated);
+			meta.set(dotPath, {
+				value: generated,
+				source: "auto",
+				secret: fieldDef.options.secret ?? false
+			});
+			continue;
+		}
+		meta.set(dotPath, {
+			value: void 0,
+			source: "default",
+			secret: fieldDef.options.secret ?? false
+		});
+	}
+	const result = buildZodSchema(schema).safeParse(resolved);
+	if (!result.success) {
+		const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+		throw new Error(`Configuration validation failed:\n${issues}`);
+	}
+	const config = result.data;
+	for (const { path, fieldDef } of fields) {
+		const dotPath = path.join(".");
+		if (meta.get(dotPath)?.value === void 0) {
+			const val = getByPath(config, path);
+			if (val !== void 0) meta.set(dotPath, {
+				value: val,
+				source: "default",
+				secret: fieldDef.options.secret ?? false
+			});
+		}
+	}
+	if (Object.keys(autoGenerated).length > 0) {
+		const merged = deepMerge(fileValues, autoGenerated);
+		ensureDir(dirname(configPath));
+		writeFileSync(configPath, CONFIG_HEADER + stringify(merged), { mode: 384 });
+	}
+	const frozen = deepFreeze(config);
+	setConfig(frozen);
+	return frozen;
+}
+/** Set a value in a YAML config file by dot-path. */
+function setConfigValue(configPath, dotPath, value) {
+	let fileValues = {};
+	if (existsSync(configPath)) {
+		const raw = parse(readFileSync(configPath, "utf-8"));
+		if (typeof raw === "object" && raw !== null) fileValues = raw;
+	}
+	setByPath(fileValues, dotPath.split("."), value);
+	ensureDir(dirname(configPath));
+	writeFileSync(configPath, CONFIG_HEADER + stringify(fileValues), { mode: 384 });
+}
+/** Get a value from a YAML config file by dot-path. */
+function getConfigValue(configPath, dotPath) {
+	if (!existsSync(configPath)) return void 0;
+	const raw = parse(readFileSync(configPath, "utf-8"));
+	if (typeof raw !== "object" || raw === null) return void 0;
+	return getByPath(raw, dotPath.split("."));
+}
+/** Read all values from a YAML config file. */
+function readConfigFile(configPath) {
+	if (!existsSync(configPath)) return {};
+	const raw = parse(readFileSync(configPath, "utf-8"));
+	if (typeof raw !== "object" || raw === null) return {};
+	return raw;
+}
+/**
+* Scan a config schema and return fields that:
+* 1. Have a `prompt` definition
+* 2. Don't have a value from CLI args, env vars, or the config file
+* 3. Don't have an `auto` strategy (auto-gen fields don't need prompting)
+*
+* Used by CLI to show interactive prompts before calling initConfig().
+*/
+function collectMissingPrompts(options) {
+	const { schema, role, cliArgs = {} } = options;
+	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${role}.yaml`);
+	let fileValues = {};
+	if (existsSync(configPath)) {
+		const raw = parse(readFileSync(configPath, "utf-8"));
+		if (typeof raw === "object" && raw !== null) fileValues = raw;
+	}
+	const fields = collectFields(schema);
+	const missing = [];
+	for (const { path, fieldDef, optionalGroupPath } of fields) {
+		if (optionalGroupPath) continue;
+		if (!fieldDef.options.prompt) continue;
+		if (getByPath(cliArgs, path) !== void 0) continue;
+		if (fieldDef.options.env) {
+			const envValue = process.env[fieldDef.options.env];
+			if (envValue !== void 0 && envValue !== "") continue;
+		}
+		if (getByPath(fileValues, path) !== void 0) continue;
+		missing.push({
+			dotPath: path.join("."),
+			prompt: fieldDef.options.prompt
+		});
+	}
+	return missing;
+}
+/**
+* Resolve config values through the same priority chain as initConfig()
+* (env vars > YAML file > Zod defaults), but **without side effects**:
+* - No auto-generation
+* - No file writes
+* - No singleton mutation
+* - Partial results (unresolvable fields are omitted, no validation error)
+*
+* Returns the best-effort resolved config as a plain object.
+*/
+function resolveConfigReadonly(options) {
+	const { schema, role } = options;
+	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${role}.yaml`);
+	let fileValues = {};
+	if (existsSync(configPath)) {
+		const raw = parse(readFileSync(configPath, "utf-8"));
+		if (typeof raw === "object" && raw !== null) fileValues = raw;
+	}
+	const fields = collectFields(schema);
+	const resolved = {};
+	for (const { path, fieldDef } of fields) {
+		if (fieldDef.options.env) {
+			const envValue = process.env[fieldDef.options.env];
+			if (envValue !== void 0 && envValue !== "") {
+				setByPath(resolved, path, coerceEnvValue(envValue, fieldDef.schema));
+				continue;
+			}
+		}
+		const fileValue = getByPath(fileValues, path);
+		if (fileValue !== void 0) {
+			setByPath(resolved, path, fileValue);
+			continue;
+		}
+		const defaultResult = fieldDef.schema.safeParse(void 0);
+		if (defaultResult.success && defaultResult.data !== void 0) setByPath(resolved, path, defaultResult.data);
+	}
+	return resolved;
+}
+/**
+* Scan an agents directory and load each agent's config.
+*
+* Expected structure:
+*   {agentsDir}/
+*     code-reviewer/agent.yaml
+*     scheduler/agent.yaml
+*
+* Returns a Map keyed by directory name (agent name).
+*/
+function loadAgents(options) {
+	const { schema, agentsDir } = options;
+	const result = /* @__PURE__ */ new Map();
+	if (!existsSync(agentsDir)) return result;
+	const zodSchema = buildZodSchema(schema);
+	for (const entry of readdirSync(agentsDir)) {
+		const agentDir = join(agentsDir, entry);
+		if (!statSync(agentDir).isDirectory()) continue;
+		const configPath = join(agentDir, "agent.yaml");
+		if (!existsSync(configPath)) continue;
+		const raw = parse(readFileSync(configPath, "utf-8"));
+		const parsed = zodSchema.parse(raw);
+		result.set(entry, parsed);
+	}
+	return result;
+}
+const serverConfigSchema = defineConfig({
+	database: {
+		url: field(z.string(), {
+			env: "FIRST_TREE_HUB_DATABASE_URL",
+			auto: "docker-pg",
+			prompt: {
+				message: "PostgreSQL:",
+				type: "select",
+				choices: [{
+					name: "Auto-provision via Docker",
+					value: "__auto__"
+				}, {
+					name: "Provide connection URL",
+					value: "__input__"
+				}]
+			}
+		}),
+		provider: field(z.enum(["docker", "external"]).default("docker"))
+	},
+	server: {
+		port: field(z.number().default(8e3), { env: "FIRST_TREE_HUB_PORT" }),
+		host: field(z.string().default("127.0.0.1"), { env: "FIRST_TREE_HUB_HOST" })
+	},
+	secrets: {
+		jwtSecret: field(z.string(), {
+			env: "FIRST_TREE_HUB_JWT_SECRET",
+			auto: "random:base64url:32",
+			secret: true
+		}),
+		encryptionKey: field(z.string(), {
+			env: "FIRST_TREE_HUB_ENCRYPTION_KEY",
+			auto: "random:hex:32",
+			secret: true
+		})
+	},
+	contextTree: {
+		repo: field(z.string(), {
+			env: "FIRST_TREE_HUB_CONTEXT_TREE_REPO",
+			prompt: { message: "Context Tree repo URL (e.g. https://github.com/org/first-tree):" }
+		}),
+		branch: field(z.string().default("main")),
+		syncInterval: field(z.number().default(60))
+	},
+	github: {
+		token: field(z.string(), {
+			env: "FIRST_TREE_HUB_GITHUB_TOKEN",
+			secret: true,
+			prompt: {
+				message: "GitHub token (create at https://github.com/settings/tokens → repo scope):",
+				type: "password"
+			}
+		}),
+		webhookSecret: field(z.string().optional(), {
+			env: "FIRST_TREE_HUB_GITHUB_WEBHOOK_SECRET",
+			secret: true
+		})
+	},
+	cors: optional({ origin: field(z.string(), { env: "FIRST_TREE_HUB_CORS_ORIGIN" }) }),
+	rateLimit: optional({
+		max: field(z.number().default(100), { env: "FIRST_TREE_HUB_RATE_LIMIT_MAX" }),
+		loginMax: field(z.number().default(5), { env: "FIRST_TREE_HUB_RATE_LIMIT_LOGIN_MAX" }),
+		webhookMax: field(z.number().default(60), { env: "FIRST_TREE_HUB_RATE_LIMIT_WEBHOOK_MAX" })
+	})
+});
+//#endregion
+//#region src/core/bootstrap.ts
+var bootstrap_exports = /* @__PURE__ */ __exportAll({
+	bootstrapToken: () => bootstrapToken,
+	checkBootstrapStatus: () => checkBootstrapStatus,
+	getGitHubToken: () => getGitHubToken,
+	getGitHubUsername: () => getGitHubUsername,
+	resolveAgentToken: () => resolveAgentToken,
+	resolveServerUrl: () => resolveServerUrl
+});
+/**
+* Get the current GitHub username from `gh auth status`.
+*/
+function getGitHubUsername() {
+	try {
+		const output = execSync("gh api /user --jq .login", { encoding: "utf-8" }).trim();
+		if (!output) throw new Error("Empty response");
+		return output;
+	} catch {
+		throw new Error("Failed to get GitHub username. Ensure `gh` CLI is installed and authenticated:\n  gh auth login");
+	}
+}
+/**
+* Get the GitHub auth token from `gh auth token`.
+*/
+function getGitHubToken() {
+	try {
+		const output = execSync("gh auth token", { encoding: "utf-8" }).trim();
+		if (!output) throw new Error("Empty response");
+		return output;
+	} catch {
+		throw new Error("Failed to get GitHub token. Ensure `gh` CLI is installed and authenticated:\n  gh auth login");
+	}
+}
+/**
+* Resolve Hub server URL from flag, env, or config.
+*/
+function resolveServerUrl(flagValue) {
+	if (flagValue) return flagValue;
+	if (process.env.FIRST_TREE_HUB_SERVER) return process.env.FIRST_TREE_HUB_SERVER;
+	try {
+		const config = getClientConfig();
+		if (config.server?.url) return config.server.url;
+	} catch {}
+	throw new Error("Server URL not configured.\n  Provide via: --server <url>, FIRST_TREE_HUB_SERVER env var, or\n  first-tree-hub config set -c server.url <url>");
+}
+/**
+* Bootstrap a token for an agent using GitHub identity.
+*/
+async function bootstrapToken(serverUrl, agentId, options = {}) {
+	const githubToken = getGitHubToken();
+	const res = await fetch(`${serverUrl}/api/v1/bootstrap/${encodeURIComponent(agentId)}/token`, {
+		method: "POST",
+		headers: {
+			"X-GitHub-Token": githubToken,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({ name: "bootstrap" })
+	});
+	if (!res.ok) {
+		const msg = (await res.json().catch(() => ({}))).error ?? `HTTP ${res.status}`;
+		throw new Error(`Bootstrap failed for "${agentId}": ${msg}`);
+	}
+	const data = await res.json();
+	if (options.saveTo === "agent" || !options.saveTo) {
+		const configDir = join(homedir(), ".first-tree-hub", "agents", agentId);
+		const configPath = `${configDir}/agent.yaml`;
+		mkdirSync(configDir, {
+			recursive: true,
+			mode: 448
+		});
+		writeFileSync(configPath, `token: "${data.token}"\ntype: claude-code\n`, { mode: 384 });
+		chmodSync(configDir, 448);
+	} else if (options.saveTo) {
+		mkdirSync(dirname(options.saveTo), { recursive: true });
+		writeFileSync(options.saveTo, data.token, { mode: 384 });
+	}
+	return data;
+}
+/**
+* Resolve agent token from FIRST_TREE_HUB_TOKEN env var.
+* Throws if not set.
+*/
+function resolveAgentToken() {
+	const token = process.env.FIRST_TREE_HUB_TOKEN;
+	if (!token) throw new Error("FIRST_TREE_HUB_TOKEN environment variable is required.");
+	return token;
+}
+/**
+* Check if an agent exists and is synced.
+*/
+async function checkBootstrapStatus(serverUrl, agentId) {
+	const githubToken = getGitHubToken();
+	const res = await fetch(`${serverUrl}/api/v1/bootstrap/${encodeURIComponent(agentId)}/status`, { headers: { "X-GitHub-Token": githubToken } });
+	if (!res.ok) {
+		const body = await res.json().catch(() => ({}));
+		throw new Error(body.error ?? `HTTP ${res.status}`);
+	}
+	return await res.json();
+}
+//#endregion
+export { resetConfig as _, getGitHubUsername as a, serverConfigSchema as b, DEFAULT_CONFIG_DIR as c, clientConfigSchema as d, collectMissingPrompts as f, readConfigFile as g, loadAgents as h, getGitHubToken as i, DEFAULT_DATA_DIR as l, initConfig as m, bootstrap_exports as n, resolveAgentToken as o, getConfigValue as p, checkBootstrapStatus as r, resolveServerUrl as s, bootstrapToken as t, agentConfigSchema as u, resetConfigMeta as v, setConfigValue as x, resolveConfigReadonly as y };