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

package/dist/slack/routes/oauth.js

@@ -1,218 +0,0 @@
-import { env } from "../../env.js";
-import { getLogger } from "../../logger.js";
-import runDbClient_default from "../../db/runDbClient.js";
-import { computeWorkspaceConnectionId, storeWorkspaceInstallation } from "../services/nango.js";
-import { getSlackClient, getSlackTeamInfo, getSlackUserInfo } from "../services/client.js";
-import { getBotTokenForTeam, setBotTokenForTeam } from "../services/workspace-tokens.js";
-import "../services/index.js";
-import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { createWorkAppSlackWorkspace } from "@inkeep/agents-core";
-
-//#region src/slack/routes/oauth.ts
-/**
-* Slack OAuth Routes
-*
-* Endpoints for Slack workspace installation via OAuth:
-* - GET /install - Redirect to Slack OAuth page
-* - GET /oauth_redirect - Handle OAuth callback
-*/
-const logger = getLogger("slack-oauth");
-const app = new OpenAPIHono();
-app.openapi(createRoute({
-	method: "get",
-	path: "/install",
-	summary: "Install Slack App",
-	description: "Redirects to Slack OAuth page for workspace installation",
-	operationId: "slack-install",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"OAuth"
-	],
-	responses: { 302: { description: "Redirect to Slack OAuth" } }
-}), (c) => {
-	const clientId = env.SLACK_CLIENT_ID;
-	const redirectUri = `${env.SLACK_APP_URL}/work-apps/slack/oauth_redirect`;
-	const botScopes = [
-		"app_mentions:read",
-		"channels:history",
-		"channels:read",
-		"chat:write",
-		"chat:write.public",
-		"commands",
-		"groups:history",
-		"groups:read",
-		"im:history",
-		"im:read",
-		"im:write",
-		"team:read",
-		"users:read",
-		"users:read.email"
-	].join(",");
-	const slackAuthUrl = new URL("https://slack.com/oauth/v2/authorize");
-	slackAuthUrl.searchParams.set("client_id", clientId || "");
-	slackAuthUrl.searchParams.set("scope", botScopes);
-	slackAuthUrl.searchParams.set("redirect_uri", redirectUri);
-	logger.info({ redirectUri }, "Redirecting to Slack OAuth");
-	return c.redirect(slackAuthUrl.toString());
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/oauth_redirect",
-	summary: "Slack OAuth Callback",
-	description: "Handles the OAuth callback from Slack after workspace installation",
-	operationId: "slack-oauth-redirect",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"OAuth"
-	],
-	request: { query: z.object({
-		code: z.string().optional(),
-		error: z.string().optional()
-	}) },
-	responses: { 302: { description: "Redirect to dashboard with workspace data" } }
-}), async (c) => {
-	const { code, error } = c.req.valid("query");
-	const dashboardUrl = `${env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000"}/default/work-apps/slack`;
-	if (error) {
-		logger.error({ error }, "Slack OAuth error");
-		return c.redirect(`${dashboardUrl}?error=${encodeURIComponent(error)}`);
-	}
-	if (!code) {
-		logger.error({}, "No code provided in OAuth callback");
-		return c.redirect(`${dashboardUrl}?error=no_code`);
-	}
-	try {
-		const tokenData = await (await fetch("https://slack.com/api/oauth.v2.access", {
-			method: "POST",
-			headers: { "Content-Type": "application/x-www-form-urlencoded" },
-			body: new URLSearchParams({
-				client_id: env.SLACK_CLIENT_ID || "",
-				client_secret: env.SLACK_CLIENT_SECRET || "",
-				code,
-				redirect_uri: `${env.SLACK_APP_URL}/work-apps/slack/oauth_redirect`
-			})
-		})).json();
-		if (!tokenData.ok) {
-			logger.error({ error: tokenData.error }, "Slack token exchange failed");
-			return c.redirect(`${dashboardUrl}?error=${encodeURIComponent(tokenData.error || "token_exchange_failed")}`);
-		}
-		const client = getSlackClient(tokenData.access_token);
-		const teamInfo = await getSlackTeamInfo(client);
-		logger.debug({ teamInfo }, "Retrieved Slack team info");
-		const installerUserId = tokenData.authed_user?.id;
-		let installerUserName;
-		if (installerUserId) try {
-			const userInfo = await getSlackUserInfo(client, installerUserId);
-			installerUserName = userInfo?.realName || userInfo?.name;
-		} catch {
-			logger.warn({ installerUserId }, "Could not fetch installer user info");
-		}
-		const workspaceData = {
-			ok: true,
-			teamId: tokenData.team?.id,
-			teamName: tokenData.team?.name,
-			teamDomain: teamInfo?.domain,
-			workspaceUrl: teamInfo?.url,
-			workspaceIconUrl: teamInfo?.icon,
-			enterpriseId: tokenData.enterprise?.id,
-			enterpriseName: tokenData.enterprise?.name,
-			isEnterpriseInstall: tokenData.is_enterprise_install || false,
-			botUserId: tokenData.bot_user_id,
-			botToken: tokenData.access_token,
-			botScopes: tokenData.scope,
-			installerUserId,
-			installerUserName,
-			appId: tokenData.app_id,
-			installedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		if (workspaceData.teamId && workspaceData.botToken) {
-			const tenantId = "default";
-			const nangoResult = await storeWorkspaceInstallation({
-				teamId: workspaceData.teamId,
-				teamName: workspaceData.teamName,
-				teamDomain: workspaceData.teamDomain,
-				workspaceUrl: workspaceData.workspaceUrl,
-				workspaceIconUrl: workspaceData.workspaceIconUrl,
-				enterpriseId: workspaceData.enterpriseId,
-				enterpriseName: workspaceData.enterpriseName,
-				botUserId: workspaceData.botUserId,
-				botToken: workspaceData.botToken,
-				botScopes: workspaceData.botScopes,
-				installerUserId: workspaceData.installerUserId,
-				installerUserName: workspaceData.installerUserName,
-				isEnterpriseInstall: workspaceData.isEnterpriseInstall,
-				appId: workspaceData.appId,
-				tenantId,
-				installationSource: "dashboard"
-			});
-			if (nangoResult.success && nangoResult.connectionId) {
-				logger.info({
-					teamId: workspaceData.teamId,
-					connectionId: nangoResult.connectionId
-				}, "Stored workspace installation in Nango");
-				try {
-					await createWorkAppSlackWorkspace(runDbClient_default)({
-						tenantId,
-						slackTeamId: workspaceData.teamId,
-						slackEnterpriseId: workspaceData.enterpriseId,
-						slackAppId: workspaceData.appId,
-						slackTeamName: workspaceData.teamName,
-						nangoConnectionId: nangoResult.connectionId,
-						status: "active"
-					});
-					logger.info({
-						teamId: workspaceData.teamId,
-						tenantId
-					}, "Persisted workspace installation to database");
-				} catch (dbError) {
-					const dbErrorMessage = dbError instanceof Error ? dbError.message : String(dbError);
-					if (dbErrorMessage.includes("duplicate key") || dbErrorMessage.includes("unique constraint")) logger.info({
-						teamId: workspaceData.teamId,
-						tenantId
-					}, "Workspace already exists in database");
-					else logger.error({
-						error: dbErrorMessage,
-						teamId: workspaceData.teamId
-					}, "Failed to persist workspace to database");
-				}
-			} else logger.warn({ teamId: workspaceData.teamId }, "Failed to store in Nango, falling back to memory");
-			setBotTokenForTeam(workspaceData.teamId, {
-				botToken: workspaceData.botToken,
-				teamName: workspaceData.teamName || "",
-				installedAt: workspaceData.installedAt
-			});
-		}
-		logger.info({
-			teamId: workspaceData.teamId,
-			teamName: workspaceData.teamName
-		}, "Slack workspace installation successful");
-		const safeWorkspaceData = {
-			ok: workspaceData.ok,
-			teamId: workspaceData.teamId,
-			teamName: workspaceData.teamName,
-			teamDomain: workspaceData.teamDomain,
-			enterpriseId: workspaceData.enterpriseId,
-			enterpriseName: workspaceData.enterpriseName,
-			isEnterpriseInstall: workspaceData.isEnterpriseInstall,
-			botUserId: workspaceData.botUserId,
-			botScopes: workspaceData.botScopes,
-			installerUserId: workspaceData.installerUserId,
-			installedAt: workspaceData.installedAt,
-			connectionId: workspaceData.teamId ? computeWorkspaceConnectionId({
-				teamId: workspaceData.teamId,
-				enterpriseId: workspaceData.enterpriseId
-			}) : void 0
-		};
-		const encodedData = encodeURIComponent(JSON.stringify(safeWorkspaceData));
-		return c.redirect(`${dashboardUrl}?success=true&workspace=${encodedData}`);
-	} catch (err) {
-		logger.error({ error: err }, "Slack OAuth callback error");
-		return c.redirect(`${dashboardUrl}?error=callback_error`);
-	}
-});
-var oauth_default = app;
-
-//#endregion
-export { oauth_default as default, getBotTokenForTeam, setBotTokenForTeam };

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

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

