veryfront 0.0.48 → 0.0.50

package/dist/integrations/confluence/connector.json

@@ -0,0 +1,104 @@
+{
+  "name": "confluence",
+  "displayName": "Confluence",
+  "icon": "confluence.svg",
+  "description": "Search, read, and create documentation in Confluence",
+  "auth": {
+    "type": "oauth2",
+    "provider": "atlassian",
+    "authorizationUrl": "https://auth.atlassian.com/authorize",
+    "tokenUrl": "https://auth.atlassian.com/oauth/token",
+    "scopes": ["read:confluence-content.all", "write:confluence-content"],
+    "callbackPath": "/api/auth/confluence/callback",
+    "tokenAuthMethod": "client_secret_post",
+    "additionalParams": {
+      "audience": "api.atlassian.com",
+      "prompt": "consent"
+    },
+    "requiredApis": [
+      {
+        "name": "Atlassian OAuth 2.0 App",
+        "enableUrl": "https://developer.atlassian.com/console/myapps/"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "ATLASSIAN_CLIENT_ID",
+      "description": "Atlassian OAuth Client ID (from your OAuth 2.0 app)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.atlassian.com/console/myapps/"
+    },
+    {
+      "name": "ATLASSIAN_CLIENT_SECRET",
+      "description": "Atlassian OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.atlassian.com/console/myapps/"
+    }
+  ],
+  "tools": [
+    {
+      "id": "search-content",
+      "name": "Search Confluence",
+      "description": "Search for pages and blog posts in Confluence",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-page",
+      "name": "Get Page",
+      "description": "Get the content of a specific Confluence page",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-page",
+      "name": "Create Page",
+      "description": "Create a new page in a Confluence space",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-page",
+      "name": "Update Page",
+      "description": "Update the content of an existing Confluence page",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-spaces",
+      "name": "List Spaces",
+      "description": "List all accessible Confluence spaces",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "search-docs",
+      "title": "Search documentation",
+      "prompt": "Search Confluence for documentation about a specific topic or feature.",
+      "category": "productivity",
+      "icon": "search"
+    },
+    {
+      "id": "summarize-page",
+      "title": "Summarize a page",
+      "prompt": "Read and summarize a Confluence page. Extract key information and action items.",
+      "category": "productivity",
+      "icon": "document"
+    },
+    {
+      "id": "create-doc",
+      "title": "Create documentation",
+      "prompt": "Create a new documentation page in Confluence with structured content.",
+      "category": "productivity",
+      "icon": "plus"
+    },
+    {
+      "id": "update-doc",
+      "title": "Update documentation",
+      "prompt": "Update an existing Confluence page with new information while preserving existing content.",
+      "category": "productivity",
+      "icon": "edit"
+    }
+  ],
+  "suggestedWith": ["jira", "slack", "notion"]
+}

package/dist/integrations/confluence/files/_env.example

@@ -0,0 +1,4 @@
+# Atlassian OAuth credentials
+# Get these from: https://developer.atlassian.com/console/myapps/
+ATLASSIAN_CLIENT_ID=your_client_id_here
+ATLASSIAN_CLIENT_SECRET=your_client_secret_here

package/dist/integrations/confluence/files/ai/tools/create-page.ts

@@ -0,0 +1,43 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createPage, formatAsStorage } from "../../lib/confluence-client.ts";
+
+export default tool({
+  id: "create-page",
+  description:
+    "Create a new page in a Confluence space. Can optionally be created as a child of an existing page.",
+  inputSchema: z.object({
+    spaceKey: z.string().describe(
+      'The key of the space to create the page in (e.g., "TEAM", "DEV")',
+    ),
+    title: z.string().describe("Title of the new page"),
+    content: z.string().describe(
+      "Content for the page (can be plain text or Confluence storage format HTML)",
+    ),
+    parentId: z.string().optional().describe(
+      "Optional ID of the parent page to create this as a child page",
+    ),
+    type: z.enum(["page", "blogpost"]).default("page").describe("Type of content to create"),
+  }),
+  async execute({ spaceKey, title, content, parentId, type }) {
+    // Check if content looks like HTML, otherwise format as storage
+    const storageContent = content.trim().startsWith("<") ? content : formatAsStorage(content);
+
+    const page = await createPage({
+      spaceKey,
+      title,
+      content: storageContent,
+      parentId,
+      type,
+    });
+
+    return {
+      id: page.id,
+      title: page.title,
+      type: page.type,
+      url: page._links.webui,
+      version: page.version.number,
+      spaceId: page.spaceId,
+    };
+  },
+});

