@sonde/packs 0.1.1 → 0.1.3

package/src/integrations/graph.test.ts

@@ -189,10 +189,10 @@ describe('graph pack', () => {
       expect(result).toBe(false);
     });
 
-    it('returns false on network error', async () => {
+    it('throws on network error', async () => {
       const fetchFn = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'));
-      const result = await graphPack.testConnection(graphConfig, graphCreds, fetchFn);
-      expect(result).toBe(false);
+      await expect(graphPack.testConnection(graphConfig, graphCreds, fetchFn))
+        .rejects.toThrow('ECONNREFUSED');
     });
   });
 

package/src/integrations/graph.ts

@@ -395,19 +395,15 @@ export const graphPack: IntegrationPack = {
   },
 
   testConnection: async (config, credentials, fetchFn) => {
-    try {
-      const token = await ensureGraphToken(credentials, fetchFn);
-      const url = `${config.endpoint.replace(/\/$/, '')}/organization?$select=id&$top=1`;
-      const res = await fetchFn(url, {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          Accept: 'application/json',
-          ...config.headers,
-        },
-      });
-      return res.ok;
-    } catch {
-      return false;
-    }
+    const token = await ensureGraphToken(credentials, fetchFn);
+    const url = `${config.endpoint.replace(/\/$/, '')}/organization?$select=id&$top=1`;
+    const res = await fetchFn(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        ...config.headers,
+      },
+    });
+    return res.ok;
   },
 };

package/src/integrations/httpbin.ts

@@ -62,11 +62,7 @@ export const httpbinPack: IntegrationPack = {
   },
 
   testConnection: async (config, _credentials, fetchFn) => {
-    try {
-      const res = await fetchFn(`${config.endpoint}/ip`);
-      return res.ok;
-    } catch {
-      return false;
-    }
+    const res = await fetchFn(`${config.endpoint}/ip`);
+    return res.ok;
   },
 };

package/src/integrations/jira.ts

