@taodigital/connectors 0.0.0-stage → 1.2.0

package/dist/servicenow.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * ServiceNow connector — incident and change management integration.
+ * Credentials stored encrypted per project.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testConnection = testConnection;
+exports.createIncident = createIncident;
+exports.createChangeRequest = createChangeRequest;
+exports.listIncidents = listIncidents;
+const core_1 = require("@taodigital/core");
+function authHeader(creds) {
+    return 'Basic ' + Buffer.from(`${creds.username}:${creds.password}`).toString('base64');
+}
+function headers(creds) {
+    return {
+        Authorization: authHeader(creds),
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+    };
+}
+async function testConnection(creds) {
+    try {
+        await (0, core_1.assertResolvesToPublicAddress)(creds.instanceUrl);
+        const res = await fetch(`${creds.instanceUrl}/api/now/table/sys_user?sysparm_limit=1`, {
+            headers: headers(creds),
+        });
+        if (!res.ok)
+            return { ok: false, error: `ServiceNow returned ${res.status}` };
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: String(err) };
+    }
+}
+async function createIncident(creds, opts) {
+    await (0, core_1.assertResolvesToPublicAddress)(creds.instanceUrl);
+    const { getSystemConfig } = await import('@taodigital/core');
+    const snCfg = await getSystemConfig('connectors_servicenow');
+    const res = await fetch(`${creds.instanceUrl}/api/now/table/incident`, {
+        method: 'POST',
+        headers: headers(creds),
+        body: JSON.stringify({
+            short_description: opts.shortDescription,
+            description: opts.description,
+            urgency: String(opts.urgency ?? opts.defaultUrgency ?? 2),
+            impact: String(opts.impact ?? opts.defaultImpact ?? 2),
+            category: opts.category ?? opts.defaultCategory ?? String(snCfg?.defaultCategory ?? ''),
+            caller_id: creds.username,
+        }),
+    });
+    if (!res.ok)
+        throw new Error(`ServiceNow error: ${res.status} ${await res.text()}`);
+    const data = (await res.json());
+    return {
+        sysId: data.result?.sys_id,
+        number: data.result?.number,
+        url: `${creds.instanceUrl}/nav_to.do?uri=incident.do?sys_id=${data.result?.sys_id}`,
+    };
+}
+async function createChangeRequest(creds, opts) {
+    await (0, core_1.assertResolvesToPublicAddress)(creds.instanceUrl);
+    const res = await fetch(`${creds.instanceUrl}/api/now/table/change_request`, {
+        method: 'POST',
+        headers: headers(creds),
+        body: JSON.stringify({
+            short_description: opts.shortDescription,
+            description: opts.description,
+            type: opts.type ?? opts.defaultType ?? 'normal',
+            requested_by: creds.username,
+        }),
+    });
+    if (!res.ok)
+        throw new Error(`ServiceNow error: ${res.status}`);
+    const data = (await res.json());
+    return { sysId: data.result?.sys_id, number: data.result?.number };
+}
+async function listIncidents(creds, opts) {
+    await (0, core_1.assertResolvesToPublicAddress)(creds.instanceUrl);
+    const { getSystemConfig } = await import('@taodigital/core');
+    const snCfg = await getSystemConfig('connectors_servicenow');
+    const pageLimit = parseInt(String(snCfg?.pageLimit ?? '25'), 10);
+    const params = new URLSearchParams({
+        sysparm_limit: String(opts?.limit ?? pageLimit),
+        sysparm_fields: 'sys_id,number,short_description,state,urgency,priority,opened_at,caller_id',
+        sysparm_display_value: 'true',
+        ...(opts?.state ? { sysparm_query: `state=${opts.state}` } : {}),
+    });
+    const res = await fetch(`${creds.instanceUrl}/api/now/table/incident?${params}`, {
+        headers: headers(creds),
+    });
+    if (!res.ok)
+        throw new Error(`ServiceNow error: ${res.status}`);
+    const data = (await res.json());
+    return (data.result ?? []);
+}

package/package.json

@@ -1,6 +1,18 @@
 {
   "name": "@taodigital/connectors",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "DATABASE_URL=postgresql://mock:mock@localhost:5432/mock MIGRATION_DATABASE_URL=postgresql://mock:mock@localhost:5432/mock tsx --test src/**/*.test.ts"
+  },
+  "dependencies": {
+    "@taodigital/core": "*"
+  }
+}

package/src/azuredevops.ts

