@commercelayer/agent-cli 0.8.0 → 1.0.0-dev.0

package/dist/builtins/extensions.js

@@ -0,0 +1,123 @@
+// Code around plain nouns, whose schema is the API's: what happens on this machine.
+//
+// organizations create and connect answer an organization token once (org_..., contract section
+// 21): it is stored like a sandbox token, in credentials.json with mode 600, and never printed.
+// create sends an Idempotency-Key, as sandbox create does, and links the folder; connect links it
+// only when no link names another organization.
+//
+// sales-calls book answers a cancel token once (section 20): stored the same way, by booking id,
+// and sent by sales-calls cancel <booking> without the agent ever holding it.
+import crypto from 'node:crypto';
+import { credentialsFile, hintOf, outWritten, readLink, storeBooking, storedBooking, storeOrg, writeLink } from '../config.js';
+import { confirm, terminal } from '../confirm.js';
+import { fail } from '../errors.js';
+import { apiUrl } from '../http.js';
+import { resourceRequest } from '../resources.js';
+import { OUT_NOT_TRACKED, removeCredentialFiles } from '../secrets.js';
+const NAME_MAX = 25;
+export const organizations = {
+    async run(run) {
+        if (run.verb.name !== 'create' && run.verb.name !== 'connect')
+            return undefined;
+        const name = run.parsed.values.name;
+        if (run.verb.name === 'create' && name !== undefined && (name.trim() === '' || name.length > NAME_MAX)) {
+            fail('invalid_value', `--name ${JSON.stringify(name)} is ${name.trim() === '' ? 'empty' : `${name.length} characters`}: an organization name has 1 to ${NAME_MAX}.`, { path: 'name', next_step: { action: 'fix_request', command: null } });
+        }
+        const req = resourceRequest('organizations', run.verb, run.parsed.id, run.parsed.values);
+        // Ending every other token of the organization is confirmed: by the schema's confirm_if, or
+        // here for a schema without it.
+        if (run.verb.name === 'connect' && run.parsed.values.revoke_others && !run.globals.dryRun) {
+            if (!run.verb.confirmIf.includes('revoke_others'))
+                await confirm(`Connect ${run.parsed.id} and end every other organization token of it`, run.line, { yes: run.globals.yes, prompter: run.prompter ?? terminal });
+            req.confirm = true;
+            req.body = { ...req.body, confirm: true };
+        }
+        if (run.verb.name === 'create') {
+            req.idempotencyKey = `c11r-${crypto.randomBytes(16).toString('base64url')}`;
+            req.timeoutMs = 120_000;
+        }
+        const r = await run.send(req);
+        if (run.globals.dryRun)
+            return r;
+        const { token, ...data } = r.data ?? {};
+        const org = (data.org ?? data.slug ?? run.parsed.id);
+        if (typeof token !== 'string' || typeof org !== 'string')
+            fail('invalid_response', `organizations ${run.verb.name} answered without the organization and its token.`, { next_step: { action: 'none' } });
+        const hint = typeof data.token_hint === 'string' ? data.token_hint : hintOf(token);
+        storeOrg(org, { token, token_hint: hint, expires_at: data.expires_at ?? null, created_at: new Date().toISOString(), api_url: apiUrl() });
+        const warnings = r.warnings.filter((w) => w.code !== 'token_shown_once');
+        const existing = (() => {
+            try {
+                return readLink();
+            }
+            catch {
+                return null;
+            }
+        })();
+        let linked = null;
+        if (run.verb.name === 'create' || !existing || existing.org === org) {
+            const link = writeLink(org);
+            linked = link.file;
+            if (link.previous)
+                warnings.push({ code: 'relinked', message: `${link.file} named ${link.previous}; it now names ${org}. The token of ${link.previous} stays stored.` });
+        }
+        else {
+            warnings.push({ code: 'not_linked', message: `${existing.file} names ${existing.org}, so this folder stays linked to it. --org ${org}, or c11r auth switch ${org}, acts on ${org}.` });
+        }
+        if (typeof data.revoked === 'number') {
+            warnings.push({ code: 'tokens_revoked', message: data.revoked ? `${data.revoked} other organization token${data.revoked === 1 ? '' : 's'} of ${org} no longer work${data.revoked === 1 ? 's' : ''}, on whatever machine held them.` : `No other organization token of ${org} was in use.` });
+        }
+        return { ...r, data: { ...data, org, token_hint: hint, credentials: credentialsFile(), linked }, warnings };
+    },
+};
+export const salesCalls = {
+    positional: { book: 'slot' },
+    prepare(verb, parsed) {
+        // The cancel token stays on this machine: cancel takes it from there.
+        if (verb.name !== 'cancel' || parsed.id === undefined || parsed.values.cancel_token !== undefined)
+            return;
+        const stored = storedBooking(parsed.id);
+        if (stored)
+            parsed.values.cancel_token = stored.cancel_token;
+        else if (verb.flags.cancel_token) {
+            fail('no_credentials', `This machine has no cancel token for booking ${parsed.id}: it was booked elsewhere, or cancelled already.`, { path: 'id', next_step: { action: 'none' } }, 'auth');
+        }
+    },
+    async run(run) {
+        if (run.verb.name === 'book') {
+            const r = await run.send(resourceRequest('sales-calls', run.verb, run.parsed.id, run.parsed.values));
+            if (run.globals.dryRun)
+                return r;
+            const { cancel_token: cancelToken, ...data } = r.data ?? {};
+            const id = data.booking?.id;
+            if (typeof cancelToken === 'string' && id !== undefined) {
+                storeBooking(String(id), { cancel_token: cancelToken, start: data.booking?.start ?? null, created_at: new Date().toISOString() });
+                return { ...r, data: { ...data, cancel_token: 'stored', credentials: credentialsFile() }, warnings: r.warnings.filter((w) => w.code !== 'token_shown_once') };
+            }
+            return { ...r, data };
+        }
+        if (run.verb.name === 'cancel') {
+            const r = await run.send(resourceRequest('sales-calls', run.verb, run.parsed.id, run.parsed.values));
+            if (!run.globals.dryRun && run.parsed.id !== undefined)
+                storeBooking(run.parsed.id, null);
+            return r;
+        }
+        return undefined;
+    },
+};
+export const credentials = {
+    async run(run) {
+        if (run.verb.name !== 'delete')
+            return undefined;
+        const r = await run.send(resourceRequest('credentials', run.verb, run.parsed.id, run.parsed.values));
+        if (run.globals.dryRun || !run.org.org)
+            return r;
+        // The secret and token files c11r wrote for it go with it.
+        const id = String(r.data?.id ?? run.parsed.id);
+        const removed = removeCredentialFiles(run.org.org, id);
+        // The warning only when it may apply: nothing found here, or a file written with --out for this organization.
+        const warn = removed.length === 0 || outWritten(run.org.org);
+        return { ...r, data: { ...(r.data ?? {}), removed_files: removed }, warnings: [...r.warnings, ...(warn ? [OUT_NOT_TRACKED] : [])] };
+    },
+};
+export const extensions = { organizations, 'sales-calls': salesCalls, credentials };

