@kbve/droid 0.1.1 → 0.1.2

package/src/lib/agents/generated/discordsh-agents-schema.ts

@@ -0,0 +1,96 @@
+/**
+ * AUTO-GENERATED by proto-to-zod — DO NOT EDIT
+ *
+ * Source: ../descriptors/discordsh_agents.binpb
+ * Config: ../discordsh_agents-zod-config.json
+ * Generated: 2026-07-20T00:37:21.620Z
+ */
+
+import { z } from 'zod';
+
+// PendingEvent
+export const PendingEventSchema = z.object({
+	id: z.number(),
+	owner: z.string(),
+	repo: z.string(),
+	number: z.number(),
+	event_type: z.string(),
+	actor: z.string().nullish(),
+	delivery_state: z.number(),
+	delivery_attempts: z.number(),
+	created_at: z.string(),
+	claimed_at: z.string().nullish(),
+});
+
+export type PendingEvent = z.infer<typeof PendingEventSchema>;
+
+// FailedEvent
+export const FailedEventSchema = z.object({
+	id: z.number(),
+	owner: z.string(),
+	repo: z.string(),
+	number: z.number(),
+	event_type: z.string(),
+	actor: z.string().nullish(),
+	delivery_attempts: z.number(),
+	last_error: z.string().nullish(),
+	created_at: z.string(),
+	updated_at: z.string(),
+});
+
+export type FailedEvent = z.infer<typeof FailedEventSchema>;
+
+// EventQueueStats
+export const EventQueueStatsSchema = z.object({
+	last_delivered_at: z.string().nullish(),
+	last_recorded_at: z.string().nullish(),
+	pending_count: z.number(),
+	in_flight_count: z.number(),
+	delivered_count: z.number(),
+	failed_count: z.number(),
+	oldest_pending_at: z.string().nullish(),
+});
+
+export type EventQueueStats = z.infer<typeof EventQueueStatsSchema>;
+
+// WebhookDelivery
+export const WebhookDeliverySchema = z.object({
+	id: z.number(),
+	guid: z.string(),
+	delivered_at: z.string(),
+	redelivery: z.boolean(),
+	duration: z.number(),
+	status: z.string(),
+	status_code: z.number(),
+	event: z.string(),
+	action: z.string().nullish(),
+});
+
+export type WebhookDelivery = z.infer<typeof WebhookDeliverySchema>;
+
+// GithubRepoHook
+export const GithubRepoHookSchema = z.object({
+	id: z.number(),
+	name: z.string(),
+	active: z.boolean(),
+	events: z.array(z.string()),
+	url: z.string().nullish(),
+	is_kbve: z.boolean(),
+	updated_at: z.string(),
+});
+
+export type GithubRepoHook = z.infer<typeof GithubRepoHookSchema>;
+
+// DiscordshConfig
+export const DiscordshConfigSchema = z.object({
+	default_repo: z.string().optional(),
+	claim_channel_id: z.string().optional(),
+	forum_channel_id: z.string().optional(),
+	noticeboard_channel_id: z.string().optional(),
+	taskboard_channel_id: z.string().optional(),
+	max_assignees: z.number().optional(),
+	mirror_pr_events: z.boolean().optional(),
+	active: z.boolean().optional(),
+});
+
+export type DiscordshConfig = z.infer<typeof DiscordshConfigSchema>;

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

