@inkeep/agents-work-apps 0.0.0-dev-20260204182014 → 0.0.0-dev-20260204210021

package/dist/slack/routes/workspaces.js

@@ -1,828 +0,0 @@
-import { getLogger } from "../../logger.js";
-import runDbClient_default from "../../db/runDbClient.js";
-import { computeWorkspaceConnectionId, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent } from "../services/nango.js";
-import { getSlackChannels, getSlackClient } from "../services/client.js";
-import "../services/index.js";
-import { requireWorkspaceAdmin } from "../middleware/permissions.js";
-import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackChannelAgentConfig, deleteWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackChannelAgentConfig, listWorkAppSlackChannelAgentConfigsByTeam, listWorkAppSlackUserMappingsByTeam, upsertWorkAppSlackChannelAgentConfig } from "@inkeep/agents-core";
-
-//#region src/slack/routes/workspaces.ts
-/**
-* Slack Workspace Routes
-*
-* RESTful endpoints for managing Slack workspaces and their configurations:
-* - GET /workspaces - List all installed workspaces
-* - GET /workspaces/:teamId - Get workspace details
-* - PUT /workspaces/:teamId/settings - Update workspace settings (default agent) [ADMIN ONLY]
-* - DELETE /workspaces/:teamId - Uninstall workspace [ADMIN ONLY]
-* - GET /workspaces/:teamId/channels - List channels
-* - GET /workspaces/:teamId/channels/:channelId/settings - Get channel config
-* - PUT /workspaces/:teamId/channels/:channelId/settings - Set channel default agent [ADMIN ONLY]
-* - DELETE /workspaces/:teamId/channels/:channelId/settings - Remove channel config [ADMIN ONLY]
-* - GET /workspaces/:teamId/users - List linked users
-*
-* Permission Model:
-* - Read operations (GET): Any authenticated user
-* - Write operations for workspace/channel configs (PUT/DELETE): Org admin/owner only
-* - User personal settings: Any authenticated user (handled in users router)
-*/
-const logger = getLogger("slack-workspaces");
-const app = new OpenAPIHono();
-app.use("/:teamId/settings", async (c, next) => {
-	if (c.req.method === "PUT") return requireWorkspaceAdmin()(c, next);
-	return next();
-});
-app.use("/:workspaceId", async (c, next) => {
-	if (c.req.method === "DELETE") return requireWorkspaceAdmin()(c, next);
-	return next();
-});
-app.use("/:teamId/channels/:channelId/settings", async (c, next) => {
-	if (c.req.method === "PUT" || c.req.method === "DELETE") return requireWorkspaceAdmin()(c, next);
-	return next();
-});
-const ChannelAgentConfigSchema = z.object({
-	projectId: z.string(),
-	agentId: z.string(),
-	agentName: z.string().optional()
-});
-const WorkspaceSettingsSchema = z.object({ defaultAgent: ChannelAgentConfigSchema.optional() });
-app.openapi(createRoute({
-	method: "get",
-	path: "/",
-	summary: "List Workspaces",
-	description: "List all installed Slack workspaces for the tenant",
-	operationId: "slack-list-workspaces",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Workspaces"
-	],
-	responses: { 200: {
-		description: "List of workspaces",
-		content: { "application/json": { schema: z.object({ workspaces: z.array(z.object({
-			connectionId: z.string(),
-			teamId: z.string(),
-			teamName: z.string().optional(),
-			tenantId: z.string(),
-			hasDefaultAgent: z.boolean(),
-			defaultAgentName: z.string().optional()
-		})) }) } }
-	} }
-}), async (c) => {
-	try {
-		const workspaces = await listWorkspaceInstallations();
-		logger.info({ count: workspaces.length }, "Listed workspace installations");
-		return c.json({ workspaces: workspaces.map((w) => ({
-			connectionId: w.connectionId,
-			teamId: w.teamId,
-			teamName: w.teamName,
-			tenantId: w.tenantId,
-			hasDefaultAgent: !!w.defaultAgent,
-			defaultAgentName: w.defaultAgent?.agentName
-		})) });
-	} catch (error) {
-		logger.error({ error }, "Failed to list workspaces");
-		return c.json({ workspaces: [] });
-	}
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/:teamId",
-	summary: "Get Workspace",
-	description: "Get details of a specific Slack workspace",
-	operationId: "slack-get-workspace",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Workspaces"
-	],
-	request: { params: z.object({ teamId: z.string() }) },
-	responses: {
-		200: {
-			description: "Workspace details",
-			content: { "application/json": { schema: z.object({
-				teamId: z.string(),
-				teamName: z.string().optional(),
-				tenantId: z.string(),
-				connectionId: z.string(),
-				defaultAgent: ChannelAgentConfigSchema.optional()
-			}) } }
-		},
-		404: { description: "Workspace not found" }
-	}
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const workspace = await findWorkspaceConnectionByTeamId(teamId);
-	if (!workspace) return c.json({ error: "Workspace not found" }, 404);
-	let defaultAgent;
-	const nangoDefault = await getWorkspaceDefaultAgentFromNango(teamId);
-	if (nangoDefault) defaultAgent = {
-		projectId: nangoDefault.projectId,
-		agentId: nangoDefault.agentId,
-		agentName: nangoDefault.agentName
-	};
-	return c.json({
-		teamId: workspace.teamId,
-		teamName: workspace.teamName,
-		tenantId: workspace.tenantId,
-		connectionId: workspace.connectionId,
-		defaultAgent
-	});
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/:teamId/settings",
-	summary: "Get Workspace Settings",
-	description: "Get settings for a Slack workspace including default agent",
-	operationId: "slack-get-workspace-settings",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Workspaces"
-	],
-	request: { params: z.object({ teamId: z.string() }) },
-	responses: { 200: {
-		description: "Workspace settings",
-		content: { "application/json": { schema: WorkspaceSettingsSchema } }
-	} }
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	let defaultAgent;
-	const nangoDefault = await getWorkspaceDefaultAgentFromNango(teamId);
-	if (nangoDefault) defaultAgent = {
-		projectId: nangoDefault.projectId,
-		agentId: nangoDefault.agentId,
-		agentName: nangoDefault.agentName
-	};
-	return c.json({ defaultAgent });
-});
-app.openapi(createRoute({
-	method: "put",
-	path: "/:teamId/settings",
-	summary: "Update Workspace Settings",
-	description: "Update workspace settings including default agent",
-	operationId: "slack-update-workspace-settings",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Workspaces"
-	],
-	request: {
-		params: z.object({ teamId: z.string() }),
-		body: { content: { "application/json": { schema: WorkspaceSettingsSchema } } }
-	},
-	responses: {
-		200: {
-			description: "Settings updated",
-			content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
-		},
-		500: {
-			description: "Failed to update settings",
-			content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
-		}
-	}
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const body = c.req.valid("json");
-	if (body.defaultAgent) {
-		if (!await setWorkspaceDefaultAgent(teamId, body.defaultAgent)) {
-			logger.warn({ teamId }, "Failed to persist workspace settings to Nango");
-			return c.json({ success: false }, 500);
-		}
-		logger.info({
-			teamId,
-			agentId: body.defaultAgent.agentId,
-			agentName: body.defaultAgent.agentName
-		}, "Saved workspace default agent to Nango");
-	} else {
-		await setWorkspaceDefaultAgent(teamId, null);
-		logger.info({ teamId }, "Cleared workspace default agent");
-	}
-	return c.json({ success: true });
-});
-app.openapi(createRoute({
-	method: "delete",
-	path: "/:workspaceId",
-	summary: "Uninstall Workspace",
-	description: "Uninstall Slack app from workspace. Accepts either teamId or connectionId.",
-	operationId: "slack-delete-workspace",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Workspaces"
-	],
-	request: { params: z.object({ workspaceId: z.string() }) },
-	responses: {
-		200: {
-			description: "Workspace uninstalled",
-			content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
-		},
-		400: { description: "Invalid connectionId format" },
-		404: { description: "Workspace not found" },
-		500: { description: "Failed to uninstall workspace" }
-	}
-}), async (c) => {
-	const { workspaceId } = c.req.valid("param");
-	let teamId;
-	let connectionId;
-	try {
-		if (workspaceId.includes(":")) {
-			connectionId = workspaceId;
-			const teamMatch = workspaceId.match(/T:([A-Z0-9]+)/);
-			if (!teamMatch) return c.json({ error: "Invalid connectionId format" }, 400);
-			teamId = teamMatch[1];
-		} else {
-			teamId = workspaceId;
-			connectionId = computeWorkspaceConnectionId({
-				teamId,
-				enterpriseId: void 0
-			});
-		}
-		const workspace = await findWorkspaceConnectionByTeamId(teamId);
-		if (!workspace) return c.json({ error: "Workspace not found" }, 404);
-		if (!await deleteWorkspaceInstallation(connectionId)) {
-			logger.error({ connectionId }, "deleteWorkspaceInstallation returned false");
-			return c.json({ error: "Failed to delete workspace from Nango" }, 500);
-		}
-		if (await deleteWorkAppSlackWorkspaceByNangoConnectionId(runDbClient_default)(connectionId)) logger.info({ connectionId }, "Deleted workspace from database");
-		const tenantId = workspace.tenantId || "default";
-		const deletedMappings = await deleteAllWorkAppSlackUserMappingsByTeam(runDbClient_default)(tenantId, teamId);
-		if (deletedMappings > 0) logger.info({
-			teamId,
-			deletedMappings
-		}, "Deleted user mappings for uninstalled workspace");
-		const deletedChannelConfigs = await deleteAllWorkAppSlackChannelAgentConfigsByTeam(runDbClient_default)(tenantId, teamId);
-		if (deletedChannelConfigs > 0) logger.info({
-			teamId,
-			deletedChannelConfigs
-		}, "Deleted channel configs for uninstalled workspace");
-		logger.info({ connectionId }, "Deleted workspace installation");
-		return c.json({ success: true });
-	} catch (error) {
-		logger.error({
-			error,
-			workspaceId
-		}, "Failed to uninstall workspace");
-		return c.json({ error: "Failed to uninstall workspace" }, 500);
-	}
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/:teamId/channels",
-	summary: "List Channels",
-	description: "List Slack channels in the workspace that the bot can see",
-	operationId: "slack-list-channels",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Channels"
-	],
-	request: {
-		params: z.object({ teamId: z.string() }),
-		query: z.object({
-			limit: z.coerce.number().optional().default(100),
-			cursor: z.string().optional(),
-			types: z.string().optional()
-		})
-	},
-	responses: {
-		200: {
-			description: "List of channels",
-			content: { "application/json": { schema: z.object({
-				channels: z.array(z.object({
-					id: z.string(),
-					name: z.string(),
-					isPrivate: z.boolean(),
-					memberCount: z.number().optional(),
-					hasAgentConfig: z.boolean(),
-					agentConfig: ChannelAgentConfigSchema.optional()
-				})),
-				nextCursor: z.string().optional()
-			}) } }
-		},
-		404: { description: "Workspace not found" }
-	}
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const { limit } = c.req.valid("query");
-	const workspace = await findWorkspaceConnectionByTeamId(teamId);
-	if (!workspace?.botToken) return c.json({ error: "Workspace not found or no bot token" }, 404);
-	const tenantId = workspace.tenantId || "default";
-	const slackClient = getSlackClient(workspace.botToken);
-	try {
-		const channels = await getSlackChannels(slackClient, limit);
-		let channelConfigs = [];
-		try {
-			channelConfigs = await listWorkAppSlackChannelAgentConfigsByTeam(runDbClient_default)(tenantId, teamId);
-		} catch (configError) {
-			logger.warn({
-				error: configError,
-				teamId
-			}, "Failed to fetch channel configs, table may not exist yet");
-		}
-		const configMap = new Map(channelConfigs.map((c$1) => [c$1.slackChannelId, c$1]));
-		const channelsWithConfig = channels.map((channel) => {
-			const config = channel.id ? configMap.get(channel.id) : void 0;
-			return {
-				id: channel.id || "",
-				name: channel.name || "",
-				isPrivate: false,
-				memberCount: channel.memberCount,
-				hasAgentConfig: !!config,
-				agentConfig: config ? {
-					projectId: config.projectId,
-					agentId: config.agentId,
-					agentName: config.agentName || void 0
-				} : void 0
-			};
-		});
-		return c.json({
-			channels: channelsWithConfig,
-			nextCursor: void 0
-		});
-	} catch (error) {
-		logger.error({
-			error,
-			teamId
-		}, "Failed to list channels");
-		return c.json({ error: "Failed to list channels" }, 500);
-	}
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/:teamId/channels/:channelId/settings",
-	summary: "Get Channel Settings",
-	description: "Get default agent configuration for a specific channel",
-	operationId: "slack-get-channel-settings",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Channels"
-	],
-	request: { params: z.object({
-		teamId: z.string(),
-		channelId: z.string()
-	}) },
-	responses: { 200: {
-		description: "Channel settings",
-		content: { "application/json": { schema: z.object({
-			channelId: z.string(),
-			agentConfig: ChannelAgentConfigSchema.optional()
-		}) } }
-	} }
-}), async (c) => {
-	const { teamId, channelId } = c.req.valid("param");
-	const tenantId = (await findWorkspaceConnectionByTeamId(teamId))?.tenantId || "default";
-	const config = await findWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
-	return c.json({
-		channelId,
-		agentConfig: config ? {
-			projectId: config.projectId,
-			agentId: config.agentId,
-			agentName: config.agentName || void 0
-		} : void 0
-	});
-});
-app.openapi(createRoute({
-	method: "put",
-	path: "/:teamId/channels/:channelId/settings",
-	summary: "Set Channel Default Agent",
-	description: "Set or update the default agent for a specific channel",
-	operationId: "slack-set-channel-settings",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Channels"
-	],
-	request: {
-		params: z.object({
-			teamId: z.string(),
-			channelId: z.string()
-		}),
-		body: { content: { "application/json": { schema: z.object({
-			agentConfig: ChannelAgentConfigSchema,
-			channelName: z.string().optional(),
-			channelType: z.string().optional()
-		}) } } }
-	},
-	responses: { 200: {
-		description: "Channel settings updated",
-		content: { "application/json": { schema: z.object({
-			success: z.boolean(),
-			configId: z.string()
-		}) } }
-	} }
-}), async (c) => {
-	const { teamId, channelId } = c.req.valid("param");
-	const body = c.req.valid("json");
-	const tenantId = (await findWorkspaceConnectionByTeamId(teamId))?.tenantId || "default";
-	const config = await upsertWorkAppSlackChannelAgentConfig(runDbClient_default)({
-		tenantId,
-		slackTeamId: teamId,
-		slackChannelId: channelId,
-		slackChannelName: body.channelName,
-		slackChannelType: body.channelType,
-		projectId: body.agentConfig.projectId,
-		agentId: body.agentConfig.agentId,
-		agentName: body.agentConfig.agentName,
-		enabled: true
-	});
-	logger.info({
-		teamId,
-		channelId,
-		agentId: body.agentConfig.agentId
-	}, "Set channel default agent");
-	return c.json({
-		success: true,
-		configId: config.id
-	});
-});
-app.use("/:teamId/channels/bulk", async (c, next) => {
-	if (c.req.method === "PUT" || c.req.method === "DELETE") return requireWorkspaceAdmin()(c, next);
-	return next();
-});
-app.openapi(createRoute({
-	method: "put",
-	path: "/:teamId/channels/bulk",
-	summary: "Bulk Set Channel Agents",
-	description: "Apply the same agent configuration to multiple channels at once",
-	operationId: "slack-bulk-set-channel-agents",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Channels"
-	],
-	request: {
-		params: z.object({ teamId: z.string() }),
-		body: { content: { "application/json": { schema: z.object({
-			channelIds: z.array(z.string()).min(1),
-			agentConfig: ChannelAgentConfigSchema
-		}) } } }
-	},
-	responses: {
-		200: {
-			description: "Channels updated",
-			content: { "application/json": { schema: z.object({
-				success: z.boolean(),
-				updated: z.number(),
-				failed: z.number(),
-				errors: z.array(z.object({
-					channelId: z.string(),
-					error: z.string()
-				})).optional()
-			}) } }
-		},
-		400: { description: "Invalid request" },
-		404: { description: "Workspace not found" }
-	}
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const body = c.req.valid("json");
-	const workspace = await findWorkspaceConnectionByTeamId(teamId);
-	if (!workspace?.botToken) return c.json({ error: "Workspace not found or no bot token" }, 404);
-	const tenantId = workspace.tenantId || "default";
-	const channels = await getSlackChannels(getSlackClient(workspace.botToken), 500);
-	const channelMap = new Map(channels.map((ch) => [ch.id, ch]));
-	let updated = 0;
-	const errors = [];
-	await Promise.all(body.channelIds.map(async (channelId) => {
-		try {
-			const channel = channelMap.get(channelId);
-			if (!channel) {
-				errors.push({
-					channelId,
-					error: "Channel not found"
-				});
-				return;
-			}
-			await upsertWorkAppSlackChannelAgentConfig(runDbClient_default)({
-				tenantId,
-				slackTeamId: teamId,
-				slackChannelId: channelId,
-				slackChannelName: channel.name || channelId,
-				slackChannelType: "public",
-				projectId: body.agentConfig.projectId,
-				agentId: body.agentConfig.agentId,
-				agentName: body.agentConfig.agentName,
-				enabled: true
-			});
-			updated++;
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			errors.push({
-				channelId,
-				error: errorMessage
-			});
-		}
-	}));
-	logger.info({
-		teamId,
-		agentId: body.agentConfig.agentId,
-		updated,
-		failed: errors.length
-	}, "Bulk set channel agents");
-	return c.json({
-		success: errors.length === 0,
-		updated,
-		failed: errors.length,
-		errors: errors.length > 0 ? errors : void 0
-	});
-});
-app.openapi(createRoute({
-	method: "delete",
-	path: "/:teamId/channels/bulk",
-	summary: "Bulk Remove Channel Configs",
-	description: "Remove agent configuration from multiple channels at once",
-	operationId: "slack-bulk-delete-channel-agents",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Channels"
-	],
-	request: {
-		params: z.object({ teamId: z.string() }),
-		body: { content: { "application/json": { schema: z.object({ channelIds: z.array(z.string()).min(1) }) } } }
-	},
-	responses: { 200: {
-		description: "Configs removed",
-		content: { "application/json": { schema: z.object({
-			success: z.boolean(),
-			removed: z.number()
-		}) } }
-	} }
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const body = c.req.valid("json");
-	const tenantId = (await findWorkspaceConnectionByTeamId(teamId))?.tenantId || "default";
-	let removed = 0;
-	await Promise.all(body.channelIds.map(async (channelId) => {
-		if (await deleteWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId)) removed++;
-	}));
-	logger.info({
-		teamId,
-		removed
-	}, "Bulk removed channel agent configs");
-	return c.json({
-		success: true,
-		removed
-	});
-});
-app.openapi(createRoute({
-	method: "delete",
-	path: "/:teamId/channels/:channelId/settings",
-	summary: "Remove Channel Config",
-	description: "Remove the default agent configuration for a channel",
-	operationId: "slack-delete-channel-settings",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Channels"
-	],
-	request: { params: z.object({
-		teamId: z.string(),
-		channelId: z.string()
-	}) },
-	responses: { 200: {
-		description: "Channel config removed",
-		content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
-	} }
-}), async (c) => {
-	const { teamId, channelId } = c.req.valid("param");
-	const tenantId = (await findWorkspaceConnectionByTeamId(teamId))?.tenantId || "default";
-	const deleted = await deleteWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
-	logger.info({
-		teamId,
-		channelId,
-		deleted
-	}, "Removed channel agent config");
-	return c.json({ success: deleted });
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/:teamId/users",
-	summary: "List Linked Users",
-	description: "List all users linked to Inkeep in this workspace",
-	operationId: "slack-list-linked-users",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { params: z.object({ teamId: z.string() }) },
-	responses: { 200: {
-		description: "List of linked users",
-		content: { "application/json": { schema: z.object({ linkedUsers: z.array(z.object({
-			id: z.string(),
-			slackUserId: z.string(),
-			slackTeamId: z.string(),
-			slackUsername: z.string().optional(),
-			slackEmail: z.string().optional(),
-			userId: z.string(),
-			linkedAt: z.string(),
-			lastUsedAt: z.string().optional()
-		})) }) } }
-	} }
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const tenantId = (await findWorkspaceConnectionByTeamId(teamId))?.tenantId || "default";
-	const linkedUsers = await listWorkAppSlackUserMappingsByTeam(runDbClient_default)(tenantId, teamId);
-	logger.info({
-		teamId,
-		tenantId,
-		count: linkedUsers.length
-	}, "Fetched linked users");
-	return c.json({ linkedUsers: linkedUsers.map((link) => ({
-		id: link.id,
-		slackUserId: link.slackUserId,
-		slackTeamId: link.slackTeamId,
-		slackUsername: link.slackUsername || void 0,
-		slackEmail: link.slackEmail || void 0,
-		userId: link.inkeepUserId,
-		linkedAt: link.linkedAt,
-		lastUsedAt: link.lastUsedAt || void 0
-	})) });
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/:teamId/health",
-	summary: "Check Workspace Health",
-	description: "Verify the bot token is valid and check permissions. Returns bot info and permission status.",
-	operationId: "slack-workspace-health",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Workspaces"
-	],
-	request: { params: z.object({ teamId: z.string() }) },
-	responses: {
-		200: {
-			description: "Health check result",
-			content: { "application/json": { schema: z.object({
-				healthy: z.boolean(),
-				botId: z.string().optional(),
-				botName: z.string().optional(),
-				teamId: z.string().optional(),
-				teamName: z.string().optional(),
-				permissions: z.object({
-					canPostMessages: z.boolean(),
-					canReadChannels: z.boolean(),
-					canReadHistory: z.boolean()
-				}),
-				error: z.string().optional()
-			}) } }
-		},
-		404: { description: "Workspace not found" }
-	}
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const workspace = await findWorkspaceConnectionByTeamId(teamId);
-	if (!workspace?.botToken) return c.json({
-		healthy: false,
-		permissions: {
-			canPostMessages: false,
-			canReadChannels: false,
-			canReadHistory: false
-		},
-		error: "Workspace not found or no bot token available"
-	});
-	try {
-		const slackClient = getSlackClient(workspace.botToken);
-		const authResult = await slackClient.auth.test();
-		if (!authResult.ok) return c.json({
-			healthy: false,
-			permissions: {
-				canPostMessages: false,
-				canReadChannels: false,
-				canReadHistory: false
-			},
-			error: "Bot token is invalid or revoked"
-		});
-		const permissions = {
-			canPostMessages: true,
-			canReadChannels: true,
-			canReadHistory: true
-		};
-		try {
-			await slackClient.conversations.list({ limit: 1 });
-		} catch {
-			permissions.canReadChannels = false;
-		}
-		logger.info({
-			teamId,
-			botId: authResult.user_id,
-			permissions
-		}, "Workspace health check completed");
-		return c.json({
-			healthy: true,
-			botId: authResult.user_id,
-			botName: authResult.user,
-			teamId: authResult.team_id,
-			teamName: authResult.team,
-			permissions
-		});
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger.error({
-			error: errorMessage,
-			teamId
-		}, "Health check failed");
-		return c.json({
-			healthy: false,
-			permissions: {
-				canPostMessages: false,
-				canReadChannels: false,
-				canReadHistory: false
-			},
-			error: errorMessage
-		});
-	}
-});
-app.openapi(createRoute({
-	method: "post",
-	path: "/:teamId/test-message",
-	summary: "Send Test Message",
-	description: "Send a test message to verify the bot is working correctly.",
-	operationId: "slack-test-message",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Workspaces"
-	],
-	request: {
-		params: z.object({ teamId: z.string() }),
-		body: { content: { "application/json": { schema: z.object({
-			channelId: z.string(),
-			message: z.string().optional()
-		}) } } }
-	},
-	responses: {
-		200: {
-			description: "Test message sent",
-			content: { "application/json": { schema: z.object({
-				success: z.boolean(),
-				messageTs: z.string().optional(),
-				error: z.string().optional()
-			}) } }
-		},
-		400: { description: "Invalid request" },
-		404: { description: "Workspace not found" }
-	}
-}), async (c) => {
-	const { teamId } = c.req.valid("param");
-	const { channelId, message } = c.req.valid("json");
-	const workspace = await findWorkspaceConnectionByTeamId(teamId);
-	if (!workspace?.botToken) return c.json({
-		success: false,
-		error: "Workspace not found or no bot token available"
-	}, 404);
-	try {
-		const slackClient = getSlackClient(workspace.botToken);
-		const testMessage = message || "✅ *Test message from Inkeep*\n\nYour Slack integration is working correctly!";
-		const result = await slackClient.chat.postMessage({
-			channel: channelId,
-			text: testMessage,
-			blocks: [{
-				type: "section",
-				text: {
-					type: "mrkdwn",
-					text: testMessage
-				}
-			}, {
-				type: "context",
-				elements: [{
-					type: "mrkdwn",
-					text: "_This is a test message from the Inkeep dashboard_"
-				}]
-			}]
-		});
-		if (!result.ok) return c.json({
-			success: false,
-			error: result.error || "Failed to send message"
-		});
-		logger.info({
-			teamId,
-			channelId,
-			messageTs: result.ts
-		}, "Test message sent");
-		return c.json({
-			success: true,
-			messageTs: result.ts
-		});
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger.error({
-			error: errorMessage,
-			teamId,
-			channelId
-		}, "Failed to send test message");
-		return c.json({
-			success: false,
-			error: errorMessage
-		});
-	}
-});
-var workspaces_default = app;
-
-//#endregion
-export { workspaces_default as default };