@learncard/cli 3.6.8 → 4.0.0

package/src/promote.ts

@@ -1,202 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import type { Command } from 'commander';
-
-import {
-    loadProject,
-    saveProject,
-    resolveServices,
-    PRODUCTION_NETWORK,
-    STAGING_NETWORK,
-    type Project,
-    type ProjectOptions,
-} from './project';
-import { loadOrgSpec } from './org/load';
-import { runOrgApply } from './org';
-import { runDoctor, type RunCommand } from './doctor';
-import { out } from './out';
-
-/**
- * Per-network resources that must be recreated on the target network after a promotion.
- * See docs/how-to-guides/deploy-infrastructure/test-safely.md §"What carries over". The
- * one thing that IS portable — your seed, and therefore the resulting did:key — is
- * printed separately by `runPromote` rather than listed here.
- */
-export const PROMOTE_CHECKLIST: readonly string[] = [
-    'Profile & profile ID',
-    'API tokens',
-    'Signing authority registrations',
-    'Credential templates',
-    'ConsentFlow contracts',
-    'Issued & claimed credentials',
-    'did:web (host-bound)',
-];
-
-const NETWORK_ALIASES: Record<string, string> = {
-    staging: STAGING_NETWORK,
-    production: PRODUCTION_NETWORK,
-};
-
-/** `resolveServices` only special-cases the literal string "staging"; translate "production" too. */
-const resolveNetworkUrl = (network: string): string =>
-    resolveServices({}, NETWORK_ALIASES[network] ?? network, {}).network;
-
-const NETWORK_DIR_NAMES: Record<string, string> = {
-    [STAGING_NETWORK]: 'staging',
-    [PRODUCTION_NETWORK]: 'production',
-};
-
-/** One project folder per network (`assertProjectNetwork` enforces this); named after the alias when known. */
-const networkDirName = (network: string): string =>
-    NETWORK_DIR_NAMES[network] ?? new URL(network).hostname;
-
-/** Pure: resolves --from/--to to network URLs and picks the target project folder. */
-export const planPromotion = (
-    from: string,
-    to: string,
-    cwd: string = process.cwd()
-): { fromNetwork: string; toNetwork: string; targetDir: string } => {
-    const fromNetwork = resolveNetworkUrl(from);
-    const toNetwork = resolveNetworkUrl(to);
-    if (fromNetwork === toNetwork)
-        throw new Error(`--from and --to resolve to the same network (${toNetwork}).`);
-    const targetDir = path.join(cwd, '.learncard', networkDirName(toNetwork));
-    return { fromNetwork, toNetwork, targetDir };
-};
-
-/** Pure: the source folder's `.env` must actually be on `--from`, or the wrong seed's org gets promoted. */
-export const assertSourceNetwork = (
-    sourceEnv: Record<string, string>,
-    from: string,
-    fromNetwork: string
-): void => {
-    const actual = resolveServices(sourceEnv, undefined, {}).network;
-    if (actual !== fromNetwork)
-        throw new Error(
-            `--from ${from} does not match this folder's network (${actual}). Run promote from the folder that is on ${from}.`
-        );
-};
-
-/** Pure: a target folder already bound to another seed would be provisioned as a different identity than the preview shows. */
-export const assertTargetSeed = (
-    targetEnv: Record<string, string>,
-    seed: string,
-    targetDir: string
-): void => {
-    if (targetEnv.SECURE_SEED && targetEnv.SECURE_SEED !== seed)
-        throw new Error(
-            `${path.join(targetDir, '.env')} already holds a different SECURE_SEED. Promotion carries this folder's seed; move that .env aside or pick a different target before re-running.`
-        );
-};
-
-export type PromoteOptions = ProjectOptions & {
-    cwd?: string;
-    from: string;
-    to: string;
-    org: string;
-    secretsOut?: string;
-    dryRun?: boolean;
-    skipDoctor?: boolean;
-};
-
-export const runPromote = async (options: PromoteOptions): Promise<void> => {
-    const { from, to, org, dryRun, skipDoctor } = options;
-    const { fromNetwork, toNetwork, targetDir } = planPromotion(from, to, options.cwd);
-    const secretsOut = options.secretsOut ?? path.join(targetDir, 'secrets.env');
-    out.log(`Promoting ${org} from ${from} to ${to}`);
-    out.log(`Target: ${targetDir}`);
-
-    const sourceProject = await loadProject(options.cwd ?? process.cwd());
-    if (!sourceProject.env.SECURE_SEED)
-        throw new Error(
-            `No SECURE_SEED in .env here. Run \`org apply\` against ${from} in this folder first.`
-        );
-    assertSourceNetwork(sourceProject.env, from, fromNetwork);
-
-    // Only the seed (and, if present, the matching profile ID) carries over — every
-    // other resource (tokens, signing authority, templates, contracts) is per-network
-    // and must be recreated by `org apply` against the target network below.
-    const carried = {
-        SECURE_SEED: sourceProject.env.SECURE_SEED,
-        ...(sourceProject.env.PROFILE_ID ? { PROFILE_ID: sourceProject.env.PROFILE_ID } : {}),
-        NETWORK_URL: toNetwork,
-    };
-
-    const targetProject = await loadProject(targetDir);
-    assertTargetSeed(targetProject.env, carried.SECURE_SEED, targetDir);
-
-    const spec = await loadOrgSpec(org);
-    if (spec.serviceAccounts?.length && !dryRun)
-        out.log(`Any new service-account tokens for ${to} go to ${secretsOut}`);
-
-    if (dryRun) {
-        out.log(
-            `Dry run: ${targetDir} is not created; previewing against ${to} with the carried-over seed.`
-        );
-        const preview: Project = {
-            env: { ...targetProject.env, ...carried },
-            envPath: targetProject.envPath,
-            existing: '',
-        };
-        await runOrgApply(org, {
-            ...options,
-            project: preview,
-            network: toNetwork,
-            dryRun,
-            secretsOut,
-        });
-    } else {
-        await fs.mkdir(targetDir, { recursive: true });
-        await saveProject(targetProject, carried);
-        await runOrgApply(org, {
-            ...options,
-            cwd: targetDir,
-            network: toNetwork,
-            dryRun,
-            secretsOut,
-        });
-    }
-
-    if (!skipDoctor && !dryRun) {
-        await runDoctor({ ...options, cwd: targetDir, network: toNetwork });
-    }
-
-    out.log(`Does not carry over from ${from} — recreate on ${to}:`);
-    for (const item of PROMOTE_CHECKLIST) out.log(`  - ${item}`);
-    out.log('Carries over: your seed → the same did:key.');
-    out.log(`Next: cd ${targetDir} && npx @learncard/cli doctor --network ${to}`);
-
-    out.set({ from: fromNetwork, to: toNetwork, targetDir, checklist: PROMOTE_CHECKLIST });
-};
-
-export const registerPromoteCommand = (program: Command, run: RunCommand): void => {
-    program
-        .command('promote')
-        .description('Move an issuer org from one network to another (e.g. staging to production).')
-        .requiredOption('--from <network>', 'source network tRPC URL or staging|production')
-        .requiredOption('--to <network>', 'target network tRPC URL or staging|production')
-        .requiredOption('--org <file>', 'org spec to re-apply on the target network')
-        .option(
-            '--secrets-out <path>',
-            'where to write the new service-account tokens (default: <target>/secrets.env, mode 0600)'
-        )
-        .option('--dry-run', 'preview changes without applying them')
-        .option('--skip-doctor', 'skip running doctor against the target network afterward')
-        .option('-y, --yes', 'accept defaults without prompting')
-        .option('--json', 'print a single JSON result on stdout')
-        .action(
-            (options: {
-                from: string;
-                to: string;
-                org: string;
-                secretsOut?: string;
-                dryRun?: boolean;
-                skipDoctor?: boolean;
-                yes?: boolean;
-                json?: boolean;
-            }) =>
-                run('promote', options, async didkit => {
-                    await runPromote({ ...options, didkit });
-                })
-        );
-};

