@kbve/droid 0.0.6 → 0.1.2

package/src/lib/agents/github/repoConfig.ts

@@ -0,0 +1,240 @@
+import {
+	botConfigFromFormDraft,
+	botConfigToFormDraft,
+	emptyBotConfigFormDraft,
+} from '../formDrafts';
+import type { AgentsCtx } from '../ctx';
+import type { AgentsApi } from '../api-types';
+import type { BotConfigFormDraft, DiscordshConfig, Result } from '../types';
+
+export function makeRepoConfig(ctx: AgentsCtx, api: AgentsApi) {
+	const { store } = ctx;
+
+	async function getRepoAllowlist(): Promise<
+		Result<{ repos: string[]; raw: string | null }>
+	> {
+		const r = await api.peekToken('github_repos');
+		if (!r.ok) return { ok: false, error: r.error };
+		if (!r.value) return { ok: true, repos: [], raw: null };
+		try {
+			const parsed = JSON.parse(r.value) as { repos?: unknown };
+			const repos = Array.isArray(parsed.repos)
+				? parsed.repos.filter((x): x is string => typeof x === 'string')
+				: [];
+			return { ok: true, repos, raw: r.value };
+		} catch {
+			return { ok: true, repos: [], raw: r.value };
+		}
+	}
+
+	async function setRepoAllowlist(repos: string[]): Promise<Result> {
+		const r = await api.addToken({
+			tokenName: 'github-repos',
+			service: 'github_repos',
+			tokenValue: JSON.stringify({ repos }),
+			description:
+				'Per-guild repo allowlist consumed by gh-webhook and gh-backfill',
+		});
+		if (!r.ok) return { ok: false, error: r.error };
+		return { ok: true };
+	}
+
+	function hydrateRepoAllowlistDraft(guildId: string, repos: string[]): void {
+		store.$repoAllowlistDrafts.set({
+			...store.$repoAllowlistDrafts.get(),
+			[guildId]: repos,
+		});
+		store.$repoAllowlistLoadedFor.set({
+			...store.$repoAllowlistLoadedFor.get(),
+			[guildId]: true,
+		});
+	}
+
+	function patchRepoAllowlistDraft(guildId: string, repos: string[]): void {
+		store.$repoAllowlistDrafts.set({
+			...store.$repoAllowlistDrafts.get(),
+			[guildId]: repos,
+		});
+	}
+
+	function clearRepoAllowlistDraft(guildId: string): void {
+		const drafts = { ...store.$repoAllowlistDrafts.get() };
+		delete drafts[guildId];
+		store.$repoAllowlistDrafts.set(drafts);
+		const loaded = { ...store.$repoAllowlistLoadedFor.get() };
+		delete loaded[guildId];
+		store.$repoAllowlistLoadedFor.set(loaded);
+	}
+
+	async function ensureRepoAllowlistLoaded(
+		guildId: string,
+		force = false,
+	): Promise<Result> {
+		if (!force && store.$repoAllowlistLoadedFor.get()[guildId]) {
+			return { ok: true };
+		}
+		const r = await getRepoAllowlist();
+		if (!r.ok) {
+			store.$repoAllowlistErrors.set({
+				...store.$repoAllowlistErrors.get(),
+				[guildId]: r.error,
+			});
+			return r;
+		}
+		hydrateRepoAllowlistDraft(guildId, r.repos);
+		store.$repoAllowlistErrors.set({
+			...store.$repoAllowlistErrors.get(),
+			[guildId]: null,
+		});
+		return { ok: true };
+	}
+
+	async function saveRepoAllowlistDraft(guildId: string): Promise<Result> {
+		const repos = store.$repoAllowlistDrafts.get()[guildId];
+		if (!repos) return { ok: false, error: 'No draft loaded yet' };
+		store.$repoAllowlistSavingFor.set({
+			...store.$repoAllowlistSavingFor.get(),
+			[guildId]: true,
+		});
+		store.$repoAllowlistErrors.set({
+			...store.$repoAllowlistErrors.get(),
+			[guildId]: null,
+		});
+		const r = await setRepoAllowlist(repos);
+		const savingDone = { ...store.$repoAllowlistSavingFor.get() };
+		delete savingDone[guildId];
+		store.$repoAllowlistSavingFor.set(savingDone);
+		if (!r.ok) {
+			store.$repoAllowlistErrors.set({
+				...store.$repoAllowlistErrors.get(),
+				[guildId]: r.error,
+			});
+		}
+		return r;
+	}
+
+	async function getBotConfig(): Promise<
+		Result<{ config: DiscordshConfig }>
+	> {
+		const r = await api.peekToken('discordsh_config');
+		if (!r.ok) return { ok: false, error: r.error };
+		if (!r.value) return { ok: true, config: {} };
+		try {
+			const parsed = JSON.parse(r.value) as Record<string, unknown>;
+			return { ok: true, config: parsed as DiscordshConfig };
+		} catch {
+			return { ok: true, config: {} };
+		}
+	}
+
+	async function setBotConfig(config: DiscordshConfig): Promise<Result> {
+		const r = await api.addToken({
+			tokenName: 'discordsh-config',
+			service: 'discordsh_config',
+			tokenValue: JSON.stringify(config),
+			description:
+				'Per-guild DiscordSH bot config (channels, defaults, toggles)',
+		});
+		if (!r.ok) return { ok: false, error: r.error };
+		return { ok: true };
+	}
+
+	function hydrateBotConfigDraft(
+		guildId: string,
+		cfg: DiscordshConfig,
+	): void {
+		store.$botConfigDrafts.set({
+			...store.$botConfigDrafts.get(),
+			[guildId]: botConfigToFormDraft(cfg),
+		});
+		store.$botConfigLoadedFor.set({
+			...store.$botConfigLoadedFor.get(),
+			[guildId]: true,
+		});
+	}
+
+	function patchBotConfigDraft(
+		guildId: string,
+		patch: Partial<BotConfigFormDraft>,
+	): void {
+		const drafts = store.$botConfigDrafts.get();
+		const cur = drafts[guildId] ?? emptyBotConfigFormDraft();
+		store.$botConfigDrafts.set({
+			...drafts,
+			[guildId]: { ...cur, ...patch },
+		});
+	}
+
+	function clearBotConfigDraft(guildId: string): void {
+		const drafts = { ...store.$botConfigDrafts.get() };
+		delete drafts[guildId];
+		store.$botConfigDrafts.set(drafts);
+		const loaded = { ...store.$botConfigLoadedFor.get() };
+		delete loaded[guildId];
+		store.$botConfigLoadedFor.set(loaded);
+	}
+
+	async function ensureBotConfigLoaded(
+		guildId: string,
+		force = false,
+	): Promise<Result> {
+		if (!force && store.$botConfigLoadedFor.get()[guildId]) {
+			return { ok: true };
+		}
+		const r = await getBotConfig();
+		if (!r.ok) {
+			store.$botConfigErrors.set({
+				...store.$botConfigErrors.get(),
+				[guildId]: r.error,
+			});
+			return r;
+		}
+		hydrateBotConfigDraft(guildId, r.config);
+		store.$botConfigErrors.set({
+			...store.$botConfigErrors.get(),
+			[guildId]: null,
+		});
+		return { ok: true };
+	}
+
+	async function saveBotConfigDraft(guildId: string): Promise<Result> {
+		const draft = store.$botConfigDrafts.get()[guildId];
+		if (!draft) return { ok: false, error: 'No draft loaded yet' };
+		store.$botConfigSavingFor.set({
+			...store.$botConfigSavingFor.get(),
+			[guildId]: true,
+		});
+		store.$botConfigErrors.set({
+			...store.$botConfigErrors.get(),
+			[guildId]: null,
+		});
+		const r = await setBotConfig(botConfigFromFormDraft(draft));
+		const savingDone = { ...store.$botConfigSavingFor.get() };
+		delete savingDone[guildId];
+		store.$botConfigSavingFor.set(savingDone);
+		if (!r.ok) {
+			store.$botConfigErrors.set({
+				...store.$botConfigErrors.get(),
+				[guildId]: r.error,
+			});
+		}
+		return r;
+	}
+
+	return {
+		getRepoAllowlist,
+		setRepoAllowlist,
+		hydrateRepoAllowlistDraft,
+		patchRepoAllowlistDraft,
+		clearRepoAllowlistDraft,
+		ensureRepoAllowlistLoaded,
+		saveRepoAllowlistDraft,
+		getBotConfig,
+		setBotConfig,
+		hydrateBotConfigDraft,
+		patchBotConfigDraft,
+		clearBotConfigDraft,
+		ensureBotConfigLoaded,
+		saveBotConfigDraft,
+	};
+}

