@keystrokehq/sentry 0.0.1

package/dist/events.mjs

@@ -0,0 +1,142 @@
+import { sentryActorSchema, sentryJsonObjectSchema } from "./schemas.mjs";
+import { z } from "zod";
+
+//#region src/events.ts
+/**
+* Sentry integration-platform webhook payload schemas.
+*
+* Every payload follows the same envelope:
+*   { action, installation: { uuid }, data: {...}, actor: {...} }
+*
+* `action` names the specific event within a resource family; the resource
+* family itself is conveyed via the `Sentry-Hook-Resource` header which the
+* trigger dispatcher uses for routing. We parse with top-level strictness
+* and allow `.passthrough()` on nested payload objects to tolerate field
+* additions by Sentry without forcing a schema rev.
+*/
+const sentryInstallationRefSchema = z.object({ uuid: z.string().min(1) }).passthrough();
+function envelope(action, dataSchema) {
+	return z.object({
+		action: z.literal(action),
+		installation: sentryInstallationRefSchema,
+		data: dataSchema,
+		actor: sentryActorSchema.optional()
+	}).passthrough();
+}
+const sentryIssueWebhookDataSchema = z.object({ issue: z.object({
+	id: z.string().min(1),
+	shortId: z.string().optional(),
+	title: z.string().optional(),
+	culprit: z.string().nullable().optional(),
+	project: sentryJsonObjectSchema.optional(),
+	status: z.string().optional(),
+	level: z.string().optional(),
+	platform: z.string().nullable().optional(),
+	url: z.string().url().optional(),
+	web_url: z.string().url().optional()
+}).passthrough() }).passthrough();
+const sentryIssueCreatedEventSchema = envelope("created", sentryIssueWebhookDataSchema);
+const sentryIssueResolvedEventSchema = envelope("resolved", sentryIssueWebhookDataSchema);
+const sentryIssueAssignedEventSchema = envelope("assigned", sentryIssueWebhookDataSchema);
+const sentryIssueUnresolvedEventSchema = envelope("unresolved", sentryIssueWebhookDataSchema);
+const sentryIssueIgnoredEventSchema = envelope("ignored", sentryIssueWebhookDataSchema);
+const sentryIssueArchivedEventSchema = envelope("archived", sentryIssueWebhookDataSchema);
+const sentryInstallationWebhookDataSchema = z.object({ installation: z.object({
+	uuid: z.string().min(1),
+	status: z.string().optional(),
+	organization: sentryJsonObjectSchema.optional(),
+	app: sentryJsonObjectSchema.optional()
+}).passthrough() }).passthrough();
+const sentryInstallationCreatedEventSchema = envelope("created", sentryInstallationWebhookDataSchema);
+const sentryInstallationDeletedEventSchema = envelope("deleted", sentryInstallationWebhookDataSchema);
+const sentryErrorWebhookDataSchema = z.object({ error: z.object({
+	event_id: z.string().optional(),
+	project: z.union([z.string(), z.number()]).optional(),
+	issue_id: z.string().optional(),
+	title: z.string().optional(),
+	message: z.string().optional(),
+	datetime: z.string().optional(),
+	web_url: z.string().url().optional()
+}).passthrough() }).passthrough();
+const sentryErrorCreatedEventSchema = envelope("created", sentryErrorWebhookDataSchema);
+const sentryCommentWebhookDataSchema = z.object({
+	comment_id: z.union([z.string(), z.number()]).optional(),
+	comment: z.string().optional(),
+	issue_id: z.union([z.string(), z.number()]).optional(),
+	project_slug: z.string().optional(),
+	timestamp: z.string().optional()
+}).passthrough();
+const sentryCommentCreatedEventSchema = envelope("created", sentryCommentWebhookDataSchema);
+const sentryCommentUpdatedEventSchema = envelope("updated", sentryCommentWebhookDataSchema);
+const sentryCommentDeletedEventSchema = envelope("deleted", sentryCommentWebhookDataSchema);
+const sentryEventAlertWebhookDataSchema = z.object({
+	event: sentryJsonObjectSchema.optional(),
+	triggered_rule: z.string().optional(),
+	issue_alert: sentryJsonObjectSchema.optional(),
+	issue_id: z.union([z.string(), z.number()]).optional()
+}).passthrough();
+const sentryEventAlertTriggeredEventSchema = envelope("triggered", sentryEventAlertWebhookDataSchema);
+const sentryMetricAlertWebhookDataSchema = z.object({
+	metric_alert: z.object({
+		id: z.union([z.string(), z.number()]),
+		identifier: z.string().optional(),
+		status: z.string().optional(),
+		title: z.string().optional()
+	}).passthrough(),
+	description_text: z.string().optional(),
+	description_title: z.string().optional(),
+	web_url: z.string().url().optional()
+}).passthrough();
+const sentryMetricAlertCriticalEventSchema = envelope("critical", sentryMetricAlertWebhookDataSchema);
+const sentryMetricAlertWarningEventSchema = envelope("warning", sentryMetricAlertWebhookDataSchema);
+const sentryMetricAlertResolvedEventSchema = envelope("resolved", sentryMetricAlertWebhookDataSchema);
+const sentrySeerCommonDataSchema = z.object({
+	run_id: z.number(),
+	group_id: z.number()
+}).passthrough();
+const sentrySeerRootCauseCompletedDataSchema = sentrySeerCommonDataSchema.extend({ root_cause: sentryJsonObjectSchema.optional() });
+const sentrySeerSolutionCompletedDataSchema = sentrySeerCommonDataSchema.extend({ solution: sentryJsonObjectSchema.optional() });
+const sentrySeerCodingCompletedDataSchema = sentrySeerCommonDataSchema.extend({ changes: z.array(sentryJsonObjectSchema).optional() });
+const sentrySeerPrCreatedDataSchema = sentrySeerCommonDataSchema.extend({ pull_requests: z.array(sentryJsonObjectSchema).optional() });
+const sentrySeerRootCauseStartedEventSchema = envelope("root_cause_started", sentrySeerCommonDataSchema);
+const sentrySeerRootCauseCompletedEventSchema = envelope("root_cause_completed", sentrySeerRootCauseCompletedDataSchema);
+const sentrySeerSolutionStartedEventSchema = envelope("solution_started", sentrySeerCommonDataSchema);
+const sentrySeerSolutionCompletedEventSchema = envelope("solution_completed", sentrySeerSolutionCompletedDataSchema);
+const sentrySeerCodingStartedEventSchema = envelope("coding_started", sentrySeerCommonDataSchema);
+const sentrySeerCodingCompletedEventSchema = envelope("coding_completed", sentrySeerCodingCompletedDataSchema);
+const sentrySeerPrCreatedEventSchema = envelope("pr_created", sentrySeerPrCreatedDataSchema);
+const sentryPreprodArtifactCommonDataSchema = z.object({
+	buildId: z.string().min(1),
+	organizationSlug: z.string().optional(),
+	projectSlug: z.string().optional(),
+	platform: z.string().nullable().optional(),
+	state: z.enum(["COMPLETED", "FAILED"]),
+	appInfo: sentryJsonObjectSchema.optional(),
+	gitInfo: sentryJsonObjectSchema.nullable().optional(),
+	errorCode: z.string().nullable().optional(),
+	errorMessage: z.string().nullable().optional()
+}).passthrough();
+const sentryPreprodArtifactSizeAnalysisCompletedEventSchema = envelope("size_analysis_completed", sentryPreprodArtifactCommonDataSchema);
+const sentryPreprodArtifactBuildDistributionCompletedEventSchema = envelope("build_distribution_completed", sentryPreprodArtifactCommonDataSchema);
+/**
+* Legacy per-project service hooks deliver a simpler envelope that omits the
+* `installation` object because the hook is not installed as an
+* integration. We accept both `data.event_id` (pre-2022 shape) and
+* `event_id` at the top level (newer shape).
+*/
+const sentryServiceHookEventAlertSchema = z.object({
+	action: z.string(),
+	project: z.string().optional(),
+	project_name: z.string().optional(),
+	event: sentryJsonObjectSchema.optional(),
+	data: sentryJsonObjectSchema.optional(),
+	triggered_rule: z.string().optional(),
+	event_id: z.string().optional()
+}).passthrough();
+const sentryDiscoverEventsPollResponseSchema = z.object({
+	data: z.array(sentryJsonObjectSchema),
+	meta: sentryJsonObjectSchema.optional()
+}).passthrough();
+
+//#endregion
+export { sentryCommentCreatedEventSchema, sentryCommentDeletedEventSchema, sentryCommentUpdatedEventSchema, sentryCommentWebhookDataSchema, sentryDiscoverEventsPollResponseSchema, sentryErrorCreatedEventSchema, sentryErrorWebhookDataSchema, sentryEventAlertTriggeredEventSchema, sentryEventAlertWebhookDataSchema, sentryInstallationCreatedEventSchema, sentryInstallationDeletedEventSchema, sentryInstallationRefSchema, sentryInstallationWebhookDataSchema, sentryIssueArchivedEventSchema, sentryIssueAssignedEventSchema, sentryIssueCreatedEventSchema, sentryIssueIgnoredEventSchema, sentryIssueResolvedEventSchema, sentryIssueUnresolvedEventSchema, sentryIssueWebhookDataSchema, sentryMetricAlertCriticalEventSchema, sentryMetricAlertResolvedEventSchema, sentryMetricAlertWarningEventSchema, sentryMetricAlertWebhookDataSchema, sentryPreprodArtifactBuildDistributionCompletedEventSchema, sentryPreprodArtifactCommonDataSchema, sentryPreprodArtifactSizeAnalysisCompletedEventSchema, sentrySeerCodingCompletedDataSchema, sentrySeerCodingCompletedEventSchema, sentrySeerCodingStartedEventSchema, sentrySeerCommonDataSchema, sentrySeerPrCreatedDataSchema, sentrySeerPrCreatedEventSchema, sentrySeerRootCauseCompletedDataSchema, sentrySeerRootCauseCompletedEventSchema, sentrySeerRootCauseStartedEventSchema, sentrySeerSolutionCompletedDataSchema, sentrySeerSolutionCompletedEventSchema, sentrySeerSolutionStartedEventSchema, sentryServiceHookEventAlertSchema };