@@ -0,0 +1,272 @@
+import type {
+  FetchFn,
+  IntegrationConfig,
+  IntegrationCredentials,
+  IntegrationPack,
+  IntegrationProbeHandler,
+} from '@sonde/shared';
+
+// --- Auth helpers ---
+
+/** Build Basic auth header from email + API token */
+function buildAuthHeaders(credentials: IntegrationCredentials): Record<string, string> {
+  const email = credentials.credentials.email ?? '';
+  const apiToken = credentials.credentials.apiToken ?? '';
+  if (email && apiToken) {
+    const encoded = Buffer.from(`${email}:${apiToken}`).toString('base64');
+    return { Authorization: `Basic ${encoded}` };
+  }
+  return {};
+}
+
+// --- REST helper ---
+
+async function jiraGet<T>(
+  path: string,
+  config: IntegrationConfig,
+  credentials: IntegrationCredentials,
+  fetchFn: FetchFn,
+  params?: Record<string, string>,
+): Promise<T> {
+  const base = `${config.endpoint.replace(/\/$/, '')}${path}`;
+  const url = new URL(base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+
+  const headers: Record<string, string> = {
+    Accept: 'application/json',
+    ...buildAuthHeaders(credentials),
+    ...config.headers,
+  };
+
+  const res = await fetchFn(url.toString(), { headers });
+  if (!res.ok) {
+    throw new Error(`Jira API returned ${res.status}: ${res.statusText}`);
+  }
+  return (await res.json()) as T;
+}
+
+// --- Probe handlers ---
+
+const issuesSearch: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const jql = params?.jql as string;
+  if (!jql) throw new Error('jql parameter is required');
+
+  const maxResults = (params?.max_results as number) || 50;
+  const queryParams: Record<string, string> = {
+    jql,
+    maxResults: String(maxResults),
+  };
+
+  const data = await jiraGet<{
+    issues?: Array<{
+      key: string;
+      fields?: {
+        summary?: string;
+        status?: { name?: string };
+        priority?: { name?: string };
+        assignee?: { displayName?: string };
+        created?: string;
+        updated?: string;
+        issuetype?: { name?: string };
+      };
+    }>;
+    total?: number;
+  }>('/rest/api/3/search/jql', config, credentials, fetchFn, queryParams);
+
+  const issues = data.issues ?? [];
+  return {
+    issues: issues.map((i) => ({
+      key: i.key,
+      summary: i.fields?.summary ?? null,
+      status: i.fields?.status?.name ?? null,
+      priority: i.fields?.priority?.name ?? null,
+      assignee: i.fields?.assignee?.displayName ?? null,
+      issueType: i.fields?.issuetype?.name ?? null,
+      created: i.fields?.created ?? null,
+      updated: i.fields?.updated ?? null,
+    })),
+    total: data.total ?? issues.length,
+    count: issues.length,
+  };
+};
+
+const issueDetail: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const key = params?.key as string;
+  if (!key) throw new Error('key parameter is required (e.g. PROJ-123)');
+
+  return jiraGet(`/rest/api/3/issue/${key}`, config, credentials, fetchFn);
+};
+
+const issueChangelog: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const key = params?.key as string;
+  if (!key) throw new Error('key parameter is required (e.g. PROJ-123)');
+
+  const data = await jiraGet<{
+    values?: Array<{
+      id?: string;
+      author?: { displayName?: string };
+      created?: string;
+      items?: Array<{
+        field?: string;
+        fromString?: string;
+        toString?: string;
+      }>;
+    }>;
+    total?: number;
+  }>(`/rest/api/3/issue/${key}/changelog`, config, credentials, fetchFn);
+
+  const entries = data.values ?? [];
+  return {
+    changelog: entries.map((e) => ({
+      id: e.id ?? null,
+      author: e.author?.displayName ?? null,
+      created: e.created ?? null,
+      items: (e.items ?? []).map((item) => ({
+        field: item.field ?? null,
+        from: item.fromString ?? null,
+        to: item.toString ?? null,
+      })),
+    })),
+    total: data.total ?? entries.length,
+  };
+};
+
+const projectsList: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const data = await jiraGet<{
+    values?: Array<{
+      key: string;
+      name: string;
+      projectTypeKey?: string;
+      style?: string;
+    }>;
+    total?: number;
+  }>('/rest/api/3/project/search', config, credentials, fetchFn);
+
+  const projects = data.values ?? [];
+  return {
+    projects: projects.map((p) => ({
+      key: p.key,
+      name: p.name,
+      projectType: p.projectTypeKey ?? null,
+      style: p.style ?? null,
+    })),
+    count: projects.length,
+  };
+};
+
+const jiraHealth: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const data = await jiraGet<{
+    baseUrl?: string;
+    version?: string;
+    deploymentType?: string;
+    serverTitle?: string;
+  }>('/rest/api/3/serverInfo', config, credentials, fetchFn);
+
+  return {
+    baseUrl: data.baseUrl ?? null,
+    version: data.version ?? null,
+    deploymentType: data.deploymentType ?? null,
+    serverTitle: data.serverTitle ?? null,
+  };
+};
+
+// --- Pack definition ---
+
+export const jiraPack: IntegrationPack = {
+  manifest: {
+    name: 'jira',
+    type: 'integration',
+    version: '0.1.0',
+    description: 'Atlassian Jira — issue search, details, changelog, and projects',
+    requires: { groups: [], files: [], commands: [] },
+    probes: [
+      {
+        name: 'issues.search',
+        description: 'Search issues via JQL query',
+        capability: 'observe',
+        params: {
+          jql: {
+            type: 'string',
+            description: 'JQL query (e.g. "project = PROJ AND status = Open")',
+            required: true,
+          },
+          max_results: {
+            type: 'number',
+            description: 'Maximum results to return (default: 50)',
+            required: false,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'issue.detail',
+        description: 'Get full issue details by key',
+        capability: 'observe',
+        params: {
+          key: {
+            type: 'string',
+            description: 'Issue key (e.g. PROJ-123)',
+            required: true,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'issue.changelog',
+        description: 'Get change history for an issue',
+        capability: 'observe',
+        params: {
+          key: {
+            type: 'string',
+            description: 'Issue key (e.g. PROJ-123)',
+            required: true,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'projects.list',
+        description: 'List all accessible projects',
+        capability: 'observe',
+        params: {},
+        timeout: 15000,
+      },
+      {
+        name: 'health',
+        description: 'Jira server info and connectivity check',
+        capability: 'observe',
+        params: {},
+        timeout: 10000,
+      },
+    ],
+    runbook: {
+      category: 'itsm',
+      probes: ['health', 'projects.list'],
+      parallel: true,
+    },
+  },
+
+  handlers: {
+    'issues.search': issuesSearch,
+    'issue.detail': issueDetail,
+    'issue.changelog': issueChangelog,
+    'projects.list': projectsList,
+    health: jiraHealth,
+  },
+
+  testConnection: async (config, credentials, fetchFn) => {
+    const url = `${config.endpoint.replace(/\/$/, '')}/rest/api/3/serverInfo`;
+    const headers: Record<string, string> = {
+      Accept: 'application/json',
+      ...buildAuthHeaders(credentials),
+      ...config.headers,
+    };
+
+    const res = await fetchFn(url, { headers });
+    return res.ok;
+  },
+};

package/src/integrations/loki.ts

@@ -0,0 +1,228 @@
+import type {
+  FetchFn,
+  IntegrationConfig,
+  IntegrationCredentials,
+  IntegrationPack,
+  IntegrationProbeHandler,
+} from '@sonde/shared';
+
+// --- Auth helpers ---
+
+/** Build auth headers: Basic (username:password) or Bearer token */
+function buildAuthHeaders(credentials: IntegrationCredentials): Record<string, string> {
+  if (credentials.authMethod === 'bearer_token') {
+    const token = credentials.credentials.token ?? '';
+    return { Authorization: `Bearer ${token}` };
+  }
+
+  const { username, password } = credentials.credentials;
+  if (username && password) {
+    const encoded = Buffer.from(`${username}:${password}`).toString('base64');
+    return { Authorization: `Basic ${encoded}` };
+  }
+  return {};
+}
+
+// --- REST helper ---
+
+async function lokiGet<T>(
+  path: string,
+  config: IntegrationConfig,
+  credentials: IntegrationCredentials,
+  fetchFn: FetchFn,
+  params?: Record<string, string>,
+): Promise<T> {
+  const base = `${config.endpoint.replace(/\/$/, '')}${path}`;
+  const url = new URL(base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+
+  const headers: Record<string, string> = {
+    Accept: 'application/json',
+    ...buildAuthHeaders(credentials),
+    ...config.headers,
+  };
+
+  const res = await fetchFn(url.toString(), { headers });
+  if (!res.ok) {
+    throw new Error(`Loki API returned ${res.status}: ${res.statusText}`);
+  }
+  return (await res.json()) as T;
+}
+
+// --- Probe handlers ---
+
+const lokiQuery: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const query = params?.query as string;
+  if (!query) throw new Error('query parameter is required (LogQL expression)');
+
+  const limit = (params?.limit as number) || 100;
+  const now = Math.floor(Date.now() / 1e9);
+  const start = params?.start as string | undefined;
+  const end = params?.end as string | undefined;
+
+  const queryParams: Record<string, string> = {
+    query,
+    limit: String(limit),
+    start: start ?? String(now - 3600),
+    end: end ?? String(now),
+  };
+
+  const data = await lokiGet<{
+    status?: string;
+    data?: {
+      resultType?: string;
+      result?: Array<{
+        stream?: Record<string, string>;
+        values?: Array<[string, string]>;
+      }>;
+    };
+  }>('/loki/api/v1/query_range', config, credentials, fetchFn, queryParams);
+
+  const results = data.data?.result ?? [];
+  return {
+    status: data.status ?? 'unknown',
+    resultType: data.data?.resultType ?? null,
+    results: results.map((r) => ({
+      stream: r.stream ?? {},
+      values: (r.values ?? []).map(([ts, line]) => ({
+        timestamp: ts,
+        line,
+      })),
+    })),
+    count: results.length,
+  };
+};
+
+const lokiLabels: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const data = await lokiGet<{
+    status?: string;
+    data?: string[];
+  }>('/loki/api/v1/labels', config, credentials, fetchFn);
+
+  return {
+    labels: data.data ?? [],
+    count: (data.data ?? []).length,
+  };
+};
+
+const lokiSeries: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const match = params?.match as string;
+  if (!match) throw new Error('match parameter is required (label selector)');
+
+  const data = await lokiGet<{
+    status?: string;
+    data?: Array<Record<string, string>>;
+  }>('/loki/api/v1/series', config, credentials, fetchFn, { match });
+
+  return {
+    series: data.data ?? [],
+    count: (data.data ?? []).length,
+  };
+};
+
+const lokiHealth: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const url = `${config.endpoint.replace(/\/$/, '')}/ready`;
+  const headers: Record<string, string> = {
+    ...buildAuthHeaders(credentials),
+    ...config.headers,
+  };
+
+  const res = await fetchFn(url, { headers });
+  return { ready: res.ok, status: res.status };
+};
+
+// --- Pack definition ---
+
+export const lokiPack: IntegrationPack = {
+  manifest: {
+    name: 'loki',
+    type: 'integration',
+    version: '0.1.0',
+    description: 'Grafana Loki — LogQL queries, labels, series, and health',
+    requires: { groups: [], files: [], commands: [] },
+    probes: [
+      {
+        name: 'query',
+        description: 'Run a LogQL query over a time range',
+        capability: 'observe',
+        params: {
+          query: {
+            type: 'string',
+            description: 'LogQL query expression (e.g. {job="varlogs"})',
+            required: true,
+          },
+          start: {
+            type: 'string',
+            description: 'Start time as Unix epoch seconds (default: 1 hour ago)',
+            required: false,
+          },
+          end: {
+            type: 'string',
+            description: 'End time as Unix epoch seconds (default: now)',
+            required: false,
+          },
+          limit: {
+            type: 'number',
+            description: 'Maximum log entries to return (default: 100)',
+            required: false,
+          },
+        },
+        timeout: 30000,
+      },
+      {
+        name: 'labels',
+        description: 'List all label names',
+        capability: 'observe',
+        params: {},
+        timeout: 10000,
+      },
+      {
+        name: 'series',
+        description: 'Find series matching a label selector',
+        capability: 'observe',
+        params: {
+          match: {
+            type: 'string',
+            description: 'Label selector (e.g. {job="varlogs"})',
+            required: true,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'health',
+        description: 'Loki readiness check',
+        capability: 'observe',
+        params: {},
+        timeout: 5000,
+      },
+    ],
+    runbook: {
+      category: 'observability',
+      probes: ['health', 'labels'],
+      parallel: true,
+    },
+  },
+
+  handlers: {
+    query: lokiQuery,
+    labels: lokiLabels,
+    series: lokiSeries,
+    health: lokiHealth,
+  },
+
+  testConnection: async (config, credentials, fetchFn) => {
+    const url = `${config.endpoint.replace(/\/$/, '')}/ready`;
+    const headers: Record<string, string> = {
+      ...buildAuthHeaders(credentials),
+      ...config.headers,
+    };
+
+    const res = await fetchFn(url, { headers });
+    return res.ok;
+  },
+};