@knowttl/gitea-axi 0.1.1 → 0.1.3

package/dist/search.js

@@ -9,7 +9,7 @@ export function validateSearch(kind, query, options) {
     const allowed = kind === 'issues' || kind === 'prs' ? ['owner', 'state', 'label', 'assignee', 'author', 'sort', 'order', 'limit', 'fields', ...(kind === 'prs' ? ['draft'] : [])] :
         kind === 'repos' ? ['owner', 'sort', 'order', 'limit', 'language', 'stars', 'fields'] : ['author', 'sort', 'order', 'limit', 'revision', 'fields'];
     for (const key of Object.keys(options)) {
-        if (!['origin', 'allow-insecure-http', 'config', 'profile', 'repo'].includes(key) && !allowed.includes(key))
+        if (!['origin', 'allow-insecure-http', 'config', 'profile', 'hostname', 'repo'].includes(key) && !allowed.includes(key))
             throw new CliError('CAPABILITY_GAP', '--' + key + ' is not evidenced for search ' + kind);
     }
     positive(options.limit, 1000, 1000);
@@ -94,9 +94,11 @@ export async function search(client, kind, query, options) {
         return true;
     });
     const key = options.sort === 'updated' ? 'updated_at' : options.sort === 'comments' ? 'comments' : options.sort === 'stars' ? 'stars_count' : options.sort === 'name' ? 'full_name' : kind === 'commits' ? 'created' : 'created_at';
+    const temporal = ['created', 'created_at', 'updated_at'].includes(key);
     rows.sort((a, b) => {
         const left = a[key] ?? '', right = b[key] ?? '';
-        const compared = typeof left === 'number' && typeof right === 'number' ? left - right : String(left).localeCompare(String(right));
+        const compared = temporal && left !== '' && right !== '' ? Date.parse(String(left)) - Date.parse(String(right)) :
+            typeof left === 'number' && typeof right === 'number' ? left - right : String(left).localeCompare(String(right));
         return (compared || String(a.id ?? a.sha).localeCompare(String(b.id ?? b.sha))) * (options.order === 'asc' ? 1 : -1);
     });
     const limit = positive(options.limit, 1000, 1000);

package/dist/stacks.js

@@ -24,6 +24,8 @@ const schema = new Ajv().compile({
                 originalBranch: { type: 'string' }, originalTips: { type: 'string' },
                 steps: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['effect', 'state'],
                         properties: { effect: branch, state: { enum: ['pending', 'dispatched', 'completed'] } } } },