package/src/lib/agents/github/tokens.ts

@@ -0,0 +1,222 @@
+import { loadCachedTokens, saveCachedTokens } from '../cache';
+import type { AgentsCtx } from '../ctx';
+import type { AgentsApi } from '../api-types';
+import {
+	AgentTokenRowSchema,
+	type TokenServiceValue,
+} from '../generated/agents-schema';
+import type { AgentTokenRow, Result } from '../types';
+
+export function makeTokens(ctx: AgentsCtx, api: AgentsApi) {
+	const { store, config, endpoints, runtime } = ctx;
+
+	async function loadTokens(guildId: string, force = false): Promise<void> {
+		const accessToken = store.$accessToken.get();
+		if (!accessToken) return;
+
+		const userId = store.$userId.get();
+
+		if (!force && userId) {
+			const cached = loadCachedTokens(userId, guildId);
+			if (cached) {
+				store.$tokens.set(cached);
+				store.$tokensError.set(null);
+				return;
+			}
+		}
+
+		const existing = runtime.tokensInflight.get(guildId);
+		if (!force && existing) return existing;
+
+		const prevAbort = runtime.tokensAbort.get(guildId);
+		if (prevAbort) prevAbort.abort();
+		const abort = new AbortController();
+		runtime.tokensAbort.set(guildId, abort);
+
+		store.$tokensLoading.set(true);
+		store.$tokensError.set(null);
+
+		const promise = (async () => {
+			try {
+				const resp = await fetch(endpoints.guildVault, {
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						Authorization: `Bearer ${accessToken}`,
+					},
+					body: JSON.stringify({
+						command: 'tokens.list_tokens',
+						server_id: guildId,
+					}),
+					signal: abort.signal,
+				});
+
+				const text = await resp.text();
+				let body: unknown;
+				try {
+					body = JSON.parse(text);
+				} catch {
+					store.$tokensError.set(
+						`HTTP ${resp.status}: ${text.slice(0, 200)}`,
+					);
+					return;
+				}
+
+				if (!resp.ok) {
+					const errMsg =
+						(body as { error?: string } | null)?.error ??
+						`HTTP ${resp.status}`;
+					store.$tokensError.set(errMsg);
+					return;
+				}
+
+				const rawRows =
+					(body as { tokens?: unknown } | null)?.tokens ?? [];
+				const parsed = AgentTokenRowSchema.array().safeParse(rawRows);
+				if (!parsed.success) {
+					store.$tokensError.set(
+						'Token list failed schema validation',
+					);
+					return;
+				}
+				const rows = parsed.data;
+				store.$tokens.set(rows);
+				if (userId) saveCachedTokens(userId, guildId, rows);
+			} catch (e) {
+				if (e instanceof DOMException && e.name === 'AbortError') {
+					return;
+				}
+				store.$tokensError.set(
+					e instanceof Error ? e.message : 'Failed to load tokens',
+				);
+			} finally {
+				store.$tokensLoading.set(false);
+				runtime.tokensInflight.delete(guildId);
+				if (runtime.tokensAbort.get(guildId) === abort) {
+					runtime.tokensAbort.delete(guildId);
+				}
+			}
+		})();
+
+		runtime.tokensInflight.set(guildId, promise);
+		return promise;
+	}
+
+	async function addToken(input: {
+		tokenName: string;
+		service: TokenServiceValue;
+		tokenValue: string;
+		description?: string | null;
+	}): Promise<Result<{ tokenId: string }>> {
+		const guildId = store.$selectedGuildId.get();
+		const accessToken = store.$accessToken.get();
+		if (!guildId || !accessToken) {
+			return { ok: false, error: 'No guild selected or session missing' };
+		}
+
+		const resp = await ctx.callGuildVault('tokens.set_token', accessToken, {
+			server_id: guildId,
+			token_name: input.tokenName,
+			service: input.service,
+			token_value: input.tokenValue,
+			description: input.description ?? null,
+		});
+
+		if (!resp.ok) return { ok: false, error: resp.error };
+		const tokenId =
+			(resp.body as { token_id?: string } | null)?.token_id ?? '';
+		await api.refreshSelectedGuild();
+		config.notify({
+			message: `Token "${input.tokenName}" registered.`,
+			severity: 'success',
+			duration: 3500,
+		});
+		return { ok: true, tokenId };
+	}
+
+	async function deleteToken(tokenId: string): Promise<Result> {
+		const guildId = store.$selectedGuildId.get();
+		const accessToken = store.$accessToken.get();
+		if (!guildId || !accessToken) {
+			return { ok: false, error: 'No guild selected or session missing' };
+		}
+
+		const resp = await ctx.callGuildVault(
+			'tokens.delete_token',
+			accessToken,
+			{ server_id: guildId, token_id: tokenId },
+		);
+
+		if (!resp.ok) return { ok: false, error: resp.error };
+		await api.refreshSelectedGuild();
+		config.notify({
+			message: 'Token deleted.',
+			severity: 'success',
+			duration: 3500,
+		});
+		return { ok: true };
+	}
+
+	async function peekToken(
+		service: TokenServiceValue,
+	): Promise<Result<{ value: string | null }>> {
+		const guildId = store.$selectedGuildId.get();
+		const accessToken = store.$accessToken.get();
+		if (!guildId || !accessToken) {
+			return { ok: false, error: 'No guild selected or session missing' };
+		}
+
+		const resp = await ctx.callGuildVault(
+			'tokens.peek_token',
+			accessToken,
+			{
+				server_id: guildId,
+				service,
+			},
+		);
+
+		if (!resp.ok) return { ok: false, error: resp.error };
+		const value =
+			(resp.body as { value?: string | null } | null)?.value ?? null;
+		return { ok: true, value };
+	}
+
+	async function toggleToken(
+		tokenId: string,
+		isActive: boolean,
+	): Promise<Result> {
+		const guildId = store.$selectedGuildId.get();
+		const accessToken = store.$accessToken.get();
+		if (!guildId || !accessToken) {
+			return { ok: false, error: 'No guild selected or session missing' };
+		}
+
+		const resp = await ctx.callGuildVault(
+			'tokens.toggle_token',
+			accessToken,
+			{ server_id: guildId, token_id: tokenId, is_active: isActive },
+		);
+
+		if (!resp.ok) return { ok: false, error: resp.error };
+		await api.refreshSelectedGuild();
+		return { ok: true };
+	}
+
+	function hasService(service: TokenServiceValue): AgentTokenRow | null {
+		const tokens = store.$tokens.get();
+		return (
+			tokens.find((t) => t.service === service && t.is_active) ??
+			tokens.find((t) => t.service === service) ??
+			null
+		);
+	}
+
+	return {
+		loadTokens,
+		addToken,
+		deleteToken,
+		peekToken,
+		toggleToken,
+		hasService,
+	};
+}