firedrill-run 2.2.5 → 3.0.0

package/dist/cli/src/ci-setup-proposals.js

@@ -0,0 +1,52 @@
+import { api, openBrowser } from './auth.js';
+import { workspaceLink } from './browser-links.js';
+import { CliError } from './http.js';
+import { selectOne, terminalText } from './prompts.js';
+import { identifier } from './world-contracts.js';
+import { ciSetupProposalMatches, ciSetupRequestDigest } from '../../contracts/ci-setup-contracts.js';
+const requirement = (value) => ({
+    managed_plan_required: 'Save a managed simulation plan.',
+    github_source_required: 'Connect a GitHub source repository.',
+    github_connection_required: 'Review GitHub installation access.',
+    repository_directory_required: 'Refresh the available GitHub repositories.',
+    repository_access_required: 'Allow access to the selected repository.',
+    preparation_budget_review_required: 'Set the maximum preparation credits.',
+    simulation_budget_review_required: 'Review the simulation credit budget.',
+    input_access_review_required: 'Review runtime inputs and execution access.',
+    separate_activation_required: 'Enable automatic runs after review.',
+    pr_plan_too_long: 'Choose a shorter plan for pull requests.',
+}[value] ?? value.replaceAll('_', ' '));
+export async function ciSetupProposal(context, id, signal) {
+    const key = identifier(id);
+    const value = await api(`${context.prefix}/ci-setup-proposals/${key}`, { actor: context.owner, workspace: context.workspace, signal });
+    if (!ciSetupProposalMatches(value, context.world, key, context.owner)
+        || await ciSetupRequestDigest(value.request) !== value.request_sha256) {
+        throw new CliError('ci_setup_proposal_unconfirmed', 'This original CI setup draft could not be confirmed for the account and world. No configuration was saved or activated.');
+    }
+    return value;
+}
+export async function reviewCISetupProposal(context, id, options, output) {
+    const value = await ciSetupProposal(context, id, options.signal);
+    const url = workspaceLink(context.workspace, value.handoff_path);
+    const available = value.available && value.current && value.can_review;
+    const needsGitHub = value.missing_requirements.some(item => ['github_connection_required', 'repository_directory_required', 'repository_access_required'].includes(item));
+    const recovery = needsGitHub && value.available ? workspaceLink(context.workspace, '/ci/new', { world: context.world, return_ci_setup: value.id }) : null;
+    output('ci_setup_proposal', { ...value, url, recovery_url: recovery }, [value.request.title, value.request.repository,
+        `Baseline: ${value.request.scenario_count.toLocaleString()} scenarios, ${value.request.repetitions.toLocaleString()} repetitions, ${value.request.planned_trials.toLocaleString()} drills.`,
+        value.request.scenario_policy.mode === 'change_relevant' ? `Change-relevant PR selection, with ${value.request.scenario_policy.mandatory_scenario_ids.length.toLocaleString()} additional mandatory cases.` : 'All planned scenarios selected.',
+        `Triggers: ${value.request.triggers.map(item => item === 'pull_request' ? 'Pull requests' : item === 'default_branch' ? 'Default branch updates' : 'Nightly').join(', ')}.`,
+        value.request.mode === 'hard_constraints' ? 'Required exact checks. Quality scores stay separate.' : 'Report only. No quality threshold.',
+        ...value.missing_requirements.map(requirement),
+        !value.available ? 'This draft is no longer available.' : !value.current ? 'The source, world or repository access changed. This draft is out of date.'
+            : !value.can_review ? needsGitHub ? 'Review GitHub access before using this draft.' : 'CI setup review is not available to this account.' : 'Review GitHub, budgets and execution access before enabling automatic runs.',
+        'No configuration, credentials, charge or automatic-run consent was created by this draft.',
+        available ? url : workspaceLink(context.workspace, `/worlds/${context.world}`),
+        ...(recovery ? [`Review GitHub access: ${recovery}`] : []),
+    ].map(terminalText).join('\n'));
+    if (!available || options.json || !process.stdin.isTTY || !process.stderr.isTTY)
+        return;
+    const open = await selectOne('Review CI setup?', [{ value: false, label: 'Not now', detail: `Keep the saved draft. Use /ci ${value.id} in this world's conversation.` },
+        { value: true, label: 'Review in the browser', detail: 'Normal Save, runtime input approval and automatic-run activation remain separate.' }], options.signal);
+    if (open && (!options.openBrowser || !await openBrowser(url)))
+        output('ci_setup_review', { url, opened: false }, url);
+}