package/dist/integrations/confluence/files/ai/tools/get-page.ts

@@ -0,0 +1,30 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { extractPlainText, getPageContent } from "../../lib/confluence-client.ts";
+
+export default tool({
+  id: "get-page",
+  description:
+    "Get the content of a specific Confluence page. Returns the page title, content, and metadata.",
+  inputSchema: z.object({
+    pageId: z.string().describe("The ID of the Confluence page to retrieve"),
+  }),
+  async execute({ pageId }) {
+    const page = await getPageContent(pageId);
+
+    const content = page.body?.storage?.value || page.body?.view?.value || "";
+    const plainTextContent = extractPlainText(content);
+
+    return {
+      id: page.id,
+      type: page.type,
+      title: page.title,
+      content: plainTextContent,
+      htmlContent: content,
+      version: page.version.number,
+      url: page._links.webui,
+      spaceId: page.spaceId,
+      parentId: page.parentId,
+    };
+  },
+});

package/dist/integrations/confluence/files/ai/tools/list-spaces.ts

@@ -0,0 +1,31 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listSpaces } from "../../lib/confluence-client.ts";
+
+export default tool({
+  id: "list-spaces",
+  description: "List all accessible Confluence spaces. Returns space keys, names, and links.",
+  inputSchema: z.object({
+    type: z.enum(["global", "personal", "all"]).default("all").describe(
+      "Type of spaces to list (global, personal, or all)",
+    ),
+    limit: z.number().min(1).max(100).default(25).describe("Maximum number of spaces to return"),
+  }),
+  async execute({ type, limit }) {
+    const spaceType = type === "all" ? undefined : type;
+
+    const spaces = await listSpaces({
+      type: spaceType,
+      limit,
+    });
+
+    return spaces.map((space) => ({
+      id: space.id,
+      key: space.key,
+      name: space.name,
+      type: space.type,
+      status: space.status,
+      url: space._links.webui,
+    }));
+  },
+});

package/dist/integrations/confluence/files/ai/tools/search-content.ts

@@ -0,0 +1,38 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { searchContent } from "../../lib/confluence-client.ts";
+
+export default tool({
+  id: "search-content",
+  description:
+    "Search for pages and blog posts in Confluence. Returns matching content with titles, excerpts, and links.",
+  inputSchema: z.object({
+    query: z.string().describe("Search query to find pages or blog posts"),
+    spaceKey: z.string().optional().describe(
+      "Optional space key to limit search to a specific space",
+    ),
+    limit: z.number().min(1).max(50).default(10).describe("Maximum number of results to return"),
+  }),
+  async execute({ query, spaceKey, limit }) {
+    const results = await searchContent(query, {
+      spaceKey,
+      limit,
+    });
+
+    return results.map((result) => ({
+      id: result.content.id,
+      type: result.content.type,
+      title: result.content.title,
+      excerpt: result.excerpt,
+      url: result.url,
+      space: result.content.space
+        ? {
+          id: result.content.space.id,
+          key: result.content.space.key,
+          name: result.content.space.name,
+        }
+        : undefined,
+      lastUpdated: result.content.history?.lastUpdated.when,
+    }));
+  },
+});

package/dist/integrations/confluence/files/ai/tools/update-page.ts

