@opengeni/api-router 0.30.3 → 1.0.0

package/src/integrations/slack-session-defaults.ts

@@ -0,0 +1,224 @@
+import {
+  resourceMountPath,
+  resourceMountPathCollisionKey,
+  type AccessGrant,
+  type GitHubRepository,
+  type RepositoryResourceRef,
+} from "@opengeni/contracts";
+import { listRecentSessionRepositoryResources } from "@opengeni/db";
+import { hasPermission, type ApiRouteDeps } from "@opengeni/core";
+import { githubRepositoryResourceRef, listWorkspaceGitHubRepositories } from "../github-access";
+
+/**
+ * A Slack task starts with at most this many repositories. Each one is a
+ * shallow, blob-filtered fetch before the first command, so the set stays
+ * small: the person's own most recently used repositories, not a catalog.
+ */
+export const SLACK_SESSION_RECENT_REPOSITORY_LIMIT = 5;
+
+/** How far back the person's own sessions count as recent use. */
+export const SLACK_SESSION_RECENT_REPOSITORY_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
+
+function githubUriKey(uri: string): string | null {
+  try {
+    const url = new URL(uri);
+    const path = url.pathname
+      .replace(/^\/+|\/+$/gu, "")
+      .replace(/\.git$/iu, "")
+      .toLowerCase();
+    return path ? `${url.host.toLowerCase()}/${path}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function positiveRepositoryId(value: unknown): number | null {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) return value;
+  if (typeof value === "string" && /^[1-9]\d{0,15}$/u.test(value)) {
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+/**
+ * Pick a Slack task's repositories: the person's recently used repositories,
+ * in recency order, that the workspace GitHub App catalog still offers them.
+ *
+ * `recent` is a usage signal only, and only repositories the person attached
+ * themselves count: an automatically attached (`optional`) one never does. A
+ * repository reaches the task only through its current catalog entry (the
+ * same catalog and `github:use` permission as the website picker), on its
+ * default branch, so a Slack task never reaches a repository the person could
+ * not attach on the website today. Archived and
+ * empty repositories are skipped when GitHub reported that, because a clone of
+ * an empty repository has nothing to check out. Every returned resource is
+ * best effort (`optional`): one failed clone warns instead of failing setup.
+ */
+export function selectRecentRepositoryResources(
+  recent: readonly RepositoryResourceRef[],
+  catalog: readonly GitHubRepository[],
+  limit = SLACK_SESSION_RECENT_REPOSITORY_LIMIT,
+): RepositoryResourceRef[] {
+  const byId = new Map<number, GitHubRepository[]>();
+  const byUri = new Map<string, GitHubRepository>();
+  const ordered = [...catalog].sort(
+    (left, right) => left.installationId - right.installationId || left.id - right.id,
+  );
+  for (const repository of ordered) {
+    byId.set(repository.id, [...(byId.get(repository.id) ?? []), repository]);
+    const key = githubUriKey(repository.cloneUrl);
+    if (key && !byUri.has(key)) byUri.set(key, repository);
+  }
+  const chosen = new Set<string>();
+  const mountKeys = new Set<string>();
+  const resources: RepositoryResourceRef[] = [];
+  for (const used of recent) {
+    if (resources.length >= limit) break;
+    // A repository OpenGeni attached automatically is not a choice the person
+    // made; counting it would keep re-attaching it to every later Slack task.
+    if (used.optional === true) continue;
+    const repositoryId = positiveRepositoryId(
+      used.githubRepositoryId ?? (used.provider === "github" ? used.repositoryId : undefined),
+    );
+    const installationId = positiveRepositoryId(
+      used.githubInstallationId ?? (used.provider === "github" ? used.installationId : undefined),
+    );
+    const candidates = repositoryId !== null ? (byId.get(repositoryId) ?? []) : [];
+    const uriKey = githubUriKey(used.uri);
+    const match =
+      candidates.find((candidate) => candidate.installationId === installationId) ??
+      candidates[0] ??
+      (uriKey ? byUri.get(uriKey) : undefined);
+    if (!match) continue;
+    const identity = `${match.installationId}:${match.id}`;
+    if (chosen.has(identity)) continue;
+    chosen.add(identity);
+    if (match.archived === true || match.sizeKb === 0) continue;
+    let resource: RepositoryResourceRef;
+    try {
+      resource = { ...githubRepositoryResourceRef(match), optional: true };
+    } catch {
+      // A malformed provider URL is one unusable repository, not a failed task.
+      continue;
+    }
+    const mountKey = resourceMountPathCollisionKey(resourceMountPath(resource));
+    if (mountKeys.has(mountKey)) continue;
+    mountKeys.add(mountKey);
+    resources.push(resource);
+  }
+  return resources;
+}
+
+/**
+ * The repositories a new Slack task starts with: the person's own recently
+ * used repositories in this workspace (their own top-level sessions active in
+ * the last 30 days, most recent first, at most five), limited to what the
+ * workspace GitHub App catalog offers them now. None when they have none; the
+ * agent can still find and clone repositories through its GitHub tools.
+ *
+ * GitHub is asked only when there is something to look up. A GitHub outage or
+ * an unconfigured App starts the task without repositories instead of failing
+ * it, with a log line for diagnosis.
+ */
+export async function slackRecentRepositoryResources(
+  deps: ApiRouteDeps,
+  grant: Pick<AccessGrant, "permissions" | "subjectId">,
+  workspaceId: string,
+  now: Date = new Date(),
+): Promise<RepositoryResourceRef[]> {
+  if (!hasPermission(grant.permissions, "github:use")) return [];
+  const recent = await listRecentSessionRepositoryResources(deps.db, {
+    workspaceId,
+    subjectId: grant.subjectId,
+    since: new Date(now.getTime() - SLACK_SESSION_RECENT_REPOSITORY_WINDOW_MS),
+  });
+  if (!recent.some((resource) => resource.optional !== true)) return [];
+  let catalog: GitHubRepository[];
+  try {
+    catalog = await listWorkspaceGitHubRepositories(deps, workspaceId);
+  } catch (error) {
+    console.error("[slack-interactions] workspace repositories unavailable", {
+      workspaceId,
+      errorCode: (error instanceof Error ? error.name : "unknown")
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]/gu, "_")
+        .slice(0, 128),
+    });
+    return [];
+  }
+  return selectRecentRepositoryResources(recent, catalog);
+}
+
+const OPEN_GENI_LINK_PATTERN =
+  /https?:\/\/([^\s/<>|?#]+)(\/workspaces\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?:\/sessions\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})?)/giu;
+
+const MAX_OTHER_DEPLOYMENT_LINKS = 5;
+
+export type OtherDeploymentLink = { url: string; host: string };
+
+function siteOf(hostname: string): string | null {
+  if (/^[\d.]+$/u.test(hostname) || hostname.includes(":")) return null;
+  const labels = hostname.split(".").filter(Boolean);
+  return labels.length >= 2 ? labels.slice(-2).join(".") : null;
+}
+
+/**
+ * OpenGeni workspace or session links in `text` that point at a sibling
+ * deployment of this one (for example staging versus production).
+ *
+ * A sibling is a different host under the same parent domain as this
+ * deployment's web origin, carrying OpenGeni's own route shape. Anything else
+ * is left alone: an unrelated product's URL must never be described as
+ * another OpenGeni.
+ */
+export function otherDeploymentLinks(
+  text: string,
+  webBaseUrl: string | null | undefined,
+): OtherDeploymentLink[] {
+  if (!webBaseUrl) return [];
+  let own: URL;
+  try {
+    own = new URL(webBaseUrl);
+  } catch {
+    return [];
+  }
+  const ownSite = siteOf(own.hostname.toLowerCase());
+  if (!ownSite) return [];
+  const found = new Map<string, OtherDeploymentLink>();
+  for (const match of text.matchAll(OPEN_GENI_LINK_PATTERN)) {
+    let url: URL;
+    try {
+      url = new URL(`https://${match[1]}${match[2]}`);
+    } catch {
+      continue;
+    }
+    const host = url.host.toLowerCase();
+    if (host === own.host.toLowerCase()) continue;
+    if (siteOf(url.hostname.toLowerCase()) !== ownSite) continue;
+    const canonical = `${match[0].split("://", 1)[0]!.toLowerCase()}://${host}${match[2]!.toLowerCase()}`;
+    if (!found.has(canonical)) found.set(canonical, { url: canonical, host });
+    if (found.size >= MAX_OTHER_DEPLOYMENT_LINKS) break;
+  }
+  return [...found.values()];
+}
+
+/**
+ * Model context for links to another OpenGeni deployment. A session id from
+ * one deployment does not exist in another, so without this the agent reports
+ * "Session not found or access denied" and asks for access that no grant in
+ * this deployment can give.
+ */
+export function otherDeploymentLinkContext(
+  text: string,
+  webBaseUrl: string | null | undefined,
+): string | null {
+  const links = otherDeploymentLinks(text, webBaseUrl);
+  if (links.length === 0 || !webBaseUrl) return null;
+  const ownHost = new URL(webBaseUrl).host.toLowerCase();
+  return [
+    `Links to a different Opengeni deployment (this one is ${ownHost}):`,
+    ...links.map((link) => `- ${link.url} is on ${link.host}.`),
+    `Workspaces, sessions and files from another deployment do not exist here, so looking up their ids in this deployment always fails as not found. Tell the user the link is for ${[...new Set(links.map((link) => link.host))].join(" and ")}, not ${ownHost}, instead of reporting the session as missing or asking for access to it.`,
+  ].join("\n");
+}

