jobarbiter 0.3.12 → 0.4.0

package/src/lib/launchd.ts

@@ -0,0 +1,193 @@
+/**
+ * LaunchAgent Management for macOS
+ *
+ * Manages the ai.jobarbiter.observer LaunchAgent for periodic transcript polling.
+ * Generates plist, writes to ~/Library/LaunchAgents/, manages via launchctl.
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+
+// ── Constants ──────────────────────────────────────────────────────────
+
+const LABEL = "ai.jobarbiter.observer";
+const LAUNCH_AGENTS_DIR = join(homedir(), "Library", "LaunchAgents");
+const PLIST_PATH = join(LAUNCH_AGENTS_DIR, `${LABEL}.plist`);
+const OBSERVER_DIR = join(homedir(), ".config", "jobarbiter", "observer");
+const LOG_PATH = join(OBSERVER_DIR, "poll.log");
+
+// ── Types ──────────────────────────────────────────────────────────────
+
+export interface DaemonStatus {
+	installed: boolean;
+	loaded: boolean;
+	interval: number | null;
+	plistPath: string;
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function resolveJobarbiterPath(): string {
+	// Try to find the jobarbiter binary
+	try {
+		const path = execSync("command -v jobarbiter", { encoding: "utf-8", timeout: 3000 }).trim();
+		if (path) return path;
+	} catch {
+		// Fall through
+	}
+
+	// Fallback: use process.execPath with the dist path
+	// This covers the case where jobarbiter is run via node directly
+	return process.execPath;
+}
+
+function generatePlist(intervalSeconds: number): string {
+	const binaryPath = resolveJobarbiterPath();
+
+	// If the binary is node itself, we need to figure out the script path
+	const isNodeBinary = binaryPath.includes("node") || binaryPath.includes("bun");
+	let programArgs: string;
+
+	if (isNodeBinary) {
+		// Find the actual CLI entry point
+		const cliPath = join(__dirname, "..", "index.js");
+		programArgs = `    <string>${binaryPath}</string>
+    <string>${cliPath}</string>
+    <string>observe</string>
+    <string>poll</string>`;
+	} else {
+		programArgs = `    <string>${binaryPath}</string>
+    <string>observe</string>
+    <string>poll</string>`;
+	}
+
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+  <key>StandardOutPath</key>
+  <string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_PATH}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>Nice</key>
+  <integer>10</integer>
+</dict>
+</plist>
+`;
+}
+
+function isLoaded(): boolean {
+	try {
+		const output = execSync(`launchctl list 2>/dev/null`, { encoding: "utf-8", timeout: 5000 });
+		return output.includes(LABEL);
+	} catch {
+		return false;
+	}
+}
+
+// ── Public API ─────────────────────────────────────────────────────────
+
+export function installDaemon(intervalSeconds = 7200): void {
+	mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+	mkdirSync(OBSERVER_DIR, { recursive: true });
+
+	// Unload existing if present
+	if (isLoaded()) {
+		try {
+			execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { timeout: 5000 });
+		} catch {
+			// May not be loaded
+		}
+	}
+
+	// Write plist
+	const plist = generatePlist(intervalSeconds);
+	writeFileSync(PLIST_PATH, plist);
+
+	// Load
+	try {
+		execSync(`launchctl load "${PLIST_PATH}"`, { timeout: 5000 });
+	} catch (err) {
+		throw new Error(`Failed to load LaunchAgent: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+
+export function uninstallDaemon(): void {
+	// Unload
+	if (isLoaded()) {
+		try {
+			execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { timeout: 5000 });
+		} catch {
+			// Best effort
+		}
+	}
+
+	// Delete plist
+	if (existsSync(PLIST_PATH)) {
+		try {
+			unlinkSync(PLIST_PATH);
+		} catch {
+			// Best effort
+		}
+	}
+}
+
+export function getDaemonStatus(): DaemonStatus {
+	const installed = existsSync(PLIST_PATH);
+	const loaded = isLoaded();
+
+	let interval: number | null = null;
+	if (installed) {
+		try {
+			const content = readFileSync(PLIST_PATH, "utf-8");
+			const match = content.match(/<key>StartInterval<\/key>\s*<integer>(\d+)<\/integer>/);
+			if (match) {
+				interval = parseInt(match[1], 10);
+			}
+		} catch {
+			// Best effort
+		}
+	}
+
+	return {
+		installed,
+		loaded,
+		interval,
+		plistPath: PLIST_PATH,
+	};
+}
+
+export function reloadDaemon(): void {
+	if (!existsSync(PLIST_PATH)) {
+		throw new Error("Daemon not installed. Run 'jobarbiter observe daemon install' first.");
+	}
+
+	try {
+		execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { timeout: 5000 });
+	} catch {
+		// May not be loaded
+	}
+
+	try {
+		execSync(`launchctl load "${PLIST_PATH}"`, { timeout: 5000 });
+	} catch (err) {
+		throw new Error(`Failed to reload daemon: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}

package/src/lib/observe.ts

@@ -125,9 +125,29 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const OBSERVATIONS_FILE = path.join(
-  os.homedir(), ".config", "jobarbiter", "observer", "observations.json"
-);
+const OBSERVER_DIR = path.join(os.homedir(), ".config", "jobarbiter", "observer");
+const OBSERVATIONS_FILE = path.join(OBSERVER_DIR, "observations.json");
+const PAUSED_FILE = path.join(OBSERVER_DIR, "PAUSED");
+
+// Check PAUSED sentinel FIRST — if paused, exit immediately
+try {
+  if (fs.existsSync(PAUSED_FILE)) {
+    const raw = fs.readFileSync(PAUSED_FILE, "utf-8");
+    const pauseData = JSON.parse(raw);
+    if (pauseData.expiresAt) {
+      const expiresAt = new Date(pauseData.expiresAt).getTime();
+      if (Date.now() < expiresAt) {
+        process.exit(0); // Still paused
+      }
+      // Expired — clean up and continue
+      fs.unlinkSync(PAUSED_FILE);
+    } else {
+      process.exit(0); // Paused indefinitely
+    }
+  }
+} catch {
+  // If PAUSED file is corrupted, continue
+}
 
 // Read stdin
 let input = "";
@@ -283,8 +303,14 @@ function appendObservation(obs) {
   // Fire-and-forget: trigger analysis pipeline via CLI
   // Spawns detached process so the AI tool is never blocked
   try {
-    const { spawn } = require("child_process");
-    // Try npx jobarbiter first, fall back to direct node invocation
+    const { spawn, execSync } = require("child_process");
+    // Self-healing: verify jobarbiter binary exists before spawning
+    try {
+      execSync("command -v jobarbiter", { stdio: "ignore", timeout: 3000 });
+    } catch {
+      // jobarbiter CLI not found — exit silently
+      return;
+    }
     const child = spawn("jobarbiter", ["analyze", "--auto"], {
       detached: true,
       stdio: "ignore",

package/src/lib/onboard.ts

@@ -21,6 +21,7 @@ import {
 	type DetectedTool,
 	type ToolCategory,
 } from "./detect-tools.js";
+import { installDaemon } from "./launchd.js";
 import {
 	loadProviderKeys,
 	saveProviderKey,
@@ -215,21 +216,71 @@ export async function runOnboardWizard(opts: { force?: boolean; baseUrl?: string
 		state.userType = userType;
 
 		// Step 2: Email & Verification
-		const { email, apiKey, userId } = await handleEmailVerification(prompt, baseUrl, userType);
-		state.email = email;
-		state.apiKey = apiKey;
-		state.userId = userId;
+		const verificationResult = await handleEmailVerification(prompt, baseUrl, userType);
+		state.email = verificationResult.email;
+		state.apiKey = verificationResult.apiKey;
+		state.userId = verificationResult.userId;
+
+		// If returning user, override userType from backend
+		const effectiveUserType = verificationResult.isReturningUser && verificationResult.userType
+			? (verificationResult.userType as "worker" | "employer")
+			: userType;
+		state.userType = effectiveUserType;
 
 		// Save config immediately after verification (with step progress)
 		saveConfig({
-			apiKey,
+			apiKey: verificationResult.apiKey,
 			baseUrl,
-			userType,
+			userType: effectiveUserType,
 			onboardingStep: 1,
 			onboardingComplete: false,
 		});
 
-		if (userType === "worker") {
+		// Returning user: show progress and resume from first incomplete step
+		if (verificationResult.isReturningUser) {
+			const config: Config = {
+				apiKey: verificationResult.apiKey,
+				baseUrl,
+				userType: effectiveUserType,
+			};
+			const progress = await fetchOnboardingProgress(config);
+			const { firstIncomplete } = showReturningUserProgress(progress);
+
+			if (firstIncomplete > (effectiveUserType === "worker" ? 6 : 5)) {
+				// Everything done except completion step
+				const continueAnyway = await prompt.confirm(`All steps look complete. Re-run onboarding anyway?`, false);
+				if (!continueAnyway) {
+					saveConfig({ ...config, onboardingComplete: true, onboardingStep: effectiveUserType === "worker" ? 7 : 6 });
+					console.log(`\n${sym.check} ${c.success("You're all set!")} Run ${c.highlight("jobarbiter status")} to check your account.\n`);
+					prompt.close();
+					return;
+				}
+			} else {
+				const continueFromStep = await prompt.confirm(`Continue from step ${firstIncomplete}?`);
+				if (!continueFromStep) {
+					// Let them start from step 2
+					console.log(c.dim("Starting from the beginning...\n"));
+					if (effectiveUserType === "worker") {
+						await runWorkerFlow(prompt, state as OnboardState, 2);
+					} else {
+						await runEmployerFlow(prompt, state as OnboardState);
+					}
+					prompt.close();
+					return;
+				}
+			}
+
+			// Resume from firstIncomplete
+			if (effectiveUserType === "worker") {
+				await runWorkerFlow(prompt, state as OnboardState, firstIncomplete);
+			} else {
+				await runEmployerFlow(prompt, state as OnboardState);
+			}
+			prompt.close();
+			return;
+		}
+
+		if (effectiveUserType === "worker") {
 			await runWorkerFlow(prompt, state as OnboardState);
 		} else {
 			await runEmployerFlow(prompt, state as OnboardState);
@@ -282,7 +333,7 @@ async function handleEmailVerification(
 	prompt: Prompt,
 	baseUrl: string,
 	userType: "worker" | "employer"
-): Promise<{ email: string; apiKey: string; userId: string }> {
+): Promise<{ email: string; apiKey: string; userId: string; isReturningUser: boolean; userType?: string }> {
 	// Workers: 1) Account, 2) Tool Detection, 3) AI Accounts, 4) Domains, 5) GitHub, 6) LinkedIn, 7) Done
 	// Employers: 1) Account, 2) (skip verification), 3) Company, 4) Domain, 5) What You Need, 6) Done (stays at 6)
 	const totalSteps = userType === "employer" ? 6 : 7;
@@ -300,6 +351,8 @@ async function handleEmailVerification(
 	// Call register API
 	console.log(c.dim("\nSending verification code..."));
 	
+	let isReturningUser = false;
+
 	try {
 		await apiUnauthenticated(baseUrl, "POST", "/v1/auth/register", {
 			email,
@@ -307,37 +360,53 @@ async function handleEmailVerification(
 		});
 	} catch (err) {
 		if (err instanceof ApiError && err.status === 409) {
-			// Email already registered and verified
-			throw new Error(`This email is already registered. Run 'jobarbiter verify-email --email ${email}' if you need to re-verify, or use a different email.`);
+			// Email already registered — switch to login flow
+			isReturningUser = true;
+			console.log(`\n${sym.rocket} ${c.bold("Welcome back!")} Sending verification code...`);
+			try {
+				await apiUnauthenticated(baseUrl, "POST", "/v1/auth/login", { email });
+			} catch (loginErr) {
+				throw new Error("Could not send login verification code. Please try again later.");
+			}
+		} else {
+			throw err;
 		}
-		throw err;
 	}
 
-	console.log(`\n${sym.check} Verification code sent to ${c.highlight(email)}`);
+	if (!isReturningUser) {
+		console.log(`\n${sym.check} Verification code sent to ${c.highlight(email)}`);
+	} else {
+		console.log(`${sym.check} Verification code sent to ${c.highlight(email)}`);
+	}
 	console.log(c.dim("   (Check your inbox and spam folder. Code expires in 15 minutes.)\n"));
 
 	// Get verification code
 	let apiKey: string | undefined;
 	let userId: string | undefined;
+	let returnedUserType: string | undefined;
 	let attempts = 0;
 	const maxAttempts = 5;
+	const verifyEndpoint = isReturningUser ? "/v1/auth/verify-login" : "/v1/auth/verify";
 
 	while (attempts < maxAttempts) {
 		const code = await prompt.question(`Enter 6-digit code: `);
-		
+
 		if (!code || code.length !== 6) {
 			console.log(c.error("Code must be 6 digits"));
 			continue;
 		}
 
 		try {
-			const result = await apiUnauthenticated(baseUrl, "POST", "/v1/auth/verify", {
+			const result = await apiUnauthenticated(baseUrl, "POST", verifyEndpoint, {
 				email,
 				code: code.trim(),
 			});
 
 			apiKey = result.apiKey as string;
 			userId = result.id as string;
+			if (isReturningUser) {
+				returnedUserType = result.userType as string;
+			}
 			break;
 		} catch (err) {
 			attempts++;
@@ -358,9 +427,125 @@ async function handleEmailVerification(
 		throw new Error("Verification failed. Please try again.");
 	}
 
-	console.log(`\n${sym.check} ${c.success("Email verified! Account created.")}\n`);
+	if (isReturningUser) {
+		console.log(`\n${sym.check} ${c.success("Welcome back! Logged in successfully.")}\n`);
+	} else {
+		console.log(`\n${sym.check} ${c.success("Email verified! Account created.")}\n`);
+	}
+
+	return { email, apiKey, userId, isReturningUser, userType: returnedUserType };
+}
+
+// ── Returning User Progress ─────────────────────────────────────────────
 
-	return { email, apiKey, userId };
+interface OnboardProgress {
+	accountCreated: boolean;
+	userType: "worker" | "employer";
+	toolsDetected: string[];
+	aiAccountsConnected: boolean;
+	domainsSet: string[];
+	githubConnected: boolean;
+	linkedinConnected: boolean;
+	bio?: string;
+	githubUsername?: string;
+}
+
+async function fetchOnboardingProgress(config: Config): Promise<OnboardProgress> {
+	const progress: OnboardProgress = {
+		accountCreated: true,
+		userType: config.userType as "worker" | "employer",
+		toolsDetected: [],
+		aiAccountsConnected: false,
+		domainsSet: [],
+		githubConnected: false,
+		linkedinConnected: false,
+	};
+
+	// Fetch profile
+	try {
+		const profile = await api(config, "GET", "/v1/profile");
+		if (profile.domains && Array.isArray(profile.domains) && (profile.domains as string[]).length > 0) {
+			progress.domainsSet = profile.domains as string[];
+		}
+		if (profile.tools && typeof profile.tools === "object") {
+			const tools = profile.tools as Record<string, unknown>;
+			if (tools.primary && Array.isArray(tools.primary) && (tools.primary as string[]).length > 0) {
+				progress.toolsDetected = tools.primary as string[];
+			}
+		}
+		if (profile.bio) {
+			progress.bio = profile.bio as string;
+		}
+		if (profile.githubUsername) {
+			progress.githubConnected = true;
+			progress.githubUsername = profile.githubUsername as string;
+		}
+	} catch {
+		// Profile doesn't exist yet — that's fine
+	}
+
+	// Check AI accounts
+	const existingProviders = loadProviderKeys();
+	progress.aiAccountsConnected = existingProviders.length > 0;
+
+	// Check verification status (LinkedIn etc.)
+	try {
+		const verificationStatus = await api(config, "GET", "/v1/verification/status");
+		if (verificationStatus.linkedin) {
+			progress.linkedinConnected = true;
+		}
+	} catch {
+		// Endpoint may not exist — gracefully ignore
+	}
+
+	return progress;
+}
+
+function showReturningUserProgress(progress: OnboardProgress): { firstIncomplete: number } {
+	const isWorker = progress.userType === "worker";
+	const totalSteps = isWorker ? 7 : 6;
+
+	console.log(`${c.bold("Here's your onboarding progress:")}\n`);
+
+	if (isWorker) {
+		const steps: Array<{ done: boolean; label: string }> = [
+			{ done: true, label: `Account created (${progress.userType})` },
+			{ done: progress.toolsDetected.length > 0, label: progress.toolsDetected.length > 0
+				? `AI Tools detected (${progress.toolsDetected.join(", ")})`
+				: "AI Tools not detected" },
+			{ done: progress.aiAccountsConnected, label: progress.aiAccountsConnected
+				? "AI Accounts connected"
+				: "AI Accounts not connected" },
+			{ done: progress.domainsSet.length > 0, label: progress.domainsSet.length > 0
+				? `Domains set (${progress.domainsSet.join(", ")})`
+				: "Domains not set" },
+			{ done: progress.githubConnected, label: progress.githubConnected
+				? `GitHub connected (${progress.githubUsername})`
+				: "GitHub not connected" },
+			{ done: progress.linkedinConnected, label: progress.linkedinConnected
+				? "LinkedIn connected"
+				: "LinkedIn not connected" },
+			{ done: false, label: "Completion" },
+		];
+
+		let firstIncomplete = totalSteps; // default to last
+		for (let i = 0; i < steps.length; i++) {
+			const step = steps[i];
+			const icon = step.done ? sym.check : sym.cross;
+			console.log(`   ${icon} Step ${i + 1}/${totalSteps} — ${step.label}`);
+			if (!step.done && firstIncomplete === totalSteps) {
+				firstIncomplete = i + 1;
+			}
+		}
+		console.log();
+		return { firstIncomplete };
+	} else {
+		// Employer — simpler progress
+		console.log(`   ${sym.check} Step 1/6 — Account created (employer)`);
+		console.log(`   ${sym.cross} Step 2/6 — Remaining setup`);
+		console.log();
+		return { firstIncomplete: 2 };
+	}
 }
 
 // ── Worker Flow ────────────────────────────────────────────────────────
@@ -580,6 +765,24 @@ async function runToolDetectionStep(
 
 			if (result.installed.length > 0) {
 				console.log(`\n  ${sym.check} ${c.success(`${result.installed.length} observer${result.installed.length > 1 ? "s" : ""} installed!`)}`);
+
+				// Install background polling daemon
+				try {
+					installDaemon(7200);
+					console.log(`  ${sym.check} ${c.success("Background poller installed (every 2 hours)")}`);
+				} catch {
+					console.log(`  ${c.dim("Background poller skipped (install later: jobarbiter observe daemon install)")}`);
+				}
+
+				// Show poller-observable tools
+				const pollerTools = allTools.filter((t) => t.installed && t.observationMethod === "poller");
+				if (pollerTools.length > 0) {
+					console.log(`\n  ${c.bold("Poller will also scan these tools:")}`);
+					for (const t of pollerTools) {
+						console.log(`    ${sym.bullet} ${formatToolDisplay(t)}`);
+					}
+				}
+
 				console.log(`\n  ${c.bold("What happens now?")}`);
 			console.log(`  Observers activate each time you use your AI tools.`);
 			console.log(`  Just work normally — every session builds your profile.\n`);
@@ -588,6 +791,8 @@ async function runToolDetectionStep(
 			console.log(`  a work report to JobArbiter. Our agents interpret these reports`);
 			console.log(`  to build and evolve your narrative profile over time.`);
 			console.log(`  Raw session data never leaves your machine.\n`);
+
+			console.log(`  ${c.dim("Manage observers: jobarbiter observe --help")}`);
 			}
 		} else {
 			console.log(c.dim("\n  Skipped — you can install observers later with 'jobarbiter observe install'.\n"));

package/src/lib/poll-state.ts

@@ -0,0 +1,119 @@
+/**
+ * Poll State Management
+ *
+ * Read/write ~/.config/jobarbiter/observer/poll-state.json
+ * Tracks per-source poll times, known sessions, pause windows,
+ * disabled sources, and interval configuration.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// ── Types ──────────────────────────────────────────────────────────────
+
+export interface PauseWindow {
+	start: string; // ISO timestamp
+	end: string;   // ISO timestamp
+}
+
+export interface PollState {
+	version: number;
+	lastPoll: Record<string, string>; // source -> ISO timestamp
+	knownSessionIds: string[];        // rolling 1000
+	pauseWindows: PauseWindow[];
+	disabledSources: string[];
+	interval: number;                 // seconds
+}
+
+// ── Paths ──────────────────────────────────────────────────────────────
+
+const OBSERVER_DIR = join(homedir(), ".config", "jobarbiter", "observer");
+const POLL_STATE_FILE = join(OBSERVER_DIR, "poll-state.json");
+
+function defaultPollState(): PollState {
+	return {
+		version: 1,
+		lastPoll: {},
+		knownSessionIds: [],
+		pauseWindows: [],
+		disabledSources: [],
+		interval: 7200,
+	};
+}
+
+// ── Core Functions ─────────────────────────────────────────────────────
+
+export function loadPollState(): PollState {
+	try {
+		if (!existsSync(POLL_STATE_FILE)) return defaultPollState();
+		const raw = readFileSync(POLL_STATE_FILE, "utf-8");
+		const data = JSON.parse(raw) as Partial<PollState>;
+		return {
+			...defaultPollState(),
+			...data,
+		};
+	} catch {
+		return defaultPollState();
+	}
+}
+
+export function savePollState(state: PollState): void {
+	mkdirSync(OBSERVER_DIR, { recursive: true });
+	writeFileSync(POLL_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+
+export function addPauseWindow(start: string, end: string): void {
+	const state = loadPollState();
+	state.pauseWindows.push({ start, end });
+	// Keep last 50 windows
+	if (state.pauseWindows.length > 50) {
+		state.pauseWindows = state.pauseWindows.slice(-50);
+	}
+	savePollState(state);
+}
+
+export function isInPauseWindow(timestamp: string): boolean {
+	const state = loadPollState();
+	const ts = new Date(timestamp).getTime();
+	return state.pauseWindows.some((w) => {
+		const start = new Date(w.start).getTime();
+		const end = new Date(w.end).getTime();
+		return ts >= start && ts <= end;
+	});
+}
+
+export function addKnownSession(sessionId: string): void {
+	const state = loadPollState();
+	if (!state.knownSessionIds.includes(sessionId)) {
+		state.knownSessionIds.push(sessionId);
+		// Rolling window of 1000
+		if (state.knownSessionIds.length > 1000) {
+			state.knownSessionIds = state.knownSessionIds.slice(-1000);
+		}
+		savePollState(state);
+	}
+}
+
+export function isKnownSession(sessionId: string): boolean {
+	const state = loadPollState();
+	return state.knownSessionIds.includes(sessionId);
+}
+
+export function getDisabledSources(): string[] {
+	return loadPollState().disabledSources;
+}
+
+export function setDisabledSource(source: string): void {
+	const state = loadPollState();
+	if (!state.disabledSources.includes(source)) {
+		state.disabledSources.push(source);
+		savePollState(state);
+	}
+}
+
+export function removeDisabledSource(source: string): void {
+	const state = loadPollState();
+	state.disabledSources = state.disabledSources.filter((s) => s !== source);
+	savePollState(state);
+}