@@ -0,0 +1,45 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatAsStorage, getPage, updatePage } from "../../lib/confluence-client.ts";
+
+export default tool({
+  id: "update-page",
+  description:
+    "Update the content or title of an existing Confluence page. Requires the current version number.",
+  inputSchema: z.object({
+    pageId: z.string().describe("The ID of the page to update"),
+    title: z.string().optional().describe(
+      "New title for the page (leave empty to keep current title)",
+    ),
+    content: z.string().optional().describe(
+      "New content for the page (can be plain text or Confluence storage format HTML)",
+    ),
+    versionMessage: z.string().optional().describe("Optional message describing the changes made"),
+  }),
+  async execute({ pageId, title, content, versionMessage }) {
+    // Get current page to retrieve version number
+    const currentPage = await getPage(pageId, ["version"]);
+
+    // Format content if provided
+    let storageContent: string | undefined;
+    if (content) {
+      storageContent = content.trim().startsWith("<") ? content : formatAsStorage(content);
+    }
+
+    const updatedPage = await updatePage(pageId, {
+      title,
+      content: storageContent,
+      version: currentPage.version.number + 1,
+      versionMessage,
+    });
+
+    return {
+      id: updatedPage.id,
+      title: updatedPage.title,
+      type: updatedPage.type,
+      url: updatedPage._links.webui,
+      version: updatedPage.version.number,
+      versionMessage: updatedPage.version.message,
+    };
+  },
+});

package/dist/integrations/confluence/files/app/api/auth/confluence/callback/route.ts