package/dist/feedback.d.mts

@@ -0,0 +1,99 @@
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import { z } from "zod";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/feedback.d.ts
+declare const retrieveUserFeedbackForProject: _keystrokehq_core0.Operation<z.ZodObject<{
+  cursor: z.ZodOptional<z.ZodString>;
+  per_page: z.ZodOptional<z.ZodNumber>;
+  query: z.ZodOptional<z.ZodString>;
+  organization_slug: z.ZodOptional<z.ZodString>;
+  project_slug: z.ZodString;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  event_id: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  email: z.ZodOptional<z.ZodString>;
+  comments: z.ZodOptional<z.ZodString>;
+  dateCreated: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$loose>>, readonly [_keystrokehq_core0.CredentialSet<"sentry", z.ZodObject<{
+  SENTRY_ACCESS_TOKEN: z.ZodString;
+  SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+  SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENTRY_ACCESS_TOKEN: z.ZodString;
+  SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+  SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const submitProjectUserFeedback: _keystrokehq_core0.Operation<z.ZodObject<{
+  organization_slug: z.ZodOptional<z.ZodString>;
+  project_slug: z.ZodString;
+  event_id: z.ZodString;
+  name: z.ZodString;
+  email: z.ZodString;
+  comments: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  event_id: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  email: z.ZodOptional<z.ZodString>;
+  comments: z.ZodOptional<z.ZodString>;
+  dateCreated: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$loose>, readonly [_keystrokehq_core0.CredentialSet<"sentry", z.ZodObject<{
+  SENTRY_ACCESS_TOKEN: z.ZodString;
+  SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+  SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENTRY_ACCESS_TOKEN: z.ZodString;
+  SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+  SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const sentryFeedbackOperations: {
+  readonly retrieveUserFeedbackForProject: _keystrokehq_core0.Operation<z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+    query: z.ZodOptional<z.ZodString>;
+    organization_slug: z.ZodOptional<z.ZodString>;
+    project_slug: z.ZodString;
+  }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    event_id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    comments: z.ZodOptional<z.ZodString>;
+    dateCreated: z.ZodOptional<z.ZodISODateTime>;
+  }, z.core.$loose>>, readonly [_keystrokehq_core0.CredentialSet<"sentry", z.ZodObject<{
+    SENTRY_ACCESS_TOKEN: z.ZodString;
+    SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+    SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+    SENTRY_ACCESS_TOKEN: z.ZodString;
+    SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+    SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>[] | undefined>], undefined>;
+  readonly submitProjectUserFeedback: _keystrokehq_core0.Operation<z.ZodObject<{
+    organization_slug: z.ZodOptional<z.ZodString>;
+    project_slug: z.ZodString;
+    event_id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+    comments: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    event_id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    comments: z.ZodOptional<z.ZodString>;
+    dateCreated: z.ZodOptional<z.ZodISODateTime>;
+  }, z.core.$loose>, readonly [_keystrokehq_core0.CredentialSet<"sentry", z.ZodObject<{
+    SENTRY_ACCESS_TOKEN: z.ZodString;
+    SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+    SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+    SENTRY_ACCESS_TOKEN: z.ZodString;
+    SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+    SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>[] | undefined>], undefined>;
+};
+//#endregion
+export { retrieveUserFeedbackForProject, sentryFeedbackOperations, submitProjectUserFeedback };

package/dist/feedback.mjs

@@ -0,0 +1,63 @@
+import { orgProjectScopeInputSchema, sentryFeedbackSchema, sentryIdSchema, sentryListInputSchema } from "./schemas.mjs";
+import { t as defineSentryEndpoint } from "./endpoint-factory-BwjbcPwW.mjs";
+import { t as SENTRY_SCOPE } from "./scopes-RRU0vt-a.mjs";
+import { z } from "zod";
+
+//#region src/feedback.ts
+/**
+* Sentry user-feedback operations. Maps to PLAN.md §6.18 (2 actions).
+*/
+const ORG_PROJECT = [{
+	name: "organization_slug",
+	placeholder: "{organization_slug}"
+}, {
+	name: "project_slug",
+	placeholder: "{project_slug}"
+}];
+const retrieveUserFeedbackForProject = defineSentryEndpoint({
+	id: "retrieve_user_feedback_for_project",
+	name: "List User Feedback",
+	description: "List user feedback submissions for a project.",
+	method: "GET",
+	path: "/api/0/projects/{organization_slug}/{project_slug}/user-feedback/",
+	pathParams: ORG_PROJECT,
+	input: sentryListInputSchema.merge(orgProjectScopeInputSchema),
+	queryFields: [
+		"cursor",
+		"per_page",
+		"query"
+	],
+	output: z.array(sentryFeedbackSchema),
+	pagination: "cursor",
+	requiredOAuthScopes: [...SENTRY_SCOPE.projectRead]
+});
+const submitProjectUserFeedback = defineSentryEndpoint({
+	id: "submit_project_user_feedback",
+	name: "Submit User Feedback",
+	description: "Submit a user-feedback record against an event.",
+	method: "POST",
+	path: "/api/0/projects/{organization_slug}/{project_slug}/user-feedback/",
+	pathParams: ORG_PROJECT,
+	input: orgProjectScopeInputSchema.extend({
+		event_id: sentryIdSchema,
+		name: z.string().min(1),
+		email: z.string().email(),
+		comments: z.string().min(1)
+	}),
+	bodyFields: [
+		"event_id",
+		"name",
+		"email",
+		"comments"
+	],
+	output: sentryFeedbackSchema,
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.projectWrite]
+});
+const sentryFeedbackOperations = {
+	retrieveUserFeedbackForProject,
+	submitProjectUserFeedback
+};
+
+//#endregion
+export { retrieveUserFeedbackForProject, sentryFeedbackOperations, submitProjectUserFeedback };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/integration-C8KHkeNG.d.mts

@@ -0,0 +1,58 @@
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_integration_authoring_official0 from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
+
+//#region src/integration.d.ts
+declare const sentryOfficialIntegration: {
+  id: "sentry";
+  name: string;
+  description: string;
+  auth: z.ZodObject<{
+    SENTRY_ACCESS_TOKEN: z.ZodString;
+    SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+    SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  proxy: {
+    hosts: string[];
+  };
+  connections: {
+    kind: "oauth";
+    tokenType: "refreshable";
+    authUrl: "https://sentry.io/oauth/authorize/";
+    tokenUrl: "https://sentry.io/oauth/token/";
+    revokeUrl: null;
+    scopes: readonly ["org:read", "project:read", "project:write", "project:admin", "team:read", "team:write", "team:admin", "member:read", "member:write", "event:read", "event:admin", "alerts:read", "alerts:write", "release:admin"];
+    vault: {
+      readonly accessToken: "SENTRY_ACCESS_TOKEN";
+    };
+    exchangeCode: (ctx: _keystrokehq_core_credential_set0.ExchangeCodeContext) => Promise<_keystrokehq_core_credential_set0.TokenResult>;
+    extractInstallationInfo: ({
+      tokenResult
+    }: _keystrokehq_core_credential_set0.ExtractInstallationContext) => {
+      externalInstallationId: string | undefined;
+      externalWorkspaceId: string | undefined;
+      externalBotUserId: string | undefined;
+      metadata: Record<string, string>;
+    };
+    id: string;
+  }[];
+};
+declare const sentryBundle: _keystrokehq_integration_authoring_official0.OfficialIntegrationBundle<"sentry", z.ZodObject<{
+  SENTRY_ACCESS_TOKEN: z.ZodString;
+  SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+  SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const sentry: _keystrokehq_core0.CredentialSet<"sentry", z.ZodObject<{
+  SENTRY_ACCESS_TOKEN: z.ZodString;
+  SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+  SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENTRY_ACCESS_TOKEN: z.ZodString;
+  SENTRY_REGION_URL: z.ZodOptional<z.ZodString>;
+  SENTRY_ORG_SLUG: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>;
+type SentryIntegrationCredentials = InferCredentialSetAuth<typeof sentry>;
+//#endregion
+export { sentryOfficialIntegration as i, sentry as n, sentryBundle as r, SentryIntegrationCredentials as t };

package/dist/integration-WwY95cWE.mjs

@@ -0,0 +1,156 @@
+import { SENTRY_DEFAULT_BASE_URL } from "./client.mjs";
+import { CredentialSet } from "@keystrokehq/core";
+import { defineOfficialIntegration } from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import { oauthDefaults } from "@keystrokehq/credential-connection";
+
+//#region src/_official/provider-app.ts
+/**
+* Internal Keystroke-owned Sentry app credentials.
+*
+* For Sentry, `clientSecret` doubles as the webhook signing secret per
+* <https://docs.sentry.io/organization/integrations/integration-platform/webhooks/>,
+* so `webhookSecret` is kept as a discrete field for symmetry with other
+* integrations even though in practice platforms will populate both from the
+* same Sentry-issued value.
+*/
+const sentryAppCredentialSet = new CredentialSet({
+	id: "sentry-app",
+	exposure: "platform-only",
+	name: "Sentry App",
+	auth: z.object({
+		clientId: z.string(),
+		clientSecret: z.string(),
+		webhookSecret: z.string()
+	})
+});
+const sentryPlatformProviderSeed = {
+	provider: "sentry",
+	appRef: "sentry-platform",
+	displayName: "Sentry Platform",
+	credentialSetName: "Keystroke Sentry Platform App",
+	envShape: {
+		KEYSTROKE_PLATFORM_SENTRY_CLIENT_ID: z.string().optional(),
+		KEYSTROKE_PLATFORM_SENTRY_CLIENT_SECRET: z.string().optional(),
+		KEYSTROKE_PLATFORM_SENTRY_WEBHOOK_SECRET: z.string().optional()
+	},
+	requiredEnvKeys: [
+		"KEYSTROKE_PLATFORM_SENTRY_CLIENT_ID",
+		"KEYSTROKE_PLATFORM_SENTRY_CLIENT_SECRET",
+		"KEYSTROKE_PLATFORM_SENTRY_WEBHOOK_SECRET"
+	],
+	externalAppIdEnvKey: "KEYSTROKE_PLATFORM_SENTRY_CLIENT_ID",
+	buildCredentials: (env) => ({
+		clientId: env.KEYSTROKE_PLATFORM_SENTRY_CLIENT_ID,
+		clientSecret: env.KEYSTROKE_PLATFORM_SENTRY_CLIENT_SECRET,
+		webhookSecret: env.KEYSTROKE_PLATFORM_SENTRY_WEBHOOK_SECRET
+	})
+};
+
+//#endregion
+//#region src/oauth-connection.ts
+const SENTRY_OAUTH_SCOPES = [
+	"org:read",
+	"project:read",
+	"project:write",
+	"project:admin",
+	"team:read",
+	"team:write",
+	"team:admin",
+	"member:read",
+	"member:write",
+	"event:read",
+	"event:admin",
+	"alerts:read",
+	"alerts:write",
+	"release:admin"
+];
+const sentryOAuthConnection = {
+	kind: "oauth",
+	tokenType: "refreshable",
+	authUrl: "https://sentry.io/oauth/authorize/",
+	tokenUrl: "https://sentry.io/oauth/token/",
+	revokeUrl: null,
+	scopes: [...SENTRY_OAUTH_SCOPES],
+	vault: { accessToken: "SENTRY_ACCESS_TOKEN" },
+	async exchangeCode(ctx) {
+		const result = await oauthDefaults.exchangeCode(ctx);
+		const orgResponse = await fetch(`${SENTRY_DEFAULT_BASE_URL}/api/0/organizations/`, {
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${result.accessToken}`,
+				Accept: "application/json"
+			}
+		});
+		let firstOrg = null;
+		if (orgResponse.ok) {
+			const orgs = await orgResponse.json();
+			if (Array.isArray(orgs) && orgs.length > 0 && isOrganizationProbe(orgs[0])) firstOrg = orgs[0];
+		}
+		result.raw._sentryOrganization = firstOrg;
+		result.raw._sentryUser = pickUser(result.raw);
+		result.raw._sentryScopes = typeof result.raw.scope === "string" ? result.raw.scope : void 0;
+		return result;
+	},
+	extractInstallationInfo({ tokenResult }) {
+		const org = tokenResult.raw._sentryOrganization;
+		const user = tokenResult.raw._sentryUser;
+		const metadata = {};
+		if (org?.name) metadata.organizationName = org.name;
+		if (org?.slug) metadata.organizationSlug = org.slug;
+		const regionUrl = org?.links?.regionUrl;
+		if (regionUrl) metadata.regionUrl = regionUrl;
+		if (user?.name) metadata.userName = user.name;
+		if (user?.email) metadata.userEmail = user.email;
+		return {
+			externalInstallationId: org?.slug,
+			externalWorkspaceId: org?.id,
+			externalBotUserId: user?.id,
+			metadata
+		};
+	}
+};
+function isOrganizationProbe(value) {
+	return typeof value === "object" && value !== null;
+}
+function pickUser(raw) {
+	const user = raw.user;
+	if (user == null || typeof user !== "object") return null;
+	const u = user;
+	return {
+		id: typeof u.id === "string" ? u.id : void 0,
+		name: typeof u.name === "string" ? u.name : void 0,
+		email: typeof u.email === "string" ? u.email : void 0
+	};
+}
+
+//#endregion
+//#region src/integration.ts
+const sentryAuthSchema = z.object({
+	SENTRY_ACCESS_TOKEN: z.string().min(1),
+	SENTRY_REGION_URL: z.string().url().optional(),
+	SENTRY_ORG_SLUG: z.string().min(1).optional()
+});
+const sentryOfficialIntegration = {
+	id: "sentry",
+	name: "Sentry",
+	description: "Sentry — issue lifecycle, release tracking, alerts, monitors, replays, feedback, and integration-platform webhook triggers",
+	auth: sentryAuthSchema,
+	proxy: { hosts: [
+		"sentry.io",
+		"us.sentry.io",
+		"de.sentry.io"
+	] },
+	connections: [{
+		id: "oauth",
+		...sentryOAuthConnection
+	}]
+};
+const sentryBundle = defineOfficialIntegration({
+	...sentryOfficialIntegration,
+	internal: { providerApp: sentryAppCredentialSet }
+});
+const sentry = sentryBundle.credentialSet;
+
+//#endregion
+export { sentryPlatformProviderSeed as a, sentryAppCredentialSet as i, sentryBundle as n, sentryOfficialIntegration as r, sentry as t };