package/src/random.ts

@@ -1,3 +0,0 @@
-import crypto from 'crypto';
-
-export const generateRandomSeed = () => crypto.randomBytes(32).toString('hex');

package/src/refresh.test.ts

@@ -1,86 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { formatRefreshVersion, mapRefreshHistoryError, runRefreshHistory } from './refresh';
-import { connect, loadProject } from './project';
-
-const { getCredentialRefreshHistory } = vi.hoisted(() => ({
-    getCredentialRefreshHistory: vi.fn(),
-}));
-vi.mock('./project', () => ({
-    loadProject: vi.fn().mockResolvedValue({ env: {} }),
-    resolveServices: vi.fn().mockReturnValue({ network: 'https://network.learncard.com/trpc' }),
-    connect: vi.fn().mockResolvedValue({ invoke: { getCredentialRefreshHistory } }),
-}));
-vi.mock('./out', () => ({ out: { log: vi.fn(), set: vi.fn() } }));
-
-describe('refresh history limit', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        getCredentialRefreshHistory.mockResolvedValue({ records: [], hasMore: false });
-    });
-
-    it.each(['abc', '0', '-1', '1.5', '', 'NaN', 'Infinity'])(
-        'rejects %j before connecting',
-        async limit => {
-            await expect(runRefreshHistory('refresh-1', { limit })).rejects.toThrow(
-                'Invalid --limit'
-            );
-            expect(loadProject).not.toHaveBeenCalled();
-            expect(connect).not.toHaveBeenCalled();
-            expect(getCredentialRefreshHistory).not.toHaveBeenCalled();
-        }
-    );
-
-    it.each(['1', '10'])('passes a validated limit of %s', async limit => {
-        await runRefreshHistory('refresh-1', { limit });
-        expect(getCredentialRefreshHistory).toHaveBeenCalledWith({
-            refreshId: 'refresh-1',
-            limit: Number(limit),
-        });
-    });
-
-    it('leaves the server default unchanged when omitted', async () => {
-        await runRefreshHistory('refresh-1', {});
-        expect(getCredentialRefreshHistory).toHaveBeenCalledWith({ refreshId: 'refresh-1' });
-    });
-});
-
-describe('formatRefreshVersion', () => {
-    it('formats version, publishedAt, and summary', () => {
-        const line = formatRefreshVersion({
-            version: 2,
-            publishedAt: '2026-01-01T00:00:00Z',
-            updateSummary: 'Finalized grades',
-        });
-        expect(line).toContain('2');
-        expect(line).toContain('2026-01-01T00:00:00Z');
-        expect(line).toContain('Finalized grades');
-    });
-
-    it('omits the summary column when absent', () => {
-        const line = formatRefreshVersion({ version: 1, publishedAt: '2026-01-01T00:00:00Z' });
-        expect(line.trim().endsWith('2026-01-01T00:00:00Z')).toBe(true);
-    });
-});
-
-describe('mapRefreshHistoryError', () => {
-    it('rewrites the "not available" failure into an actionable message', () => {
-        const mapped = mapRefreshHistoryError(
-            new Error('Credential refresh is not available'),
-            'https://network.learncard.com/trpc'
-        );
-        expect(mapped.message).toContain("isn't enabled on this network");
-        expect(mapped.message).toContain('https://network.learncard.com/trpc');
-        expect(mapped.message).toContain('--network staging');
-    });
-
-    it('passes other errors through unchanged', () => {
-        const original = new Error('Refresh not found');
-        expect(mapRefreshHistoryError(original, 'x')).toBe(original);
-    });
-
-    it('wraps non-Error throwables', () => {
-        const mapped = mapRefreshHistoryError('boom', 'x');
-        expect(mapped).toBeInstanceOf(Error);
-        expect(mapped.message).toBe('boom');
-    });
-});

