edsger 0.76.0 → 0.78.0

package/dist/phases/sync-org-repos/index.js

@@ -1,133 +0,0 @@
-/**
- * Phase: sync-org-repos
- *
- * Fetches all repositories from a GitHub organization via the Edsger GitHub
- * App (server-side, through the MCP `github/org_repos` endpoint), then upserts
- * a row into the team-scoped `repositories` table for each repo. Products are
- * NOT created here — a product is a higher-level grouping that a user links one
- * or more repositories to afterwards.
- *
- * Repos are listed with a short-lived GitHub App installation token minted on
- * the server, so this no longer depends on the user's machine having the `gh`
- * CLI installed, authenticated, and on PATH. Forks and archived repos are
- * filtered out server-side.
- */
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-import { logDebug, logError, logInfo, logWarning } from '../../utils/logger.js';
-const ORG_NAME_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
-async function fetchOrgRepos(teamId, orgLogin, verbose) {
-    logInfo(`Fetching repos for org "${orgLogin}" via Edsger GitHub App...`);
-    const result = (await callMcpEndpoint('github/org_repos', {
-        team_id: teamId,
-        org: orgLogin,
-    }));
-    if (!result.configured) {
-        throw new Error(result.message ||
-            `The Edsger GitHub App is not configured for "${orgLogin}".`);
-    }
-    const repos = result.repos ?? [];
-    if (verbose) {
-        logDebug(`Fetched ${repos.length} source repos from ${orgLogin}`);
-    }
-    return repos;
-}
-export async function syncOrgRepos(opts) {
-    const { teamId, orgLogin, userId, verbose } = opts;
-    if (!ORG_NAME_RE.test(orgLogin) || orgLogin.length > 39) {
-        return {
-            status: 'error',
-            message: `Invalid GitHub organization name: "${orgLogin}"`,
-            total: 0,
-            created: 0,
-            skipped: 0,
-        };
-    }
-    if (!hasSupabaseSession()) {
-        return {
-            status: 'error',
-            message: 'Supabase session unavailable. Sign in to the Edsger desktop app.',
-            total: 0,
-            created: 0,
-            skipped: 0,
-        };
-    }
-    const supabase = getSupabase();
-    let orgRepos;
-    try {
-        orgRepos = await fetchOrgRepos(teamId, orgLogin, verbose);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logError(`Failed to fetch repos: ${msg}`);
-        return {
-            status: 'error',
-            message: `Failed to fetch repos from GitHub: ${msg}`,
-            total: 0,
-            created: 0,
-            skipped: 0,
-        };
-    }
-    if (orgRepos.length === 0) {
-        logWarning(`No repos found in org "${orgLogin}"`);
-        return {
-            status: 'success',
-            message: `No repositories found in ${orgLogin}`,
-            total: 0,
-            created: 0,
-            skipped: 0,
-        };
-    }
-    logInfo(`Found ${orgRepos.length} repos in ${orgLogin}`);
-    const repoFullNames = orgRepos.map((r) => r.full_name);
-    const { data: existing } = await supabase
-        .from('repositories')
-        .select('full_name')
-        .eq('team_id', teamId)
-        .in('full_name', repoFullNames);
-    const existingRepos = new Set((existing || []).map((r) => r.full_name));
-    const toCreate = orgRepos.filter((r) => !existingRepos.has(r.full_name));
-    // Refresh metadata + last_synced_at on every synced repo (new and existing)
-    // via upsert keyed on (team_id, full_name).
-    const now = new Date().toISOString();
-    const rows = orgRepos.map((repo) => ({
-        team_id: teamId,
-        created_by: userId,
-        github_repo_id: repo.id,
-        full_name: repo.full_name,
-        owner: repo.full_name.split('/')[0] ?? null,
-        name: repo.name,
-        url: repo.html_url,
-        description: repo.description,
-        default_branch: repo.default_branch,
-        private: repo.private,
-        language: repo.language,
-        last_synced_at: now,
-    }));
-    if (verbose) {
-        for (const r of toCreate) {
-            logDebug(`  Will create repository: ${r.full_name}`);
-        }
-    }
-    const { error: upsertError } = await supabase
-        .from('repositories')
-        .upsert(rows, { onConflict: 'team_id,full_name' });
-    if (upsertError) {
-        logError(`Failed to upsert repositories: ${upsertError.message}`);
-        return {
-            status: 'error',
-            message: `Failed to sync repositories: ${upsertError.message}`,
-            total: orgRepos.length,
-            created: 0,
-            skipped: existingRepos.size,
-        };
-    }
-    return {
-        status: 'success',
-        message: `Synced ${orgRepos.length} repos: ${toCreate.length} new, ${existingRepos.size} updated`,
-        total: orgRepos.length,
-        created: toCreate.length,
-        skipped: existingRepos.size,
-        repos: toCreate.map((r) => r.full_name),
-    };
-}

