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

package/dist/slack/routes/index.js

@@ -1,64 +0,0 @@
-import oauth_default from "./oauth.js";
-import users_default, { pendingSessionTokens } from "./users.js";
-import events_default from "./events.js";
-import internal_default from "./internal.js";
-import resources_default from "./resources.js";
-import workspaces_default from "./workspaces.js";
-import { OpenAPIHono } from "@hono/zod-openapi";
-
-//#region src/slack/routes/index.ts
-/**
-* Slack Work App Routes - Main Router
-*
-* Modular RESTful API structure:
-*
-* OAuth & Installation (oauth.ts):
-*   GET  /install                    - Redirect to Slack OAuth
-*   GET  /oauth_redirect             - OAuth callback
-*
-* Workspaces (workspaces.ts):
-*   GET  /workspaces                 - List all workspaces
-*   GET  /workspaces/:teamId         - Get workspace details
-*   GET  /workspaces/:teamId/settings - Get workspace settings
-*   PUT  /workspaces/:teamId/settings - Update workspace settings [ADMIN]
-*   DELETE /workspaces/:teamId       - Uninstall workspace [ADMIN]
-*   GET  /workspaces/:teamId/channels - List channels
-*   GET/PUT/DELETE /workspaces/:teamId/channels/:channelId/settings - Channel config
-*   GET  /workspaces/:teamId/users   - List linked users
-*
-* Users (users.ts):
-*   GET  /users/me/settings          - Get user's personal settings
-*   PUT  /users/me/settings          - Update user's personal settings
-*   GET  /users/link-status          - Check link status
-*   POST /users/link/verify-token    - Verify JWT link token (primary linking method)
-*   POST /users/connect              - Create Nango session
-*   POST /users/disconnect           - Disconnect/unlink user
-*   GET  /users/status               - Get user connection status
-*   POST /users/refresh-session      - Refresh session token
-*
-* Resources (resources.ts):
-*   GET  /projects                   - List projects
-*   GET  /projects/:projectId/agents - List agents in project
-*   GET  /agents                     - List all agents
-*
-* Events & Commands (events.ts):
-*   POST /commands                   - Handle slash commands
-*   POST /events                     - Handle Slack events
-*   POST /nango-webhook              - Handle Nango webhooks
-*
-* Internal/Debug (internal.ts):
-*   POST /register-workspace         - Register workspace (memory cache)
-*   GET  /workspace-info             - Get workspace info
-*   POST /debug/generate-token       - Generate test tokens (dev only)
-*/
-const app = new OpenAPIHono();
-app.route("/workspaces", workspaces_default);
-app.route("/users", users_default);
-app.route("/", oauth_default);
-app.route("/", events_default);
-app.route("/", internal_default);
-app.route("/", resources_default);
-var routes_default = app;
-
-//#endregion
-export { routes_default as default, pendingSessionTokens };

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

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

package/dist/slack/routes/internal.js

@@ -1,107 +0,0 @@
-import { env } from "../../env.js";
-import { getLogger } from "../../logger.js";
-import { getConnectionAccessToken } from "../services/nango.js";
-import { getSlackChannels, getSlackClient, getSlackTeamInfo } from "../services/client.js";
-import { setBotTokenForTeam } from "../services/workspace-tokens.js";
-import "../services/index.js";
-import "./oauth.js";
-import { OpenAPIHono } from "@hono/zod-openapi";
-
-//#region src/slack/routes/internal.ts
-/**
-* Slack Internal/Debug Routes
-*
-* Endpoints for internal operations and debugging:
-* - POST /register-workspace - Register workspace bot token (memory cache)
-* - POST /debug/generate-token - Generate test tokens (dev only)
-* - GET /workspace-info - Get workspace info from Nango
-*/
-const logger = getLogger("slack-internal");
-const app = new OpenAPIHono();
-app.post("/register-workspace", async (c) => {
-	const { teamId, teamName, botToken } = await c.req.json();
-	if (!teamId) return c.json({ error: "teamId is required" }, 400);
-	if (!botToken) return c.json({ error: "botToken is required" }, 400);
-	setBotTokenForTeam(teamId, {
-		botToken,
-		teamName: teamName || "",
-		installedAt: (/* @__PURE__ */ new Date()).toISOString()
-	});
-	logger.info({
-		teamId,
-		teamName
-	}, "Registered workspace bot token");
-	return c.json({
-		success: true,
-		teamId
-	});
-});
-app.get("/workspace-info", async (c) => {
-	const connectionId = c.req.query("connectionId");
-	if (!connectionId) return c.json({ error: "connectionId is required" }, 400);
-	try {
-		const accessToken = await getConnectionAccessToken(connectionId);
-		if (!accessToken) return c.json({ error: "No access token found" }, 404);
-		const client = getSlackClient(accessToken);
-		const [team, channels] = await Promise.all([getSlackTeamInfo(client), getSlackChannels(client, 20)]);
-		logger.debug({
-			hasTeam: !!team,
-			channelCount: channels.length
-		}, "Retrieved Slack workspace info");
-		return c.json({
-			team,
-			channels
-		});
-	} catch (error) {
-		logger.error({
-			error,
-			connectionId
-		}, "Failed to fetch Slack workspace info");
-		return c.json({ error: "Failed to fetch workspace info" }, 500);
-	}
-});
-app.post("/debug/generate-token", async (c) => {
-	if (env.ENVIRONMENT === "production") return c.json({ error: "This endpoint is not available in production" }, 403);
-	const { userId, tenantId, slackUserId, slackTeamId, slackEnterpriseId } = await c.req.json();
-	if (!userId) return c.json({ error: "userId is required" }, 400);
-	if (!slackUserId) return c.json({ error: "slackUserId is required" }, 400);
-	if (!slackTeamId) return c.json({ error: "slackTeamId is required" }, 400);
-	try {
-		const { signSlackUserToken } = await import("@inkeep/agents-core");
-		const token = await signSlackUserToken({
-			inkeepUserId: userId,
-			tenantId: tenantId || "default",
-			slackTeamId,
-			slackUserId,
-			slackEnterpriseId
-		});
-		logger.info({
-			userId,
-			tenantId: tenantId || "default",
-			slackTeamId,
-			slackUserId
-		}, "Generated Slack user token for debugging");
-		return c.json({
-			token,
-			expiresIn: "5m",
-			tokenType: "slackUser",
-			payload: {
-				sub: userId,
-				tenantId: tenantId || "default",
-				slack: {
-					teamId: slackTeamId,
-					userId: slackUserId,
-					enterpriseId: slackEnterpriseId
-				}
-			}
-		});
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger.error({ error: errorMessage }, "Failed to generate Slack user token");
-		return c.json({ error: `Failed to generate token: ${errorMessage}` }, 500);
-	}
-});
-var internal_default = app;
-
-//#endregion
-export { internal_default as default };

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

@@ -1,12 +0,0 @@
-import { WorkAppsVariables } from "../types.js";
-import { getBotTokenForTeam, setBotTokenForTeam } from "../services/workspace-tokens.js";
-import "../services/index.js";
-import { OpenAPIHono } from "@hono/zod-openapi";
-
-//#region src/slack/routes/oauth.d.ts
-
-declare const app: OpenAPIHono<{
-  Variables: WorkAppsVariables;
-}, {}, "/">;
-//#endregion
-export { app as default, getBotTokenForTeam, setBotTokenForTeam };

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