@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/adapters/git/git-workspace-manager.js

@@ -1,289 +0,0 @@
-import { execFile as nodeExecFile } from 'node:child_process';
-import { access, mkdir, rm } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { promisify } from 'node:util';
-import { createWakePaths } from '../../lib/paths.js';
-import { branchNameForIssue } from '../../domain/branch-naming.js';
-const execFile = promisify(nodeExecFile);
-// Re-exported for existing callers (this adapter's own use below, plus
-// adapters/runner/stage-prompt.ts and tests) — the canonical definition now
-// lives in domain/branch-naming.ts so core/ can use it without importing a
-// concrete adapter.
-export { branchNameForIssue };
-async function git(args, cwd) {
-    const result = await execFile('git', args, {
-        cwd,
-        env: process.env,
-        encoding: 'utf8',
-        maxBuffer: 1024 * 1024 * 16,
-    });
-    return { stdout: result.stdout.trim(), stderr: result.stderr.trim() };
-}
-async function gitExitCode(args, cwd) {
-    try {
-        await execFile('git', args, {
-            cwd,
-            env: process.env,
-            encoding: 'utf8',
-            maxBuffer: 1024 * 1024 * 16,
-        });
-        return 0;
-    }
-    catch (error) {
-        const maybeExit = error;
-        return typeof maybeExit.code === 'number' ? maybeExit.code : 1;
-    }
-}
-export class WorkspaceValidationError extends Error {
-    failureSource = 'wake-workspace-validation';
-    constructor(message) {
-        super(message);
-        this.name = 'WorkspaceValidationError';
-    }
-}
-async function detectDefaultBranch(repoPath) {
-    await git(['remote', 'set-head', 'origin', '--auto'], repoPath);
-    const { stdout } = await git(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], repoPath);
-    const defaultBranch = stdout.replace(/^origin\//, '');
-    if (defaultBranch.length === 0) {
-        throw new Error(`Unable to detect default branch for ${repoPath}`);
-    }
-    return defaultBranch;
-}
-async function pathExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function defaultRemoteUrlForRepo(repo) {
-    return `https://github.com/${repo}.git`;
-}
-export function buildWorkspaceCloneArgs(input) {
-    return [
-        'clone',
-        '--no-local',
-        '--branch',
-        input.defaultBranch,
-        input.sourceRepoPath,
-        input.workspacePath,
-    ];
-}
-async function tryUpdateFromDefaultBranch(workspacePath) {
-    try {
-        const { stdout: status } = await git(['status', '--porcelain'], workspacePath);
-        if (status.length > 0) {
-            return { mergeConflictDetected: false, preExistingUncommittedChanges: true };
-        }
-        await git(['fetch', 'origin'], workspacePath);
-        const defaultBranch = await detectDefaultBranch(workspacePath);
-        const { stdout: count } = await git(['rev-list', '--count', `HEAD..origin/${defaultBranch}`], workspacePath);
-        if (parseInt(count.trim(), 10) === 0) {
-            return { mergeConflictDetected: false };
-        }
-        const { stdout: upstreamChanges } = await git([
-            'log',
-            '--date=short',
-            '--pretty=format:%h %ad %an <%ae>%n    %s',
-            `HEAD..origin/${defaultBranch}`,
-        ], workspacePath);
-        // Probe for conflicts without touching the index or worktree. A real merge
-        // would need committer identity even with --no-commit on some Git versions.
-        try {
-            await git(['merge-tree', '--write-tree', 'HEAD', `origin/${defaultBranch}`], workspacePath);
-            await git([
-                '-c',
-                'user.email=wake@example.invalid',
-                '-c',
-                'user.name=Wake',
-                'merge',
-                '--no-edit',
-                `origin/${defaultBranch}`,
-            ], workspacePath);
-            return {
-                mergeConflictDetected: false,
-                ...(upstreamChanges.length === 0 ? {} : { upstreamChanges }),
-            };
-        }
-        catch {
-            return { mergeConflictDetected: true };
-        }
-    }
-    catch {
-        // Fetch or branch detection failed — leave workspace as-is, no conflict reported
-        return { mergeConflictDetected: false };
-    }
-}
-async function validateWorkspace(input) {
-    await git(['fetch', 'origin'], input.workspacePath);
-    const { stdout: actualRemoteUrl } = await git(['remote', 'get-url', 'origin'], input.workspacePath);
-    const { stdout: actualBranch } = await git(['rev-parse', '--abbrev-ref', 'HEAD'], input.workspacePath);
-    const { stdout: baseRevision } = await git(['merge-base', 'HEAD', input.expectedBaseRef], input.workspacePath);
-    const { stdout: headRevision } = await git(['rev-parse', 'HEAD'], input.workspacePath);
-    const { stdout: status } = await git(['status', '--porcelain'], input.workspacePath);
-    const remoteExit = await gitExitCode(['ls-remote', '--exit-code', 'origin', 'HEAD'], input.workspacePath);
-    const validation = {
-        repo: input.repo,
-        expectedBranch: input.expectedBranch,
-        actualBranch,
-        expectedRemoteUrl: input.expectedRemoteUrl,
-        actualRemoteUrl,
-        baseRevision,
-        headRevision,
-        clean: status.length === 0,
-        remoteAvailable: remoteExit === 0,
-    };
-    const failures = [];
-    if (actualRemoteUrl !== input.expectedRemoteUrl) {
-        failures.push(`expected origin ${input.expectedRemoteUrl}, found ${actualRemoteUrl}`);
-    }
-    if (actualBranch !== input.expectedBranch) {
-        failures.push(`expected branch ${input.expectedBranch}, found ${actualBranch}`);
-    }
-    if (!validation.clean && input.allowUncommittedChanges !== true) {
-        failures.push('working tree has uncommitted or untracked changes');
-    }
-    if (!validation.remoteAvailable) {
-        failures.push('origin remote is not available');
-    }
-    if (failures.length > 0) {
-        throw new WorkspaceValidationError(`Workspace validation failed: ${failures.join('; ')}`);
-    }
-    return validation;
-}
-async function recordWorkspaceBookkeeping(workspacePath) {
-    const { stdout: branch } = await git(['rev-parse', '--abbrev-ref', 'HEAD'], workspacePath);
-    const { stdout: headRevision } = await git(['rev-parse', 'HEAD'], workspacePath);
-    const { stdout: diffSummary } = await git(['diff', '--stat', 'HEAD'], workspacePath);
-    const { stdout: untracked } = await git(['ls-files', '--others', '--exclude-standard'], workspacePath);
-    let hasUpstream = true;
-    let count;
-    let commits;
-    try {
-        const { stdout: upstream } = await git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], workspacePath);
-        const { stdout: ahead } = await git(['rev-list', '--count', `${upstream}..HEAD`], workspacePath);
-        count = parseInt(ahead, 10);
-        const { stdout: commitLog } = await git(['log', '--pretty=format:%h %s', `${upstream}..HEAD`], workspacePath);
-        commits = commitLog.length === 0 ? [] : commitLog.split('\n');
-    }
-    catch {
-        hasUpstream = false;
-        const { stdout: commitLog } = await git(['log', '--pretty=format:%h %s'], workspacePath);
-        commits = commitLog.length === 0 ? [] : commitLog.split('\n');
-        count = commits.length;
-    }
-    return {
-        branch,
-        headRevision,
-        diffSummary,
-        untrackedFiles: untracked.length === 0 ? [] : untracked.split('\n'),
-        unpushedCommits: {
-            hasUpstream,
-            count,
-            commits,
-        },
-    };
-}
-export function createGitWorkspaceManager(options) {
-    const paths = createWakePaths(options.wakeRoot);
-    const remoteUrlForRepo = options.remoteUrlForRepo ?? defaultRemoteUrlForRepo;
-    async function ensureCanonicalClone(repo) {
-        const repoPath = paths.repoRoot(repo);
-        const remoteUrl = remoteUrlForRepo(repo);
-        if (await pathExists(repoPath)) {
-            // The canonical clone is only ever touched by one tick at a time, so an
-            // index.lock found here can't be a live concurrent writer - it's a leftover
-            // from a process that was killed mid-git-operation (e.g. a container
-            // restart). Left in place it wedges every future tick on this repo with
-            // "Unable to create index.lock: File exists", so clear it defensively
-            // before running any git command against the clone.
-            await rm(join(repoPath, '.git', 'index.lock'), { force: true });
-            await git(['fetch', 'origin'], repoPath);
-            const defaultBranch = await detectDefaultBranch(repoPath);
-            await git(['checkout', defaultBranch], repoPath);
-            await git(['reset', '--hard', `origin/${defaultBranch}`], repoPath);
-            await git(['clean', '-fdx'], repoPath);
-            return { repoPath, defaultBranch };
-        }
-        else {
-            await mkdir(dirname(repoPath), { recursive: true });
-            await git(['clone', remoteUrl, repoPath], dirname(repoPath));
-            const defaultBranch = await detectDefaultBranch(repoPath);
-            return { repoPath, defaultBranch };
-        }
-    }
-    return {
-        async prepareWorkspace({ workId, repo, issueNumber, }) {
-            // The workspace is keyed by work item; `repo` still drives the clone and
-            // `issueNumber` still names the branch, which stays human-readable and
-            // provider-facing (spec D2).
-            const workspacePath = paths.workspaceDir(workId);
-            if (await pathExists(workspacePath)) {
-                const updateResult = await tryUpdateFromDefaultBranch(workspacePath);
-                const defaultBranch = await detectDefaultBranch(workspacePath);
-                const validation = await validateWorkspace({
-                    workspacePath,
-                    repo,
-                    expectedBranch: branchNameForIssue(issueNumber),
-                    expectedRemoteUrl: remoteUrlForRepo(repo),
-                    expectedBaseRef: `origin/${defaultBranch}`,
-                    ...(updateResult.preExistingUncommittedChanges === true
-                        ? { allowUncommittedChanges: true }
-                        : {}),
-                });
-                return { workspacePath, ...updateResult, validation };
-            }
-            const { repoPath, defaultBranch } = await ensureCanonicalClone(repo);
-            const remoteUrl = remoteUrlForRepo(repo);
-            await mkdir(dirname(workspacePath), { recursive: true });
-            await git(buildWorkspaceCloneArgs({
-                sourceRepoPath: repoPath,
-                workspacePath,
-                defaultBranch,
-            }), dirname(workspacePath));
-            const branch = branchNameForIssue(issueNumber);
-            await git(['remote', 'set-url', 'origin', remoteUrl], workspacePath);
-            await git(['checkout', '-B', branch], workspacePath);
-            const validation = await validateWorkspace({
-                workspacePath,
-                repo,
-                expectedBranch: branch,
-                expectedRemoteUrl: remoteUrl,
-                expectedBaseRef: `origin/${defaultBranch}`,
-            });
-            return { workspacePath, mergeConflictDetected: false, validation };
-        },
-        async prepareReadOnlyClone({ repo, }) {
-            // Refine only reads the issue and, at most, the canonical clone -
-            // it never gets a per-issue branch/workspace of its own (only
-            // 'implement' pays that cost).
-            const { repoPath } = await ensureCanonicalClone(repo);
-            const defaultBranch = await detectDefaultBranch(repoPath);
-            const validation = await validateWorkspace({
-                workspacePath: repoPath,
-                repo,
-                expectedBranch: defaultBranch,
-                expectedRemoteUrl: remoteUrlForRepo(repo),
-                expectedBaseRef: `origin/${defaultBranch}`,
-            });
-            return { workspacePath: repoPath, validation };
-        },
-        async recordWorkspaceBookkeeping({ workspacePath, }) {
-            return recordWorkspaceBookkeeping(workspacePath);
-        },
-        async cleanupWorkspace({ workspacePath }) {
-            // On Windows, a just-exited git subprocess (or AV/indexer) can hold a brief
-            // handle on files it touched; a bare rm races that and fails EBUSY/EPERM.
-            // maxRetries/retryDelay make fs.rm retry with backoff instead of throwing.
-            await rm(workspacePath, {
-                recursive: true,
-                force: true,
-                maxRetries: 5,
-                retryDelay: 200,
-            });
-        },
-    };
-}