package/dist/slack/routes/resources.js

@@ -1,163 +0,0 @@
-import { getLogger } from "../../logger.js";
-import manageDbClient_default from "../../db/manageDbClient.js";
-import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { listAgents, listProjectsPaginated } from "@inkeep/agents-core";
-
-//#region src/slack/routes/resources.ts
-/**
-* Slack Resources Routes
-*
-* Endpoints for listing projects and agents:
-* - GET /projects - List projects for tenant
-* - GET /projects/:projectId/agents - List agents in project
-* - GET /agents - List all agents (flat view)
-*/
-const logger = getLogger("slack-resources");
-const app = new OpenAPIHono();
-const ProjectSchema = z.object({
-	id: z.string(),
-	name: z.string().nullable(),
-	description: z.string().nullable().optional()
-});
-const AgentSchema = z.object({
-	id: z.string(),
-	name: z.string().nullable(),
-	projectId: z.string(),
-	projectName: z.string().nullable().optional()
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/projects",
-	summary: "List Projects",
-	description: "List all projects for the tenant",
-	operationId: "slack-list-projects",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Resources"
-	],
-	request: { query: z.object({
-		tenantId: z.string().optional().default("default"),
-		limit: z.coerce.number().optional().default(100)
-	}) },
-	responses: { 200: {
-		description: "List of projects",
-		content: { "application/json": { schema: z.object({ projects: z.array(ProjectSchema) }) } }
-	} }
-}), async (c) => {
-	const { tenantId, limit } = c.req.valid("query");
-	try {
-		const result = await listProjectsPaginated(manageDbClient_default)({
-			tenantId,
-			pagination: { limit }
-		});
-		return c.json({ projects: result.data.map((p) => ({
-			id: p.id,
-			name: p.name,
-			description: p.description
-		})) });
-	} catch (error) {
-		logger.error({
-			error,
-			tenantId
-		}, "Failed to list projects");
-		return c.json({ projects: [] });
-	}
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/projects/:projectId/agents",
-	summary: "List Agents in Project",
-	description: "List all agents within a specific project",
-	operationId: "slack-list-project-agents",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Resources"
-	],
-	request: {
-		params: z.object({ projectId: z.string() }),
-		query: z.object({ tenantId: z.string().optional().default("default") })
-	},
-	responses: { 200: {
-		description: "List of agents",
-		content: { "application/json": { schema: z.object({ agents: z.array(AgentSchema) }) } }
-	} }
-}), async (c) => {
-	const { projectId } = c.req.valid("param");
-	const { tenantId } = c.req.valid("query");
-	try {
-		const agents = await listAgents(manageDbClient_default)({ scopes: {
-			tenantId,
-			projectId
-		} });
-		return c.json({ agents: agents.map((a) => ({
-			id: a.id,
-			name: a.name,
-			projectId,
-			projectName: void 0
-		})) });
-	} catch (error) {
-		logger.error({
-			error,
-			tenantId,
-			projectId
-		}, "Failed to list agents");
-		return c.json({ agents: [] });
-	}
-});
-app.openapi(createRoute({
-	method: "get",
-	path: "/agents",
-	summary: "List All Agents",
-	description: "List all agents across all projects (flat view)",
-	operationId: "slack-list-all-agents",
-	tags: [
-		"Work Apps",
-		"Slack",
-		"Resources"
-	],
-	request: { query: z.object({ tenantId: z.string().optional().default("default") }) },
-	responses: { 200: {
-		description: "List of agents",
-		content: { "application/json": { schema: z.object({ agents: z.array(AgentSchema) }) } }
-	} }
-}), async (c) => {
-	const { tenantId } = c.req.valid("query");
-	try {
-		const projectsResult = await listProjectsPaginated(manageDbClient_default)({
-			tenantId,
-			pagination: { limit: 100 }
-		});
-		const allAgents = (await Promise.all((projectsResult.data || []).map(async (project) => {
-			try {
-				return (await listAgents(manageDbClient_default)({ scopes: {
-					tenantId,
-					projectId: project.id
-				} })).map((agent) => ({
-					id: agent.id,
-					name: agent.name,
-					projectId: project.id,
-					projectName: project.name
-				}));
-			} catch (error) {
-				logger.warn({
-					projectId: project.id,
-					error
-				}, "Failed to fetch agents for project");
-				return [];
-			}
-		}))).flat();
-		return c.json({ agents: allAgents });
-	} catch (error) {
-		logger.error({
-			error,
-			tenantId
-		}, "Failed to list agents");
-		return c.json({ agents: [] });
-	}
-});
-var resources_default = app;
-
-//#endregion
-export { resources_default as default };

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

@@ -1,15 +0,0 @@
-import { WorkAppsVariables } from "../types.js";
-import { OpenAPIHono } from "@hono/zod-openapi";
-
-//#region src/slack/routes/users.d.ts
-
-declare const app: OpenAPIHono<{
-  Variables: WorkAppsVariables;
-}, {}, "/">;
-declare const pendingSessionTokens: Map<string, {
-  token: string;
-  expiresAt: string;
-  createdAt: number;
-}>;
-//#endregion
-export { app as default, pendingSessionTokens };