@@ -0,0 +1,141 @@
+/**
+ * Azure DevOps connector — credentials passed in, never read from env.
+ * Uses a Personal Access Token (PAT) stored encrypted in Connector.config.
+ *
+ * API reference: https://learn.microsoft.com/en-us/rest/api/azure/devops/
+ */
+
+import { assertResolvesToPublicAddress } from '@taodigital/core';
+
+export interface AzureDevOpsCredentials {
+  organization: string;  // Azure DevOps org name
+  project: string;       // project name or ID
+  pat: string;           // Personal Access Token
+  areaPath?: string;     // default work item area path (optional)
+}
+
+const API_VERSION = '7.1';
+
+function apiBase(creds: AzureDevOpsCredentials): string {
+  return `https://dev.azure.com/${encodeURIComponent(creds.organization)}/${encodeURIComponent(creds.project)}/_apis`;
+}
+
+function authHeaders(pat: string): Record<string, string> {
+  const encoded = Buffer.from(`:${pat}`).toString('base64');
+  return {
+    Authorization: `Basic ${encoded}`,
+    'Content-Type': 'application/json',
+  };
+}
+
+export async function testConnection(
+  creds: AzureDevOpsCredentials,
+): Promise<{ ok: boolean; login?: string; error?: string }> {
+  try {
+    await assertResolvesToPublicAddress('https://dev.azure.com');
+    const base = apiBase(creds);
+    const res = await fetch(
+      `${base}/wit/wiql?api-version=${API_VERSION}`,
+      {
+        method: 'POST',
+        headers: authHeaders(creds.pat),
+        body: JSON.stringify({ query: "SELECT [System.Id] FROM WorkItems WHERE [System.TeamProject] = @project ORDER BY [System.ChangedDate] DESC" }),
+        signal: AbortSignal.timeout(10_000),
+      },
+    );
+    if (res.status === 401) return { ok: false, error: 'Invalid PAT or insufficient permissions.' };
+    if (res.status === 404) return { ok: false, error: `Organization "${creds.organization}" or project "${creds.project}" not found.` };
+    if (!res.ok) return { ok: false, error: `Azure DevOps returned ${res.status}.` };
+    return { ok: true, login: `${creds.organization}/${creds.project}` };
+  } catch (err: any) {
+    return { ok: false, error: err?.message ?? 'Could not reach Azure DevOps.' };
+  }
+}
+
+export async function listRecentWorkItems(
+  creds: AzureDevOpsCredentials,
+  types: string[] = ['Bug', 'User Story', 'Task'],
+  limit = 20,
+): Promise<Array<{ id: number; title: string; type: string; state: string; url: string }>> {
+  await assertResolvesToPublicAddress('https://dev.azure.com');
+  const base = apiBase(creds);
+  const typeFilter = types.map((t) => `'${t}'`).join(', ');
+  const wiqlRes = await fetch(`${base}/wit/wiql?api-version=${API_VERSION}`, {
+    method: 'POST',
+    headers: authHeaders(creds.pat),
+    body: JSON.stringify({
+      query: `SELECT [System.Id],[System.Title],[System.WorkItemType],[System.State] FROM WorkItems WHERE [System.TeamProject] = @project AND [System.WorkItemType] IN (${typeFilter}) ORDER BY [System.ChangedDate] DESC`,
+    }),
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!wiqlRes.ok) throw new Error(`Azure DevOps WIQL error: ${wiqlRes.status}`);
+  const wiql = (await wiqlRes.json()) as any;
+  const ids: number[] = (wiql.workItems ?? []).slice(0, limit).map((w: any) => w.id);
+  if (ids.length === 0) return [];
+
+  const itemsRes = await fetch(
+    `${base}/wit/workitems?ids=${ids.join(',')}&fields=System.Id,System.Title,System.WorkItemType,System.State&api-version=${API_VERSION}`,
+    { headers: authHeaders(creds.pat), signal: AbortSignal.timeout(15_000) },
+  );
+  if (!itemsRes.ok) throw new Error(`Azure DevOps work items fetch error: ${itemsRes.status}`);
+  const items = (await itemsRes.json()) as any;
+  return (items.value ?? []).map((w: any) => ({
+    id: w.id,
+    title: w.fields?.['System.Title'] ?? '',
+    type: w.fields?.['System.WorkItemType'] ?? '',
+    state: w.fields?.['System.State'] ?? '',
+    url: `https://dev.azure.com/${creds.organization}/${creds.project}/_workitems/edit/${w.id}`,
+  }));
+}
+
+export async function createBug(
+  creds: AzureDevOpsCredentials,
+  title: string,
+  description: string,
+  priority: 1 | 2 | 3 | 4 = 2,
+): Promise<{ id: number; url: string; title: string }> {
+  await assertResolvesToPublicAddress('https://dev.azure.com');
+  const base = apiBase(creds);
+  const patchOps: any[] = [
+    { op: 'add', path: '/fields/System.Title', value: title },
+    { op: 'add', path: '/fields/Microsoft.VSTS.TCM.ReproSteps', value: description },
+    { op: 'add', path: '/fields/Microsoft.VSTS.Common.Priority', value: priority },
+  ];
+  if (creds.areaPath) {
+    patchOps.push({ op: 'add', path: '/fields/System.AreaPath', value: creds.areaPath });
+  }
+
+  const res = await fetch(`${base}/wit/workitems/$Bug?api-version=${API_VERSION}`, {
+    method: 'POST',
+    headers: { ...authHeaders(creds.pat), 'Content-Type': 'application/json-patch+json' },
+    body: JSON.stringify(patchOps),
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) throw new Error(`Azure DevOps create bug error: ${res.status}`);
+  const item = (await res.json()) as any;
+  return {
+    id: item.id,
+    title: item.fields?.['System.Title'] ?? title,
+    url: `https://dev.azure.com/${creds.organization}/${creds.project}/_workitems/edit/${item.id}`,
+  };
+}
+
+export async function listPipelines(
+  creds: AzureDevOpsCredentials,
+  limit = 10,
+): Promise<Array<{ id: number; name: string; status: string; url: string }>> {
+  await assertResolvesToPublicAddress('https://dev.azure.com');
+  const base = apiBase(creds);
+  const res = await fetch(
+    `${base}/pipelines?api-version=${API_VERSION}&$top=${limit}`,
+    { headers: authHeaders(creds.pat), signal: AbortSignal.timeout(15_000) },
+  );
+  if (!res.ok) throw new Error(`Azure DevOps pipelines error: ${res.status}`);
+  const data = (await res.json()) as any;
+  return (data.value ?? []).map((p: any) => ({
+    id: p.id,
+    name: p.name,
+    status: p._links?.web ? 'active' : 'unknown',
+    url: p._links?.web?.href ?? `https://dev.azure.com/${creds.organization}/${creds.project}/_build?definitionId=${p.id}`,
+  }));
+}

package/src/confluence.ts

@@ -0,0 +1,120 @@
+/**
+ * Confluence connector — reads pages for requirements-to-test generation.
+ * Same credential shape as JIRA (Atlassian unified auth).
+ */
+
+import { assertResolvesToPublicAddress } from '@taodigital/core';
+
+export interface ConfluenceCredentials {
+  baseUrl: string;    // e.g. https://yourcompany.atlassian.net or https://api.atlassian.com/ex/confluence/{cloudId}
+  email: string;
+  apiToken: string;
+  password?: string;  // Server / Data Center — takes priority over apiToken
+  spaceKey?: string;  // e.g. "QA" or "PROD"
+  bearerToken?: string; // Atlassian OAuth 2.0 token — same app as Jira
+  proxyUrl?: string;  // e.g. http://corporate-proxy:8080 — enables on-prem Confluence, skips SSRF guard
+}
+
+function validateProxyUrl(proxyUrl: string): void {
+  let parsed: URL;
+  try { parsed = new URL(proxyUrl); } catch { throw new Error(`Invalid proxy URL: ${proxyUrl}`); }
+  const h = parsed.hostname.toLowerCase();
+  if (h === 'localhost' || h === '127.0.0.1' || h === '::1' || h === '169.254.169.254') {
+    throw new Error('Proxy URL must not target localhost or metadata addresses');
+  }
+}
+
+async function makeFetch(creds: ConfluenceCredentials): Promise<typeof fetch> {
+  if (creds.proxyUrl) {
+    validateProxyUrl(creds.proxyUrl);
+    const { ProxyAgent } = await import('undici');
+    const dispatcher = new ProxyAgent(creds.proxyUrl);
+    return (url, init) => fetch(url, { ...(init ?? {}), dispatcher } as any);
+  }
+  return fetch;
+}
+
+function authHeader(creds: ConfluenceCredentials): string {
+  if (creds.bearerToken) return `Bearer ${creds.bearerToken}`;
+  const secret = creds.password || creds.apiToken;
+  return 'Basic ' + Buffer.from(`${creds.email}:${secret}`).toString('base64');
+}
+
+export async function testConnection(creds: ConfluenceCredentials): Promise<{ ok: boolean; error?: string }> {
+  try {
+    const doFetch = await makeFetch(creds);
+    if (!creds.proxyUrl) await assertResolvesToPublicAddress(creds.baseUrl);
+    const res = await doFetch(`${creds.baseUrl}/wiki/rest/api/user/current`, {
+      headers: { Authorization: authHeader(creds), Accept: 'application/json' },
+    });
+    if (!res.ok) return { ok: false, error: `Confluence returned ${res.status}` };
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+
+export async function listSpaces(creds: ConfluenceCredentials) {
+  await assertResolvesToPublicAddress(creds.baseUrl);
+  const { getSystemConfig } = await import('@taodigital/core');
+  const cfg = await getSystemConfig('connectors_confluence');
+  const spacesLimit = parseInt(String(cfg?.spacesLimit ?? '50'), 10);
+  const res = await fetch(`${creds.baseUrl}/wiki/rest/api/space?limit=${spacesLimit}`, {
+    headers: { Authorization: authHeader(creds), Accept: 'application/json' },
+  });
+  if (!res.ok) throw new Error(`Confluence error: ${res.status}`);
+  const data = (await res.json()) as any;
+  return (data.results ?? []).map((s: any) => ({ key: s.key, name: s.name }));
+}
+
+export async function listPages(creds: ConfluenceCredentials, spaceKey?: string, limit?: number) {
+  await assertResolvesToPublicAddress(creds.baseUrl);
+  const { getSystemConfig } = await import('@taodigital/core');
+  const cfg = await getSystemConfig('connectors_confluence');
+  const resolvedLimit = limit ?? parseInt(String(cfg?.pagesLimit ?? '25'), 10);
+  const space = spaceKey ?? creds.spaceKey;
+  const url = space
+    ? `${creds.baseUrl}/wiki/rest/api/content?spaceKey=${space}&limit=${resolvedLimit}&type=page`
+    : `${creds.baseUrl}/wiki/rest/api/content?limit=${resolvedLimit}&type=page`;
+
+  const res = await fetch(url, {
+    headers: { Authorization: authHeader(creds), Accept: 'application/json' },
+  });
+  if (!res.ok) throw new Error(`Confluence error: ${res.status}`);
+  const data = (await res.json()) as any;
+  return (data.results ?? []).map((p: any) => ({ id: p.id, title: p.title }));
+}
+
+export async function getPageContent(creds: ConfluenceCredentials, pageId: string): Promise<string> {
+  await assertResolvesToPublicAddress(creds.baseUrl);
+  const res = await fetch(
+    `${creds.baseUrl}/wiki/rest/api/content/${pageId}?expand=body.storage`,
+    { headers: { Authorization: authHeader(creds), Accept: 'application/json' } }
+  );
+  if (!res.ok) throw new Error(`Confluence error: ${res.status}`);
+  const page = (await res.json()) as any;
+  // Strip HTML tags for plain text consumption by the AI.
+  return (page.body?.storage?.value ?? '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+/** Full-text search across Confluence — finds pages that mention a screen URL or name. */
+export async function searchPages(creds: ConfluenceCredentials, text: string, limit?: number) {
+  await assertResolvesToPublicAddress(creds.baseUrl);
+  const { getSystemConfig } = await import('@taodigital/core');
+  const cfg = await getSystemConfig('connectors_confluence');
+  const resolvedLimit = limit ?? parseInt(String(cfg?.searchLimit ?? '5'), 10);
+  const safeText = text.replace(/["\\]/g, ' ').trim();
+  const spaceClause = creds.spaceKey ? ` AND space = "${creds.spaceKey}"` : '';
+  const cql = `type = page AND text ~ "${safeText}"${spaceClause} ORDER BY lastModified DESC`;
+  const res = await fetch(
+    `${creds.baseUrl}/wiki/rest/api/content/search?cql=${encodeURIComponent(cql)}&limit=${resolvedLimit}`,
+    { headers: { Authorization: authHeader(creds), Accept: 'application/json' } }
+  );
+  if (!res.ok) return [];
+  const data = (await res.json()) as any;
+  return (data.results ?? []).map((p: any) => ({
+    id: p.id,
+    title: p.title,
+    url: `${creds.baseUrl}/wiki${p._links?.webui ?? ''}`,
+  }));
+}