@knowttl/gitea-axi 0.1.2 → 0.1.4

package/dist/reads.js

@@ -111,8 +111,8 @@ export async function listIssues(client, base, kind, options) {
         truncated: page.truncated || rows.length > limit, next: page.next, continuation: page.truncated || rows.length > limit,
         help: [`gitea-axi ${kind} view <number> --repo ${base.split('/').slice(-2).join('/')}`, ...continuationHelp(page, rows.length, limit)] };
 }
-async function complete(client, path) {
-    const page = await collect(client, path);
+async function complete(client, path, signal) {
+    const page = await collect(client, path, undefined, signal);
     if (page.truncated)
         throw new CliError('RESPONSE_LIMIT', 'Related collection exceeds the bounded read; use the raw API to page explicitly');
     return page.items;
@@ -127,11 +127,11 @@ async function reviews(client, path, full) {
     }
     return result;
 }
-export async function checks(client, base, sha) {
-    const combined = object(await read(client, base + '/commits/' + encodeURIComponent(sha) + '/status'));
+export async function checks(client, base, sha, signal) {
+    const combined = object(await read(client, base + '/commits/' + encodeURIComponent(sha) + '/status', signal));
     if (combined.sha !== sha && !(combined.sha === '' && combined.total_count === 0 && (combined.statuses === null || Array.isArray(combined.statuses) && !combined.statuses.length)))
         throw new CliError('INVALID_RESPONSE', 'Check response does not match the pull request head SHA');
-    const statuses = await complete(client, base + '/commits/' + encodeURIComponent(sha) + '/statuses');
+    const statuses = await complete(client, base + '/commits/' + encodeURIComponent(sha) + '/statuses', signal);
     statuses.sort((a, b) => Number(b.id) - Number(a.id));
     const latest = new Map();
     for (const status of statuses)
@@ -146,28 +146,37 @@ export async function checks(client, base, sha) {
 export async function watchChecks(client, base, number, options) {
     const seconds = positive(options.timeout, 30, 3600);
     const interval = positive(options.interval, 5, 60) * 1000;
-    const stop = Date.now() + seconds * 1000;
+    const stop = Math.min(client.deadline, Date.now() + seconds * 1000);
     const controller = new AbortController();
+    let head = null;
+    let latest;
     const cancel = () => controller.abort();
     process.once('SIGINT', cancel);
     process.once('SIGTERM', cancel);
     try {
         while (true) {
-            const pull = object(await read(client, base + '/pulls/' + number));
+            const pull = object(await read(client, base + '/pulls/' + number, controller.signal));
             const sha = object(pull.head).sha;
             if (typeof sha !== 'string' || !sha)
                 throw new CliError('INVALID_RESPONSE', 'Pull request head SHA is missing');
-            const result = await checks(client, base, sha);
+            head = sha;
+            const result = await checks(client, base, sha, controller.signal);
+            latest = result;
             if (!options.watch || result.items.length > 0 && !result.pending || result.failed || Date.now() >= stop || controller.signal.aborted)
-                return { ...result, cancelled: controller.signal.aborted };
+                return { ...result, exitCode: controller.signal.aborted ? 8 : result.exitCode, cancelled: controller.signal.aborted };
             await delay(Math.min(interval, Math.max(1, stop - Date.now())), undefined, { signal: controller.signal }).catch(error => {
                 if (!controller.signal.aborted)
                     throw error;
             });
             if (Date.now() >= stop || controller.signal.aborted)
-                return { ...result, cancelled: controller.signal.aborted };
+                return { ...result, exitCode: controller.signal.aborted ? 8 : result.exitCode, cancelled: controller.signal.aborted };
         }
     }
+    catch (error) {
+        if (!controller.signal.aborted)
+            throw error;
+        return { ...(latest ?? { head, items: [], passed: 0, failed: 0, pending: 0 }), exitCode: 8, cancelled: true };
+    }
     finally {
         process.removeListener('SIGINT', cancel);
         process.removeListener('SIGTERM', cancel);
@@ -196,7 +205,8 @@ export async function view(client, base, kind, number, options) {
                 headRepository: head.repo == null ? null : { name: object(head.repo).name, nameWithOwner: object(head.repo).full_name },
                 headRepositoryOwner: head.repo == null ? null : user(object(head.repo).owner), isCrossRepository: head.repo_id == null || tail.repo_id == null ? null : head.repo_id !== tail.repo_id,
                 mergeCommit: row.merge_commit_sha ? { oid: row.merge_commit_sha } : null, mergedBy: user(row.merged_by),
-                mergeable: row.mergeable == null ? 'UNKNOWN' : row.mergeable ? 'MERGEABLE' : 'CONFLICTING', reviewRequests: users(row.requested_reviewers) });
+                mergeable: row.mergeable == null ? 'UNKNOWN' : row.mergeable ? 'MERGEABLE' : 'CONFLICTING', reviewRequests: [...users(row.requested_reviewers),
+                    ...(row.requested_reviewers_teams ?? []).map(team => ({ type: 'team', id: team.id, name: team.name }))] });
         }
         if (options.reviews || requested.has('reviews') || requested.has('latestReviews')) {
             const all = await reviews(client, path, Boolean(options.full || fields));

package/dist/registry.js

@@ -22,6 +22,7 @@ export const command = {
 };
 export const limits = { timeoutMs: 30_000, responseBytes: 2_000_000 };
 const globalFlags = {
+    json: { type: 'boolean', description: 'Emit JSON instead of TOON; help follows this format, version remains plain text' },
     origin: command.flags.origin, 'allow-insecure-http': command.flags['allow-insecure-http'], help: command.flags.help,
     config: { type: 'string', description: 'Absolute configuration path' },
     profile: { type: 'string', description: 'Select one file profile' },
@@ -91,7 +92,7 @@ const definitions = [
     ['pr view', { ...repo, ...detail, reviews: { type: 'boolean' }, checks: { type: 'boolean' } }],
     ['pr checks', { ...repo, watch: { type: 'boolean' }, timeout: { type: 'string', description: 'Watch deadline seconds, required with --watch' }, interval: { type: 'string', description: 'Watch interval seconds, default 5' } }],
     ['pr diff', { ...repo, full: detail.full }],
-    ['release list', { ...repo, limit: list.limit, 'exclude-drafts': { type: 'boolean' }, 'exclude-pre-releases': { type: 'boolean' } }],
+    ['release list', { ...repo, limit: { ...list.limit, description: 'Maximum returned records, default 10, maximum 1000' }, 'exclude-drafts': { type: 'boolean' }, 'exclude-pre-releases': { type: 'boolean' } }],
     ['release view', { ...repo, full: detail.full }], ['api', { ...writeFlags,
             method: { type: 'string', short: 'X', description: 'HTTP method; cannot combine with a positional method' },
             field: { type: 'string', multiple: true, description: 'Repeatable key=value; numbers, booleans and null become JSON values' },
@@ -144,7 +145,7 @@ for (const command of commands) {
     if (['repo create', 'repo fork'].includes(command.path.join(' ')))
         Object.assign(command.flags, workspace);
 }
-commands.push({ path: ['capabilities'], description: 'Inspect all baseline command IDs, flags, globals and PR fields without claiming full parity', flags: { help: globalFlags.help }, effect: 'local-read' });
+commands.push({ path: ['capabilities'], description: 'Inspect all baseline command IDs, flags, globals and PR fields without claiming full parity', flags: { help: globalFlags.help, json: globalFlags.json }, effect: 'local-read' });
 const refusedFlags = [
     ['repo create', ['internal']],
     ['release create', ['latest', 'discussion-category']],

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', 'json'].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

@@ -3,7 +3,7 @@ import { constants, existsSync } from 'node:fs';
 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';
@@ -11,6 +11,7 @@ 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(',') + ']';
@@ -45,7 +46,7 @@ async function key(root) {
     }
     return readPrivateFile(path, true);
 }
-export async function reconcile(client, id) {
+export async function reconcile(client, id, json = false) {
     if (!/^[a-f0-9-]{36}$/.test(id))
         usage('Select the exact confirmation ID');
     const receipt = JSON.parse(await readPrivateFile(join(directory(), id + '.json'), true));
@@ -53,8 +54,8 @@ export async function reconcile(client, id) {
         throw new CliError('CONFIRMATION_MISMATCH', 'Reconciliation origin differs from the attempted write');
     const observations = await observe(client, receipt.reads);
     controlText(id);
-    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' };
+    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' }, json);
 }
 async function observe(client, paths) {
     const observations = [];
@@ -268,8 +269,8 @@ export async function write(client, identity, plan, options, executeLocal) {
         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: controlText('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') }, Boolean(options.json));
     }
     const id = String(options.confirm);
     if (!/^[a-f0-9-]{36}$/.test(id))
@@ -356,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)
@@ -415,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) }, Boolean(options.json));
 }
 export async function rawWritePlan(client, method, path, payload) {
     const route = validatePayload(method, path, payload);
@@ -434,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) {