package/dist/src/adapters/github/github-artifact-verifier.js

@@ -1,38 +0,0 @@
-import { buildResourceUri } from '../../domain/resource-uri.js';
-const githubPrUrlPattern = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/;
-export function createGitHubArtifactVerifier(deps) {
-    return {
-        async verify(artifact, context) {
-            if (artifact.kind !== 'pr') {
-                return null;
-            }
-            const match = githubPrUrlPattern.exec(artifact.url);
-            if (match === null) {
-                return null;
-            }
-            const [, owner, repo, numberStr] = match;
-            if (owner === undefined || repo === undefined || numberStr === undefined) {
-                return null;
-            }
-            // GitHub owner/repo names are case-insensitive, so the URL's rendered
-            // casing (owner/repo, as linked by the agent) can legitimately differ
-            // from the configured context.repo string.
-            if (`${owner}/${repo}`.toLowerCase() !== context.repo.toLowerCase()) {
-                return null;
-            }
-            try {
-                const pr = await deps.client.getPullRequest(owner, repo, Number(numberStr));
-                if (pr.head.ref !== context.branch) {
-                    return null;
-                }
-                // Built from context.repo, not the URL's owner/repo casing, so this
-                // resourceUri exact-matches the one discoverPullRequests/pollWatchedPr
-                // build from the same configured repo string.
-                return { resourceUri: buildResourceUri('github', 'pr', `${context.repo}#${numberStr}`) };
-            }
-            catch {
-                return null;
-            }
-        },
-    };
-}