package/dist/phases/sync-sentry-issues/index.d.ts

@@ -1,29 +0,0 @@
-/**
- * sync-sentry-issues phase: pull every issue from a Sentry project and
- * mirror them into the product's local issues table. Uses the same
- * source_* schema and batch RPC contract as the GitHub variant — only
- * the API client and the source-state vocabulary
- * (unresolved/resolved/ignored vs open/closed) differ.
- *
- * Production hardening matches sync-github-issues:
- *   - Sentry client retries 429 / 5xx / network errors with exponential
- *     backoff (honouring Retry-After).
- *   - Upserts are batched (MAX_BATCH_SIZE per round-trip).
- *   - Deletion sweep is keyed on a sync-start timestamp cutoff.
- *   - Skipped if any batch fails, to avoid wrongly marking live issues
- *     as deleted from a partial fetch.
- */
-import { type SentryClientConfig } from './sentry-client.js';
-import { type SentryIssueLite, type SentrySyncResult } from './types.js';
-export interface SyncSentryIssuesOptions extends SentryClientConfig {
-    productId: string;
-    verbose?: boolean;
-}
-/**
- * Build the markdown description we drop into `issues.description` for a
- * fresh insert. Pulls only fields that are reliably present on the list
- * endpoint — the full event payload would require an extra fetch per
- * issue, which isn't worth it for the sync-list view.
- */
-export declare function formatSentryDescription(item: SentryIssueLite): string;
-export declare function syncSentryIssues(options: SyncSentryIssuesOptions): Promise<SentrySyncResult>;

package/dist/phases/sync-sentry-issues/index.js