package/src/refresh.ts

@@ -1,93 +0,0 @@
-import type { Command } from 'commander';
-import type { CredentialRefreshVersionMetadata } from '@learncard/types';
-
-import { connect, loadProject, resolveServices, type ProjectOptions } from './project';
-import { out } from './out';
-import { parseLimit } from './inbox';
-
-export type RefreshHistoryOptions = ProjectOptions & { limit?: string };
-
-/** One human-readable line per published version: `version  publishedAt  summary`. */
-export const formatRefreshVersion = (record: CredentialRefreshVersionMetadata): string =>
-    `${String(record.version).padEnd(7)} ${record.publishedAt}  ${record.updateSummary ?? ''}`.trimEnd();
-
-const NOT_AVAILABLE_PATTERN = /credential refresh is not available/i;
-
-/** Rewrites the network's generic "not available" failure into an actionable message. */
-export const mapRefreshHistoryError = (error: unknown, network: string): Error => {
-    const message = error instanceof Error ? error.message : String(error);
-    if (NOT_AVAILABLE_PATTERN.test(message)) {
-        return new Error(
-            `Credential refresh isn't enabled on this network (${network}). Use --network staging or ask LearnCard to enable it.`
-        );
-    }
-    return error instanceof Error ? error : new Error(message);
-};
-
-export const runRefreshHistory = async (
-    refreshId: string,
-    options: RefreshHistoryOptions
-): Promise<void> => {
-    const limit = options.limit === undefined ? undefined : parseLimit(options.limit);
-    const project = await loadProject(process.cwd());
-    const services = resolveServices(project.env, options.network);
-    const learnCard = await connect(project, options);
-
-    let records: CredentialRefreshVersionMetadata[];
-    let hasMore: boolean;
-    try {
-        const result = await learnCard.invoke.getCredentialRefreshHistory({
-            refreshId,
-            ...(limit !== undefined ? { limit } : {}),
-        });
-        records = result.records;
-        hasMore = result.hasMore;
-    } catch (error) {
-        throw mapRefreshHistoryError(error, services.network);
-    }
-
-    if (!records.length) {
-        out.log(`No published versions found for ${refreshId}.`);
-        out.set({ refreshId, versions: [], hasMore });
-        return;
-    }
-
-    out.log('version  publishedAt  summary');
-    for (const record of records) out.log(formatRefreshVersion(record));
-    if (hasMore) out.log('…more. Raise --limit to see additional versions.');
-
-    out.set({
-        refreshId,
-        versions: records.map(record => ({
-            version: record.version,
-            publishedAt: record.publishedAt,
-            updateSummary: record.updateSummary,
-        })),
-        hasMore,
-    });
-};
-
-export const registerRefreshCommand = (
-    program: Command,
-    run: (
-        command: string,
-        options: { json?: boolean },
-        action: (didkit: Promise<Buffer>) => Promise<void>,
-        wrap?: boolean
-    ) => Promise<void>
-): void => {
-    const refresh = program
-        .command('refresh')
-        .description('Managed credential refresh: audit published versions of a transcript.');
-    refresh
-        .command('history <refreshId>')
-        .description('List the published version history for a managed refresh.')
-        .option('--limit <n>', 'how many versions to list')
-        .option('--network <url>', 'network tRPC URL or staging (default: production)')
-        .option('--json', 'print a single JSON result on stdout')
-        .action((refreshId, options) =>
-            run('refresh history', options, async didkit => {
-                await runRefreshHistory(refreshId, { ...options, didkit });
-            })
-        );
-};