package/dist/builtins/index.js

@@ -0,0 +1,8 @@
+// The nouns with code of their own. Each brings a schema document in the API's format, so help,
+// validation and confirmation are the engine's. report is a plain noun: the API's schema drives
+// it. skills (c11r skills sync) comes with deliverable 4.
+import { auth } from './auth.js';
+import { loops } from './loops.js';
+import { sandbox, status } from './sandbox.js';
+export const builtins = { sandbox, status, loops, auth };
+export { extensions } from './extensions.js';

package/dist/builtins/loops.js

@@ -0,0 +1,215 @@
+// c11r loops: a skill, a policy and a cadence (contract section 9). Definitions live in loops.yml
+// in the project folder, next to store.yml, so they travel with the configuration; the API keeps
+// each loop's cursor. The CLI is not a daemon: loops run <name> does one pass, and whatever
+// schedules the agent repeats it every `every`.
+//
+// A policy allows verbs: a bare verb is the skill's own noun (approve), <noun>.<verb> another
+// Manage noun's verb on the same item (payments.capture). Each must be in the noun's schema
+// loop.verbs; the API checks again on every pass.
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import { projectDir } from '../config.js';
+import { CliError, closest, fail, fixWith } from '../errors.js';
+import { envelope } from '../http.js';
+import { parseSchema } from '../schema.js';
+import { apiSchema } from '../schemas.js';
+const NAME = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const EVERY = /^[1-9]\d*(m|h|d)$/;
+const policyFlags = (required) => [
+    { name: 'skill', type: 'string', required, description: 'The Manage skill or playbook the loop runs, as in manage-orders.' },
+    { name: 'every', type: 'string', required, description: 'How often a pass should run, as in 15m, 2h or 1d. The scheduler reads it; the CLI does not wait.' },
+    { name: 'allow', type: 'array', required, description: 'A verb the policy allows, repeated: approve, payments.capture. Only verbs the noun\'s schema lists in loop.verbs.' },
+    { name: 'max_total', type: 'array', description: 'The largest order total acted on, in major units: 500 for every currency, or EUR=500, repeated per currency. Above it, the item waits for the human.' },
+    { name: 'market', type: 'array', description: 'A market code the loop acts in, repeated. Items in other markets wait. Without it, every market.' },
+];
+export const loops = {
+    schema: parseSchema({
+        noun: 'loops',
+        group: 'manage',
+        skill: 'manage-loops',
+        kind: 'task',
+        description: 'Loops: a skill on a schedule, under a policy written in advance. Definitions are in loops.yml in the project folder; each pass is one c11r loops run.',
+        id: { accepts: ['name'], example: 'orders-15m' },
+        verbs: [
+            { verb: 'list', method: 'GET', state: 'none', effect: 'Lists the loops of loops.yml.' },
+            { verb: 'get', method: 'GET', path: '/v1/loops/{id}', state: 'none', effect: 'Returns a loop from loops.yml, with its last pass when the organization has run it.' },
+            { verb: 'create', method: 'POST', path: '/v1/loops/{id}', state: 'none', body: policyFlags(true), effect: 'Adds a loop to loops.yml, after checking its policy against the skill noun\'s schema. Nothing runs until a pass.' },
+            { verb: 'update', method: 'PATCH', path: '/v1/loops/{id}', state: 'none', body: policyFlags(false), effect: 'Changes a loop in loops.yml. A flag given replaces what is there: --allow replaces the whole list.' },
+            { verb: 'delete', method: 'DELETE', path: '/v1/loops/{id}', state: 'none', destructive: true, deletes: true, effect: 'Removes a loop from loops.yml, and its cursor from the organization.' },
+            { verb: 'run', method: 'POST', path: '/v1/loops/{id}/run', effect: 'One pass: what is waiting since the last pass, and the actions the policy allows. Answers done, waiting (new: true for what appeared since the last pass) and failed. With --dry-run nothing changes and the last pass time stays.' },
+        ],
+    }),
+    async run(run) {
+        const name = run.parsed.id;
+        if (name !== undefined && !NAME.test(name))
+            fail('invalid_value', `${name} is not a loop name: lowercase letters, digits and dashes, as in orders-15m.`, { path: 'id' });
+        const file = loopsFile();
+        switch (run.verb.name) {
+            case 'list': {
+                const all = readLoops(file);
+                return envelope({ items: Object.entries(all).map(([n, d]) => ({ name: n, ...d })), total: Object.keys(all).length, file });
+            }
+            case 'get':
+                return get(run, name, file);
+            case 'create':
+            case 'update':
+                return write(run, name, file);
+            case 'delete':
+                return remove(run, name, file);
+            case 'run':
+                return pass(run, name, file);
+        }
+        return undefined;
+    },
+};
+export const loopsFile = () => path.join(projectDir(), 'loops.yml');
+function readDoc(file) {
+    if (!fs.existsSync(file))
+        return new YAML.Document({ loops: {} });
+    const doc = YAML.parseDocument(fs.readFileSync(file, 'utf8'));
+    if (doc.errors.length)
+        fail('invalid_config', `${file} is not valid YAML: ${doc.errors[0].message}`, { path: 'loops.yml' });
+    return doc;
+}
+export function readLoops(file) {
+    const raw = (readDoc(file).toJS() ?? {});
+    const out = {};
+    for (const [name, d] of Object.entries(raw.loops ?? {})) {
+        const def = d;
+        if (!def || typeof def.skill !== 'string' || !Array.isArray(def.policy?.allow))
+            fail('invalid_config', `${file}: loop ${name} needs a skill and a policy with allow.`, { path: `loops.${name}` });
+        out[name] = def;
+    }
+    return out;
+}
+function one(file, name) {
+    const def = readLoops(file)[name];
+    if (!def)
+        fail('not_found', `${file} has no loop ${name}.`, { path: 'id', did_you_mean: closest(name, Object.keys(readLoops(file))), next_step: fixWith('c11r loops list') });
+    return def;
+}
+async function get(run, name, file) {
+    const def = one(file, name);
+    const warnings = [];
+    let last = null;
+    let state = null;
+    if (run.org.token) {
+        try {
+            const r = await run.send({ method: 'GET', path: `/loops/${name}` });
+            last = r.data;
+            state = r.state;
+        }
+        catch (e) {
+            if (!(e instanceof CliError && e.kind === 'not_found'))
+                warnings.push({ code: 'last_pass_unknown', message: `The last pass could not be read: ${e.message}` });
+        }
+    }
+    return envelope({ name, ...def, last_pass: last, file }, { state, warnings });
+}
+async function write(run, name, file) {
+    const v = run.parsed.values;
+    const existing = readLoops(file)[name];
+    if (run.verb.name === 'create' && existing)
+        fail('conflict', `${file} already has a loop ${name}.`, { path: 'id', next_step: fixWith(`c11r loops update ${name}`) });
+    if (run.verb.name === 'update' && !existing)
+        one(file, name);
+    const def = {
+        skill: v.skill ?? existing.skill,
+        every: v.every ?? existing.every,
+        policy: {
+            allow: v.allow ?? existing.policy.allow,
+            ...(v.max_total !== undefined ? { max_total: maxTotal(v.max_total) } : existing?.policy.max_total !== undefined ? { max_total: existing.policy.max_total } : {}),
+            ...(v.market !== undefined ? { markets: v.market } : existing?.policy.markets ? { markets: existing.policy.markets } : {}),
+        },
+    };
+    if (!EVERY.test(def.every))
+        fail('invalid_value', `--every ${def.every} is not a cadence: a number and m, h or d, as in 15m.`, { path: 'every' });
+    const warnings = await checkPolicy(def);
+    if (!run.globals.dryRun) {
+        const doc = readDoc(file);
+        if (!doc.has('loops'))
+            doc.set('loops', {});
+        doc.setIn(['loops', name], doc.createNode(def));
+        if (!fs.existsSync(file))
+            doc.commentBefore = ' Loops: a skill, a policy and a cadence. c11r loops run <name> does one pass;\n whatever schedules the agent repeats it every `every`.';
+        fs.writeFileSync(file, doc.toString({ lineWidth: 0 }));
+    }
+    return envelope({ name, ...def, file, ...(run.globals.dryRun ? { dry_run: true, would: [{ file, loop: name, verb: run.verb.name }] } : {}) }, {
+        warnings,
+        next: [
+            { command: `c11r loops run ${name} --dry-run`, why: 'what one pass would do now, with nothing changed' },
+            { command: `c11r loops run ${name}`, why: `one pass; a scheduler repeats it every ${def.every}` },
+        ],
+    });
+}
+/** 500, or EUR=500 per currency. */
+function maxTotal(items) {
+    const plain = items.filter((i) => !i.includes('='));
+    if (plain.length && plain.length !== items.length)
+        fail('invalid_value', '--max-total takes one amount, or one CURRENCY=amount per currency, not both.', { path: 'max_total' });
+    const amount = (s) => {
+        const n = Number(s);
+        if (s.trim() === '' || !Number.isFinite(n) || n < 0)
+            fail('invalid_value', `--max-total ${s} is not an amount in major units, as in 500.`, { path: 'max_total' });
+        return n;
+    };
+    if (plain.length) {
+        if (plain.length > 1)
+            fail('invalid_value', '--max-total takes one amount for every currency.', { path: 'max_total' });
+        return amount(plain[0]);
+    }
+    return Object.fromEntries(items.map((i) => {
+        const [ccy, n] = i.split('=');
+        if (!/^[A-Z]{3}$/.test(ccy))
+            fail('invalid_value', `--max-total ${i}: ${ccy} is not a currency code, as in EUR.`, { path: 'max_total' });
+        return [ccy, amount(n)];
+    }));
+}
+/** The policy's verbs against the skill noun's schema; a playbook is checked by the API at the first pass. */
+async function checkPolicy(def) {
+    if (!def.policy.allow.length)
+        fail('missing_argument', 'A loop needs at least one --allow.', { path: 'allow' });
+    if (!def.skill.startsWith('manage-'))
+        return [{ code: 'policy_unchecked', message: `${def.skill} is not a Manage skill: the API checks its policy at the first pass.` }];
+    const noun = def.skill.slice('manage-'.length);
+    const schema = await apiSchema(noun, []);
+    const allowed = schema.loop?.verbs ?? [];
+    if (!allowed.length)
+        fail('policy_forbidden', `No loop acts on ${noun}: its schema has no loop.`, { path: 'skill' });
+    for (const verb of def.policy.allow) {
+        if (!allowed.includes(verb)) {
+            fail('policy_forbidden', `A ${def.skill} loop may not allow ${verb}. It may allow ${allowed.join(', ')}.`, { path: 'allow', did_you_mean: closest(verb, allowed), details: { loopable: allowed }, next_step: fixWith(`c11r schema ${noun}`) });
+        }
+    }
+    return [];
+}
+async function remove(run, name, file) {
+    one(file, name);
+    if (run.globals.dryRun)
+        return envelope({ name, file, dry_run: true, would: [{ file, loop: name, verb: 'delete' }] });
+    const warnings = [];
+    let cursor = 'none';
+    if (run.org.token) {
+        try {
+            await run.send({ method: 'DELETE', path: `/loops/${name}` });
+            cursor = 'forgotten';
+        }
+        catch (e) {
+            if (!(e instanceof CliError && e.kind === 'not_found'))
+                throw e;
+        }
+    }
+    else {
+        warnings.push({ code: 'cursor_kept', message: 'No organization to forget the cursor in: only loops.yml changed.' });
+    }
+    const doc = readDoc(file);
+    doc.deleteIn(['loops', name]);
+    fs.writeFileSync(file, doc.toString({ lineWidth: 0 }));
+    return envelope({ name, file, deleted: true, cursor }, { warnings });
+}
+async function pass(run, name, file) {
+    const def = one(file, name);
+    // dry_run goes in the body, as the pass's own: the pass reports what it would do.
+    return run.send({ method: 'POST', path: `/loops/${name}/run`, body: { skill: def.skill, policy: def.policy, dry_run: run.globals.dryRun }, dryRun: false });
+}

