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

package/dist/slack/routes/users.js

@@ -1,430 +0,0 @@
-import { getLogger } from "../../logger.js";
-import runDbClient_default from "../../db/runDbClient.js";
-import { createConnectSession } from "../services/nango.js";
-import "../services/index.js";
-import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { createWorkAppSlackUserMapping, deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingByInkeepUserId, findWorkAppSlackUserSettings, upsertWorkAppSlackUserSettings, verifySlackLinkToken } from "@inkeep/agents-core";
-
-//#region src/slack/routes/users.ts
-/**
-* Slack User Routes
-*
-* Endpoints for user linking and personal settings:
-* - GET /users/me/settings - Get user's personal settings
-* - PUT /users/me/settings - Update user's personal default agent
-* - GET /link-status - Check link status
-* - POST /link/verify-token - Verify JWT link token (primary linking method)
-* - POST /connect - Create Nango session
-* - POST /disconnect - Disconnect user
-*/
-const logger = getLogger("slack-users");
-const app = new OpenAPIHono();
-const UserSettingsSchema = z.object({
-	defaultProjectId: z.string().optional(),
-	defaultAgentId: z.string().optional(),
-	defaultAgentName: z.string().optional()
-});
-const pendingSessionTokens = /* @__PURE__ */ new Map();
-setInterval(() => {
-	const now = Date.now();
-	const maxAge = 600 * 1e3;
-	for (const [key, value] of pendingSessionTokens.entries()) if (now - value.createdAt > maxAge) pendingSessionTokens.delete(key);
-}, 60 * 1e3);
-app.openapi(createRoute({
-	method: "get",
-	path: "/me/settings",
-	summary: "Get User Settings",
-	description: "Get user's personal Slack settings including default agent",
-	operationId: "slack-get-user-settings",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { query: z.object({
-		slackUserId: z.string(),
-		slackTeamId: z.string(),
-		tenantId: z.string().optional().default("default")
-	}) },
-	responses: { 200: {
-		description: "User settings",
-		content: { "application/json": { schema: UserSettingsSchema } }
-	} }
-}), async (c) => {
-	const { slackUserId, slackTeamId, tenantId } = c.req.valid("query");
-	const settings = await findWorkAppSlackUserSettings(runDbClient_default)(tenantId, slackTeamId, slackUserId);
-	return c.json({
-		defaultProjectId: settings?.defaultProjectId || void 0,
-		defaultAgentId: settings?.defaultAgentId || void 0,
-		defaultAgentName: settings?.defaultAgentName || void 0
-	});
-});
-app.openapi(createRoute({
-	method: "put",
-	path: "/me/settings",
-	summary: "Update User Settings",
-	description: "Update user's personal default agent",
-	operationId: "slack-update-user-settings",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { body: { content: { "application/json": { schema: z.object({
-		slackUserId: z.string(),
-		slackTeamId: z.string(),
-		tenantId: z.string().optional(),
-		settings: UserSettingsSchema
-	}) } } } },
-	responses: { 200: {
-		description: "Settings updated",
-		content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
-	} }
-}), async (c) => {
-	const body = c.req.valid("json");
-	const tenantId = body.tenantId || "default";
-	await upsertWorkAppSlackUserSettings(runDbClient_default)({
-		tenantId,
-		slackTeamId: body.slackTeamId,
-		slackUserId: body.slackUserId,
-		defaultProjectId: body.settings.defaultProjectId,
-		defaultAgentId: body.settings.defaultAgentId,
-		defaultAgentName: body.settings.defaultAgentName
-	});
-	logger.info({
-		slackUserId: body.slackUserId,
-		agentId: body.settings.defaultAgentId
-	}, "Updated user settings");
-	return c.json({ success: true });
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/link-status",
-	summary: "Check Link Status",
-	description: "Check if a Slack user is linked to an Inkeep account",
-	operationId: "slack-link-status",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { query: z.object({
-		slackUserId: z.string(),
-		slackTeamId: z.string(),
-		tenantId: z.string().optional().default("default")
-	}) },
-	responses: { 200: {
-		description: "Link status",
-		content: { "application/json": { schema: z.object({
-			linked: z.boolean(),
-			linkId: z.string().optional(),
-			linkedAt: z.string().optional(),
-			slackUsername: z.string().optional()
-		}) } }
-	} }
-}), async (c) => {
-	const { slackUserId, slackTeamId, tenantId } = c.req.valid("query");
-	const link = await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, slackUserId, slackTeamId, "work-apps-slack");
-	if (link) return c.json({
-		linked: true,
-		linkId: link.id,
-		linkedAt: link.linkedAt,
-		slackUsername: link.slackUsername || void 0
-	});
-	return c.json({ linked: false });
-});
-app.openapi(createRoute({
-	method: "post",
-	path: "/link/verify-token",
-	summary: "Verify Link Token",
-	description: "Verify a JWT link token and create user mapping",
-	operationId: "slack-verify-link-token",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { body: { content: { "application/json": { schema: z.object({
-		token: z.string().min(1),
-		userId: z.string().min(1),
-		userEmail: z.string().email().optional()
-	}) } } } },
-	responses: {
-		200: {
-			description: "Link successful",
-			content: { "application/json": { schema: z.object({
-				success: z.boolean(),
-				linkId: z.string().optional(),
-				slackUsername: z.string().optional(),
-				slackTeamId: z.string().optional(),
-				tenantId: z.string().optional()
-			}) } }
-		},
-		400: { description: "Invalid or expired token" },
-		409: { description: "Account already linked" }
-	}
-}), async (c) => {
-	const body = c.req.valid("json");
-	try {
-		const verifyResult = await verifySlackLinkToken(body.token);
-		if (!verifyResult.valid || !verifyResult.payload) {
-			logger.warn({ error: verifyResult.error }, "Invalid link token");
-			return c.json({ error: verifyResult.error || "Invalid or expired link token. Please run /inkeep link in Slack to get a new one." }, 400);
-		}
-		const { tenantId, slack } = verifyResult.payload;
-		const { teamId, userId: slackUserId, enterpriseId, username } = slack;
-		const existingLink = await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, slackUserId, teamId, "work-apps-slack");
-		if (existingLink && existingLink.inkeepUserId === body.userId) {
-			logger.info({
-				slackUserId,
-				tenantId,
-				inkeepUserId: body.userId
-			}, "Slack user already linked to same account");
-			return c.json({
-				success: true,
-				linkId: existingLink.id,
-				slackUsername: existingLink.slackUsername || void 0,
-				slackTeamId: teamId,
-				tenantId
-			});
-		}
-		if (existingLink) logger.info({
-			slackUserId,
-			existingUserId: existingLink.inkeepUserId,
-			newUserId: body.userId,
-			tenantId
-		}, "Slack user already linked, updating to new user");
-		const slackUserMapping = await createWorkAppSlackUserMapping(runDbClient_default)({
-			tenantId,
-			clientId: "work-apps-slack",
-			slackUserId,
-			slackTeamId: teamId,
-			slackEnterpriseId: enterpriseId,
-			slackUsername: username,
-			slackEmail: body.userEmail,
-			inkeepUserId: body.userId
-		});
-		logger.info({
-			slackUserId,
-			slackTeamId: teamId,
-			tenantId,
-			inkeepUserId: body.userId,
-			linkId: slackUserMapping.id
-		}, "Successfully linked Slack user to Inkeep account via JWT token");
-		return c.json({
-			success: true,
-			linkId: slackUserMapping.id,
-			slackUsername: username || void 0,
-			slackTeamId: teamId,
-			tenantId
-		});
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		if (errorMessage.includes("duplicate key") || errorMessage.includes("unique constraint")) {
-			logger.warn({ userId: body.userId }, "Slack user already linked");
-			return c.json({ error: "This Slack account is already linked to an Inkeep account." }, 409);
-		}
-		logger.error({
-			error,
-			userId: body.userId
-		}, "Failed to verify link token");
-		return c.json({ error: "Failed to verify link. Please try again." }, 500);
-	}
-});
-app.openapi(createRoute({
-	method: "post",
-	path: "/connect",
-	summary: "Create Nango Connect Session",
-	description: "Create a Nango session for Slack OAuth flow. Used by the dashboard.",
-	operationId: "slack-user-connect",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { body: { content: { "application/json": { schema: z.object({
-		userId: z.string().describe("Inkeep user ID"),
-		userEmail: z.string().optional().describe("User email"),
-		userName: z.string().optional().describe("User display name"),
-		tenantId: z.string().optional().describe("Tenant ID"),
-		sessionToken: z.string().optional().describe("Pre-authenticated session token"),
-		sessionExpiresAt: z.string().optional().describe("Session expiration ISO timestamp")
-	}) } } } },
-	responses: {
-		200: {
-			description: "Connect session created",
-			content: { "application/json": { schema: z.object({
-				sessionToken: z.string().optional(),
-				connectUrl: z.string().optional()
-			}) } }
-		},
-		400: { description: "Missing required userId" },
-		500: { description: "Failed to create session" }
-	}
-}), async (c) => {
-	const { userId, userEmail, userName, tenantId, sessionToken, sessionExpiresAt } = c.req.valid("json");
-	if (!userId) return c.json({ error: "userId is required" }, 400);
-	if (sessionToken && sessionExpiresAt) {
-		pendingSessionTokens.set(userId, {
-			token: sessionToken,
-			expiresAt: sessionExpiresAt,
-			createdAt: Date.now()
-		});
-		logger.info({ userId }, "Stored pending session token for Slack connection");
-	}
-	logger.debug({
-		userId,
-		userEmail,
-		userName,
-		hasSessionToken: !!sessionToken
-	}, "Creating Nango connect session");
-	const session = await createConnectSession({
-		userId,
-		userEmail,
-		userName,
-		tenantId: tenantId || "default"
-	});
-	if (!session) return c.json({ error: "Failed to create session" }, 500);
-	return c.json(session);
-});
-app.openapi(createRoute({
-	method: "post",
-	path: "/disconnect",
-	summary: "Disconnect User",
-	description: "Unlink a Slack user from their Inkeep account.",
-	operationId: "slack-user-disconnect",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { body: { content: { "application/json": { schema: z.object({
-		userId: z.string().optional().describe("Inkeep user ID"),
-		slackUserId: z.string().optional().describe("Slack user ID"),
-		slackTeamId: z.string().optional().describe("Slack team ID"),
-		tenantId: z.string().optional().describe("Tenant ID")
-	}) } } } },
-	responses: {
-		200: {
-			description: "User disconnected",
-			content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
-		},
-		400: { description: "Missing required identifiers" },
-		404: { description: "No connection found" },
-		500: { description: "Failed to disconnect" }
-	}
-}), async (c) => {
-	const { userId, slackUserId, slackTeamId, tenantId } = c.req.valid("json");
-	if (!userId && !(slackUserId && slackTeamId)) return c.json({ error: "Either userId or (slackUserId + slackTeamId) is required" }, 400);
-	try {
-		const effectiveTenantId = tenantId || "default";
-		if (slackUserId && slackTeamId) {
-			if (await deleteWorkAppSlackUserMapping(runDbClient_default)(effectiveTenantId, slackUserId, slackTeamId, "work-apps-slack")) {
-				logger.info({
-					slackUserId,
-					slackTeamId,
-					tenantId: effectiveTenantId
-				}, "User unlinked");
-				return c.json({ success: true });
-			}
-			return c.json({ error: "No link found for this user" }, 404);
-		}
-		if (userId) {
-			const userMappings = await findWorkAppSlackUserMappingByInkeepUserId(runDbClient_default)(userId);
-			if (userMappings.length === 0) return c.json({ error: "No link found for this user" }, 404);
-			let deletedCount = 0;
-			for (const mapping of userMappings) if (await deleteWorkAppSlackUserMapping(runDbClient_default)(mapping.tenantId, mapping.slackUserId, mapping.slackTeamId, "work-apps-slack")) deletedCount++;
-			logger.info({
-				userId,
-				deletedCount
-			}, "User disconnected from Slack");
-			return c.json({ success: true });
-		}
-		return c.json({ error: "No connection found for this user" }, 404);
-	} catch (error) {
-		logger.error({
-			error,
-			userId,
-			slackUserId,
-			slackTeamId
-		}, "Failed to disconnect from Slack");
-		return c.json({ error: "Failed to disconnect" }, 500);
-	}
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/status",
-	summary: "Get Connection Status",
-	description: "Check if an Inkeep user has a linked Slack account.",
-	operationId: "slack-user-status",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Users"
-	],
-	request: { query: z.object({ userId: z.string().describe("Inkeep user ID") }) },
-	responses: {
-		200: {
-			description: "Connection status",
-			content: { "application/json": { schema: z.object({
-				connected: z.boolean(),
-				connection: z.object({
-					connectionId: z.string(),
-					appUserId: z.string(),
-					appUserEmail: z.string(),
-					slackDisplayName: z.string(),
-					linkedAt: z.string(),
-					tenantId: z.string(),
-					slackUserId: z.string(),
-					slackTeamId: z.string()
-				}).nullable()
-			}) } }
-		},
-		400: { description: "Missing userId" },
-		500: { description: "Failed to get status" }
-	}
-}), async (c) => {
-	const { userId: appUserId } = c.req.valid("query");
-	try {
-		const userMappings = await findWorkAppSlackUserMappingByInkeepUserId(runDbClient_default)(appUserId);
-		if (userMappings.length === 0) {
-			logger.debug({
-				appUserId,
-				connected: false
-			}, "Retrieved connection status from DB");
-			return c.json({
-				connected: false,
-				connection: null
-			});
-		}
-		const mostRecent = userMappings.sort((a, b) => new Date(b.linkedAt).getTime() - new Date(a.linkedAt).getTime())[0];
-		const connection = {
-			connectionId: mostRecent.id,
-			appUserId: mostRecent.inkeepUserId,
-			appUserEmail: mostRecent.slackEmail || "",
-			slackDisplayName: mostRecent.slackUsername || "",
-			linkedAt: mostRecent.linkedAt,
-			tenantId: mostRecent.tenantId,
-			slackUserId: mostRecent.slackUserId,
-			slackTeamId: mostRecent.slackTeamId
-		};
-		logger.debug({
-			appUserId,
-			connected: true
-		}, "Retrieved connection status from DB");
-		return c.json({
-			connected: true,
-			connection
-		});
-	} catch (error) {
-		logger.error({
-			error,
-			appUserId
-		}, "Failed to get connection status");
-		return c.json({ error: "Failed to get connection status" }, 500);
-	}
-});
-var users_default = app;
-
-//#endregion
-export { users_default as default, pendingSessionTokens };

package/dist/slack/routes/workspaces.d.ts

@@ -1,10 +0,0 @@
-import { ManageAppVariables } from "../types.js";
-import { OpenAPIHono } from "@hono/zod-openapi";
-
-//#region src/slack/routes/workspaces.d.ts
-
-declare const app: OpenAPIHono<{
-  Variables: ManageAppVariables;
-}, {}, "/">;
-//#endregion
-export { app as default };