@@ -0,0 +1,11 @@
+/**
+ * Confluence OAuth Callback
+ */
+
+import { confluenceConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(confluenceConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

package/dist/integrations/confluence/files/app/api/auth/confluence/route.ts

@@ -0,0 +1,9 @@
+/**
+ * Confluence OAuth Initiation
+ */
+
+import { confluenceConfig, createOAuthInitHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(confluenceConfig, {
+  tokenStore: memoryTokenStore,
+});

package/dist/integrations/confluence/files/lib/confluence-client.ts

@@ -0,0 +1,281 @@
+import { getAccessToken, getCloudId } from "./token-store.ts";
+
+const CONFLUENCE_API_BASE = "https://api.atlassian.com/ex/confluence";
+
+interface ConfluenceResponse<T> {
+  results: T[];
+  size: number;
+  start?: number;
+  limit?: number;
+  _links?: {
+    next?: string;
+    base?: string;
+  };
+}
+
+export interface ConfluenceSpace {
+  id: string;
+  key: string;
+  name: string;
+  type: string;
+  status: string;
+  _links: {
+    webui: string;
+  };
+}
+
+export interface ConfluencePage {
+  id: string;
+  type: "page" | "blogpost";
+  status: string;
+  title: string;
+  spaceId?: string;
+  parentId?: string;
+  version: {
+    number: number;
+    message?: string;
+  };
+  body?: {
+    storage?: {
+      value: string;
+      representation: "storage";
+    };
+    view?: {
+      value: string;
+      representation: "view";
+    };
+  };
+  _links: {
+    webui: string;
+    tinyui?: string;
+  };
+}
+
+export interface ConfluenceSearchResult {
+  content: {
+    id: string;
+    type: string;
+    status: string;
+    title: string;
+    space?: {
+      id: string;
+      key: string;
+      name: string;
+    };
+    history?: {
+      lastUpdated: {
+        when: string;
+      };
+    };
+    _links: {
+      webui: string;
+    };
+  };
+  excerpt?: string;
+  url: string;
+  resultGlobalContainer?: {
+    title: string;
+  };
+}
+
+async function confluenceFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  const cloudId = await getCloudId();
+
+  if (!token || !cloudId) {
+    throw new Error("Not authenticated with Confluence. Please connect your Atlassian account.");
+  }
+
+  const url = `${CONFLUENCE_API_BASE}/${cloudId}${endpoint}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Confluence API error: ${response.status} ${error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listSpaces(options?: {
+  limit?: number;
+  type?: "global" | "personal";
+}): Promise<ConfluenceSpace[]> {
+  const params = new URLSearchParams();
+
+  if (options?.limit) {
+    params.set("limit", options.limit.toString());
+  }
+  if (options?.type) {
+    params.set("type", options.type);
+  }
+
+  const query = params.toString();
+  const endpoint = `/wiki/rest/api/space${query ? `?${query}` : ""}`;
+
+  const response = await confluenceFetch<ConfluenceResponse<ConfluenceSpace>>(endpoint);
+  return response.results || [];
+}
+
+export async function searchContent(
+  query: string,
+  options?: {
+    cql?: string;
+    limit?: number;
+    spaceKey?: string;
+  },
+): Promise<ConfluenceSearchResult[]> {
+  const params = new URLSearchParams();
+
+  // Build CQL query
+  let cqlQuery = options?.cql || `title ~ "${query}" OR text ~ "${query}"`;
+
+  if (options?.spaceKey) {
+    cqlQuery += ` AND space = "${options.spaceKey}"`;
+  }
+
+  params.set("cql", cqlQuery);
+
+  if (options?.limit) {
+    params.set("limit", options.limit.toString());
+  }
+
+  const response = await confluenceFetch<ConfluenceResponse<ConfluenceSearchResult>>(
+    `/wiki/rest/api/search?${params.toString()}`,
+  );
+
+  return response.results || [];
+}
+
+export function getPage(pageId: string, expand?: string[]): Promise<ConfluencePage> {
+  const params = new URLSearchParams();
+
+  if (expand && expand.length > 0) {
+    params.set("expand", expand.join(","));
+  }
+
+  const query = params.toString();
+  const endpoint = `/wiki/rest/api/content/${pageId}${query ? `?${query}` : ""}`;
+
+  return confluenceFetch<ConfluencePage>(endpoint);
+}
+
+export function getPageContent(pageId: string): Promise<ConfluencePage> {
+  return getPage(pageId, ["body.storage", "body.view", "version", "space"]);
+}
+
+export function createPage(options: {
+  spaceKey: string;
+  title: string;
+  content: string;
+  parentId?: string;
+  type?: "page" | "blogpost";
+}): Promise<ConfluencePage> {
+  const body = {
+    type: options.type || "page",
+    title: options.title,
+    space: {
+      key: options.spaceKey,
+    },
+    body: {
+      storage: {
+        value: options.content,
+        representation: "storage" as const,
+      },
+    },
+    ...(options.parentId && {
+      ancestors: [{ id: options.parentId }],
+    }),
+  };
+
+  return confluenceFetch<ConfluencePage>("/wiki/rest/api/content", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+export async function updatePage(
+  pageId: string,
+  options: {
+    title?: string;
+    content?: string;
+    version: number;
+    versionMessage?: string;
+  },
+): Promise<ConfluencePage> {
+  const _currentPage = await getPage(pageId, ["version"]);
+
+  const body: Record<string, unknown> = {
+    version: {
+      number: options.version,
+      message: options.versionMessage,
+    },
+    type: "page",
+  };
+
+  if (options.title) {
+    body.title = options.title;
+  }
+
+  if (options.content) {
+    body.body = {
+      storage: {
+        value: options.content,
+        representation: "storage",
+      },
+    };
+  }
+
+  return confluenceFetch<ConfluencePage>(`/wiki/rest/api/content/${pageId}`, {
+    method: "PUT",
+    body: JSON.stringify(body),
+  });
+}
+
+// Helper function to convert storage format to plain text
+export function extractPlainText(storageHtml: string): string {
+  // Remove HTML tags and decode entities
+  return storageHtml
+    .replace(/<[^>]*>/g, " ")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+// Helper to format text as Confluence storage format (simple HTML)
+export function formatAsStorage(text: string): string {
+  // Split by double newlines for paragraphs
+  const paragraphs = text.split("\n\n").filter((p) => p.trim());
+
+  return paragraphs
+    .map((p) => `<p>${escapeHtml(p.trim())}</p>`)
+    .join("\n");
+}
+
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}

package/dist/integrations/confluence/files/lib/token-store.ts

@@ -0,0 +1,5 @@
+/**
+ * Confluence Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";