package/dist/src/adapters/github/github-auth.js

@@ -1,16 +0,0 @@
-import { execFile as nodeExecFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFile = promisify(nodeExecFile);
-export async function resolveGitHubToken(deps) {
-    try {
-        const result = await (deps?.execFile ?? execFile)('gh', ['auth', 'token']);
-        const token = String(result.stdout).trim();
-        if (token.length === 0) {
-            throw new Error('empty token');
-        }
-        return token;
-    }
-    catch (error) {
-        throw new Error(`Failed to resolve GitHub token via gh auth token: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-}

package/dist/src/adapters/github/github-client.js

@@ -1,249 +0,0 @@
-import { Octokit } from '@octokit/rest';
-import { createEtagCache, fetchPaginatedWithEtag, fetchSingleWithEtag, } from './github-etag-cache.js';
-// Octokit's built-in request-log plugin routes every non-2xx response
-// through `log.error` (console.error by default) before the error reaches
-// our code, including the 304s that ETag-based conditional requests are
-// *expected* to produce (see github-etag-cache.ts). Without this override,
-// normal cache-hit traffic prints as spurious stderr errors. The plugin only
-// hands `log.error` a pre-formatted string (`METHOD path - STATUS with id
-// ID in Nms`), not the response object, so we extract the actual status
-// code from that fixed format rather than substring-matching "304"
-// anywhere in the message.
-function requestLogStatus(message) {
-    const match = / - (\d{3}) with id /.exec(message);
-    return match === null ? undefined : Number(match[1]);
-}
-export function createGitHubClient(token) {
-    const octokit = new Octokit({
-        auth: token,
-        log: {
-            debug: () => { },
-            info: () => { },
-            warn: console.warn.bind(console),
-            error: (message) => {
-                if (requestLogStatus(message) !== 304) {
-                    console.error(message);
-                }
-            },
-        },
-    });
-    const etagCache = createEtagCache();
-    return {
-        async getAuthenticatedLogin() {
-            const { data } = await octokit.rest.users.getAuthenticated();
-            return data.login;
-        },
-        // `maxResults` is a hard cap on issues returned, not just a page size:
-        // octokit.paginate otherwise walks every page regardless of page size,
-        // which burns GitHub's rate limit (a "fourth budget") on repos with many
-        // issues. Stop paginating as soon as the cap is reached.
-        async listIssues(owner, repo, maxResults, since) {
-            const perPage = Math.min(maxResults, 100);
-            return fetchPaginatedWithEtag({
-                cache: etagCache,
-                cacheKey: `issues:${owner}/${repo}`,
-                maxResults,
-                pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listForRepo, {
-                    owner,
-                    repo,
-                    state: 'all',
-                    per_page: perPage,
-                    ...(since === undefined ? {} : { since }),
-                    ...(headers === undefined ? {} : { headers }),
-                }),
-            });
-        },
-        async listComments(owner, repo, issueNumber, perPage) {
-            return fetchPaginatedWithEtag({
-                cache: etagCache,
-                cacheKey: `issue-comments:${owner}/${repo}#${issueNumber}`,
-                pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listComments, {
-                    owner,
-                    repo,
-                    issue_number: issueNumber,
-                    per_page: perPage,
-                    ...(headers === undefined ? {} : { headers }),
-                }),
-            });
-        },
-        async getIssue(owner, repo, issueNumber) {
-            const { data } = await octokit.rest.issues.get({
-                owner,
-                repo,
-                issue_number: issueNumber,
-            });
-            return data;
-        },
-        async createComment(owner, repo, issueNumber, body) {
-            return octokit.rest.issues.createComment({
-                owner,
-                repo,
-                issue_number: issueNumber,
-                body,
-            });
-        },
-        async setLabels(owner, repo, issueNumber, labels) {
-            return octokit.rest.issues.setLabels({
-                owner,
-                repo,
-                issue_number: issueNumber,
-                labels,
-            });
-        },
-        async getPullRequest(owner, repo, pullNumber) {
-            const { data } = await octokit.rest.pulls.get({
-                owner,
-                repo,
-                pull_number: pullNumber,
-            });
-            return data;
-        },
-        async getRequiredStatusChecks(owner, repo, branch) {
-            const data = await fetchSingleWithEtag({
-                cache: etagCache,
-                cacheKey: `required-status-checks:${owner}/${repo}@${branch}`,
-                request: async (headers) => {
-                    const response = await octokit.rest.repos.getBranch({
-                        owner,
-                        repo,
-                        branch,
-                        ...(headers === undefined ? {} : { headers }),
-                    });
-                    return { data: response.data, headers: response.headers ?? {} };
-                },
-            });
-            const requiredStatusChecks = data.protection?.required_status_checks;
-            return {
-                contexts: requiredStatusChecks?.contexts ?? [],
-                checks: (requiredStatusChecks?.checks ?? [])
-                    .map((check) => check.context)
-                    .filter((context) => typeof context === 'string'),
-            };
-        },
-        async listCheckRunsForRef(owner, repo, ref) {
-            const data = await fetchSingleWithEtag({
-                cache: etagCache,
-                cacheKey: `check-runs:${owner}/${repo}@${ref}`,
-                request: async (headers) => {
-                    const response = await octokit.rest.checks.listForRef({
-                        owner,
-                        repo,
-                        ref,
-                        per_page: 100,
-                        ...(headers === undefined ? {} : { headers }),
-                    });
-                    return { data: response.data, headers: response.headers ?? {} };
-                },
-            });
-            return data.check_runs;
-        },
-        async getCombinedStatusForRef(owner, repo, ref) {
-            const data = await fetchSingleWithEtag({
-                cache: etagCache,
-                cacheKey: `combined-status:${owner}/${repo}@${ref}`,
-                request: async (headers) => {
-                    const response = await octokit.rest.repos.getCombinedStatusForRef({
-                        owner,
-                        repo,
-                        ref,
-                        ...(headers === undefined ? {} : { headers }),
-                    });
-                    return { data: response.data, headers: response.headers ?? {} };
-                },
-            });
-            return data.statuses;
-        },
-        async listPullRequests(owner, repo, maxResults) {
-            const perPage = Math.min(maxResults, 100);
-            return fetchPaginatedWithEtag({
-                cache: etagCache,
-                cacheKey: `pulls:${owner}/${repo}`,
-                maxResults,
-                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.list, {
-                    owner,
-                    repo,
-                    state: 'open',
-                    per_page: perPage,
-                    ...(headers === undefined ? {} : { headers }),
-                }),
-            });
-        },
-        async listReviews(owner, repo, pullNumber, perPage) {
-            return fetchPaginatedWithEtag({
-                cache: etagCache,
-                cacheKey: `pr-reviews:${owner}/${repo}#${pullNumber}`,
-                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviews, {
-                    owner,
-                    repo,
-                    pull_number: pullNumber,
-                    per_page: perPage,
-                    ...(headers === undefined ? {} : { headers }),
-                }),
-            });
-        },
-        async listReviewComments(owner, repo, pullNumber, perPage) {
-            return fetchPaginatedWithEtag({
-                cache: etagCache,
-                cacheKey: `pr-review-comments:${owner}/${repo}#${pullNumber}`,
-                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviewComments, {
-                    owner,
-                    repo,
-                    pull_number: pullNumber,
-                    per_page: perPage,
-                    ...(headers === undefined ? {} : { headers }),
-                }),
-            });
-        },
-        async listPullRequestFiles(owner, repo, pullNumber) {
-            return fetchPaginatedWithEtag({
-                cache: etagCache,
-                cacheKey: `pr-files:${owner}/${repo}#${pullNumber}`,
-                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listFiles, {
-                    owner,
-                    repo,
-                    pull_number: pullNumber,
-                    per_page: 100,
-                    ...(headers === undefined ? {} : { headers }),
-                }),
-            });
-        },
-        async createPullRequestApproval(owner, repo, pullNumber, body) {
-            await octokit.rest.pulls.createReview({
-                owner,
-                repo,
-                pull_number: pullNumber,
-                event: 'APPROVE',
-                body,
-            });
-        },
-        // GitHub's REST merge method takes a lowercase merge_method value,
-        // distinct from the GraphQL PullRequestMergeMethod enum used by
-        // enablePullRequestAutoMerge below.
-        async mergePullRequest(owner, repo, pullNumber, mergeMethod) {
-            await octokit.rest.pulls.merge({
-                owner,
-                repo,
-                pull_number: pullNumber,
-                merge_method: mergeMethod.toLowerCase(),
-            });
-        },
-        async enablePullRequestAutoMerge(pullRequestNodeId, mergeMethod) {
-            await octokit.graphql(`mutation EnableWakeAutoMerge($pullRequestId: ID!, $mergeMethod: PullRequestMergeMethod!) {
-          enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId, mergeMethod: $mergeMethod }) {
-            pullRequest {
-              id
-            }
-          }
-        }`, { pullRequestId: pullRequestNodeId, mergeMethod });
-        },
-        async replyToReviewComment(owner, repo, pullNumber, commentId, body) {
-            return octokit.rest.pulls.createReplyForReviewComment({
-                owner,
-                repo,
-                pull_number: pullNumber,
-                comment_id: commentId,
-                body,
-            });
-        },
-    };
-}