package/src/replHelpers.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import type {
-    ExportLearnCardBundleOptions,
-    LearnCardBundleWallet,
-    RestoreLearnCardFromBundleOptions,
-} from '@learncard/holder-continuity';
-import {
-    createExportLearnCardBundleHelper,
-    createRestoreLearnCardFromBundleHelper,
-} from './replHelpers';
-
-const createWallet = (did: string): LearnCardBundleWallet => ({
-    id: { did: () => did },
-    invoke: {},
-    index: { LearnCloud: { get: async () => [], add: async () => true } },
-    read: { get: async () => undefined },
-    store: { LearnCloud: {} },
-});
-
-describe('createExportLearnCardBundleHelper', () => {
-    it('uses the default wallet when only options are provided', async () => {
-        const defaultWallet = createWallet('did:key:default');
-        const exportBundle = vi.fn(async () => ({
-            data: Buffer.from(''),
-            manifest: {} as never,
-            warnings: [],
-        }));
-        const helper = createExportLearnCardBundleHelper(exportBundle, defaultWallet);
-        const options: ExportLearnCardBundleOptions = { out: './bundle.zip', password: 'secret' };
-
-        await helper(options);
-
-        expect(exportBundle).toHaveBeenCalledWith(defaultWallet, options);
-    });
-
-    it('uses the provided wallet when wallet and options are both provided', async () => {
-        const defaultWallet = createWallet('did:key:default');
-        const otherWallet = createWallet('did:key:other');
-        const exportBundle = vi.fn(async () => ({
-            data: Buffer.from(''),
-            manifest: {} as never,
-            warnings: [],
-        }));
-        const helper = createExportLearnCardBundleHelper(exportBundle, defaultWallet);
-        const options: ExportLearnCardBundleOptions = { out: './bundle.zip', password: 'secret' };
-
-        await helper(otherWallet, options);
-
-        expect(exportBundle).toHaveBeenCalledWith(otherWallet, options);
-    });
-});
-
-describe('createRestoreLearnCardFromBundleHelper', () => {
-    it('merges default init config with per-call overrides', async () => {
-        const restoreBundle = vi.fn(async () => ({ restored: true }));
-        const helper = createRestoreLearnCardFromBundleHelper(restoreBundle, {
-            network: true,
-            allowRemoteContexts: true,
-            didkit: 'node',
-        });
-        const options: Omit<RestoreLearnCardFromBundleOptions, 'init'> & {
-            init?: Partial<RestoreLearnCardFromBundleOptions['init']>;
-        } = {
-            password: 'secret',
-            init: { network: 'http://localhost:4000/trpc' },
-        };
-
-        await helper('./bundle.zip', options);
-
-        expect(restoreBundle).toHaveBeenCalledWith('./bundle.zip', {
-            password: 'secret',
-            init: {
-                network: 'http://localhost:4000/trpc',
-                allowRemoteContexts: true,
-                didkit: 'node',
-            },
-        });
-    });
-});