package/src/integrations/slack-task-file-upload.ts

@@ -0,0 +1,323 @@
+import { createHash } from "node:crypto";
+import {
+  hasOpenGeniSlackFileUploadScope,
+  OPENGENI_SLACK_BOT_CREDENTIAL_LABEL,
+  OPENGENI_SLACK_BOT_CREDENTIAL_ROLE,
+  type AccessGrant,
+} from "@opengeni/contracts";
+import {
+  fileOwnerContextForAgent,
+  hasPermission,
+  requireOpenGeniSlackBotConnection,
+  requirePermission,
+  type ApiRouteDeps,
+} from "@opengeni/core";
+import {
+  checkpointSlackFileUpload,
+  claimSlackFileUpload,
+  getSlackBotUserLink,
+  getSlackInteractionForSession,
+  recordAuditEvent,
+  releaseSlackFileUploadClaim,
+  renewSlackFileUploadClaim,
+  requireFileForSubject,
+  resolveSlackInstallationRoute,
+  resolveSlackTargetAuthority,
+  withSessionRlsActorContext,
+  type SlackInteraction,
+} from "@opengeni/db";
+import { HTTPException } from "hono/http-exception";
+import { createOpenGeniSlackBotInteractionClient } from "./slack-bot";
+import { runSlackFileUpload, SlackFileUploadClaimLostError } from "./slack-file-upload-flow";
+
+export const SLACK_TASK_FILE_UPLOAD_MAX_BYTES = 25 * 1024 * 1024;
+const CLAIM_LEASE_MS = 60_000;
+
+/** The source and destination are canonical authorities, never a URL or channel supplied by the model. */
+export async function uploadSlackTaskFile(
+  deps: ApiRouteDeps,
+  input: {
+    grant: AccessGrant;
+    sessionId: string;
+    fileId: string;
+    operationId: string;
+    authorize: () => Promise<void>;
+  },
+) {
+  await input.authorize();
+  const { grant } = input;
+  requirePermission(grant, "connections:read");
+  const actor = await fileOwnerContextForAgent(deps, grant, "files:read");
+  const scope = { accountId: grant.accountId, workspaceId: grant.workspaceId };
+  const resolveTarget = async () => {
+    const interaction = await getSlackInteractionForSession(deps.db, {
+      ...scope,
+      sessionId: input.sessionId,
+    });
+    if (
+      !interaction?.initiatingSlackUserId ||
+      !interaction.slackThreadTs ||
+      !/^\d{1,20}\.\d{1,12}$/.test(interaction.slackThreadTs)
+    ) {
+      throw new HTTPException(422, {
+        message: "File delivery requires this session's existing Slack task thread",
+      });
+    }
+    if (
+      interaction.visibility === "private" &&
+      actor.initiatingHumanSubjectId !== interaction.owningSubjectId
+    ) {
+      throw new HTTPException(403, {
+        message: "Private Slack file delivery requires the task owner's current attempt",
+      });
+    }
+    assertSlackTaskUploadTarget(interaction);
+    const home = await resolveSlackInstallationRoute(deps.db, interaction.slackTeamId);
+    if (
+      !home ||
+      home.accountId !== grant.accountId ||
+      home.connectionId !== interaction.connectionId
+    ) {
+      throw new HTTPException(403, { message: "Slack task installation authority changed" });
+    }
+    const link = await getSlackBotUserLink(
+      deps.db,
+      home.workspaceId,
+      interaction.connectionId,
+      interaction.initiatingSlackUserId,
+    );
+    if (!link || link.subjectId !== interaction.owningSubjectId) {
+      throw new HTTPException(403, { message: "Slack task requester is no longer linked" });
+    }
+    const requester = await resolveSlackTargetAuthority(deps.db, {
+      subjectId: link.subjectId,
+      targetAccountId: grant.accountId,
+      targetWorkspaceId: grant.workspaceId,
+    });
+    if (!requester || !slackTaskRequesterCanReceiveFile(requester.permissions)) {
+      throw new HTTPException(403, {
+        message: "Slack task requester no longer has file delivery access",
+      });
+    }
+    return { interaction, home };
+  };
+
+  return withSessionRlsActorContext(actor, async () => {
+    const target = await resolveTarget();
+    const file = await requireFileForSubject(deps.db, {
+      ...scope,
+      subjectId: grant.subjectId,
+      fileId: input.fileId,
+    });
+    if (file.workspaceId !== grant.workspaceId) {
+      throw new HTTPException(422, {
+        message: "Select a retained file from this Slack task's workspace",
+      });
+    }
+    assertSlackTaskUploadFile(file, target.interaction.visibility);
+    const connection = await requireOpenGeniSlackBotConnection(
+      deps.db,
+      target.home.workspaceId,
+      target.interaction.connectionId,
+    );
+    if (!hasOpenGeniSlackFileUploadScope(connection.grantedScopes)) {
+      throw new HTTPException(422, {
+        message:
+          "A Slack administrator must apply the Opengeni bot manifest and reinstall the bot to grant files:write. A personal Slack connection is not needed.",
+      });
+    }
+    if (!deps.objectStorage)
+      throw new HTTPException(503, { message: "Retained file storage is unavailable" });
+    let stored;
+    try {
+      stored = await deps.objectStorage.getObjectBytes(file.objectKey);
+    } catch {
+      throw new HTTPException(503, { message: "Retained file content is unavailable" });
+    }
+    if (
+      !stored ||
+      stored.bytes.byteLength !== file.sizeBytes ||
+      createHash("sha256").update(stored.bytes).digest("hex") !== file.sha256
+    ) {
+      throw new HTTPException(409, {
+        message: "Retained file content does not match its immutable identity",
+      });
+    }
+    const filename = file.safeFilename.slice(0, 200);
+    if (!filename || /[\r\n\0]/.test(filename))
+      throw new HTTPException(422, { message: "Invalid retained filename" });
+    const binding = {
+      ...scope,
+      sessionId: input.sessionId,
+      interactionId: target.interaction.id,
+      connectionId: target.interaction.connectionId,
+      fileId: input.fileId,
+      subjectId: actor.initiatingHumanSubjectId ?? grant.subjectId,
+      operationId: input.operationId,
+      requestDigest: createHash("sha256")
+        .update(
+          JSON.stringify({
+            fileId: file.id,
+            sha256: file.sha256,
+            sizeBytes: file.sizeBytes,
+            contentType: file.contentType,
+            filename,
+            channelId: target.interaction.slackChannelId,
+            threadTimestamp: target.interaction.slackThreadTs,
+            connectionId: target.interaction.connectionId,
+            slackTeamId: target.interaction.slackTeamId,
+          }),
+        )
+        .digest("hex"),
+    };
+    const claimHolderId = crypto.randomUUID();
+    const claim = await claimSlackFileUpload(deps.db, {
+      ...binding,
+      claimHolderId,
+      leaseMs: CLAIM_LEASE_MS,
+    });
+    if (claim.status === "conflict")
+      throw new HTTPException(409, {
+        message: "operationId is already bound to a different Slack file delivery",
+      });
+    if (claim.status === "busy")
+      throw new HTTPException(409, {
+        message: "Slack file delivery is already in progress; retry with the same operationId",
+      });
+    const claimScope = {
+      ...scope,
+      sessionId: input.sessionId,
+      operationId: input.operationId,
+      claimHolderId,
+    };
+    const authorizeProviderRequest = async () => {
+      await input.authorize();
+      await fileOwnerContextForAgent(deps, grant, "files:read");
+      const currentTarget = await resolveTarget();
+      if (
+        currentTarget.interaction.id !== target.interaction.id ||
+        currentTarget.interaction.connectionId !== target.interaction.connectionId ||
+        currentTarget.interaction.slackChannelId !== target.interaction.slackChannelId ||
+        currentTarget.interaction.slackThreadTs !== target.interaction.slackThreadTs ||
+        currentTarget.interaction.visibility !== target.interaction.visibility ||
+        currentTarget.home.workspaceId !== target.home.workspaceId
+      )
+        throw new HTTPException(403, { message: "Slack file delivery target changed" });
+      const currentFile = await requireFileForSubject(deps.db, {
+        ...scope,
+        subjectId: grant.subjectId,
+        fileId: file.id,
+      });
+      assertSlackTaskUploadFile(currentFile, currentTarget.interaction.visibility);
+      if (
+        currentFile.sha256 !== file.sha256 ||
+        currentFile.sizeBytes !== file.sizeBytes ||
+        currentFile.objectKey !== file.objectKey
+      ) {
+        throw new HTTPException(409, { message: "Slack file delivery source changed" });
+      }
+      if (!(await renewSlackFileUploadClaim(deps.db, { ...claimScope, leaseMs: CLAIM_LEASE_MS })))
+        throw new SlackFileUploadClaimLostError();
+    };
+    try {
+      const client = await createOpenGeniSlackBotInteractionClient(
+        { ...deps, authorizeProviderRequest },
+        {
+          accountId: target.home.accountId,
+          workspaceId: target.home.workspaceId,
+          connectionId: target.interaction.connectionId,
+          subjectId: grant.subjectId,
+          sessionId: input.sessionId,
+        },
+      );
+      const result = await runSlackFileUpload({
+        state: claim.operation,
+        provider: client,
+        checkpoint: (update) => checkpointSlackFileUpload(deps.db, { ...claimScope, ...update }),
+        channelId: target.interaction.slackChannelId,
+        threadTimestamp: target.interaction.slackThreadTs!,
+        ...(target.interaction.visibility === "private"
+          ? { privateRecipientSlackUserId: target.interaction.initiatingSlackUserId! }
+          : {}),
+        filename,
+        bytes: stored.bytes,
+      });
+      await recordAuditEvent(deps.db, {
+        ...scope,
+        subjectId: grant.subjectId,
+        action: "slack.file.upload",
+        targetType: "workspace_file",
+        targetId: file.id,
+        metadata: {
+          operationId: input.operationId,
+          sessionId: input.sessionId,
+          interactionId: target.interaction.id,
+          slackFileId: result.slackFileId,
+          replayed: result.replayed,
+        },
+      });
+      return {
+        status: "uploaded" as const,
+        fileId: file.id,
+        ...result,
+        channelId: target.interaction.slackChannelId,
+        threadTimestamp: target.interaction.slackThreadTs,
+        receipt: {
+          credentialRole: OPENGENI_SLACK_BOT_CREDENTIAL_ROLE,
+          credentialLabel: OPENGENI_SLACK_BOT_CREDENTIAL_LABEL,
+          connectionId: target.interaction.connectionId,
+          slackTeamId: target.interaction.slackTeamId,
+          operation: "file.upload",
+          operationId: input.operationId,
+        },
+      };
+    } finally {
+      if (claim.status === "claimed") await releaseSlackFileUploadClaim(deps.db, claimScope);
+    }
+  });
+}
+
+export function slackTaskRequesterCanReceiveFile(permissions: AccessGrant["permissions"]): boolean {
+  return hasPermission(permissions, "files:read") && hasPermission(permissions, "sessions:read");
+}
+
+/** Private shortcuts bind a runnable session before its bot-DM route commits. */
+export function assertSlackTaskUploadTarget(
+  interaction: Pick<
+    SlackInteraction,
+    "visibility" | "slackChannelId" | "slackThreadTs" | "routeKey" | "ackSlackMessageTs"
+  >,
+): void {
+  if (
+    interaction.visibility === "private" &&
+    (!interaction.slackChannelId.startsWith("D") ||
+      interaction.routeKey !== `${interaction.slackChannelId}:${interaction.slackThreadTs}` ||
+      (interaction.ackSlackMessageTs !== null &&
+        interaction.ackSlackMessageTs !== interaction.slackThreadTs))
+  ) {
+    throw new HTTPException(409, {
+      message: "Private Slack file delivery must wait for this task's committed bot-DM thread",
+    });
+  }
+}
+
+export function assertSlackTaskUploadFile(
+  file: { status: string; scope?: string | undefined; sizeBytes: number; sha256: string | null },
+  visibility: string,
+): void {
+  if (file.status !== "ready" || !file.sha256 || !/^[a-f0-9]{64}$/.test(file.sha256)) {
+    throw new HTTPException(422, {
+      message: "Publish a ready, immutable file before uploading it to Slack",
+    });
+  }
+  if (file.scope === "personal" && visibility !== "private") {
+    throw new HTTPException(403, {
+      message: "Personal files cannot be uploaded to a shared Slack task thread",
+    });
+  }
+  if (file.sizeBytes < 1 || file.sizeBytes > SLACK_TASK_FILE_UPLOAD_MAX_BYTES) {
+    throw new HTTPException(413, {
+      message: "Slack task file delivery supports nonempty files up to 25 MiB",
+    });
+  }
+}