@overdeck/desktop 0.49.1 → 0.49.2

package/server/factory-D4V2wd_V.js

@@ -1,717 +0,0 @@
-import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { $r as LinearApiError, Zr as GitHubApiError, oi as init_errors, p as loadConfigSync, t as init_config_yaml } from "./config-yaml-BwOEANMr.js";
-import { a as TrackerAuthError, i as NotImplementedError, o as init_interface, r as IssueNotFoundError } from "./rally-api-ShZ4kvn0.js";
-import { n as init_dist_src, t as Octokit } from "./dist-src-BM9eudEd.js";
-import { n as init_rally, t as RallyTracker } from "./rally-B1OMtzch.js";
-import { Effect } from "effect";
-import { LinearClient } from "@linear/sdk";
-//#region ../../lib/tracker/linear.ts
-/**
-* Linear Issue Tracker Adapter
-*
-* Implements IssueTracker interface for Linear.
-*/
-/**
-* Wrap an arbitrary Linear SDK promise as an Effect that emits LinearApiError
-* on failure.
-*/
-function linearCall(operation, thunk) {
-	return Effect.tryPromise({
-		try: thunk,
-		catch: (cause) => {
-			return new LinearApiError({
-				operation,
-				message: cause?.message ?? String(cause),
-				cause
-			});
-		}
-	});
-}
-var STATE_MAP, UUID_RE, LinearTracker;
-var init_linear = __esmMin((() => {
-	init_interface();
-	init_errors();
-	STATE_MAP = {
-		backlog: "open",
-		unstarted: "open",
-		started: "in_progress",
-		completed: "closed",
-		canceled: "closed"
-	};
-	UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-	LinearTracker = class {
-		name = "linear";
-		client;
-		defaultTeam;
-		constructor(apiKey, options) {
-			if (!apiKey) throw new TrackerAuthError({
-				tracker: "linear",
-				message: "API key is required"
-			});
-			this.client = new LinearClient({ apiKey });
-			this.defaultTeam = options?.team;
-		}
-		listIssues(filters) {
-			const team = filters?.team ?? this.defaultTeam;
-			const self = this;
-			return linearCall("listIssues", async () => {
-				const limit = filters?.limit;
-				const filter = {
-					team: team ? { key: { eq: team } } : void 0,
-					state: filters?.state ? { type: { eq: self.reverseMapState(filters.state) } } : filters?.includeClosed ? void 0 : { type: { neq: "completed" } },
-					labels: filters?.labels?.length ? { name: { in: filters.labels } } : void 0,
-					assignee: filters?.assignee ? { name: { containsIgnoreCase: filters.assignee } } : void 0
-				};
-				const query = `query ListIssues($filter: IssueFilter, $first: Int!, $after: String) {
-        issues(filter: $filter, first: $first, after: $after) {
-          nodes {
-            id identifier title description url priority dueDate createdAt updatedAt
-            state { type } assignee { name } labels { nodes { name } }
-          }
-          pageInfo { hasNextPage endCursor }
-        }
-      }`;
-				const nodes = [];
-				let after = null;
-				do {
-					const first = Math.min(limit === void 0 ? 50 : limit - nodes.length, 50);
-					const page = (await self.client.client.rawRequest(query, {
-						filter,
-						first,
-						after
-					})).data?.issues;
-					if (!page?.nodes || !Array.isArray(page.nodes)) throw new Error("Incomplete Linear issues response");
-					nodes.push(...page.nodes);
-					after = page.pageInfo?.hasNextPage && page.pageInfo.endCursor ? page.pageInfo.endCursor : null;
-				} while (after !== null && (limit === void 0 || nodes.length < limit));
-				return (limit === void 0 ? nodes : nodes.slice(0, limit)).map((node) => self.normalizeListedIssue(node));
-			});
-		}
-		getIssue(id) {
-			const self = this;
-			return linearCall("getIssue", async () => {
-				if (UUID_RE.test(id) || /^([A-Z]+)-(\d+)$/i.test(id)) {
-					const issue = await self.client.issue(id);
-					if (issue) return await self.normalizeIssue(issue);
-				}
-				return null;
-			}).pipe(Effect.flatMap((issue) => issue ? Effect.succeed(issue) : Effect.fail(new IssueNotFoundError({
-				id,
-				tracker: "linear"
-			}))), Effect.catchTag("LinearApiError", () => Effect.fail(new IssueNotFoundError({
-				id,
-				tracker: "linear"
-			}))));
-		}
-		updateIssue(id, update) {
-			const self = this;
-			return self.getIssue(id).pipe(Effect.flatMap((issue) => {
-				const updatePayload = {};
-				if (update.title !== void 0) updatePayload.title = update.title;
-				if (update.description !== void 0) updatePayload.description = update.description;
-				if (update.priority !== void 0) updatePayload.priority = update.priority;
-				if (update.dueDate !== void 0) updatePayload.dueDate = update.dueDate;
-				const stateTransition = update.state !== void 0 ? self.transitionIssue(id, update.state) : Effect.succeed(void 0);
-				const applyDirect = Object.keys(updatePayload).length > 0 ? linearCall("updateIssue", () => self.client.updateIssue(issue.id, updatePayload)).pipe(Effect.asVoid) : Effect.succeed(void 0);
-				return stateTransition.pipe(Effect.flatMap(() => applyDirect), Effect.flatMap(() => self.getIssue(id)));
-			}));
-		}
-		createIssue(newIssue) {
-			const team = newIssue.team ?? this.defaultTeam;
-			const self = this;
-			if (!team) return Effect.fail(new LinearApiError({
-				operation: "createIssue",
-				message: "Team is required to create an issue"
-			}));
-			return linearCall("createIssue:lookupTeam", () => self.client.teams({ filter: { key: { eq: team } } })).pipe(Effect.flatMap((teams) => {
-				if (teams.nodes.length === 0) return Effect.fail(new LinearApiError({
-					operation: "createIssue",
-					message: `Team not found: ${team}`
-				}));
-				const teamId = teams.nodes[0].id;
-				return linearCall("createIssue", () => self.client.createIssue({
-					teamId,
-					title: newIssue.title,
-					description: newIssue.description,
-					priority: newIssue.priority,
-					dueDate: newIssue.dueDate
-				})).pipe(Effect.flatMap((result) => linearCall("createIssue:fetchCreated", async () => {
-					const created = await result.issue;
-					if (!created) throw new Error("Failed to create issue");
-					return await self.normalizeIssue(created);
-				})));
-			}));
-		}
-		getComments(issueId) {
-			const self = this;
-			return linearCall("getComments", async () => {
-				return (await (await self.client.issue(issueId)).comments()).nodes.map((c) => ({
-					id: c.id,
-					issueId,
-					body: c.body,
-					author: c.user?.then((u) => u?.name ?? "Unknown"),
-					createdAt: c.createdAt.toISOString(),
-					updatedAt: c.updatedAt.toISOString()
-				}));
-			});
-		}
-		addComment(issueId, body) {
-			const self = this;
-			return linearCall("addComment", async () => {
-				const comment = await (await self.client.createComment({
-					issueId,
-					body
-				})).comment;
-				if (!comment) throw new Error("Failed to create comment");
-				return {
-					id: comment.id,
-					issueId,
-					body: comment.body,
-					author: "Overdeck",
-					createdAt: comment.createdAt.toISOString(),
-					updatedAt: comment.updatedAt.toISOString()
-				};
-			});
-		}
-		transitionIssue(id, state) {
-			const self = this;
-			return linearCall("transitionIssue:resolve", async () => {
-				let linearIssue;
-				if (UUID_RE.test(id)) linearIssue = await self.client.issue(id);
-				else {
-					const results = await self.client.searchIssues(id, { first: 1 });
-					if (results.nodes.length > 0) linearIssue = results.nodes[0];
-					else return null;
-				}
-				return linearIssue;
-			}).pipe(Effect.flatMap((linearIssue) => {
-				if (!linearIssue) return Effect.fail(new IssueNotFoundError({
-					id,
-					tracker: "linear"
-				}));
-				return linearCall("transitionIssue:apply", async () => {
-					const team = await linearIssue.team;
-					if (!team) throw new Error("Could not determine issue team");
-					const states = await team.states();
-					let targetState;
-					if (state === "in_review") {
-						targetState = states.nodes.find((s) => s.name.toLowerCase() === "in review");
-						if (!targetState) {
-							targetState = states.nodes.filter((s) => s.type === "started").sort((a, b) => (a.position ?? 0) - (b.position ?? 0))[0];
-							if (!targetState) throw new Error("No \"In Review\" or \"started\" state found in Linear");
-						}
-					} else {
-						const targetStateType = self.reverseMapState(state);
-						targetState = states.nodes.filter((s) => s.type === targetStateType).sort((a, b) => (a.position ?? 0) - (b.position ?? 0))[0];
-						if (!targetState) throw new Error(`No state found matching type: ${targetStateType}`);
-					}
-					await self.client.updateIssue(linearIssue.id, { stateId: targetState.id });
-				});
-			}));
-		}
-		linkPR(issueId, prUrl) {
-			const self = this;
-			return self.getIssue(issueId).pipe(Effect.flatMap((issue) => linearCall("linkPR", () => self.client.createAttachment({
-				issueId: issue.id,
-				title: "Pull Request",
-				url: prUrl
-			}))), Effect.asVoid);
-		}
-		getChildIssues(_parentId) {
-			return Effect.succeed([]);
-		}
-		/** Map a raw-GraphQL listed node (relations already inlined) — no lazy SDK loads. */
-		normalizeListedIssue(node) {
-			return {
-				id: node.id,
-				ref: node.identifier,
-				title: node.title,
-				description: node.description ?? "",
-				state: this.mapState(node.state?.type ?? "backlog"),
-				labels: node.labels?.nodes?.flatMap((label) => label.name ? [label.name] : []) ?? [],
-				assignee: node.assignee?.name ?? void 0,
-				url: node.url,
-				tracker: "linear",
-				priority: node.priority ?? void 0,
-				dueDate: node.dueDate ?? void 0,
-				createdAt: node.createdAt,
-				updatedAt: node.updatedAt
-			};
-		}
-		async normalizeIssue(linearIssue) {
-			const state = await linearIssue.state;
-			const assignee = await linearIssue.assignee;
-			const labels = await linearIssue.labels();
-			let dueDate;
-			if (linearIssue.dueDate) dueDate = linearIssue.dueDate instanceof Date ? linearIssue.dueDate.toISOString() : String(linearIssue.dueDate);
-			return {
-				id: linearIssue.id,
-				ref: linearIssue.identifier,
-				title: linearIssue.title,
-				description: linearIssue.description ?? "",
-				state: this.mapState(state?.type ?? "backlog"),
-				labels: labels?.nodes?.map((l) => l.name) ?? [],
-				assignee: assignee?.name,
-				url: linearIssue.url,
-				tracker: "linear",
-				priority: linearIssue.priority,
-				dueDate,
-				createdAt: linearIssue.createdAt instanceof Date ? linearIssue.createdAt.toISOString() : String(linearIssue.createdAt),
-				updatedAt: linearIssue.updatedAt instanceof Date ? linearIssue.updatedAt.toISOString() : String(linearIssue.updatedAt)
-			};
-		}
-		mapState(linearState) {
-			return STATE_MAP[linearState] ?? "open";
-		}
-		reverseMapState(state) {
-			switch (state) {
-				case "open": return "unstarted";
-				case "in_progress":
-				case "in_review": return "started";
-				case "closed": return "completed";
-				default: return "unstarted";
-			}
-		}
-	};
-}));
-//#endregion
-//#region ../../lib/tracker/github.ts
-/**
-* GitHub Issues Tracker Adapter
-*
-* Implements IssueTracker interface for GitHub Issues.
-*/
-/**
-* Extract issue number from various formats: "300", "#300", "PAN-300"
-*/
-function parseIssueNumber(id) {
-	const match = id.match(/(\d+)$/);
-	return match ? parseInt(match[1], 10) : NaN;
-}
-/**
-* Wrap an Octokit promise in an Effect that emits typed errors.
-*
-* Treats HTTP 404 as IssueNotFoundError; everything else becomes
-* GitHubApiError carrying the status code (or 0 for network failures).
-*/
-function octokitToProgram(operation, resourceId, thunk) {
-	return Effect.tryPromise({
-		try: thunk,
-		catch: (cause) => {
-			const status = cause?.status ?? 0;
-			if (status === 404) return new IssueNotFoundError({
-				id: resourceId,
-				tracker: "github"
-			});
-			return new GitHubApiError({
-				operation,
-				status,
-				message: cause?.message ?? String(cause),
-				cause
-			});
-		}
-	});
-}
-var GitHubTracker;
-var init_github = __esmMin((() => {
-	init_dist_src();
-	init_interface();
-	init_errors();
-	GitHubTracker = class {
-		name = "github";
-		octokit;
-		owner;
-		repo;
-		constructor(token, owner, repo) {
-			if (!token) throw new TrackerAuthError({
-				tracker: "github",
-				message: "Token is required"
-			});
-			if (!owner || !repo) throw new Error("GitHub owner and repo are required");
-			this.octokit = new Octokit({ auth: token });
-			this.owner = owner;
-			this.repo = repo;
-		}
-		listIssues(filters) {
-			const state = this.mapStateToGitHub(filters?.state);
-			return Effect.tryPromise({
-				try: () => this.octokit.issues.listForRepo({
-					owner: this.owner,
-					repo: this.repo,
-					state: filters?.includeClosed ? "all" : state,
-					labels: filters?.labels?.join(",") || void 0,
-					assignee: filters?.assignee || void 0,
-					per_page: filters?.limit ?? 50
-				}),
-				catch: (cause) => {
-					return new GitHubApiError({
-						operation: "listIssues",
-						status: cause?.status ?? 0,
-						message: cause?.message ?? String(cause),
-						cause
-					});
-				}
-			}).pipe(Effect.map((response) => {
-				return response.data.filter((item) => !item.pull_request).map((issue) => this.normalizeIssue(issue));
-			}));
-		}
-		getIssue(id) {
-			const issueNumber = parseIssueNumber(id);
-			if (isNaN(issueNumber)) return Effect.fail(new IssueNotFoundError({
-				id,
-				tracker: "github"
-			}));
-			return octokitToProgram("getIssue", id, () => this.octokit.issues.get({
-				owner: this.owner,
-				repo: this.repo,
-				issue_number: issueNumber
-			})).pipe(Effect.map(({ data: issue }) => this.normalizeIssue(issue)));
-		}
-		updateIssue(id, update) {
-			const issueNumber = parseIssueNumber(id);
-			const updatePayload = {};
-			if (update.title !== void 0) updatePayload.title = update.title;
-			if (update.description !== void 0) updatePayload.body = update.description;
-			if (update.state !== void 0) updatePayload.state = update.state === "closed" ? "closed" : "open";
-			if (update.labels !== void 0) updatePayload.labels = update.labels;
-			if (update.assignee !== void 0) updatePayload.assignees = update.assignee ? [update.assignee] : [];
-			return octokitToProgram("updateIssue", id, () => this.octokit.issues.update({
-				owner: this.owner,
-				repo: this.repo,
-				issue_number: issueNumber,
-				...updatePayload
-			})).pipe(Effect.flatMap(() => this.getIssue(id)));
-		}
-		createIssue(newIssue) {
-			return Effect.tryPromise({
-				try: () => this.octokit.issues.create({
-					owner: this.owner,
-					repo: this.repo,
-					title: newIssue.title,
-					body: newIssue.description,
-					labels: newIssue.labels,
-					assignees: newIssue.assignee ? [newIssue.assignee] : void 0
-				}),
-				catch: (cause) => {
-					return new GitHubApiError({
-						operation: "createIssue",
-						status: cause?.status ?? 0,
-						message: cause?.message ?? String(cause),
-						cause
-					});
-				}
-			}).pipe(Effect.map(({ data: issue }) => this.normalizeIssue(issue)));
-		}
-		getComments(issueId) {
-			const issueNumber = parseIssueNumber(issueId);
-			return Effect.tryPromise({
-				try: () => this.octokit.issues.listComments({
-					owner: this.owner,
-					repo: this.repo,
-					issue_number: issueNumber
-				}),
-				catch: (cause) => {
-					return new GitHubApiError({
-						operation: "getComments",
-						status: cause?.status ?? 0,
-						message: cause?.message ?? String(cause),
-						cause
-					});
-				}
-			}).pipe(Effect.map(({ data: comments }) => comments.map((c) => ({
-				id: String(c.id),
-				issueId,
-				body: c.body ?? "",
-				author: c.user?.login ?? "Unknown",
-				createdAt: c.created_at,
-				updatedAt: c.updated_at
-			}))));
-		}
-		addComment(issueId, body) {
-			const issueNumber = parseIssueNumber(issueId);
-			return Effect.tryPromise({
-				try: () => this.octokit.issues.createComment({
-					owner: this.owner,
-					repo: this.repo,
-					issue_number: issueNumber,
-					body
-				}),
-				catch: (cause) => {
-					return new GitHubApiError({
-						operation: "addComment",
-						status: cause?.status ?? 0,
-						message: cause?.message ?? String(cause),
-						cause
-					});
-				}
-			}).pipe(Effect.map(({ data: comment }) => ({
-				id: String(comment.id),
-				issueId,
-				body: comment.body ?? "",
-				author: comment.user?.login ?? "Unknown",
-				createdAt: comment.created_at,
-				updatedAt: comment.updated_at
-			})));
-		}
-		transitionIssue(id, state) {
-			const issueNumber = parseIssueNumber(id);
-			const owner = this.owner;
-			const repo = this.repo;
-			const octokit = this.octokit;
-			const self = this;
-			const addLabels = (labels) => Effect.tryPromise({
-				try: () => octokit.issues.addLabels({
-					owner,
-					repo,
-					issue_number: issueNumber,
-					labels
-				}),
-				catch: (cause) => {
-					return new GitHubApiError({
-						operation: "addLabels",
-						status: cause?.status ?? 0,
-						message: cause?.message ?? String(cause),
-						cause
-					});
-				}
-			});
-			const removeLabelSilent = (name) => Effect.tryPromise({
-				try: () => octokit.issues.removeLabel({
-					owner,
-					repo,
-					issue_number: issueNumber,
-					name
-				}),
-				catch: () => new GitHubApiError({
-					operation: "removeLabel",
-					status: 0,
-					message: "remove failed"
-				})
-			}).pipe(Effect.orElseSucceed(() => void 0));
-			const ensureLabelExists = (name, description, color) => Effect.tryPromise({
-				try: () => octokit.issues.getLabel({
-					owner,
-					repo,
-					name
-				}),
-				catch: () => new GitHubApiError({
-					operation: "getLabel",
-					status: 404,
-					message: "label missing"
-				})
-			}).pipe(Effect.matchEffect({
-				onFailure: () => Effect.tryPromise({
-					try: () => octokit.issues.createLabel({
-						owner,
-						repo,
-						name,
-						description,
-						color
-					}),
-					catch: () => new GitHubApiError({
-						operation: "createLabel",
-						status: 0,
-						message: "create failed"
-					})
-				}).pipe(Effect.orElseSucceed(() => void 0)),
-				onSuccess: () => Effect.succeed(void 0)
-			}));
-			if (state === "in_progress") return self.getIssue(id).pipe(Effect.flatMap((issue) => {
-				const currentLabels = new Set(issue.labels ?? []);
-				return ensureLabelExists("in-progress", "In progress", "0075ca").pipe(Effect.flatMap(() => addLabels(["in-progress"])), Effect.flatMap(() => Effect.forEach([
-					"in-review",
-					"planned",
-					"in-planning",
-					"review-ready",
-					"done",
-					"merged",
-					"verifying-on-main",
-					"needs-close-out",
-					"closed-out"
-				].filter((label) => currentLabels.has(label)), (label) => removeLabelSilent(label), { concurrency: 1 })), Effect.asVoid);
-			}));
-			if (state === "in_review") return ensureLabelExists("in-review", "In review", "e4e669").pipe(Effect.flatMap(() => addLabels(["in-review"])), Effect.flatMap(() => removeLabelSilent("in-progress")), Effect.asVoid);
-			return self.getIssue(id).pipe(Effect.flatMap((issue) => {
-				const labelsToRemove = ["in-progress", "in-review"].filter((l) => issue.labels?.includes(l));
-				return Effect.forEach(labelsToRemove, (label) => removeLabelSilent(label), { concurrency: 1 }).pipe(Effect.flatMap(() => self.updateIssue(id, { state })));
-			}), Effect.asVoid);
-		}
-		linkPR(issueId, prUrl) {
-			return this.addComment(issueId, `Linked Pull Request: ${prUrl}`).pipe(Effect.asVoid);
-		}
-		getChildIssues(_parentId) {
-			return Effect.succeed([]);
-		}
-		normalizeIssue(ghIssue) {
-			const labels = ghIssue.labels.map((l) => typeof l === "string" ? l : l.name);
-			return {
-				id: String(ghIssue.id),
-				ref: `#${ghIssue.number}`,
-				title: ghIssue.title,
-				description: ghIssue.body ?? "",
-				state: this.mapStateFromGitHub(ghIssue.state, labels),
-				labels,
-				author: ghIssue.user?.login,
-				assignee: ghIssue.assignee?.login,
-				url: ghIssue.html_url,
-				tracker: "github",
-				priority: void 0,
-				dueDate: void 0,
-				createdAt: ghIssue.created_at,
-				updatedAt: ghIssue.updated_at
-			};
-		}
-		mapStateFromGitHub(ghState, labels = []) {
-			if (ghState === "closed") return "closed";
-			if (labels.includes("in-progress")) return "in_progress";
-			return "open";
-		}
-		mapStateToGitHub(state) {
-			if (!state) return "open";
-			if (state === "closed") return "closed";
-			return "open";
-		}
-	};
-}));
-//#endregion
-//#region ../../lib/tracker/gitlab.ts
-/**
-* GitLab Issues Tracker Adapter (Stub)
-*
-* Placeholder implementation for GitLab Issues support.
-* Full implementation will use @gitbeaker/rest.
-*/
-var notImplemented, GitLabTracker;
-var init_gitlab = __esmMin((() => {
-	init_interface();
-	notImplemented = (feature) => Effect.fail(new NotImplementedError({ feature }));
-	GitLabTracker = class {
-		name = "gitlab";
-		constructor(token, projectId) {
-			this.token = token;
-			this.projectId = projectId;
-			this.token;
-			this.projectId;
-		}
-		listIssues(_filters) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		getIssue(_id) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		updateIssue(_id, _update) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		createIssue(_issue) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		getComments(_issueId) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		addComment(_issueId, _body) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		transitionIssue(_id, _state) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		linkPR(_issueId, _prUrl) {
-			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
-		}
-		getChildIssues(_parentId) {
-			return Effect.succeed([]);
-		}
-	};
-}));
-//#endregion
-//#region ../../lib/tracker/factory.ts
-/**
-* Get tracker API key from config.yaml (Settings page).
-* This is checked FIRST — env vars are the fallback, not the other way around.
-*/
-function getTrackerKeyFromConfig(trackerType) {
-	try {
-		const { config: yamlConfig } = loadConfigSync();
-		return yamlConfig.trackerKeys[trackerType];
-	} catch {
-		return;
-	}
-}
-/**
-* Create a tracker instance from configuration.
-* Priority: config.yaml (Settings) > environment variable > custom env var name
-*/
-function createTracker(config) {
-	switch (config.type) {
-		case "linear": {
-			const configKey = getTrackerKeyFromConfig("linear");
-			const envKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.LINEAR_API_KEY;
-			const apiKey = configKey || envKey;
-			if (!apiKey) throw new TrackerAuthError({
-				tracker: "linear",
-				message: `API key not found. Configure in Settings or set ${config.apiKeyEnv ?? "LINEAR_API_KEY"} environment variable.`
-			});
-			return new LinearTracker(apiKey, { team: config.team });
-		}
-		case "github": {
-			const configKey = getTrackerKeyFromConfig("github");
-			const envToken = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITHUB_TOKEN;
-			const token = configKey || envToken;
-			if (!token) throw new TrackerAuthError({
-				tracker: "github",
-				message: `Token not found. Configure in Settings or set ${config.tokenEnv ?? "GITHUB_TOKEN"} environment variable.`
-			});
-			if (!config.owner || !config.repo) throw new Error("GitHub tracker requires owner and repo configuration");
-			return new GitHubTracker(token, config.owner, config.repo);
-		}
-		case "gitlab": {
-			const configKey = getTrackerKeyFromConfig("gitlab");
-			const envToken = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITLAB_TOKEN;
-			const token = configKey || envToken;
-			if (!token) throw new TrackerAuthError({
-				tracker: "gitlab",
-				message: `Token not found. Configure in Settings or set ${config.tokenEnv ?? "GITLAB_TOKEN"} environment variable.`
-			});
-			if (!config.projectId) throw new Error("GitLab tracker requires projectId configuration");
-			return new GitLabTracker(token, config.projectId);
-		}
-		case "rally": {
-			const configKey = getTrackerKeyFromConfig("rally");
-			const envKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.RALLY_API_KEY;
-			const apiKey = configKey || envKey;
-			if (!apiKey) throw new TrackerAuthError({
-				tracker: "rally",
-				message: `API key not found. Configure in Settings or set ${config.apiKeyEnv ?? "RALLY_API_KEY"} environment variable.`
-			});
-			return new RallyTracker({
-				apiKey,
-				server: config.server,
-				workspace: config.workspace,
-				project: config.project
-			});
-		}
-		default: throw new Error(`Unknown tracker type: ${config.type}`);
-	}
-}
-/**
-* Create tracker from trackers configuration section
-*/
-function createTrackerFromConfig(trackersConfig, trackerType) {
-	const config = trackersConfig[trackerType];
-	if (!config) throw new Error(`No configuration found for tracker: ${trackerType}. Add [trackers.${trackerType}] to config.`);
-	return createTracker({
-		...config,
-		type: trackerType
-	});
-}
-var init_factory = __esmMin((() => {
-	init_interface();
-	init_linear();
-	init_github();
-	init_gitlab();
-	init_rally();
-	init_config_yaml();
-}));
-//#endregion
-export { init_linear as a, LinearTracker as i, createTrackerFromConfig as n, init_factory as r, createTracker as t };
-
-//# sourceMappingURL=factory-D4V2wd_V.js.map