package/src/replHelpers.ts

@@ -1,45 +0,0 @@
-import type {
-    ExportLearnCardBundleOptions,
-    LearnCardBundleWallet,
-    RestoreLearnCardFromBundleOptions,
-    RestoreLearnCardInit,
-} from '@learncard/holder-continuity';
-
-type ExportLearnCardBundleFn = typeof import('@learncard/holder-continuity').exportLearnCardBundle;
-type RestoreLearnCardFromBundleFn =
-    typeof import('@learncard/holder-continuity').restoreLearnCardFromBundle;
-
-export const createExportLearnCardBundleHelper = (
-    exportBundle: ExportLearnCardBundleFn,
-    defaultWallet: LearnCardBundleWallet
-) => {
-    return (
-        walletOrOptions: LearnCardBundleWallet | ExportLearnCardBundleOptions,
-        maybeOptions?: ExportLearnCardBundleOptions
-    ) => {
-        if (maybeOptions)
-            return exportBundle(walletOrOptions as LearnCardBundleWallet, maybeOptions);
-
-        return exportBundle(defaultWallet, walletOrOptions as ExportLearnCardBundleOptions);
-    };
-};
-
-export const createRestoreLearnCardFromBundleHelper = (
-    restoreBundle: RestoreLearnCardFromBundleFn,
-    defaultInit: RestoreLearnCardInit
-) => {
-    return (
-        path: string,
-        options: Omit<RestoreLearnCardFromBundleOptions, 'init'> & {
-            init?: Partial<RestoreLearnCardInit>;
-        } = {}
-    ) => {
-        return restoreBundle(path, {
-            ...options,
-            init: {
-                ...defaultInit,
-                ...(options.init ?? {}),
-            } as RestoreLearnCardInit,
-        });
-    };
-};

package/src/revoke.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { recipientOf, templateUriOf } from './revoke';
-
-describe('revoke targeting', () => {
-    it('reads the template URI from the credential boostId', () => {
-        expect(templateUriOf({ boostId: 'lc:network:x/trpc:boost:1' }, {})).toBe(
-            'lc:network:x/trpc:boost:1'
-        );
-    });
-
-    it('prefers an explicit --template-uri', () => {
-        expect(templateUriOf({ boostId: 'lc:boost:a' }, { templateUri: 'lc:boost:b' })).toBe(
-            'lc:boost:b'
-        );
-    });
-
-    it('explains when a credential did not come from a template', () => {
-        expect(() => templateUriOf({ id: 'urn:uuid:1' }, {})).toThrow(/not issued from a template/);
-    });
-
-    it('finds the recipient holding the exact credential URI', () => {
-        const records = [
-            { to: { profileId: 'alice' }, uri: 'lc:network:x/trpc:credential:1' },
-            { to: { profileId: 'bob' }, uri: 'lc:network:x/trpc:credential:2' },
-        ];
-        expect(recipientOf(records, 'lc:network:x/trpc:credential:2')).toBe('bob');
-        expect(recipientOf(records, 'lc:network:x/trpc:credential:9')).toBeUndefined();
-    });
-});