package/dist/builtins/sandbox.js

@@ -0,0 +1,186 @@
+// c11r sandbox create [--name] [--seed], get, reset, claim, destroy (contract section 4), and
+// c11r status (section 5). They are built in for what happens on this machine: create stores the
+// sandbox token (mode 600, ~/.config/c11r/credentials.json) and links the folder (.c11r.json);
+// reset moves both to the new organization; destroy forgets them. The token is printed never,
+// not even by create: only its hint.
+import crypto from 'node:crypto';
+import { credentialsFile, defaultOrg, markOutWritten, outWritten, storedLogin, forgetOrg, LINK_FILE, readLink, removeLink, renameOrg, storedOrgs, storeOrg, writeLink, hintOf } from '../config.js';
+import { CliError, fail } from '../errors.js';
+import { apiUrl, envelope, request } from '../http.js';
+import { parseSchema } from '../schema.js';
+import { OUT_NOT_TRACKED, removeOrgSecrets } from '../secrets.js';
+import { VERSION } from '../version.js';
+/** The longest sandbox name the API takes (contract: 422 invalid_argument past it). */
+const NAME_MAX = 25;
+export const sandbox = {
+    schema: parseSchema({
+        noun: 'sandbox',
+        group: 'setup',
+        skill: 'setup-sandbox',
+        kind: 'task',
+        description: 'The anonymous sandbox: a Commerce Layer organization in test mode, claimed later by a human. create stores its token on this machine and links the folder to it.',
+        verbs: [
+            {
+                verb: 'create',
+                method: 'POST',
+                path: '/v1/sandboxes',
+                state: 'none',
+                live: false,
+                body: [
+                    { name: 'name', type: 'string', description: 'The organization name; without it, an invented one. A name starting zztest marks a test organization.' },
+                    { name: 'seed', type: 'boolean', description: 'Loads the demo dataset: two markets, six products, shipping and a test payment method, enough to place a test order at once.' },
+                ],
+                effect: 'Creates a sandbox, stores its token on this machine (never printed) and links this folder to it with .c11r.json. With --seed it answers once the seed is applied, in about 20 seconds.',
+            },
+            { verb: 'get', method: 'GET', path: '/v1/sandbox', live: false, effect: 'Returns the sandbox: organization, expiry, whether it is seeded, the token hint and the claim status.' },
+            {
+                verb: 'reset',
+                method: 'POST',
+                path: '/v1/sandbox/reset',
+                live: false,
+                destructive: true,
+                body: [{ name: 'seed', type: 'boolean', description: 'Seeds the fresh organization, or not; without it, as before.' }],
+                effect: 'Replaces the sandbox with a fresh organization behind the same token, seeded as before, and retires the old one. The slug changes; this machine and .c11r.json follow it.',
+            },
+            { verb: 'claim', method: 'POST', path: '/v1/sandbox/claim', live: false, effect: 'Returns a one-time claim URL, valid 30 minutes, for the human to open: they sign in with Commerce Layer and pick a plan. The agent never opens it for them.' },
+            {
+                verb: 'destroy',
+                method: 'POST',
+                path: '/v1/sandbox/destroy',
+                live: false,
+                destructive: true,
+                deletes: true,
+                effect: 'Revokes the token, deletes what Commerce Layer lets the API delete, and marks the organization for deletion by support. Answers what was wiped and what is kept. This machine forgets the token and the folder link.',
+            },
+        ],
+    }),
+    async run(run) {
+        const values = run.parsed.values;
+        switch (run.verb.name) {
+            case 'create':
+                return create(run, values);
+            case 'get':
+                return run.send({ method: 'GET', path: '/sandbox' });
+            case 'claim':
+                return run.send({ method: 'POST', path: '/sandbox/claim', body: {} });
+            case 'reset':
+                return reset(run, values);
+            case 'destroy':
+                return destroy(run);
+        }
+        return undefined;
+    },
+};
+async function create(run, values) {
+    const name = values.name;
+    if (name !== undefined && (name.trim() === '' || name.length > NAME_MAX)) {
+        fail('invalid_value', `--name ${JSON.stringify(name)} is ${name.trim() === '' ? 'empty' : `${name.length} characters`}: a sandbox name has 1 to ${NAME_MAX}.`, { path: 'name', next_step: { action: 'fix_request', command: null } });
+    }
+    const seed = Boolean(values.seed);
+    const test = process.env.C11R_TEST === '1' || Boolean(name?.startsWith('zztest'));
+    // The token goes only when this folder, --org or C11R_ORG names a sandbox: the API then
+    // finishes a failed seed there, or answers 409 conflict naming it, rather than make a second
+    // one for the same folder. A token picked only because it is the one stored stays home.
+    const named = run.org.source === 'link' || run.org.source === 'flag' || run.org.source === 'env' || run.org.source === 'token_env';
+    // A fresh key per create: after a 5xx or a lost connection the same create is repeated with it,
+    // and the API answers the sandbox (and token) it made, rather than leave one with a lost token.
+    const idempotencyKey = `c11r-${crypto.randomBytes(16).toString('base64url')}`;
+    const r = await request({ method: 'POST', path: '/sandboxes', body: { ...(name ? { name } : {}), seed, test }, dryRun: run.globals.dryRun, timeoutMs: seed ? 120_000 : 60_000, idempotencyKey }, { live: false, token: named ? run.org.token : null });
+    if (run.globals.dryRun)
+        return r;
+    const { token, ...data } = r.data ?? {};
+    if (typeof token !== 'string' || typeof data.org !== 'string')
+        fail('invalid_response', 'The API created a sandbox without returning its org and token.', { next_step: { action: 'none' } });
+    const hint = typeof data.token_hint === 'string' ? data.token_hint : hintOf(token);
+    storeOrg(data.org, { token, token_hint: hint, expires_at: data.expires_at ?? null, created_at: new Date().toISOString(), api_url: apiUrl() });
+    const link = writeLink(data.org);
+    // The API says to store the token: the CLI has, and printed none of it.
+    const warnings = r.warnings.filter((w) => w.code !== 'token_shown_once');
+    if (link.previous)
+        warnings.push({ code: 'relinked', message: `${link.file} named ${link.previous}; it now names ${data.org}. The token of ${link.previous} stays stored.` });
+    return { ...r, data: { ...data, token_hint: hint, credentials: credentialsFile(), linked: link.file }, warnings };
+}
+async function reset(run, values) {
+    const r = await run.send({ method: 'POST', path: '/sandbox/reset', body: values.seed === undefined ? {} : { seed: values.seed } });
+    if (run.globals.dryRun)
+        return r;
+    const { org, previous_org: previous } = r.data ?? {};
+    const before = previous ?? run.org.org;
+    if (typeof org === 'string' && before && org !== before) {
+        renameOrg(before, org, r.data.expires_at ? { expires_at: r.data.expires_at } : {});
+        const link = readLink();
+        if (link?.org === before)
+            writeLink(org);
+    }
+    return r;
+}
+async function destroy(run) {
+    let r;
+    try {
+        r = await run.send({ method: 'POST', path: '/sandbox/destroy', body: {} });
+    }
+    catch (e) {
+        // After a destroy the token answers 401: a destroy whose answer was lost, repeated, lands
+        // here. The sandbox is gone either way, so this machine forgets it too.
+        if (!(e instanceof CliError && e.code === 'unauthorized') || run.globals.dryRun || !run.org.org)
+            throw e;
+        const out = outWritten(run.org.org);
+        markOutWritten(run.org.org, false);
+        forgetOrg(run.org.org);
+        const link = removeLink(run.org.org);
+        const secrets = removeOrgSecrets(run.org.org);
+        return envelope({ org: run.org.org, already_destroyed: true, forgotten: { credentials: true, link, secrets } }, { state: e.state, warnings: [{ code: 'already_destroyed', message: `The API no longer accepts the token of ${run.org.org}: it was destroyed already. This machine forgot it too.` }, ...(out ? [OUT_NOT_TRACKED] : [])] });
+    }
+    if (run.globals.dryRun)
+        return r;
+    const org = r.data?.org ?? run.org.org;
+    if (!org)
+        return r;
+    const out = outWritten(org);
+    markOutWritten(org, false);
+    forgetOrg(org);
+    const link = removeLink(org);
+    const secrets = removeOrgSecrets(org);
+    return { ...r, data: { ...r.data, forgotten: { credentials: true, link, secrets } }, warnings: [...r.warnings, ...(out ? [OUT_NOT_TRACKED] : [])] };
+}
+export const status = {
+    schema: parseSchema({
+        noun: 'status',
+        kind: 'task',
+        description: 'c11r status: where this machine and folder stand. The organization picked and from where, its lifecycle state, plan, mode, limits, usage and what is waiting.',
+        verbs: [{ verb: 'get', method: 'GET', path: '/v1/status', state: 'none', effect: 'Returns the status. c11r status is the same as c11r status get.' }],
+    }),
+    defaultVerb: 'get',
+    async run(run) {
+        // Status works at every state: an unresolved organization is shown, not raised.
+        const r = await run.send({ method: 'GET', path: '/status' });
+        const link = (() => {
+            try {
+                return readLink();
+            }
+            catch {
+                return null;
+            }
+        })();
+        const stored = Object.entries(storedOrgs()).map(([org, o]) => ({ org, token_hint: o.token_hint, expires_at: o.expires_at }));
+        const cli = {
+            version: VERSION,
+            api_url: apiUrl(),
+            org: run.org.org ? { slug: run.org.org, from: run.org.source } : null,
+            ...(run.org.problem ? { org_problem: { code: run.org.problem.code, message: run.org.problem.message } } : {}),
+            link: link ? { file: link.file, org: link.org } : { file: null, name: LINK_FILE },
+            credentials: credentialsFile(),
+            stored,
+            login: (() => {
+                const l = storedLogin();
+                // Local only: what auth login stored, never the secret, no call to the API.
+                return l ? { client_id: l.client_id, email: l.user?.email ?? null, stored_at: l.created_at } : null;
+            })(),
+            default_org: defaultOrg(),
+        };
+        // The API's cli (package, latest) and this machine's, in one object.
+        const api = r.data && typeof r.data === 'object' && !Array.isArray(r.data) ? r.data : { status: r.data };
+        const data = { ...api, cli: { ...(api.cli && typeof api.cli === 'object' ? api.cli : {}), ...cli } };
+        return { ...r, data };
+    },
+};