@hesed/sentry 0.1.0

package/dist/commands/sentry/project/issues.js

@@ -0,0 +1,44 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { readConfig } from '../../../config.js';
+import { formatAsToon } from '../../../format.js';
+import { clearClients, listProjectIssues } from '../../../sentry/sentry-client.js';
+export default class ProjectIssues extends Command {
+    static args = {
+        projectSlug: Args.string({ description: 'Project slug', required: true }),
+    };
+    static description = "List a Sentry project's issues";
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-project',
+        '<%= config.bin %> <%= command.id %> my-project --query "is:unresolved"',
+    ];
+    static flags = {
+        cursor: Flags.string({ description: 'Pagination cursor', required: false }),
+        query: Flags.string({ description: 'Search query (e.g. "is:unresolved")', required: false }),
+        'short-id-lookup': Flags.boolean({ description: 'Enable short ID lookup', required: false }),
+        'stats-period': Flags.string({ description: 'Time period (e.g. 24h, 7d)', required: false }),
+        toon: Flags.boolean({ description: 'Format output as toon', required: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProjectIssues);
+        const config = await readConfig(this.config.configDir, this.log.bind(this));
+        if (!config)
+            return;
+        const params = {};
+        if (flags.cursor)
+            params.cursor = flags.cursor;
+        if (flags.query)
+            params.query = flags.query;
+        if (flags['short-id-lookup'])
+            params.shortIdLookup = flags['short-id-lookup'];
+        if (flags['stats-period'])
+            params.statsPeriod = flags['stats-period'];
+        const result = await listProjectIssues(config.auth, args.projectSlug, params);
+        clearClients();
+        if (flags.toon) {
+            this.log(formatAsToon(result));
+        }
+        else {
+            this.logJson(result);
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+interface AuthConfig {
+    authToken: string;
+    host: string;
+    organization: string;
+}
+interface Config {
+    auth: AuthConfig;
+}
+export declare function readConfig(configDir: string, log: (message: string) => void): Promise<Config | undefined>;
+export {};

package/dist/config.js

@@ -0,0 +1,18 @@
+import { default as fs } from 'fs-extra';
+import { default as path } from 'node:path';
+export async function readConfig(configDir, log) {
+    const configPath = path.join(configDir, 'sentry-config.json');
+    try {
+        return await fs.readJSON(configPath);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.toLowerCase().includes('no such file or directory')) {
+            log('Missing authentication config');
+        }
+        else {
+            log(msg);
+        }
+        return undefined;
+    }
+}

package/dist/format.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Format data as TOON (Token-Oriented Object Notation)
+ */
+export declare function formatAsToon(data: unknown): string;

package/dist/format.js

@@ -0,0 +1,10 @@
+import { encode } from '@toon-format/toon';
+/**
+ * Format data as TOON (Token-Oriented Object Notation)
+ */
+export function formatAsToon(data) {
+    if (!data) {
+        return '';
+    }
+    return encode(data);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/sentry/sentry-api.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Generic API result
+ */
+export interface ApiResult {
+    data?: unknown;
+    error?: unknown;
+    success: boolean;
+}
+export interface Config {
+    authToken: string;
+    host: string;
+    organization: string;
+}
+/**
+ * Sentry REST API client
+ */
+export declare class SentryApi {
+    private config;
+    constructor(config: Config);
+    /**
+     * Clear client (no persistent client for REST API)
+     */
+    clearClients(): void;
+    /**
+     * Debug source maps for a project event
+     */
+    debugSourceMaps(projectSlug: string, eventId: string, params?: {
+        exception_idx?: string;
+        frame_idx?: string;
+    }): Promise<ApiResult>;
+    /**
+     * Retrieve an event for a project
+     */
+    getEvent(projectSlug: string, eventId: string): Promise<ApiResult>;
+    /**
+     * Retrieve an issue
+     */
+    getIssue(issueId: string): Promise<ApiResult>;
+    /**
+     * Retrieve a specific event from an issue
+     */
+    getIssueEvent(issueId: string, eventId: string): Promise<ApiResult>;
+    /**
+     * Retrieve tag details for an issue
+     */
+    getTagDetails(issueId: string, tagKey: string, params?: {
+        environment?: string[];
+    }): Promise<ApiResult>;
+    /**
+     * List an issue's events
+     */
+    listIssueEvents(issueId: string, params?: {
+        cursor?: string;
+        end?: string;
+        environment?: string[];
+        full?: boolean;
+        start?: string;
+        statsPeriod?: string;
+    }): Promise<ApiResult>;
+    /**
+     * List an issue's hashes
+     */
+    listIssueHashes(issueId: string, params?: {
+        cursor?: string;
+    }): Promise<ApiResult>;
+    /**
+     * List an organization's issues
+     */
+    listOrgIssues(params?: {
+        cursor?: string;
+        end?: string;
+        environment?: string[];
+        limit?: number;
+        project?: number[];
+        query?: string;
+        sort?: string;
+        start?: string;
+        statsPeriod?: string;
+    }): Promise<ApiResult>;
+    /**
+     * List a project's events
+     */
+    listProjectEvents(projectSlug: string, params?: {
+        cursor?: string;
+        end?: string;
+        full?: boolean;
+        start?: string;
+        statsPeriod?: string;
+    }): Promise<ApiResult>;
+    /**
+     * List a project's issues
+     */
+    listProjectIssues(projectSlug: string, params?: {
+        cursor?: string;
+        query?: string;
+        shortIdLookup?: boolean;
+        statsPeriod?: string;
+    }): Promise<ApiResult>;
+    /**
+     * List a tag's values for an issue
+     */
+    listTagValues(issueId: string, tagKey: string, params?: {
+        cursor?: string;
+        environment?: string[];
+    }): Promise<ApiResult>;
+    /**
+     * Test Sentry API connection
+     */
+    testConnection(): Promise<ApiResult>;
+    /**
+     * Update an issue
+     */
+    updateIssue(issueId: string, data: {
+        assignedTo?: string;
+        hasSeen?: boolean;
+        isBookmarked?: boolean;
+        isPublic?: boolean;
+        isSubscribed?: boolean;
+        status?: string;
+        statusDetails?: Record<string, unknown>;
+    }): Promise<ApiResult>;
+    /**
+     * Make an authenticated request to the Sentry API
+     */
+    private buildQueryString;
+    private request;
+}

package/dist/sentry/sentry-api.js

@@ -0,0 +1,176 @@
+/**
+ * Sentry REST API client
+ */
+export class SentryApi {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Clear client (no persistent client for REST API)
+     */
+    clearClients() { }
+    /**
+     * Debug source maps for a project event
+     */
+    async debugSourceMaps(projectSlug, eventId, params) {
+        return this.request(`/projects/${this.config.organization}/${projectSlug}/events/${eventId}/source-map-debug/`, {
+            params,
+        });
+    }
+    /**
+     * Retrieve an event for a project
+     */
+    async getEvent(projectSlug, eventId) {
+        return this.request(`/projects/${this.config.organization}/${projectSlug}/events/${eventId}/`);
+    }
+    /**
+     * Retrieve an issue
+     */
+    async getIssue(issueId) {
+        return this.request(`/organizations/${this.config.organization}/issues/${issueId}/`);
+    }
+    /**
+     * Retrieve a specific event from an issue
+     */
+    async getIssueEvent(issueId, eventId) {
+        return this.request(`/organizations/${this.config.organization}/issues/${issueId}/events/${eventId}/`);
+    }
+    /**
+     * Retrieve tag details for an issue
+     */
+    async getTagDetails(issueId, tagKey, params) {
+        return this.request(`/organizations/${this.config.organization}/issues/${issueId}/tags/${tagKey}/`, { params });
+    }
+    /**
+     * List an issue's events
+     */
+    async listIssueEvents(issueId, params) {
+        return this.request(`/organizations/${this.config.organization}/issues/${issueId}/events/`, { params });
+    }
+    /**
+     * List an issue's hashes
+     */
+    async listIssueHashes(issueId, params) {
+        return this.request(`/organizations/${this.config.organization}/issues/${issueId}/hashes/`, { params });
+    }
+    /**
+     * List an organization's issues
+     */
+    async listOrgIssues(params) {
+        return this.request(`/organizations/${this.config.organization}/issues/`, { params });
+    }
+    /**
+     * List a project's events
+     */
+    async listProjectEvents(projectSlug, params) {
+        return this.request(`/projects/${this.config.organization}/${projectSlug}/events/`, { params });
+    }
+    /**
+     * List a project's issues
+     */
+    async listProjectIssues(projectSlug, params) {
+        return this.request(`/projects/${this.config.organization}/${projectSlug}/issues/`, { params });
+    }
+    /**
+     * List a tag's values for an issue
+     */
+    async listTagValues(issueId, tagKey, params) {
+        return this.request(`/organizations/${this.config.organization}/issues/${issueId}/tags/${tagKey}/values/`, { params });
+    }
+    /**
+     * Test Sentry API connection
+     */
+    async testConnection() {
+        const result = await this.request(`/organizations/${this.config.organization}/issues/?limit=1`);
+        if (result.success) {
+            return {
+                data: { baseUrl: this.config.host, organization: this.config.organization },
+                success: true,
+            };
+        }
+        return result;
+    }
+    /**
+     * Update an issue
+     */
+    async updateIssue(issueId, data) {
+        return this.request(`/organizations/${this.config.organization}/issues/${issueId}/`, {
+            body: JSON.stringify(data),
+            method: 'PUT',
+        });
+    }
+    /**
+     * Make an authenticated request to the Sentry API
+     */
+    buildQueryString(params) {
+        const searchParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    searchParams.append(key, String(item));
+            }
+            else {
+                searchParams.set(key, String(value));
+            }
+        }
+        return searchParams.toString();
+    }
+    async request(path, options) {
+        try {
+            let url = `${this.config.host}${path}`;
+            if (options?.params) {
+                const qs = this.buildQueryString(options.params);
+                if (qs)
+                    url += `?${qs}`;
+            }
+            const headers = {
+                Accept: 'application/json',
+                Authorization: `Bearer ${this.config.authToken}`,
+            };
+            if (options?.body) {
+                headers['Content-Type'] = 'application/json';
+            }
+            // eslint-disable-next-line n/no-unsupported-features/node-builtins -- fetch is available in Node 18+
+            const response = await fetch(url, {
+                body: options?.body,
+                headers,
+                method: options?.method ?? 'GET',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorData;
+                try {
+                    errorData = JSON.parse(errorText);
+                }
+                catch {
+                    errorData = errorText;
+                }
+                return {
+                    error: errorData,
+                    success: false,
+                };
+            }
+            const text = await response.text();
+            if (!text) {
+                return {
+                    data: true,
+                    success: true,
+                };
+            }
+            const data = JSON.parse(text);
+            return {
+                data,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : String(error),
+                success: false,
+            };
+        }
+    }
+}

package/dist/sentry/sentry-client.d.ts

@@ -0,0 +1,61 @@
+import { type ApiResult, type Config } from './sentry-api.js';
+export declare function clearClients(): void;
+export declare function testConnection(config: Config): Promise<ApiResult>;
+export declare function listOrgIssues(config: Config, params?: {
+    cursor?: string;
+    end?: string;
+    environment?: string[];
+    limit?: number;
+    project?: number[];
+    query?: string;
+    sort?: string;
+    start?: string;
+    statsPeriod?: string;
+}): Promise<ApiResult>;
+export declare function getIssue(config: Config, issueId: string): Promise<ApiResult>;
+export declare function updateIssue(config: Config, issueId: string, data: {
+    assignedTo?: string;
+    hasSeen?: boolean;
+    isBookmarked?: boolean;
+    isPublic?: boolean;
+    isSubscribed?: boolean;
+    status?: string;
+    statusDetails?: Record<string, unknown>;
+}): Promise<ApiResult>;
+export declare function listIssueEvents(config: Config, issueId: string, params?: {
+    cursor?: string;
+    end?: string;
+    environment?: string[];
+    full?: boolean;
+    start?: string;
+    statsPeriod?: string;
+}): Promise<ApiResult>;
+export declare function getIssueEvent(config: Config, issueId: string, eventId: string): Promise<ApiResult>;
+export declare function listIssueHashes(config: Config, issueId: string, params?: {
+    cursor?: string;
+}): Promise<ApiResult>;
+export declare function getTagDetails(config: Config, issueId: string, tagKey: string, params?: {
+    environment?: string[];
+}): Promise<ApiResult>;
+export declare function listTagValues(config: Config, issueId: string, tagKey: string, params?: {
+    cursor?: string;
+    environment?: string[];
+}): Promise<ApiResult>;
+export declare function listProjectEvents(config: Config, projectSlug: string, params?: {
+    cursor?: string;
+    end?: string;
+    full?: boolean;
+    start?: string;
+    statsPeriod?: string;
+}): Promise<ApiResult>;
+export declare function listProjectIssues(config: Config, projectSlug: string, params?: {
+    cursor?: string;
+    query?: string;
+    shortIdLookup?: boolean;
+    statsPeriod?: string;
+}): Promise<ApiResult>;
+export declare function getEvent(config: Config, projectSlug: string, eventId: string): Promise<ApiResult>;
+export declare function debugSourceMaps(config: Config, projectSlug: string, eventId: string, params?: {
+    exception_idx?: string;
+    frame_idx?: string;
+}): Promise<ApiResult>;

package/dist/sentry/sentry-client.js

@@ -0,0 +1,66 @@
+import { SentryApi } from './sentry-api.js';
+let sentryApi = null;
+function initSentry(config) {
+    if (!sentryApi) {
+        sentryApi = new SentryApi(config);
+    }
+    return sentryApi;
+}
+export function clearClients() {
+    if (sentryApi) {
+        sentryApi.clearClients();
+        sentryApi = null;
+    }
+}
+export async function testConnection(config) {
+    const api = initSentry(config);
+    return api.testConnection();
+}
+export async function listOrgIssues(config, params) {
+    const api = initSentry(config);
+    return api.listOrgIssues(params);
+}
+export async function getIssue(config, issueId) {
+    const api = initSentry(config);
+    return api.getIssue(issueId);
+}
+export async function updateIssue(config, issueId, data) {
+    const api = initSentry(config);
+    return api.updateIssue(issueId, data);
+}
+export async function listIssueEvents(config, issueId, params) {
+    const api = initSentry(config);
+    return api.listIssueEvents(issueId, params);
+}
+export async function getIssueEvent(config, issueId, eventId) {
+    const api = initSentry(config);
+    return api.getIssueEvent(issueId, eventId);
+}
+export async function listIssueHashes(config, issueId, params) {
+    const api = initSentry(config);
+    return api.listIssueHashes(issueId, params);
+}
+export async function getTagDetails(config, issueId, tagKey, params) {
+    const api = initSentry(config);
+    return api.getTagDetails(issueId, tagKey, params);
+}
+export async function listTagValues(config, issueId, tagKey, params) {
+    const api = initSentry(config);
+    return api.listTagValues(issueId, tagKey, params);
+}
+export async function listProjectEvents(config, projectSlug, params) {
+    const api = initSentry(config);
+    return api.listProjectEvents(projectSlug, params);
+}
+export async function listProjectIssues(config, projectSlug, params) {
+    const api = initSentry(config);
+    return api.listProjectIssues(projectSlug, params);
+}
+export async function getEvent(config, projectSlug, eventId) {
+    const api = initSentry(config);
+    return api.getEvent(projectSlug, eventId);
+}
+export async function debugSourceMaps(config, projectSlug, eventId, params) {
+    const api = initSentry(config);
+    return api.debugSourceMaps(projectSlug, eventId, params);
+}