@@ -0,0 +1,126 @@
+import type { AgentsCtx } from '../ctx';
+import type { BackfillResult } from '../types';
+
+type Fail = { ok: false; error: string };
+
+export function makeBackfill(ctx: AgentsCtx) {
+	const { store, endpoints } = ctx;
+
+	function patchBackfillDraft(
+		guildId: string,
+		partial: Partial<{ owner: string; repo: string }>,
+	): void {
+		const drafts = store.$backfillDrafts.get();
+		const cur = drafts[guildId] ?? { owner: '', repo: '' };
+		store.$backfillDrafts.set({
+			...drafts,
+			[guildId]: { ...cur, ...partial },
+		});
+	}
+
+	function clearBackfillResult(guildId: string): void {
+		const m = { ...store.$backfillResults.get() };
+		delete m[guildId];
+		store.$backfillResults.set(m);
+	}
+
+	async function runBackfill(input: {
+		owner: string;
+		repo: string;
+		state?: 'open' | 'closed' | 'all';
+		maxPages?: number;
+		perPage?: number;
+	}): Promise<BackfillResult | Fail> {
+		const accessToken = store.$accessToken.get();
+		const guildId = store.$selectedGuildId.get();
+		if (!accessToken || !guildId) {
+			return { ok: false, error: 'No guild selected or session missing' };
+		}
+
+		try {
+			const resp = await fetch(endpoints.ghBackfill, {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${accessToken}`,
+				},
+				body: JSON.stringify({
+					owner: input.owner,
+					repo: input.repo,
+					guild_id: guildId,
+					state: input.state ?? 'open',
+					max_pages: input.maxPages ?? 1,
+					per_page: input.perPage ?? 30,
+				}),
+			});
+			const text = await resp.text();
+			let body: unknown;
+			try {
+				body = JSON.parse(text);
+			} catch {
+				return {
+					ok: false,
+					error: `HTTP ${resp.status}: ${text.slice(0, 200)}`,
+				};
+			}
+			if (!resp.ok) {
+				const errMsg =
+					(body as { error?: string } | null)?.error ??
+					`HTTP ${resp.status}`;
+				return { ok: false, error: errMsg };
+			}
+			const b = body as {
+				upserted?: number;
+				pages_walked?: number;
+				rate_limit_remaining?: number | null;
+			};
+			return {
+				ok: true,
+				upserted: b.upserted ?? 0,
+				pages: b.pages_walked ?? 0,
+				rateLimitRemaining: b.rate_limit_remaining ?? null,
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				error: e instanceof Error ? e.message : 'Network error',
+			};
+		}
+	}
+
+	async function runBackfillForGuild(guildId: string): Promise<void> {
+		const draft = store.$backfillDrafts.get()[guildId] ?? {
+			owner: '',
+			repo: '',
+		};
+		if (!draft.owner || !draft.repo) return;
+		store.$backfillBusyFor.set({
+			...store.$backfillBusyFor.get(),
+			[guildId]: true,
+		});
+		const resultsClear = { ...store.$backfillResults.get() };
+		delete resultsClear[guildId];
+		store.$backfillResults.set(resultsClear);
+		const r = await runBackfill({
+			owner: draft.owner,
+			repo: draft.repo,
+			state: 'open',
+			maxPages: 1,
+			perPage: 30,
+		});
+		const busyDone = { ...store.$backfillBusyFor.get() };
+		delete busyDone[guildId];
+		store.$backfillBusyFor.set(busyDone);
+		store.$backfillResults.set({
+			...store.$backfillResults.get(),
+			[guildId]: r,
+		});
+	}
+
+	return {
+		patchBackfillDraft,
+		clearBackfillResult,
+		runBackfill,
+		runBackfillForGuild,
+	};
+}

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

@@ -0,0 +1,131 @@
+import type { AgentsCtx } from '../ctx';
+import type { AgentsApi } from '../api-types';
+import {
+	EventQueueStatsSchema,
+	FailedEventSchema,
+	PendingEventSchema,
+} from '../generated/discordsh-agents-schema';
+import type {
+	EventQueueStats,
+	FailedEvent,
+	PendingEvent,
+	Result,
+} from '../types';
+
+export function makeEvents(ctx: AgentsCtx, api: AgentsApi) {
+	const { store, endpoints } = ctx;
+
+	async function loadEventStats(guildId: string): Promise<void> {
+		store.$eventStatsLoading.set({
+			...store.$eventStatsLoading.get(),
+			[guildId]: true,
+		});
+		const r = await ctx.callJson<EventQueueStats>(endpoints.ghAdmin, {
+			command: 'events.stats',
+			server_id: guildId,
+		});
+		const loading = { ...store.$eventStatsLoading.get() };
+		delete loading[guildId];
+		store.$eventStatsLoading.set(loading);
+		if (!r.ok) return;
+		const parsed = EventQueueStatsSchema.safeParse(r.data);
+		if (!parsed.success) return;
+		store.$eventStats.set({
+			...store.$eventStats.get(),
+			[guildId]: parsed.data,
+		});
+	}
+
+	async function loadFailedEvents(
+		guildId: string,
+		limit = 10,
+	): Promise<void> {
+		store.$failedEventsLoading.set({
+			...store.$failedEventsLoading.get(),
+			[guildId]: true,
+		});
+		const r = await ctx.callJson<{ events: FailedEvent[] }>(
+			endpoints.ghAdmin,
+			{ command: 'events.failed', server_id: guildId, limit },
+		);
+		const loading = { ...store.$failedEventsLoading.get() };
+		delete loading[guildId];
+		store.$failedEventsLoading.set(loading);
+		if (!r.ok) return;
+		const parsed = FailedEventSchema.array().safeParse(r.data.events ?? []);
+		if (!parsed.success) return;
+		store.$failedEvents.set({
+			...store.$failedEvents.get(),
+			[guildId]: parsed.data,
+		});
+	}
+
+	async function loadPendingEvents(
+		guildId: string,
+		limit = 10,
+	): Promise<void> {
+		store.$pendingEventsLoading.set({
+			...store.$pendingEventsLoading.get(),
+			[guildId]: true,
+		});
+		const r = await ctx.callJson<{ events: PendingEvent[] }>(
+			endpoints.ghAdmin,
+			{ command: 'events.pending', server_id: guildId, limit },
+		);
+		const loading = { ...store.$pendingEventsLoading.get() };
+		delete loading[guildId];
+		store.$pendingEventsLoading.set(loading);
+		if (!r.ok) return;
+		const parsed = PendingEventSchema.array().safeParse(
+			r.data.events ?? [],
+		);
+		if (!parsed.success) return;
+		store.$pendingEvents.set({
+			...store.$pendingEvents.get(),
+			[guildId]: parsed.data,
+		});
+	}
+
+	async function requeueEvent(
+		guildId: string,
+		eventId: number,
+		reason?: string,
+	): Promise<Result> {
+		const key = `${guildId}:${eventId}`;
+		store.$eventRequeueBusyFor.set({
+			...store.$eventRequeueBusyFor.get(),
+			[key]: true,
+		});
+		const trimmedReason =
+			typeof reason === 'string' && reason.trim().length > 0
+				? reason.trim().slice(0, 512)
+				: undefined;
+		const r = await ctx.callJson<{ requeued: boolean; event_id: number }>(
+			endpoints.ghAdmin,
+			{
+				command: 'events.requeue',
+				server_id: guildId,
+				event_id: eventId,
+				...(trimmedReason ? { reason: trimmedReason } : {}),
+			},
+		);
+		const busy = { ...store.$eventRequeueBusyFor.get() };
+		delete busy[key];
+		store.$eventRequeueBusyFor.set(busy);
+		if (!r.ok) return { ok: false, error: r.error };
+		const cur = store.$failedEvents.get()[guildId] ?? [];
+		store.$failedEvents.set({
+			...store.$failedEvents.get(),
+			[guildId]: cur.filter((e) => e.id !== eventId),
+		});
+		void api.loadEventStats(guildId);
+		return { ok: true };
+	}
+
+	return {
+		loadEventStats,
+		loadFailedEvents,
+		loadPendingEvents,
+		requeueEvent,
+	};
+}

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

@@ -0,0 +1,150 @@
+import type { AgentsCtx } from '../ctx';
+import type { AgentsApi } from '../api-types';
+import type { PatValidation, Result } from '../types';
+
+export function makePat(ctx: AgentsCtx, api: AgentsApi) {
+	const { store } = ctx;
+
+	function setPatDraft(guildId: string, pat: string): void {
+		store.$patDrafts.set({ ...store.$patDrafts.get(), [guildId]: pat });
+		const validated = { ...store.$patValidatedFor.get() };
+		if (validated[guildId]) {
+			delete validated[guildId];
+			store.$patValidatedFor.set(validated);
+		}
+	}
+
+	function clearPatState(guildId: string): void {
+		const drafts = { ...store.$patDrafts.get() };
+		delete drafts[guildId];
+		store.$patDrafts.set(drafts);
+		const validated = { ...store.$patValidatedFor.get() };
+		delete validated[guildId];
+		store.$patValidatedFor.set(validated);
+		const errs = { ...store.$patErrors.get() };
+		delete errs[guildId];
+		store.$patErrors.set(errs);
+	}
+
+	async function validateGithubPat(
+		pat: string,
+	): Promise<Result<PatValidation>> {
+		try {
+			const resp = await fetch('https://api.github.com/user', {
+				headers: {
+					Authorization: `Bearer ${pat}`,
+					Accept: 'application/vnd.github+json',
+					'X-GitHub-Api-Version': '2022-11-28',
+				},
+			});
+			if (resp.status === 401) {
+				return { ok: false, error: 'GitHub rejected the token (401).' };
+			}
+			if (!resp.ok) {
+				return {
+					ok: false,
+					error: `GitHub /user returned ${resp.status}.`,
+				};
+			}
+			const user = (await resp.json()) as { login?: string };
+			if (!user.login) {
+				return { ok: false, error: 'GitHub response missing login.' };
+			}
+			const scopesHeader = resp.headers.get('x-oauth-scopes') ?? '';
+			const tokenTypeHeader =
+				resp.headers.get('x-github-authentication-token-type') ??
+				resp.headers.get('x-github-token-type') ??
+				'unknown';
+			const scopes = scopesHeader
+				.split(',')
+				.map((s) => s.trim())
+				.filter(Boolean);
+			return {
+				ok: true,
+				login: user.login,
+				scopes,
+				tokenType: tokenTypeHeader,
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				error: e instanceof Error ? e.message : 'Network error',
+			};
+		}
+	}
+
+	async function validatePatForGuild(guildId: string): Promise<Result> {
+		const pat = store.$patDrafts.get()[guildId] ?? '';
+		if (!pat) return { ok: false, error: 'No PAT entered' };
+		store.$patValidatingFor.set({
+			...store.$patValidatingFor.get(),
+			[guildId]: true,
+		});
+		store.$patErrors.set({ ...store.$patErrors.get(), [guildId]: null });
+		const validatedClear = { ...store.$patValidatedFor.get() };
+		delete validatedClear[guildId];
+		store.$patValidatedFor.set(validatedClear);
+		const r = await validateGithubPat(pat);
+		const validatingDone = { ...store.$patValidatingFor.get() };
+		delete validatingDone[guildId];
+		store.$patValidatingFor.set(validatingDone);
+		if (!r.ok) {
+			store.$patErrors.set({
+				...store.$patErrors.get(),
+				[guildId]: r.error,
+			});
+			return r;
+		}
+		store.$patValidatedFor.set({
+			...store.$patValidatedFor.get(),
+			[guildId]: {
+				login: r.login,
+				scopes: r.scopes,
+				tokenType: r.tokenType,
+			},
+		});
+		return { ok: true };
+	}
+
+	async function savePatForGuild(
+		guildId: string,
+		tokenName: string,
+	): Promise<Result<{ tokenId: string }>> {
+		const pat = store.$patDrafts.get()[guildId] ?? '';
+		if (!pat) return { ok: false, error: 'No PAT entered' };
+		const validated = store.$patValidatedFor.get()[guildId] ?? null;
+		store.$patSavingFor.set({
+			...store.$patSavingFor.get(),
+			[guildId]: true,
+		});
+		store.$patErrors.set({ ...store.$patErrors.get(), [guildId]: null });
+		const r = await api.addToken({
+			tokenName,
+			service: 'github',
+			tokenValue: pat,
+			description: validated
+				? `GitHub PAT for ${validated.login}`
+				: 'GitHub PAT',
+		});
+		const savingDone = { ...store.$patSavingFor.get() };
+		delete savingDone[guildId];
+		store.$patSavingFor.set(savingDone);
+		if (r.ok) {
+			clearPatState(guildId);
+		} else {
+			store.$patErrors.set({
+				...store.$patErrors.get(),
+				[guildId]: r.error,
+			});
+		}
+		return r;
+	}
+
+	return {
+		setPatDraft,
+		clearPatState,
+		validateGithubPat,
+		validatePatForGuild,
+		savePatForGuild,
+	};
+}