package/src/revoke.ts

@@ -1,65 +0,0 @@
-import { connect, ensureIdentity, loadProject, type ProjectOptions } from './project';
-import { out } from './out';
-
-export interface RevokeOptions extends ProjectOptions {
-    suspend?: boolean;
-    templateUri?: string;
-    recipient?: string;
-}
-
-/** Template URI comes from the credential's `boostId`; the recipient from the network's recipient list. */
-export const templateUriOf = (credential: unknown, options: RevokeOptions): string => {
-    const value =
-        credential && typeof credential === 'object' ? (credential as Record<string, unknown>) : {};
-    const templateUri =
-        options.templateUri || (typeof value.boostId === 'string' ? value.boostId : undefined);
-    if (!templateUri)
-        throw new Error(
-            'This credential was not issued from a template. Pass --template-uri <uri> and --recipient <profileId>.'
-        );
-    return templateUri;
-};
-
-type Recipient = { to: { profileId: string }; uri?: string };
-
-/** Find which recipient of a template holds this exact credential URI. */
-export const recipientOf = (records: Recipient[], credentialUri: string): string | undefined =>
-    records.find(record => record.uri === credentialUri)?.to.profileId;
-
-export const runRevoke = async (uri: string, options: RevokeOptions): Promise<void> => {
-    const project = await loadProject(process.cwd());
-    await ensureIdentity(project, options);
-    const learnCard = await connect(project, options);
-    const credential =
-        options.templateUri && options.recipient ? undefined : await learnCard.read.get(uri);
-    const templateUri = templateUriOf(credential, options);
-    let profileId = options.recipient;
-    let cursor: string | undefined;
-    while (!profileId) {
-        const page = await learnCard.invoke.getPaginatedBoostRecipients(
-            templateUri,
-            100,
-            cursor,
-            true
-        );
-        profileId = recipientOf(page.records, uri);
-        if (profileId || !page.hasMore) break;
-        cursor = page.cursor ?? undefined;
-    }
-    if (!profileId)
-        throw new Error(
-            `No recipient of ${templateUri} holds ${uri}. If it was sent to an email and not yet claimed, there is nothing to revoke; otherwise pass --recipient <profileId>.`
-        );
-    const target = { templateUri, profileId };
-    const result = options.suspend
-        ? await learnCard.invoke.suspendBoostRecipient(target.templateUri, target.profileId, uri)
-        : await learnCard.invoke.revokeBoostRecipient(target.templateUri, target.profileId, uri);
-    if (!result) throw new Error('The network did not update this credential.');
-    const status = options.suspend ? 'suspended' : 'revoked';
-    out.log(
-        `${options.suspend ? 'Suspended' : 'Revoked'} ${uri}. Verifiers will see status: ${status} when they next refresh its status list; no propagation interval is documented.`
-    );
-    out.log('Only credentials with a credentialStatus entry support status-list verification.');
-    out.log('Check the delivered JSON: npx @learncard/cli verify credential.json');
-    out.set({ credentialUri: uri, templateUri, recipient: profileId, action: status });
-};

package/src/send-template.test.ts

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { templateCredential, personalizeSendMjs } from './send';
-import { SEND_FROM_TEMPLATE_MJS } from './generated/snippets';
-
-describe('template sending', () => {
-    it('personalizes replacement metacharacters literally', () => {
-        const output = personalizeSendMjs('$&', { name: '$&', description: '$&' });
-        expect(output).toContain('displayName: "$&"');
-        expect(output).toContain('description: "$&"');
-    });
-    it('includes Boost terms needed when the network stamps boostId', () => {
-        const credential = templateCredential('did:key:issuer');
-        expect(credential['@context']).toContain('https://ctx.learncard.com/boosts/1.0.1.json');
-        expect(credential.type).toContain('BoostCredential');
-    });
-    it('reuses the persisted template rather than creating another one', () => {
-        expect(SEND_FROM_TEMPLATE_MJS).toContain('templateUri: process.env.TEMPLATE_URI');
-        expect(SEND_FROM_TEMPLATE_MJS).not.toContain('createBoost');
-    });
-});