package/dist/cli/src/company-policies.js

@@ -0,0 +1,229 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, open } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { api } from './auth.js';
+import { CliError } from './http.js';
+import { selectMany, selectOne } from './prompts.js';
+import { identifier } from './world-contracts.js';
+import { selectedWorkspace } from './world-access.js';
+import { samePolicyVersion, policyActionConfirmed, policyUploadDestination } from '../../contracts/context-contracts.js';
+export async function selectPolicies(scope, agent, signal) {
+    if (!await selectOne('Include company policies in this criterion?', [{ value: false, label: 'No policies' },
+        { value: true, label: 'Choose policy versions and passages' }], signal))
+        return [];
+    const prefix = `/api/workspaces/${identifier(scope.workspace)}/agents/${identifier(agent)}/policies`;
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal };
+    const selected = new Map();
+    let number = 1;
+    while (true) {
+        const page = await api(`${prefix}?status=available&page=${number}`, auth);
+        if (!page.count)
+            throw new CliError('policy_selection_empty', 'No extracted policies are available. Upload one with firedrill policies, or continue without policy context.', 2);
+        const ids = await selectMany('Company policies', page.results.map(row => ({ value: row.id, label: `${row.name} · Version ${row.version}` })), signal, [...selected.keys()]);
+        for (const row of page.results) {
+            if (ids.includes(row.id))
+                selected.set(row.id, row);
+            else
+                selected.delete(row.id);
+        }
+        const action = await selectOne('Policy selection', [{ value: 'done', label: `Continue with ${selected.size} selected versions` },
+            ...(page.next ? [{ value: 'next', label: 'Next page' }] : []), ...(number > 1 ? [{ value: 'previous', label: 'Previous page' }] : [])], signal);
+        if (action === 'done')
+            break;
+        number += action === 'next' ? 1 : -1;
+    }
+    const refs = [];
+    for (const row of selected.values()) {
+        const paragraphs = new Set();
+        number = 1;
+        while (true) {
+            const page = await api(`${prefix}/${identifier(row.id)}/paragraphs?page=${number}`, auth);
+            if (!samePolicyVersion(page.policy, row) || !page.policy.available || page.policy.sha256 !== row.sha256
+                || page.policy.text_sha256 !== row.text_sha256)
+                throw new CliError('policy_selection_changed', 'This policy version is no longer available. Reopen policy selection.', 2);
+            const ids = await selectMany(`${row.name}: select applicable passages`, page.results.map(one => ({ value: one.id,
+                label: `${one.id}${one.page ? ` · Page ${one.page}` : ''}`, detail: one.text })), signal, [...paragraphs]);
+            for (const one of page.results) {
+                if (ids.includes(one.id))
+                    paragraphs.add(one.id);
+                else
+                    paragraphs.delete(one.id);
+            }
+            const action = await selectOne('Passages', [{ value: 'done', label: `Continue with ${paragraphs.size} selected passages` },
+                ...(page.next ? [{ value: 'next', label: 'Next page' }] : []), ...(number > 1 ? [{ value: 'previous', label: 'Previous page' }] : [])], signal);
+            if (action === 'done')
+                break;
+            number += action === 'next' ? 1 : -1;
+        }
+        if (!paragraphs.size || !row.available || !row.text_sha256)
+            throw new CliError('policy_passages_required', 'Choose at least one applicable passage for each policy version. No criterion was saved.', 2);
+        refs.push({ revision_id: identifier(row.id), sha256: row.sha256, text_sha256: row.text_sha256,
+            paragraphs: [...paragraphs].sort((a, b) => Number(a.slice(1)) - Number(b.slice(1))) });
+    }
+    return refs;
+}
+async function fileBytes(path, maximum) {
+    const absolute = resolve(path);
+    const previous = await lstat(absolute);
+    if (!previous.isFile() || previous.isSymbolicLink() || previous.size < 1 || previous.size > maximum) {
+        throw new CliError('policy_file_invalid', 'Choose a regular policy document within the configured upload capacity.');
+    }
+    const handle = await open(absolute, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const before = await handle.stat();
+        if (before.dev !== previous.dev || before.ino !== previous.ino || before.size !== previous.size || before.mtimeMs !== previous.mtimeMs)
+            throw new Error();
+        const data = Buffer.alloc(before.size);
+        let used = 0;
+        while (used < data.length) {
+            const read = await handle.read(data, used, data.length - used, used);
+            if (!read.bytesRead)
+                throw new Error();
+            used += read.bytesRead;
+        }
+        const after = await handle.stat();
+        if (after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
+            throw new Error();
+        return data;
+    }
+    catch {
+        throw new CliError('policy_file_changed', 'The selected policy file changed while reading it. No document was uploaded.');
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function policyCommand(args, options, output) {
+    const interactive = !options.json && Boolean(process.stdin.isTTY && process.stderr.isTTY);
+    const scope = await selectedWorkspace({ ...options, interactive });
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    let agent = options.agent ? identifier(options.agent) : undefined;
+    if (!agent && interactive) {
+        let page = 1;
+        while (!agent) {
+            const data = await api(`/api/workspaces/${scope.workspace}/agents?page=${page}`, auth);
+            const choices = data.results.map(row => ({ value: row.id, label: row.name }));
+            if (page > 1)
+                choices.push({ value: 'previous', label: 'Previous page' });
+            if (data.next)
+                choices.push({ value: 'next', label: 'Next page' });
+            if (!choices.length)
+                throw new CliError('agent_required', 'Connect an agent before adding company policies.');
+            const selected = await selectOne('Agent', choices, options.signal);
+            if (selected === 'next')
+                page += 1;
+            else if (selected === 'previous')
+                page -= 1;
+            else
+                agent = identifier(selected);
+        }
+    }
+    if (!agent)
+        throw new CliError('agent_required', 'Use --agent <id> or run firedrill policies interactively.', 2);
+    const prefix = `/api/workspaces/${scope.workspace}/agents/${agent}/policies`;
+    let action = args[0];
+    if (!action && interactive)
+        action = await selectOne('Company policies', [{ value: 'list', label: 'View policies' },
+            { value: 'upload', label: 'Upload a policy', detail: 'Use --file <path> and --name <name>. Text, Markdown, PDF and DOCX are supported.' }], options.signal);
+    action ??= 'list';
+    if (!['list', 'show', 'paragraphs', 'upload', 'archive', 'restore', 'revoke', 'remove'].includes(action) || args.length > 2) {
+        throw new CliError('arguments_invalid', 'Use policies list, show|paragraphs <revision>, upload, or archive|restore|revoke|remove <revision>.', 2);
+    }
+    if (['list', 'upload'].includes(action) && args.length > 1 || !['list', 'paragraphs'].includes(action) && (options.page !== undefined || options.search !== undefined)
+        || action !== 'upload' && (options.file !== undefined || options.name !== undefined || options.request !== undefined)
+        || !['list', 'upload'].includes(action) && options.policy !== undefined
+        || action !== 'upload' && options.basis !== undefined
+        || ['list', 'show', 'paragraphs'].includes(action) && options.consent !== undefined) {
+        throw new CliError('arguments_invalid', 'Choose only the arguments for this policy action. Upload options do not apply to inspection commands.', 2);
+    }
+    const page = options.page ?? '1';
+    if (!/^[1-9][0-9]{0,8}$/.test(page) || (options.search?.length ?? 0) > 200)
+        throw new CliError('arguments_invalid', 'Use valid policy paging and search.', 2);
+    if (action === 'list' || action === 'paragraphs') {
+        const revision = action === 'paragraphs' ? identifier(args[1] ?? '') : null;
+        const suffix = revision ? `/${revision}/paragraphs` : '';
+        const data = await api(`${prefix}${suffix}?page=${page}&q=${encodeURIComponent(options.search ?? '')}${options.policy && !revision ? `&policy_id=${identifier(options.policy)}` : ''}`, auth);
+        output('result', data, [data.results.map(row => 'text' in row ? `${row.id}${row.page ? ` · Page ${row.page}` : ''}\n${row.text}`
+                : `${row.name} · Version ${row.version} · ${row.state}\n${row.id}`).join('\n\n') || 'No matching policy records.',
+            ...(data.next ? [`Next page: --page ${Number(page) + 1}`] : [])].join('\n'));
+        return;
+    }
+    if (action === 'show') {
+        const data = await api(`${prefix}/${identifier(args[1] ?? '')}`, auth);
+        output('result', data, `${data.name} · Version ${data.version}\n${data.filename}\n${data.state}${data.archived ? ' · Archived' : ''}\n${data.id}${data.failure ? `\n${data.failure}` : ''}`);
+        return;
+    }
+    if (action !== 'upload') {
+        const revision = identifier(args[1] ?? '');
+        const row = await api(`${prefix}/${revision}`, auth);
+        const accepted = options.consent || interactive && await selectOne(action === 'remove' || action === 'revoke'
+            ? 'Revoke policy access and remove affected saved grading copies?' : `${action === 'archive' ? 'Archive' : 'Restore'} this policy?`, [{ value: false, label: 'Cancel' }, { value: true, label: 'Continue' }], options.signal);
+        if (!accepted)
+            throw new CliError('policy_consent_required', 'No policy was changed. Use --approve-policy for an explicit automated action.', 2);
+        const operation = action === 'archive' ? 'archive' : action === 'restore' ? 'restore' : action === 'revoke' ? 'revoke_version' : 'remove';
+        const body = { action: operation, basis_version: row.latest_version };
+        const result = await api(`${prefix}/${revision}`, { ...auth, method: 'POST', body });
+        if (!policyActionConfirmed(result, row, operation))
+            throw new CliError('policy_change_unconfirmed', 'The policy change could not be confirmed. Inspect the saved version before continuing.', 2);
+        output('result', result, `Policy updated: ${result.name} · Version ${result.version} · ${result.state}`);
+        return;
+    }
+    if (!options.file || !options.name?.trim())
+        throw new CliError('policy_file_required', 'Use policies upload --file <path> --name <name>. No file has been read or uploaded.', 2);
+    const filename = basename(options.file);
+    const formats = { txt: 'text', md: 'markdown', pdf: 'pdf', docx: 'docx' };
+    const format = formats[filename.split('.').at(-1).toLowerCase()];
+    if (!format)
+        throw new CliError('policy_file_invalid', 'Choose a text, Markdown, PDF or DOCX file.', 2);
+    const accepted = options.consent || interactive && await selectOne('Upload this private policy document? Do not include credentials.', [{ value: false, label: 'Keep it local' }, { value: true, label: 'Upload policy', detail: `${filename}. Policy text is evaluator-only unless separately selected as agent context.` }], options.signal);
+    if (!accepted)
+        throw new CliError('policy_consent_required', 'No document was uploaded. Use --approve-policy for explicit automated transfer consent.', 2);
+    const policy = options.policy ? identifier(options.policy) : null;
+    if (policy && !options.basis || options.basis && !/^(?:0|[1-9][0-9]{0,8})$/.test(options.basis)) {
+        throw new CliError('policy_basis_required', 'For a new version, use --policy-id and its exact --basis-version from policies show.', 2);
+    }
+    const capacity = await api(prefix, auth);
+    if (!capacity.limits?.upload_bytes || !Number.isSafeInteger(capacity.limits.upload_bytes))
+        throw new CliError('policy_capacity_unavailable', 'Policy upload capacity is unavailable. No file was uploaded.');
+    const data = await fileBytes(options.file, capacity.limits.upload_bytes);
+    const key = options.request ? identifier(options.request) : randomUUID();
+    output('policy_upload_intent', { request_key: key, agent_id: agent, sha256: createHash('sha256').update(data).digest('hex') }, `Policy upload request: ${key}\nKeep this request key. If interrupted, repeat the same command and file with --request-key ${key}.`);
+    const body = { policy_id: policy, basis_version: Number(options.basis ?? '0'),
+        name: options.name.trim(), filename, format, input_kind: 'upload', size: data.length,
+        sha256: createHash('sha256').update(data).digest('hex'), content_upload_consent: true };
+    const row = await api(prefix, { ...auth, method: 'POST', idempotencyKey: key, body });
+    if (row.agent_id !== agent || policy && row.policy_id !== policy || row.sha256 !== body.sha256
+        || row.filename !== body.filename || row.format !== body.format || row.name !== body.name
+        || row.version !== body.basis_version + 1)
+        throw new CliError('policy_upload_unconfirmed', 'The original policy upload could not be confirmed. Recover the same request before continuing.', 2);
+    if (row.state === 'uploading') {
+        let target;
+        try {
+            target = policyUploadDestination(row, scope.workspace, format);
+        }
+        catch {
+            throw new CliError('policy_upload_refused', 'The upload destination could not be confirmed. No document was sent.');
+        }
+        let uploaded;
+        try {
+            uploaded = await fetch(target, { method: 'PUT', headers: row.headers, body: data, credentials: 'omit', redirect: 'error',
+                signal: AbortSignal.any([options.signal, AbortSignal.timeout(120000)]) });
+        }
+        catch {
+            throw new CliError('policy_upload_uncertain', `Upload response unconfirmed. Repeat only the original command with --request-key ${key}; keep the same file and fields.`);
+        }
+        await uploaded.body?.cancel();
+        if (!uploaded.ok && uploaded.status !== 412)
+            throw new CliError('policy_upload_uncertain', `Upload not confirmed. Inspect the same request ${key} before retrying.`);
+        const complete = await api(`${prefix}/${row.id}/complete`, { ...auth, method: 'POST', body: {} });
+        if (!samePolicyVersion(complete, row) || !['queued', 'ready'].includes(complete.state))
+            throw new CliError('policy_processing_unconfirmed', 'Check the original policy version before continuing. Processing is not confirmed.', 2);
+        output('result', complete, `${complete.name} · Version ${complete.version} · ${complete.state}\nText extraction happens in the background. This did not run or evaluate the agent.`);
+    }
+    else {
+        if (!['queued', 'ready'].includes(row.state))
+            throw new CliError('policy_upload_closed', row.failure ?? 'This upload is closed. Inspect the retained version before starting another.', 2);
+        output('result', row, `${row.name} · Version ${row.version} · ${row.state}`);
+    }
+}

package/dist/cli/src/completion.js

@@ -0,0 +1,79 @@
+import { CliError } from './http.js';
+export const commandNames = ['init', 'status', 'register', 'descriptors', 'library', 'world', 'plan', 'apply', 'run', 'watch', 'report', 'tools', 'mcp', 'help',
+    'login', 'signup', 'logout', 'docs', 'support', 'onboarding', 'workspace', 'settings', 'team', 'vault', 'values', 'billing', 'ci', 'source', 'connect',
+    'runner', 'simulation', 'driver', 'criteria', 'assess', 'priority', 'changes', 'policies', 'context', 'recipes', 'sources',
+    'datasets', 'sessions', 'configuration', 'connections', 'models', 'real-operations', 'recordings', 'inspect', 'completion',
+    'agents', 'worlds', 'scenarios', 'personas', 'evaluations', 'simulations'];
+const subcommands = {
+    help: 'advanced',
+    library: 'list show history save archive restore fork request withdraw-request',
+    world: 'save history show request withdraw-request', register: 'request withdraw-request', descriptors: 'request withdraw-request',
+    plan: 'show',
+    driver: 'review',
+    context: 'list import show records request resume complete accept discover remove withdraw',
+    recipes: 'list save request show use archive',
+    report: 'drill assignments findings scores diagnoses assessments assessment-status checks performance model-usage composite compare export',
+    sources: 'list options use status withdraw',
+    connections: 'prepare preparations preparation preparation-decision choose-preparation continue-preparation cancel-preparation compatibility',
+    onboarding: 'show open',
+    source: 'inspect snapshot runtime',
+    runner: 'enroll list status connect revoke authorize grants grant jobs claim runtime abandon cleanup run-cleanup evidence completion',
+    vault: 'list show save rotate expiry remove request resume open',
+    values: 'list show save recover remove forget',
+    recordings: 'list show records request open upload',
+    billing: 'summary options credits credit-help usage credit-ledger credit-allocations credit-work credit-purchases credit-purchase recharge credit-settings purchases purchase open refresh-purchase invoices invoice lines refresh-invoice subscribe change topup portal redeem',
+    inspect: 'workflows rules events collections show entries schema',
+    settings: 'show update open', team: 'list show invite invitations request resume withdraw revoke role remove open',
+    agents: 'new archive restore remove requests request resume withdraw', worlds: 'new creation continue-creation withdraw-creation archive restore remove requests request resume withdraw',
+    scenarios: 'create edit duplicate archive restore definition history paths requests request withdraw-request discover discoveries discovery cancel-discovery drafts draft edit-draft accept-draft coverage world-events revise-execution',
+    datasets: 'list show document export request save withdraw start-status',
+    sessions: 'list show close request withdraw timelines timeline-events schedule timeline-control timeline-request timeline-apply timeline-withdraw extension-quote extend extensions extension-status application-checkpoints application-checkpoint save-application-state coordinated-checkpoints coordinated-checkpoint save-world-and-agent',
+    simulation: 'resume pause resume-scheduling cancel control-request continue-control withdraw-control requests request',
+    tools: 'runnable sessions session access state init validate push catalog catalog-categories catalog-show catalog-operations catalog-operation add save catalog-setups catalog-status catalog-withdraw contribute contributions contribution contribution-withdraw setups setup setup-members setup-status start-many stop-setup quote extension-quote extend extensions extension-status group-state group-state-members group-state-status group-state-quote capture-group reset-group fork-group start start-status stop remove removal remove-status connect connections connection-request disconnect open checkpoint reset restore fork resume transitions transition checkpoint-status instances removed instance call activity result download checkpoints data datasets dataset dataset-document dataset-export dataset-request dataset-save dataset-withdraw versions list requests show services operations operation import upload status complete withdraw revoke',
+    workspace: 'list use refresh organizations create requests request withdraw', ci: 'list show scenarios access approvals revisions automatic-history runs run result criteria scores delivery delivery-history inputs open',
+};
+/** Prints installation input only. Never edits or sources a shell profile. */
+export function completionScript(shell) {
+    if (shell === 'bash')
+        return `_firedrill_complete() {
+  COMPREPLY=()
+  local current="\${COMP_WORDS[COMP_CWORD]}" choices='${commandNames.join(' ')}'
+  if [[ $COMP_CWORD -eq 2 ]]; then
+    case "\${COMP_WORDS[1]}" in
+${Object.entries(subcommands).map(([key, values]) => `      ${key}) choices='${values}' ;;`).join('\n')}
+      completion) choices='bash zsh fish' ;;
+      *) return ;;
+    esac
+  elif [[ $COMP_CWORD -ne 1 ]]; then
+    return
+  fi
+  COMPREPLY=( $(compgen -W "$choices" -- "$current") )
+}
+complete -o default -F _firedrill_complete firedrill
+`;
+    if (shell === 'zsh')
+        return `#compdef firedrill
+_firedrill_complete() {
+  local -a choices
+  if (( CURRENT == 2 )); then
+    choices=(${commandNames.join(' ')})
+  elif (( CURRENT == 3 )); then
+    case "$words[2]" in
+${Object.entries(subcommands).map(([key, values]) => `      ${key}) choices=(${values}) ;;`).join('\n')}
+      completion) choices=(bash zsh fish) ;;
+      *) _files; return ;;
+    esac
+  else
+    _files; return
+  fi
+  _describe 'Firedrill command' choices
+}
+compdef _firedrill_complete firedrill
+`;
+    if (shell === 'fish')
+        return `complete -c firedrill -f -n '__fish_use_subcommand' -a '${commandNames.join(' ')}'
+${Object.entries(subcommands).map(([key, values]) => `complete -c firedrill -f -n '__fish_seen_subcommand_from ${key}; and test (count (commandline -opc)) -eq 2' -a '${values}'`).join('\n')}
+complete -c firedrill -f -n '__fish_seen_subcommand_from completion; and test (count (commandline -opc)) -eq 2' -a 'bash zsh fish'
+`;
+    throw new CliError('shell_required', 'Use firedrill completion bash, zsh or fish. The script is printed only; install it in your own shell configuration.', 2);
+}