+                prune: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['branch', 'number', 'head', 'merge'],
+                        properties: { branch, number: { type: 'integer', minimum: 1 }, head: { type: 'string', pattern: '^[a-f0-9]{40}$' }, merge: { type: 'string', pattern: '^[a-f0-9]{40}$' } } } },
                 rebase: { type: 'object', additionalProperties: false,
                     required: ['branches', 'oldBases', 'originalTips', 'expectedTips', 'originalBranch', 'cursor', 'dispatched', 'authorDate'],
                     properties: { branches: { type: 'array', items: branch, uniqueItems: true }, oldBases: tips, originalTips: tips, expectedTips: tips,
@@ -39,6 +41,12 @@ async function stackAt(path, git) {
         value.pulls.some(pull => !value.branches.includes(pull.branch))) {
         throw new CliError('STACK_INVALID', 'Stack metadata is invalid, inconsistent or belongs to a different origin');
     }
+    const prune = value.pending?.prune;
+    if (prune && (value.pending.action !== 'sync' || new Set(prune.map(item => item.branch)).size !== prune.length ||
+        prune.some(item => !value.branches.includes(item.branch) || !value.pulls.some(pull => pull.branch === item.branch && pull.number === item.number) ||
+            value.pending.steps.filter(step => step.effect === 'prune ' + item.branch).length !== 1))) {
+        throw new CliError('STACK_INVALID', 'Prune checkpoints must describe only the owned stack branches and linked PRs');
+    }
     const rebase = value.pending?.rebase;
     if (rebase) {
         if (rebase.cursor > rebase.branches.length || rebase.branches.some(branch => !value.branches.includes(branch) || !rebase.oldBases[branch]) ||
@@ -53,7 +61,13 @@ async function stackAt(path, git) {
     return value;
 }
 async function ancestor(git, parent, child) {
-    return (await git.run(['merge-base', parent, child])) === await git.tip(parent);
+    return (await git.run(['merge-base', parent, child], [0, 1])) === await git.tip(parent);
+}
+function releaseBranch(state, branch) {
+    state.branches = state.branches.filter(name => name !== branch);
+    state.pulls = state.pulls.filter(pull => pull.branch !== branch);
+    if (state.pending?.prune)
+        state.pending.prune = state.pending.prune.filter(item => item.branch !== branch);
 }
 export async function stackWorkflow(client, identity, action, args, options) {
     const git = await new Git(String(options.workspace), identity.origin, identity.token).workspace();
@@ -107,6 +121,8 @@ export async function stackWorkflow(client, identity, action, args, options) {
     state.remote = remote.name;
     const plans = [];
     const commands = [];
+    const prune = [];
+    const fetchedRefs = [];
     let destination;
     let remove = false;
     let rebase;
@@ -249,21 +265,43 @@ export async function stackWorkflow(client, identity, action, args, options) {
             linked.state = pull.state;
             linked.merged = pull.merged === true;
         }
+        for (const member of [...state.branches]) {
+            if (snapshot.refs.split('\n').some(line => line.startsWith('refs/heads/' + member + ' ')))
+                continue;
+            const pending = before?.pending;
+            const recorded = pending?.prune?.find(item => item.branch === member);
+            const checkpoint = pending?.steps.find(step => step.effect === 'prune ' + member);
+            const linked = state.pulls.find(pull => pull.branch === member);
+            const pull = page.items.find(pull => pull.number === linked?.number);
+            if (!recoveringSync || !recorded || !checkpoint || checkpoint.state === 'pending' || !pull ||
+                pull.number !== recorded.number || pull.state !== 'closed' || pull.merged !== true ||
+                object(pull.head).sha !== recorded.head || pull.merge_commit_sha !== recorded.merge ||
+                !pending.originalTips.split('\n').includes('refs/heads/' + member + ' ' + recorded.head) ||
+                !await git.run(['rev-parse', '--verify', '--quiet', recorded.head + '^{commit}'], [0, 1]) ||
+                !await git.run(['rev-parse', '--verify', '--quiet', recorded.merge + '^{commit}'], [0, 1]) ||
+                !await ancestor(git, recorded.head, recorded.merge)) {
+                throw new CliError('STACK_RECOVERY_REQUIRED', 'An absent owned branch requires its dispatched prune checkpoint and verified merged PR history');
+            }
+            releaseBranch(state, member);
+        }
         const existing = [state.trunk, ...state.branches].filter(name => remoteRefs.split('\n').some(line => line.endsWith('\trefs/heads/' + name)));
+        for (const name of existing)
+            fetchedRefs.push({ ref: 'refs/remotes/' + remote.name + '/' + name,
+                head: remoteRefs.split('\n').find(line => line.endsWith('\trefs/heads/' + name)).split('\t')[0] });
         if (existing.length)
             commands.push(['fetch', '--no-tags', '--', remote.url, ...existing.map(name => 'refs/heads/' + name + ':refs/remotes/' + remote.name + '/' + name)]);
         if (options.prune) {
             for (const member of [...state.branches]) {
                 const linked = state.pulls.find(pull => pull.branch === member);
                 const pull = page.items.find(pull => pull.number === linked?.number);
-                if (!linked || !pull || pull.merged !== true || object(pull.head).sha !== await git.tip('refs/heads/' + member))
+                if (!linked || !pull || pull.state !== 'closed' || pull.merged !== true || object(pull.head).sha !== await git.tip('refs/heads/' + member))
                     continue;
                 if (member === snapshot.branch || snapshot.worktrees.split('\n').includes('branch refs/heads/' + member))
                     continue;
                 const merge = String(pull.merge_commit_sha);
-                if (!/^[a-f0-9]{40}$/.test(merge) || !await git.run(['rev-parse', '--verify', '--quiet', merge + '^{commit}'], [0, 1]) ||
-                    !await ancestor(git, 'refs/heads/' + member, merge))
+                if (!/^[a-f0-9]{40}$/.test(merge))
                     continue;
+                prune.push({ branch: member, number: linked.number, head: linked.head, merge });
                 commands.push(['branch', '-d', member]);
             }
         }
@@ -349,7 +387,7 @@ export async function stackWorkflow(client, identity, action, args, options) {
     const local = 'gitea.local.stack.' + localAction;
     const begin = { method: 'LOCAL', path: git.cwd, local, payload: { phase: 'begin', action, args, options: { ...options, preview: undefined, confirm: undefined }, remote,
             ...(recovering ? { recoverLocal: before.pending.confirmations } : {}) } };
-    const finish = { method: 'LOCAL', path: git.cwd, local, payload: { phase: 'finish', state, commands, remove, destination } };
+    const finish = { method: 'LOCAL', path: git.cwd, local, payload: { phase: 'finish', state, commands, prune, remove, destination } };
     const steps = [begin];
     const apiResultIndices = [];
     for (const [index, plan] of plans.entries()) {
@@ -374,7 +412,9 @@ export async function stackWorkflow(client, identity, action, args, options) {
                 if (action !== 'rebase')
                     state.pending = { action, confirmations: recovering ? [...before.pending.confirmations] : [],
                         originalBranch: before?.pending?.originalBranch ?? snapshot.branch, originalTips: before?.pending?.originalTips ?? snapshot.refs,
-                        steps: [...plans.map(plan => ({ effect: plan.target, state: 'pending' })), ...commands.map(command => ({ effect: command[0], state: 'pending' }))] };
+                        ...(prune.length ? { prune: structuredClone(prune) } : {}),
+                        steps: [...plans.map(plan => ({ effect: plan.target, state: 'pending' })),
+                            ...commands.map(command => ({ effect: command[0] === 'branch' ? 'prune ' + command[2] : command[0], state: 'pending' }))] };
                 state.pending.confirmations.push(confirmation);
                 await save(path, state);
                 return { state: 'started' };
@@ -452,12 +492,25 @@ export async function stackWorkflow(client, identity, action, args, options) {
             }
             else {
                 for (const [index, command] of commands.entries()) {
+                    if (action === 'sync' && command[0] === 'branch') {
+                        const selected = prune.find(item => item.branch === command[2]);
+                        if (await git.tip('refs/heads/' + selected.branch) !== selected.head)
+                            throw new CliError('CONFIRMATION_MISMATCH', 'A prune candidate changed before deletion');
+                        if (!await git.run(['rev-parse', '--verify', '--quiet', selected.merge + '^{commit}'], [0, 1]) ||
+                            !await ancestor(git, selected.head, selected.merge))
+                            continue;
+                    }
                     state.pending.steps[plans.length + index].state = 'dispatched';
                     await save(path, state);
                     await git.run(command);
+                    if (prune.length && command[0] === 'fetch') {
+                        for (const expected of fetchedRefs) {
+                            if (await git.tip(expected.ref) !== expected.head)
+                                throw new CliError('CONFIRMATION_MISMATCH', 'Fetched branch differs from the confirmed remote graph');
+                        }
+                    }
                     if (action === 'sync' && command[0] === 'branch') {
-                        state.branches = state.branches.filter(name => name !== command[2]);
-                        state.pulls = state.pulls.filter(pull => pull.branch !== command[2]);
+                        releaseBranch(state, command[2]);
                     }
                     state.pending.steps[plans.length + index].state = 'completed';
                     await save(path, state);

package/dist/transport.js

@@ -28,13 +28,14 @@ export class Client {
         this.token = token;
         this.deadline = Date.now() + timeoutMs;
     }
-    async request(path, text = false, mutation) {
+    async request(path, text = false, mutation, signal) {
         canonicalPath(path);
         const url = new URL(path, this.origin);
         if (url.origin !== this.origin || !path.startsWith('/') || path.startsWith('//'))
             throw new CliError('UNSAFE_PATH', 'Request must stay within the selected origin');
         try {
             const form = mutation?.upload ? new FormData() : undefined;
+            const timeout = AbortSignal.timeout(Math.max(1, Math.min(limits.timeoutMs, this.deadline - Date.now())));
             if (form && mutation?.upload)
                 form.set('attachment', new Blob([Buffer.from(mutation.upload.base64, 'base64')], { type: mutation.upload.type }), mutation.upload.name);
             const response = await fetch(url, {
@@ -42,7 +43,7 @@ export class Client {
                 ...(form ? { body: form } : mutation?.payload === undefined ? {} : { body: JSON.stringify(mutation.payload) }),
                 headers: { accept: text ? 'text/plain' : 'application/json', ...(mutation && !form ? { 'content-type': 'application/json' } : {}), ...(this.token ? { authorization: 'token ' + this.token } : {}) },
                 redirect: 'error',
-                signal: AbortSignal.timeout(Math.max(1, Math.min(limits.timeoutMs, this.deadline - Date.now()))),
+                signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
             });
             if (mutation?.sensitive) {
                 await response.body?.cancel();
@@ -87,7 +88,7 @@ export class Client {
             throw new CliError('TRANSPORT_ERROR', 'Gitea request failed (' + transportCause(error) + '); check the selected origin and connection');
         }
     }
-    async get(path) { return (await this.request(path)).data; }
+    async get(path, signal) { return (await this.request(path, false, undefined, signal)).data; }
     async attachment(uuid, expectedType) {
         if (!/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(uuid))
             throw new CliError('UNSAFE_PATH', 'Invalid attachment UUID');

package/dist/writes.js

@@ -1,15 +1,17 @@
 import { createHash, createHmac, randomBytes, randomUUID } from 'node:crypto';
 import { constants, existsSync } from 'node:fs';
-import { mkdir, open, rm } from 'node:fs/promises';
+import { mkdir, open, readdir, rm } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join } from 'node:path';
-import { canonicalPath, collect, effectFor, object, read, validate, validatePayload } from './api.js';
+import { canonicalPath, collect, effectFor, object, read, routeFor, validate, validatePayload } from './api.js';
 import { CliError } from './error.js';
 import { readPrivateFile, writePrivateFile } from './private-file.js';
 import { verifyPull } from './pulls.js';
 import { verifyWorkflow } from './repo-workflows.js';
 import { actionValues, valuePlan, verifyValue } from './action-values.js';
 import { verifyUploads } from './attachments.js';
+import { controlText } from './credentials.js';
+import { writeOutput } from './output.js';
 function canonical(value) {
     if (Array.isArray(value))
         return '[' + value.map(canonical).join(',') + ']';
@@ -21,9 +23,9 @@ const digest = (value) => createHash('sha256').update(canonical(value)).digest('
 const usage = (message) => { throw new CliError('USAGE', message, 2); };
 const logPath = () => process.env.GITEA_AXI_WRITE_LOG ?? join(process.platform === 'win32' ? process.env.LOCALAPPDATA ?? homedir() : process.env.XDG_STATE_HOME ?? join(homedir(), '.local/state'), 'gitea-axi', 'writes.log');
 const directory = () => join(dirname(logPath()), 'write-receipts');
-const command = (id, options) => 'gitea-axi write reconcile ' + id +
-    (options.config ? ' --config ' + shell(String(options.config)) : '') + (options.profile ? ' --profile ' + shell(String(options.profile)) : '') +
-    (options.origin ? ' --origin ' + shell(String(options.origin)) : '') + (options['allow-insecure-http'] ? ' --allow-insecure-http' : '');
+const command = (id, options) => controlText('gitea-axi write reconcile ' + id) +
+    (options.config ? controlText(' --config ') + shell(String(options.config)) : '') + (options.profile ? controlText(' --profile ') + shell(String(options.profile)) : '') +
+    (options.origin ? controlText(' --origin ') + shell(String(options.origin)) : '') + (options['allow-insecure-http'] ? controlText(' --allow-insecure-http') : '');
 function shell(value) { return "'" + value.replaceAll("'", "'\\''") + "'"; }
 async function key(root) {
     await mkdir(root, { recursive: true, mode: 0o700 });
@@ -51,8 +53,9 @@ export async function reconcile(client, id) {
     if (receipt.origin !== client.origin)
         throw new CliError('CONFIRMATION_MISMATCH', 'Reconciliation origin differs from the attempted write');
     const observations = await observe(client, receipt.reads);
-    return { confirmation: id, operations: receipt.operations, states: receipt.states, observations,
-        help: 'Inspect the exact identity and requested fields in these reads before authorizing any new attempt' };
+    controlText(id);
+    return writeOutput({ confirmation: id, operations: receipt.operations, states: receipt.states, observations,
+        help: 'Inspect the exact identity and requested fields in these reads before authorizing any new attempt' });
 }
 async function observe(client, paths) {
     const observations = [];
@@ -225,11 +228,9 @@ export async function write(client, identity, plan, options, executeLocal) {
             return { method: step.method, path: step.path, payload: step.payload, local: localOperation(step).operation };
         const route = validatePayload(step.method, step.path, step.payload);
         const segments = canonicalPath(step.path).split('/');
-        if (/\{(?:template_)?repo\}/.test(route.path)) {
-            for (const [index, segment] of route.path.split('/').entries()) {
-                if (/^\{(?:owner|repo|org|template_owner|template_repo)\}$/.test(segment)) {
-                    segments[index] = encodeURIComponent(decodeURIComponent(segments[index]).toLowerCase());
-                }
+        for (const [index, segment] of route.path.split('/').entries()) {
+            if (/^\{(?:owner|repo|org|template_owner|template_repo)\}$/.test(segment)) {
+                segments[index] = encodeURIComponent(decodeURIComponent(segments[index]).toLowerCase());
             }
         }
         return { method: step.method, path: segments.join('/'), ...(step.payload === undefined ? {} : { payload: step.payload }), ...(step.upload ? { upload: step.upload } : {}) };
@@ -238,6 +239,25 @@ export async function write(client, identity, plan, options, executeLocal) {
     const effectDigest = (value) => plan.sensitive ? createHmac('sha256', secret).update(canonical(value)).digest('hex') : digest(value);
     const attempt = effectDigest({ origin: client.origin, steps: effectSteps });
     const guards = [...new Set(effectSteps.filter((_, index) => !plan.steps[index].createdPull).map(step => join(root, effectDigest({ origin: client.origin, step }) + '.attempt')))];
+    const organization = (path) => /^\/api\/v1\/orgs\/([^/?]+)/.exec(canonicalPath(path))?.[1];
+    const organizations = new Set(effectSteps.map(step => organization(step.path)).filter(value => value !== undefined));
+    if (organizations.size) {
+        for (const name of await readdir(root)) {
+            if (!/^[a-f0-9]{64}\.attempt$/.test(name))
+                continue;
+            const previous = await readPrivateFile(join(root, name), true);
+            if (!/^[a-f0-9-]{36}$/.test(previous))
+                usage('Invalid persisted confirmation ID');
+            const receipt = JSON.parse(await readPrivateFile(join(root, previous + '.json'), true));
+            if (receipt.guardVersion !== 2 && receipt.origin === client.origin &&
+                receipt.reads.some(path => {
+                    const org = organization(path);
+                    return org !== undefined && organizations.has(encodeURIComponent(decodeURIComponent(org).toLowerCase()));
+                })) {
+                throw new CliError('WRITE_OUTCOME_UNKNOWN', 'An attempt already exists; reconcile with ' + command(previous, options));
+            }
+        }
+    }
     for (const guard of guards) {
         if (existsSync(guard)) {
             const previous = await readPrivateFile(guard, true);
@@ -245,18 +265,19 @@ export async function write(client, identity, plan, options, executeLocal) {
         }
     }
     if (options.preview) {
-        const id = randomUUID();
-        const receipt = { binding, origin: client.origin, reads: plan.reads, states: plan.steps.map(() => 'pending'), operations, attempt,
+        const id = controlText(randomUUID());
+        const receipt = { binding, origin: client.origin, reads: plan.reads, states: plan.steps.map(() => 'pending'), operations, attempt, guardVersion: 2,
             ...(plan.steps.every(step => step.local) ? { localTarget: plan.target, localGuards: guards.map(path => path.slice(root.length + 1, -8)) } : {}) };
         await writePrivateFile(join(root, id + '.json'), JSON.stringify(receipt));
-        return { confirmation: id, origin: client.origin, target: plan.target, operations, steps: plan.steps.map(({ upload, ...step }) => ({ ...step, ...(plan.sensitive && step.payload !== undefined ? { payload: '[REDACTED]' } : {}), ...(upload ? { upload: { name: upload.name, type: upload.type, size: upload.size, sha256: upload.sha256 } } : {}) })), preconditions: plan.preconditions,
-            ...(plan.notes ? { notes: plan.notes } : {}), help: 'Repeat the same command with --confirm ' + id + ' instead of --preview' };
+        return writeOutput({ confirmation: id, origin: client.origin, target: plan.target, operations, steps: plan.steps.map(({ upload, ...step }) => ({ ...step, ...(plan.sensitive && step.payload !== undefined ? { payload: '[REDACTED]' } : {}), ...(upload ? { upload: { name: upload.name, type: upload.type, size: upload.size, sha256: upload.sha256 } } : {}) })), preconditions: plan.preconditions,
+            ...(plan.notes ? { notes: plan.notes } : {}), help: controlText('Repeat the same command with --confirm ' + id + ' instead of --preview') });
     }
     const id = String(options.confirm);
     if (!/^[a-f0-9-]{36}$/.test(id))
         usage('Use the confirmation ID returned by --preview');
     const path = join(root, id + '.json');
     const receipt = JSON.parse(await readPrivateFile(path, true));
+    controlText(id);
     if (receipt.states.some(state => state !== 'pending'))
         throw new CliError('WRITE_OUTCOME_UNKNOWN', 'Confirmation was already dispatched; reconcile with ' + command(id, options));
     if (receipt.binding !== binding)
@@ -285,6 +306,7 @@ export async function write(client, identity, plan, options, executeLocal) {
             throw error;
         }
     }
+    receipt.guardVersion = 2;
     const results = [];
     const outcome = () => 'steps=' + receipt.states.join(',') + (receipt.createdPull ? '; created PR id=' + receipt.createdPull.id + ' number=' + receipt.createdPull.number : '') + (receipt.createdParent ? '; existing parent id=' + receipt.createdParent.id + (receipt.createdParent.number ? ' number=' + receipt.createdParent.number : '') : '') + '; reconcile with ' + command(id, options);
     for (const [index, step] of plan.steps.entries()) {
@@ -335,6 +357,19 @@ export async function write(client, identity, plan, options, executeLocal) {
             const result = dispatched.local ? await executeLocal(dispatched, results, id) :
                 (await client.request(dispatched.path, false, { ...dispatched, ...(plan.sensitive ? { sensitive: true } : {}) })).data;
             results.push(result);
+            if (plan.wikiRename) {
+                const original = dispatched.path.split('?')[0];
+                const page = object(validate(original, result));
+                if (typeof page.sub_url !== 'string' || !page.sub_url)
+                    throw new CliError('INVALID_RESPONSE', 'Wiki rename returned no page identity');
+                // Gitea's sub_url is already escaped and may differ from the requested display title.
+                const renamed = original.slice(0, original.lastIndexOf('/') + 1) + page.sub_url;
+                const url = new URL(renamed, client.origin);
+                if (url.origin !== client.origin || url.pathname !== renamed || url.search || url.hash || routeFor(renamed).operation !== 'repoGetWikiPage') {
+                    throw new CliError('INVALID_RESPONSE', 'Wiki rename returned an unsafe page identity');
+                }
+                receipt.reads = [renamed];
+            }
             if (plan.steps.some(step => step.assetParent === index)) {
                 const parent = object(result);
                 if (!Number.isSafeInteger(parent.id) || Number(parent.id) <= 0)
@@ -394,7 +429,7 @@ export async function write(client, identity, plan, options, executeLocal) {
         recovered.states = recovered.states.map(state => state === 'completed' ? state : 'recovered');
         await writePrivateFile(join(root, previous + '.json'), JSON.stringify(recovered));
     }
-    return { confirmation: id, states: receipt.states, results, observations, ...(plan.notes ? { notes: plan.notes } : {}), reconcile: command(id, options) };
+    return writeOutput({ confirmation: id, states: receipt.states, results, observations, ...(plan.notes ? { notes: plan.notes } : {}), reconcile: command(id, options) });
 }
 export async function rawWritePlan(client, method, path, payload) {
     const route = validatePayload(method, path, payload);
@@ -413,7 +448,17 @@ export async function rawWritePlan(client, method, path, payload) {
     if (verification.endsWith('/issues'))
         verification += '?state=all&type=issues';
     const preconditions = await observe(client, [verification]);
-    return { target: path, steps: [{ method, path, ...(payload === undefined ? {} : { payload }) }], reads: [verification], preconditions };
+    let reads = [verification];
+    const wikiRename = route.operation === 'repoEditWikiPage';
+    if (wikiRename)
+        reads = [verification.slice(0, verification.lastIndexOf('/page/')) + '/pages'];
+    if (route.operation === 'repoEdit' && typeof object(payload).name === 'string' && object(payload).name !== '') {
+        const id = object(preconditions[0].data).id;
+        if (!Number.isSafeInteger(id) || Number(id) <= 0)
+            throw new CliError('INVALID_RESPONSE', 'Repository rename requires an immutable repository identity');
+        reads = ['/api/v1/repositories/' + id];
+    }
+    return { target: path, steps: [{ method, path, ...(payload === undefined ? {} : { payload }) }], reads, preconditions, ...(wikiRename ? { wikiRename: true } : {}) };
 }
 const names = (value) => [...new Set(Array.isArray(value) ? value.map(String) : [String(value)])];
 export async function issueLabelPlan(client, operation, base, number, options) {

package/generated/help.txt

@@ -784,7 +784,7 @@ commands[128]:
         description: OWNER/NAME; otherwise a matching local origin remote
       limit:
         type: string
-        description: "Maximum returned records, default 30, maximum 1000"
+        description: "Maximum returned records, default 10, maximum 1000"
       "exclude-drafts":
         type: boolean
       "exclude-pre-releases":

package/generated/host-inventory.json

@@ -1120,7 +1120,7 @@
         },
         "limit": {
           "type": "string",
-          "description": "Maximum returned records, default 30, maximum 1000"
+          "description": "Maximum returned records, default 10, maximum 1000"
         },
         "exclude-drafts": {
           "type": "boolean"