@vellumai/assistant 0.8.3 → 0.8.4

package/src/runtime/routes/sanity-routes.ts

@@ -0,0 +1,159 @@
+/**
+ * Route definitions for Sanity CMS connection management.
+ *
+ * POST /v1/sanity/discover — project/dataset discovery using the stored API token
+ * POST /v1/sanity/connect  — finalise connection by writing the sidecar file
+ *
+ * Both routes use policyKey: "secrets" — they read credentials and write
+ * workspace data, the same policy tier as the existing secrets routes.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { z } from "zod";
+
+import { credentialKey } from "../../security/credential-key.js";
+import { getSecureKeyAsync } from "../../security/secure-keys.js";
+import { getWorkspaceDir } from "../../util/platform.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function getStoredToken(): Promise<string | undefined> {
+  return getSecureKeyAsync(credentialKey("sanity", "api_token"));
+}
+
+function writeSidecar(relPath: string, data: Record<string, unknown>): void {
+  const workspaceDir = getWorkspaceDir();
+  const absPath = join(workspaceDir, relPath);
+  mkdirSync(dirname(absPath), { recursive: true });
+  writeFileSync(absPath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/discover
+// ---------------------------------------------------------------------------
+
+async function handleDiscover(
+  args: RouteHandlerArgs,
+): Promise<Record<string, unknown>> {
+  const token = await getStoredToken();
+  if (!token) {
+    return { error: "no_token" };
+  }
+
+  const projectId =
+    typeof args.body?.projectId === "string" ? args.body.projectId : undefined;
+
+  if (!projectId) {
+    // List all projects this token has access to
+    const response = await fetch("https://api.sanity.io/v2021-06-07/projects", {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      return { error: "token_scope_limited" };
+    }
+
+    if (!response.ok) {
+      return { error: "discovery_failed" };
+    }
+
+    const raw = (await response.json()) as Array<{
+      id: string;
+      displayName?: string;
+    }>;
+    const projects = raw.map((p) => ({
+      id: p.id,
+      displayName: p.displayName ?? p.id,
+    }));
+    return { projects };
+  }
+
+  // List datasets for a specific project
+  const response = await fetch(
+    `https://api.sanity.io/v2021-06-07/projects/${projectId}/datasets`,
+    {
+      headers: { Authorization: `Bearer ${token}` },
+    },
+  );
+
+  if (response.status === 401 || response.status === 403) {
+    return { error: "token_scope_limited" };
+  }
+
+  if (!response.ok) {
+    return { error: "discovery_failed" };
+  }
+
+  const raw = (await response.json()) as Array<{ name: string }>;
+  const datasets = raw.map((d) => d.name);
+  return { projectId, datasets };
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/connect
+// ---------------------------------------------------------------------------
+
+async function handleConnect(
+  args: RouteHandlerArgs,
+): Promise<Record<string, unknown>> {
+  const token = await getStoredToken();
+  if (!token) {
+    throw new BadRequestError(
+      "Sanity API token not found. Store it first via POST /v1/secrets.",
+    );
+  }
+
+  const projectId =
+    typeof args.body?.projectId === "string" ? args.body.projectId.trim() : "";
+  const dataset =
+    typeof args.body?.dataset === "string" ? args.body.dataset.trim() : "";
+
+  if (!projectId) {
+    throw new BadRequestError(
+      "projectId is required and must be a non-empty string",
+    );
+  }
+  if (!dataset) {
+    throw new BadRequestError(
+      "dataset is required and must be a non-empty string",
+    );
+  }
+
+  writeSidecar("data/sanity-connection.json", { projectId, dataset });
+
+  return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "sanity_discover",
+    endpoint: "sanity/discover",
+    method: "POST",
+    policyKey: "secrets",
+    summary: "Discover Sanity projects and datasets using the stored API token",
+    requestBody: z.object({ projectId: z.string().optional() }).optional(),
+    handler: handleDiscover,
+  },
+  {
+    operationId: "sanity_connect",
+    endpoint: "sanity/connect",
+    method: "POST",
+    policyKey: "secrets",
+    summary: "Finalise Sanity connection and write sidecar file",
+    requestBody: z.object({
+      projectId: z.string(),
+      dataset: z.string(),
+    }),
+    handler: handleConnect,
+  },
+];

package/src/runtime/routes/slack-channel-routes.ts

@@ -0,0 +1,187 @@
+import { z } from "zod";
+
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../../daemon/message-types/sync.js";
+import {
+  getBindingByConversation,
+  updateExternalChatName,
+} from "../../memory/external-conversation-store.js";
+import {
+  getSlackConversationInfo,
+  SlackApiError,
+} from "../../messaging/providers/slack/api.js";
+import { publishSyncInvalidation } from "../sync/sync-publisher.js";
+import { NotFoundError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+type ResolveReason =
+  | "auth"
+  | "dm"
+  | "no_name"
+  | "not_found"
+  | "permission"
+  | "rate_limit"
+  | "slack_error";
+
+interface SlackChannelResolveResponse {
+  channelId: string;
+  channelName?: string;
+  cached: boolean;
+  resolved: boolean;
+  reason?: ResolveReason;
+}
+
+const SlackChannelResolveResponseSchema = z.object({
+  channelId: z.string(),
+  channelName: z.string().optional(),
+  cached: z.boolean(),
+  resolved: z.boolean(),
+  reason: z
+    .enum([
+      "auth",
+      "dm",
+      "no_name",
+      "not_found",
+      "permission",
+      "rate_limit",
+      "slack_error",
+    ])
+    .optional(),
+});
+
+function friendlyCachedName(
+  externalChatId: string,
+  externalChatName?: string | null,
+): string | undefined {
+  const trimmed = externalChatName?.trim();
+  if (!trimmed || trimmed === externalChatId) return undefined;
+  return trimmed;
+}
+
+function usableResolvedName(
+  externalChatId: string,
+  name?: string,
+  nameNormalized?: string,
+): string | undefined {
+  for (const candidate of [name, nameNormalized]) {
+    const trimmed = candidate?.trim();
+    if (trimmed && trimmed !== externalChatId) return trimmed;
+  }
+  return undefined;
+}
+
+function reasonForSlackError(err: unknown): ResolveReason {
+  if (err instanceof SlackApiError) {
+    switch (err.category) {
+      case "auth":
+        return "auth";
+      case "channel_not_found":
+      case "not_found":
+        return "not_found";
+      case "permission":
+        return "permission";
+      case "rate_limit":
+        return "rate_limit";
+      default:
+        return "slack_error";
+    }
+  }
+  return "slack_error";
+}
+
+async function handleSlackChannelNameResolve({
+  pathParams = {},
+}: RouteHandlerArgs): Promise<SlackChannelResolveResponse> {
+  const conversationId = pathParams.conversationId?.trim();
+  if (!conversationId) {
+    throw new NotFoundError("Conversation not found");
+  }
+
+  const binding = getBindingByConversation(conversationId);
+
+  if (!binding || binding.sourceChannel !== "slack") {
+    throw new NotFoundError("Conversation not found");
+  }
+
+  const channelId = binding.externalChatId;
+  const cachedName = friendlyCachedName(channelId, binding.externalChatName);
+  if (cachedName) {
+    return {
+      channelId,
+      channelName: cachedName,
+      cached: true,
+      resolved: true,
+    };
+  }
+
+  if (channelId.startsWith("D")) {
+    return {
+      channelId,
+      cached: false,
+      resolved: false,
+      reason: "dm",
+    };
+  }
+
+  let info;
+  try {
+    info = await getSlackConversationInfo(channelId);
+  } catch (err) {
+    return {
+      channelId,
+      cached: false,
+      resolved: false,
+      reason: reasonForSlackError(err),
+    };
+  }
+
+  const channelName = usableResolvedName(
+    channelId,
+    info?.name,
+    info?.nameNormalized,
+  );
+  if (!channelName) {
+    return {
+      channelId,
+      cached: false,
+      resolved: false,
+      reason: "no_name",
+    };
+  }
+
+  updateExternalChatName(conversationId, channelName);
+  await publishSyncInvalidation([
+    SYNC_TAGS.conversationsList,
+    conversationMetadataSyncTag(conversationId),
+  ]);
+
+  return {
+    channelId,
+    channelName,
+    cached: false,
+    resolved: true,
+  };
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "slack_channel_name_resolve",
+    endpoint: "conversations/:conversationId/slack-channel/resolve",
+    method: "POST",
+    handler: handleSlackChannelNameResolve,
+    summary: "Resolve Slack channel name",
+    description:
+      "Resolve and persist a friendly Slack channel name for an external conversation binding.",
+    tags: ["conversations", "slack"],
+    pathParams: [
+      {
+        name: "conversationId",
+        type: "string",
+        description: "Conversation ID whose Slack channel name should resolve.",
+      },
+    ],
+    responseBody: SlackChannelResolveResponseSchema,
+  },
+];

package/src/runtime/services/conversation-serializer.ts

@@ -23,7 +23,10 @@ import {
 } from "../../memory/conversation-crud.js";
 import type { ExternalConversationBinding } from "../../memory/external-conversation-store.js";
 import { getBindingsForConversations } from "../../memory/external-conversation-store.js";
-import { buildSlackMessageDeepLinks } from "../../messaging/providers/slack/deep-link.js";
+import {
+  buildSlackMessageDeepLinks,
+  buildSlackWebChannelUrl,
+} from "../../messaging/providers/slack/deep-link.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -91,10 +94,11 @@ function buildForkParent(
 }
 
 function buildChannelBinding(binding: ExternalConversationBinding) {
+  const externalChatName =
+    binding.externalChatName?.trim() ||
+    (binding.sourceChannel === "slack" ? binding.externalChatId : undefined);
   const slackConfig =
-    binding.sourceChannel === "slack" && binding.externalThreadId
-      ? getConfig().slack
-      : undefined;
+    binding.sourceChannel === "slack" ? getConfig().slack : undefined;
   const slackThreadLink =
     slackConfig && binding.externalThreadId
       ? buildSlackMessageDeepLinks({
@@ -112,10 +116,31 @@ function buildChannelBinding(binding: ExternalConversationBinding) {
           ...(slackThreadLink ? { link: slackThreadLink } : {}),
         }
       : undefined;
+  const slackChannelWebUrl = slackConfig
+    ? buildSlackWebChannelUrl({
+        teamUrl: slackConfig.teamUrl,
+        channelId: binding.externalChatId,
+      })
+    : undefined;
+  const slackChannel =
+    binding.sourceChannel === "slack"
+      ? {
+          channelId: binding.externalChatId,
+          name: externalChatName,
+          ...(slackChannelWebUrl
+            ? {
+                link: {
+                  webUrl: slackChannelWebUrl,
+                },
+              }
+            : {}),
+        }
+      : undefined;
 
   return {
     sourceChannel: binding.sourceChannel,
     externalChatId: binding.externalChatId,
+    ...(externalChatName ? { externalChatName } : {}),
     ...(binding.externalThreadId
       ? { externalThreadId: binding.externalThreadId }
       : {}),
@@ -123,6 +148,7 @@ function buildChannelBinding(binding: ExternalConversationBinding) {
     displayName: binding.displayName,
     username: binding.username,
     ...(slackThread ? { slackThread } : {}),
+    ...(slackChannel ? { slackChannel } : {}),
   };
 }
 

package/src/schedule/integration-status.ts

@@ -10,7 +10,9 @@ import {
  * Check whether a provider has an active connection, handling both BYO
  * (local SQLite) and managed (platform) modes.
  */
-async function isOAuthProviderConnected(provider: string): Promise<boolean> {
+export async function isOAuthProviderConnected(
+  provider: string,
+): Promise<boolean> {
   const providerRow = getProvider(provider);
   const managedKey = providerRow?.managedServiceConfigKey;