@@ -1,153 +0,0 @@
-/**
- * sync-sentry-issues phase: pull every issue from a Sentry project and
- * mirror them into the product's local issues table. Uses the same
- * source_* schema and batch RPC contract as the GitHub variant — only
- * the API client and the source-state vocabulary
- * (unresolved/resolved/ignored vs open/closed) differ.
- *
- * Production hardening matches sync-github-issues:
- *   - Sentry client retries 429 / 5xx / network errors with exponential
- *     backoff (honouring Retry-After).
- *   - Upserts are batched (MAX_BATCH_SIZE per round-trip).
- *   - Deletion sweep is keyed on a sync-start timestamp cutoff.
- *   - Skipped if any batch fails, to avoid wrongly marking live issues
- *     as deleted from a partial fetch.
- */
-import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
-import { markExternalIssuesDeletedSince, upsertInBatches, } from '../sync-shared/mcp.js';
-import { SentryClient } from './sentry-client.js';
-import { acquireSyncSentryIssuesLock, updateSyncSentryIssuesState, } from './state.js';
-function initialStatusFor(sentryStatus) {
-    return sentryStatus === 'unresolved' ? 'backlog' : 'archived';
-}
-/**
- * Build the markdown description we drop into `issues.description` for a
- * fresh insert. Pulls only fields that are reliably present on the list
- * endpoint — the full event payload would require an extra fetch per
- * issue, which isn't worth it for the sync-list view.
- */
-export function formatSentryDescription(item) {
-    const lines = [];
-    if (item.shortId) {
-        lines.push(`**Sentry ID:** ${item.shortId}`);
-    }
-    if (item.level) {
-        lines.push(`**Level:** ${item.level}`);
-    }
-    if (item.platform) {
-        lines.push(`**Platform:** ${item.platform}`);
-    }
-    if (item.culprit) {
-        lines.push(`**Culprit:** ${item.culprit}`);
-    }
-    if (item.count !== undefined && item.count !== null) {
-        const userPart = item.userCount !== undefined && item.userCount !== null
-            ? ` across ${item.userCount} ${item.userCount === 1 ? 'user' : 'users'}`
-            : '';
-        lines.push(`**Events:** ${item.count}${userPart}`);
-    }
-    if (item.firstSeen) {
-        lines.push(`**First seen:** ${item.firstSeen}`);
-    }
-    if (item.lastSeen) {
-        lines.push(`**Last seen:** ${item.lastSeen}`);
-    }
-    lines.push('');
-    lines.push(`[View in Sentry](${item.permalink})`);
-    return lines.join('\n');
-}
-function toUpsertInput(item) {
-    return {
-        sourceId: item.id,
-        name: item.shortId ? `[${item.shortId}] ${item.title}` : item.title,
-        description: formatSentryDescription(item),
-        sourceUrl: item.permalink,
-        sourceState: item.status,
-        sourceUpdatedAt: item.lastSeen,
-        sourceData: {
-            id: item.id,
-            shortId: item.shortId ?? null,
-            status: item.status,
-            level: item.level ?? null,
-            platform: item.platform ?? null,
-            count: item.count ?? null,
-            userCount: item.userCount ?? null,
-            isUnhandled: item.isUnhandled ?? null,
-            firstSeen: item.firstSeen ?? null,
-            lastSeen: item.lastSeen,
-            permalink: item.permalink,
-        },
-        initialStatus: initialStatusFor(item.status),
-    };
-}
-export async function syncSentryIssues(options) {
-    const { productId, authToken, org, project, baseUrl, verbose } = options;
-    const lock = acquireSyncSentryIssuesLock(productId);
-    if (!lock) {
-        return {
-            status: 'error',
-            message: 'Another Sentry sync is already running for this product',
-        };
-    }
-    const syncStartedAt = new Date().toISOString();
-    try {
-        updateSyncSentryIssuesState(productId, {
-            lastAttemptedAt: syncStartedAt,
-        });
-        const sourceLabel = `${org}/${project}`;
-        logInfo(`Syncing Sentry issues from ${sourceLabel} → product ${productId}`);
-        const client = new SentryClient({ authToken, org, project, baseUrl });
-        const remoteIssues = await client.listAllIssues();
-        logInfo(`Fetched ${remoteIssues.length} issues from Sentry`);
-        if (verbose) {
-            logInfo(`Will upsert ${remoteIssues.length} issues in batches`);
-        }
-        const inputs = remoteIssues.map(toUpsertInput);
-        const { result, failedBatches } = await upsertInBatches(productId, 'sentry', inputs, (error, batchIndex) => {
-            logError(`Batch ${batchIndex} failed: ${error.message}`);
-        });
-        let deletedCount = 0;
-        if (failedBatches === 0) {
-            deletedCount = await markExternalIssuesDeletedSince(productId, 'sentry', syncStartedAt);
-        }
-        else {
-            logWarning(`Skipping deletion sweep: ${failedBatches} batch(es) failed; would risk wrongly flagging live issues as deleted`);
-        }
-        updateSyncSentryIssuesState(productId, {
-            lastSyncedAt: new Date().toISOString(),
-            lastSource: sourceLabel,
-            lastError: failedBatches > 0
-                ? `${failedBatches} batch(es) failed during sync`
-                : undefined,
-        });
-        const summary = `created=${result.created} updated=${result.updated} refreshed=${result.refreshed} deleted=${deletedCount}${failedBatches > 0 ? ` (${failedBatches} batch(es) failed)` : ''}`;
-        if (failedBatches === 0) {
-            logSuccess(`Sentry sync complete: ${summary}`);
-        }
-        else {
-            logWarning(`Sentry sync completed with errors: ${summary}`);
-        }
-        return {
-            status: failedBatches === 0 ? 'success' : 'error',
-            message: summary,
-            source: sourceLabel,
-            fetchedCount: remoteIssues.length,
-            createdCount: result.created,
-            updatedCount: result.updated,
-            refreshedCount: result.refreshed,
-            deletedCount,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Sentry sync failed: ${errorMessage}`);
-        updateSyncSentryIssuesState(productId, { lastError: errorMessage });
-        return {
-            status: 'error',
-            message: `Sentry sync failed: ${errorMessage}`,
-        };
-    }
-    finally {
-        lock.release();
-    }
-}

package/dist/phases/sync-sentry-issues/sentry-client.d.ts

@@ -1,66 +0,0 @@
-/**
- * Tiny Sentry REST client: just enough to list issues for a project, with
- * cursor-based pagination via the Link header. Implemented with `fetch`
- * rather than pulling in an SDK so the dep footprint stays small.
- *
- * Production hardening:
- *   - per-request timeout via AbortController
- *   - retry with exponential backoff for 429 / 5xx, honouring Retry-After
- *   - retry for transient network errors (ECONNRESET, ETIMEDOUT, ...)
- *
- * Sentry's default `query` filter is `is:unresolved`, which would silently
- * hide resolved/ignored issues. We pass `query=` (empty string) to bypass
- * that filter and return everything.
- */
-import { type SentryIssueLite } from './types.js';
-export interface SentryClientConfig {
-    authToken: string;
-    org: string;
-    project: string;
-    /** Defaults to https://sentry.io/api/0. Override for self-hosted Sentry. */
-    baseUrl?: string;
-    /** Per-request timeout in ms. Defaults to 30s. */
-    timeoutMs?: number;
-    /** Number of retry attempts on retryable failures. Defaults to 3. */
-    retries?: number;
-    /** Base delay (ms) for exponential backoff. Defaults to 500. Tests pass 1. */
-    baseDelayMs?: number;
-}
-export declare class SentryClient {
-    private readonly authToken;
-    private readonly org;
-    private readonly project;
-    private readonly baseUrl;
-    private readonly timeoutMs;
-    private readonly retries;
-    private readonly baseDelayMs;
-    constructor(config: SentryClientConfig);
-    listAllIssues(): Promise<SentryIssueLite[]>;
-    /**
-     * Single-request retry loop. Retries on:
-     *   - network error / abort
-     *   - HTTP 429 (rate limited; honours Retry-After header)
-     *   - HTTP 5xx (server error)
-     *
-     * Does NOT retry on 4xx other than 429 — those are deterministic
-     * (auth, permission, not found) and won't get better with another try.
-     */
-    private requestWithRetry;
-}
-/**
- * Accept either a Sentry host root (`https://sentry.io/`,
- * `https://sentry.internal.acme.com/`) or an explicit API root
- * (`https://sentry.io/api/0`) and return the latter.
- *
- * Matches the official `sentry-cli` convention where users set
- * `SENTRY_URL` to the host and the tool appends `/api/0` itself.
- */
-export declare function normaliseBaseUrl(input: string): string;
-/**
- * Parse Sentry's Link header. The next-page entry looks like:
- *   <https://...>; rel="next"; results="true"; cursor="100:1:0"
- * We return the cursor string only when `results="true"` — Sentry returns
- * a "next" entry even at the end of the list with `results="false"`, and
- * pagination would loop forever if we trusted that.
- */
-export declare function parseNextCursor(linkHeader: string | null): string | null;

package/dist/phases/sync-sentry-issues/sentry-client.js

@@ -1,221 +0,0 @@
-/**
- * Tiny Sentry REST client: just enough to list issues for a project, with
- * cursor-based pagination via the Link header. Implemented with `fetch`
- * rather than pulling in an SDK so the dep footprint stays small.
- *
- * Production hardening:
- *   - per-request timeout via AbortController
- *   - retry with exponential backoff for 429 / 5xx, honouring Retry-After
- *   - retry for transient network errors (ECONNRESET, ETIMEDOUT, ...)
- *
- * Sentry's default `query` filter is `is:unresolved`, which would silently
- * hide resolved/ignored issues. We pass `query=` (empty string) to bypass
- * that filter and return everything.
- */
-const PER_PAGE = 100;
-const DEFAULT_BASE_URL = 'https://sentry.io/api/0';
-const DEFAULT_TIMEOUT_MS = 30_000;
-const DEFAULT_RETRIES = 3;
-const DEFAULT_BASE_DELAY_MS = 500;
-const MAX_BACKOFF_MS = 30_000;
-export class SentryClient {
-    authToken;
-    org;
-    project;
-    baseUrl;
-    timeoutMs;
-    retries;
-    baseDelayMs;
-    constructor(config) {
-        this.authToken = config.authToken;
-        this.org = config.org;
-        this.project = config.project;
-        this.baseUrl = normaliseBaseUrl(config.baseUrl ?? DEFAULT_BASE_URL);
-        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        this.retries = config.retries ?? DEFAULT_RETRIES;
-        this.baseDelayMs = config.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
-    }
-    async listAllIssues() {
-        const all = [];
-        let cursor = null;
-        for (;;) {
-            const url = new URL(`${this.baseUrl}/projects/${encodeURIComponent(this.org)}/${encodeURIComponent(this.project)}/issues/`);
-            url.searchParams.set('limit', String(PER_PAGE));
-            url.searchParams.set('query', '');
-            if (cursor) {
-                url.searchParams.set('cursor', cursor);
-            }
-            const res = await this.requestWithRetry(url.toString());
-            if (!res.ok) {
-                const body = await safeReadBody(res);
-                throw new Error(`Sentry API ${res.status} ${res.statusText}: ${body || '(no body)'}`);
-            }
-            const page = (await res.json());
-            all.push(...page);
-            const next = parseNextCursor(res.headers.get('Link'));
-            if (!next || page.length === 0) {
-                break;
-            }
-            cursor = next;
-        }
-        return all;
-    }
-    /**
-     * Single-request retry loop. Retries on:
-     *   - network error / abort
-     *   - HTTP 429 (rate limited; honours Retry-After header)
-     *   - HTTP 5xx (server error)
-     *
-     * Does NOT retry on 4xx other than 429 — those are deterministic
-     * (auth, permission, not found) and won't get better with another try.
-     */
-    async requestWithRetry(url) {
-        let lastError;
-        for (let attempt = 0; attempt <= this.retries; attempt++) {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-            try {
-                const res = await fetch(url, {
-                    headers: {
-                        Authorization: `Bearer ${this.authToken}`,
-                        Accept: 'application/json',
-                    },
-                    signal: controller.signal,
-                });
-                if (res.status === 429 ||
-                    (res.status >= 500 && res.status < 600)) {
-                    if (attempt < this.retries) {
-                        const delay = computeRetryDelay(res.headers.get('Retry-After'), attempt, this.baseDelayMs);
-                        // Drain the body so the connection can be reused.
-                        await safeReadBody(res);
-                        await sleep(delay);
-                        continue;
-                    }
-                }
-                return res;
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt < this.retries && isRetryableNetworkError(error)) {
-                    await sleep(computeBackoffDelay(attempt, this.baseDelayMs));
-                    continue;
-                }
-                throw error;
-            }
-            finally {
-                clearTimeout(timer);
-            }
-        }
-        // If we exit the loop without returning, every attempt was a retryable
-        // failure that exhausted the retry budget. Throw the last error so the
-        // caller sees something actionable.
-        throw lastError instanceof Error
-            ? lastError
-            : new Error(`Sentry request failed after ${this.retries + 1} attempts`);
-    }
-}
-/**
- * Accept either a Sentry host root (`https://sentry.io/`,
- * `https://sentry.internal.acme.com/`) or an explicit API root
- * (`https://sentry.io/api/0`) and return the latter.
- *
- * Matches the official `sentry-cli` convention where users set
- * `SENTRY_URL` to the host and the tool appends `/api/0` itself.
- */
-export function normaliseBaseUrl(input) {
-    let url = input.trim().replace(/\/+$/, '');
-    // If the path already ends in /api/N for any version digit, leave it.
-    if (/\/api\/\d+$/.test(url)) {
-        return url;
-    }
-    // No /api/N segment present — append /api/0.
-    url = `${url}/api/0`;
-    return url;
-}
-async function safeReadBody(res) {
-    try {
-        return (await res.text()).slice(0, 500);
-    }
-    catch {
-        return '';
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-/**
- * Compute backoff for HTTP-level retries. Honours `Retry-After` if the
- * server set one (capped at MAX_BACKOFF_MS so a misconfigured server
- * can't pin us for an hour), otherwise exponential.
- */
-function computeRetryDelay(retryAfterHeader, attempt, baseDelayMs) {
-    if (retryAfterHeader) {
-        // Retry-After is either a delta-seconds integer or an HTTP-date.
-        const asNumber = Number(retryAfterHeader);
-        if (Number.isFinite(asNumber) && asNumber >= 0) {
-            return Math.min(asNumber * 1000, MAX_BACKOFF_MS);
-        }
-        const asDate = Date.parse(retryAfterHeader);
-        if (!Number.isNaN(asDate)) {
-            return Math.min(Math.max(asDate - Date.now(), 0), MAX_BACKOFF_MS);
-        }
-    }
-    return computeBackoffDelay(attempt, baseDelayMs);
-}
-function computeBackoffDelay(attempt, baseDelayMs) {
-    // Exponential with jitter: base * 2^attempt + random(0..base/2)
-    const exp = baseDelayMs * 2 ** attempt;
-    const jitter = Math.random() * (baseDelayMs / 2);
-    return Math.min(exp + jitter, MAX_BACKOFF_MS);
-}
-/**
- * Network errors that are worth retrying. Excludes user-controlled
- * AbortErrors that aren't from our timer (so a caller can cancel cleanly).
- */
-function isRetryableNetworkError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const { code } = error;
-    if (code === 'ECONNRESET' ||
-        code === 'ECONNREFUSED' ||
-        code === 'ETIMEDOUT' ||
-        code === 'EAI_AGAIN' ||
-        code === 'UND_ERR_SOCKET' ||
-        code === 'UND_ERR_CONNECT_TIMEOUT') {
-        return true;
-    }
-    // AbortError from our own timeout is retryable; from a caller signal,
-    // we'd never get here because the caller would have aborted the await.
-    if (error.name === 'AbortError') {
-        return true;
-    }
-    return false;
-}
-/**
- * Parse Sentry's Link header. The next-page entry looks like:
- *   <https://...>; rel="next"; results="true"; cursor="100:1:0"
- * We return the cursor string only when `results="true"` — Sentry returns
- * a "next" entry even at the end of the list with `results="false"`, and
- * pagination would loop forever if we trusted that.
- */
-export function parseNextCursor(linkHeader) {
-    if (!linkHeader) {
-        return null;
-    }
-    for (const part of linkHeader.split(',')) {
-        const trimmed = part.trim();
-        const isNext = /\brel="next"/.test(trimmed);
-        const hasResults = /\bresults="true"/.test(trimmed);
-        if (!isNext || !hasResults) {
-            continue;
-        }
-        const cursorMatch = /\bcursor="([^"]+)"/.exec(trimmed);
-        if (cursorMatch) {
-            return cursorMatch[1] ?? null;
-        }
-    }
-    return null;
-}

