@kbve/droid 0.0.6 → 0.1.2

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

@@ -0,0 +1,155 @@
+/**
+ * AUTO-GENERATED by proto-to-zod — DO NOT EDIT
+ *
+ * Source: ../descriptors/agents.binpb
+ * Config: ../agents-zod-config.json
+ * Generated: 2026-07-20T00:37:21.617Z
+ */
+
+import { z } from 'zod';
+
+export const TokenServices = [
+	'github_webhook',
+	'github',
+	'github_repos',
+	'discordsh_config',
+] as const;
+
+export type TokenServiceValue = (typeof TokenServices)[number];
+
+export const TokenServiceSchema = z.enum(TokenServices);
+
+// PeekTokenResponse
+export const PeekTokenResponseSchema = z.object({
+	value: z.string().optional(),
+});
+
+export type PeekTokenResponse = z.infer<typeof PeekTokenResponseSchema>;
+
+// PeekTokenRequest
+export const PeekTokenRequestSchema = z.object({
+	server_id: z
+		.string()
+		.regex(
+			/^\d{17,20}$/,
+			'Must be a valid Discord snowflake (17-20 digits)',
+		),
+	service: z
+		.string()
+		.regex(
+			/^[a-z0-9_]{2,32}$/,
+			'Service must be 2-32 chars: lowercase a-z, 0-9, underscore',
+		),
+});
+
+export type PeekTokenRequest = z.infer<typeof PeekTokenRequestSchema>;
+
+// ToggleTokenRequest
+export const ToggleTokenRequestSchema = z.object({
+	server_id: z
+		.string()
+		.regex(
+			/^\d{17,20}$/,
+			'Must be a valid Discord snowflake (17-20 digits)',
+		),
+	token_id: z
+		.string()
+		.regex(
+			/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+			'token_id must be a UUID',
+		),
+	is_active: z.boolean(),
+});
+
+export type ToggleTokenRequest = z.infer<typeof ToggleTokenRequestSchema>;
+
+// DeleteTokenRequest
+export const DeleteTokenRequestSchema = z.object({
+	server_id: z
+		.string()
+		.regex(
+			/^\d{17,20}$/,
+			'Must be a valid Discord snowflake (17-20 digits)',
+		),
+	token_id: z
+		.string()
+		.regex(
+			/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+			'token_id must be a UUID',
+		),
+});
+
+export type DeleteTokenRequest = z.infer<typeof DeleteTokenRequestSchema>;
+
+// AgentTokenRow
+export const AgentTokenRowSchema = z.object({
+	token_id: z.string(),
+	token_name: z.string(),
+	service: z.string(),
+	description: z.string().nullish(),
+	is_active: z.boolean(),
+	created_at: z.string(),
+	updated_at: z.string().nullish(),
+});
+
+export type AgentTokenRow = z.infer<typeof AgentTokenRowSchema>;
+
+// ListTokensResponse
+export const ListTokensResponseSchema = z.object({
+	tokens: z.array(AgentTokenRowSchema).optional(),
+});
+
+export type ListTokensResponse = z.infer<typeof ListTokensResponseSchema>;
+
+// ListTokensRequest
+export const ListTokensRequestSchema = z.object({
+	server_id: z
+		.string()
+		.regex(
+			/^\d{17,20}$/,
+			'Must be a valid Discord snowflake (17-20 digits)',
+		),
+});
+
+export type ListTokensRequest = z.infer<typeof ListTokensRequestSchema>;
+
+// SetTokenRequest
+export const SetTokenRequestSchema = z.object({
+	server_id: z
+		.string()
+		.regex(
+			/^\d{17,20}$/,
+			'Must be a valid Discord snowflake (17-20 digits)',
+		),
+	service: z
+		.string()
+		.regex(
+			/^[a-z0-9_]{2,32}$/,
+			'Service must be 2-32 chars: lowercase a-z, 0-9, underscore',
+		),
+	token_name: z
+		.string()
+		.regex(
+			/^[a-z0-9_-]{3,64}$/,
+			'Token name must be 3-64 lowercase chars: a-z, 0-9, underscore, dash',
+		),
+	token_value: z
+		.string()
+		.min(10, 'Token value must be 10-8000 characters')
+		.max(8000, 'Token value must be 10-8000 characters'),
+	description: z.string().optional(),
+});
+
+export type SetTokenRequest = z.infer<typeof SetTokenRequestSchema>;
+
+// AgentError
+export const AgentErrorSchema = z.object({
+	success: z.boolean(),
+	message: z.string(),
+	code: z.number(),
+	sqlstate: z.string().optional(),
+	hint: z.string().optional(),
+	context: z.string().optional(),
+});
+
+export type AgentError = z.infer<typeof AgentErrorSchema>;

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,
+	};
+}