package/dist/src/adapters/github/github-etag-cache.js

@@ -1,57 +0,0 @@
-export function createEtagCache() {
-    return new Map();
-}
-function isNotModifiedError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'status' in error &&
-        error.status === 304);
-}
-export async function fetchSingleWithEtag(input) {
-    const cached = input.cache.get(input.cacheKey);
-    try {
-        const response = await input.request(cached === undefined ? undefined : { 'if-none-match': cached.etag });
-        if (typeof response.headers.etag === 'string') {
-            input.cache.set(input.cacheKey, { etag: response.headers.etag, data: response.data });
-        }
-        return response.data;
-    }
-    catch (error) {
-        if (isNotModifiedError(error) && cached !== undefined) {
-            return cached.data;
-        }
-        throw error;
-    }
-}
-export async function fetchPaginatedWithEtag(input) {
-    const cached = input.cache.get(input.cacheKey);
-    const results = [];
-    let pageCount = 0;
-    let lastHeaders = {};
-    try {
-        for await (const page of input.pages(cached === undefined ? undefined : { 'if-none-match': cached.etag })) {
-            pageCount += 1;
-            lastHeaders = page.headers;
-            results.push(...page.data);
-            if (input.maxResults !== undefined && results.length >= input.maxResults) {
-                break;
-            }
-        }
-    }
-    catch (error) {
-        if (isNotModifiedError(error) && cached !== undefined) {
-            return input.maxResults === undefined ? cached.data : cached.data.slice(0, input.maxResults);
-        }
-        throw error;
-    }
-    const truncated = input.maxResults !== undefined && results.length > input.maxResults
-        ? results.slice(0, input.maxResults)
-        : results;
-    if (pageCount <= 1 && typeof lastHeaders.etag === 'string') {
-        input.cache.set(input.cacheKey, { etag: lastHeaders.etag, data: truncated });
-    }
-    else {
-        input.cache.delete(input.cacheKey);
-    }
-    return truncated;
-}