package/dist/phases/sync-sentry-issues/state.d.ts

@@ -1,23 +0,0 @@
-/**
- * Per-product sync state for sync-sentry-issues. Stored at
- * `~/.edsger/sync-sentry-issues-state/<productId>.json`.
- *
- * We keep the lock + last-synced-at because Sentry's API doesn't surface
- * deletions (issues that were marked deleted on Sentry's side just stop
- * appearing). Like the GitHub variant we re-pull the full list on each
- * run; the cursor field is reserved for a future incremental optimisation
- * via `lastSeen` filter.
- */
-import { type LockHandle } from '../find-shared/scan-state.js';
-export type { LockHandle };
-export interface SyncSentryIssuesState {
-    lastSyncedAt?: string;
-    lastAttemptedAt?: string;
-    lastError?: string;
-    /** "<org>/<project>" we last synced from. */
-    lastSource?: string;
-}
-export declare const loadSyncSentryIssuesState: (productId: string) => SyncSentryIssuesState;
-export declare const saveSyncSentryIssuesState: (productId: string, state: SyncSentryIssuesState) => void;
-export declare const updateSyncSentryIssuesState: (productId: string, patch: Partial<SyncSentryIssuesState>) => SyncSentryIssuesState;
-export declare const acquireSyncSentryIssuesLock: (productId: string, staleAfterMs?: number) => LockHandle | null;

package/dist/phases/sync-sentry-issues/state.js

@@ -1,18 +0,0 @@
-/**
- * Per-product sync state for sync-sentry-issues. Stored at
- * `~/.edsger/sync-sentry-issues-state/<productId>.json`.
- *
- * We keep the lock + last-synced-at because Sentry's API doesn't surface
- * deletions (issues that were marked deleted on Sentry's side just stop
- * appearing). Like the GitHub variant we re-pull the full list on each
- * run; the cursor field is reserved for a future incremental optimisation
- * via `lastSeen` filter.
- */
-import { createScanStateModule, } from '../find-shared/scan-state.js';
-const m = createScanStateModule({
-    dirName: 'sync-sentry-issues-state',
-});
-export const loadSyncSentryIssuesState = m.load;
-export const saveSyncSentryIssuesState = m.save;
-export const updateSyncSentryIssuesState = m.update;
-export const acquireSyncSentryIssuesLock = m.acquireLock;