@wpmoo/toolkit 0.9.0

package/dist/module-actions.js

@@ -0,0 +1,114 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { addModuleToSourceRepoInAddonsYaml, removeModuleFromSourceRepoInAddonsYaml, } from './addons-yaml.js';
+import { readEnvironmentMetadata } from './environment.js';
+import { realGit, stageAll } from './git.js';
+import { pathUnderBase, validateModuleName, validateRepoPath } from './path-validation.js';
+import { readAddonsYaml, writeAddonsYaml } from './repo-actions.js';
+const validSourceTypes = ['private', 'oca', 'external'];
+function normalizeSourceType(value) {
+    return validSourceTypes.includes(value) ? value : 'private';
+}
+function sourceRepoPath(target, sourceType, repoPath) {
+    return pathUnderBase(join(target, `odoo/custom/src/${sourceType}`), repoPath, 'repo path');
+}
+function modulePath(target, sourceType, repoPath, moduleName) {
+    return pathUnderBase(sourceRepoPath(target, sourceType, repoPath), moduleName, 'module name');
+}
+function titleizeModule(moduleName) {
+    return moduleName
+        .split(/[_-]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function manifestContent(moduleName, odooVersion) {
+    return `{
+    "name": "${titleizeModule(moduleName)}",
+    "version": "${odooVersion}.1.0.0",
+    "category": "Productivity",
+    "summary": "TODO",
+    "depends": ["base"],
+    "data": [
+        "security/ir.model.access.csv",
+    ],
+    "installable": True,
+    "application": False,
+    "license": "LGPL-3",
+}
+`;
+}
+async function writeIfMissing(path, content) {
+    try {
+        await readFile(path, 'utf8');
+    }
+    catch {
+        await writeFile(path, content, 'utf8');
+    }
+}
+async function usesAddonsYaml(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return metadata?.engine !== 'compose';
+}
+export async function addModuleToSourceRepo(options, git = realGit) {
+    const repoPath = validateRepoPath(options.repoPath);
+    const moduleName = validateModuleName(options.moduleName);
+    const sourceType = normalizeSourceType(options.sourceType);
+    const destination = modulePath(options.target, sourceType, repoPath, moduleName);
+    await mkdir(join(destination, 'models'), { recursive: true });
+    await mkdir(join(destination, 'security'), { recursive: true });
+    await mkdir(join(destination, 'views'), { recursive: true });
+    await writeIfMissing(join(destination, '__init__.py'), 'from . import models\n');
+    await writeIfMissing(join(destination, '__manifest__.py'), manifestContent(moduleName, options.odooVersion));
+    await writeIfMissing(join(destination, 'models/__init__.py'), '');
+    await writeIfMissing(join(destination, 'security/ir.model.access.csv'), 'id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink\n');
+    await writeIfMissing(join(destination, 'views/.gitkeep'), '');
+    if (sourceType === 'private' && (await usesAddonsYaml(options.target))) {
+        const addonsYaml = await readAddonsYaml(options.target);
+        await writeAddonsYaml(options.target, addModuleToSourceRepoInAddonsYaml(addonsYaml, repoPath, moduleName));
+    }
+    if (options.stage) {
+        await stageAll(git, sourceRepoPath(options.target, sourceType, repoPath));
+        await stageAll(git, options.target);
+    }
+}
+export async function listModulesInSourceRepo(target, repoPath, sourceType) {
+    const safeRepoPath = validateRepoPath(repoPath);
+    const resolvedSourceType = normalizeSourceType(sourceType);
+    try {
+        const entries = await readdir(sourceRepoPath(target, resolvedSourceType, safeRepoPath), { withFileTypes: true });
+        const modules = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            try {
+                await readFile(join(sourceRepoPath(target, resolvedSourceType, safeRepoPath), entry.name, '__manifest__.py'), 'utf8');
+                return entry.name;
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        return modules.filter((moduleName) => Boolean(moduleName)).sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function removeModuleFromSourceRepo(options, git = realGit) {
+    const repoPath = validateRepoPath(options.repoPath);
+    const moduleName = validateModuleName(options.moduleName);
+    const sourceType = normalizeSourceType(options.sourceType);
+    if (sourceType === 'private' && (await usesAddonsYaml(options.target))) {
+        const addonsYaml = await readAddonsYaml(options.target);
+        await writeAddonsYaml(options.target, removeModuleFromSourceRepoInAddonsYaml(addonsYaml, repoPath, moduleName));
+    }
+    if (options.deleteFiles) {
+        await rm(modulePath(options.target, sourceType, repoPath, moduleName), { recursive: true, force: true });
+    }
+    if (options.stage) {
+        if (options.deleteFiles) {
+            await stageAll(git, sourceRepoPath(options.target, sourceType, repoPath));
+        }
+        await stageAll(git, options.target);
+    }
+}

package/dist/odoo-versions.js

@@ -0,0 +1 @@
+export const supportedOdooVersions = ['19.0', '18.0', '17.0', '16.0'];

package/dist/path-validation.js

@@ -0,0 +1,50 @@
+import { isAbsolute, relative, resolve } from 'node:path';
+const windowsDrivePattern = /^[a-zA-Z]:/;
+function invalidPathError(label) {
+    return new Error(`Invalid ${label}: use a single path segment without traversal.`);
+}
+export function validatePathSegment(value, label) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`Invalid ${label}: value is required.`);
+    }
+    if (normalized === '.' ||
+        normalized === '..' ||
+        normalized.includes('/') ||
+        normalized.includes('\\') ||
+        normalized.includes('\0') ||
+        normalized.includes(':') ||
+        isAbsolute(normalized) ||
+        windowsDrivePattern.test(normalized)) {
+        throw invalidPathError(label);
+    }
+    return normalized;
+}
+export function isValidPathSegment(value) {
+    try {
+        validatePathSegment(value, 'path');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function validateRepoPath(value) {
+    return validatePathSegment(value, 'repo path');
+}
+export function validateModuleName(value) {
+    return validatePathSegment(value, 'module name');
+}
+export function validateAddonName(value) {
+    return validatePathSegment(value, 'addon name');
+}
+export function pathUnderBase(base, segment, label) {
+    const safeSegment = validatePathSegment(segment, label);
+    const resolvedBase = resolve(base);
+    const destination = resolve(resolvedBase, safeSegment);
+    const relativePath = relative(resolvedBase, destination);
+    if (relativePath === '' || relativePath.startsWith('..') || isAbsolute(relativePath)) {
+        throw invalidPathError(label);
+    }
+    return destination;
+}

package/dist/prompt-copy.js

@@ -0,0 +1,8 @@
+export function renderRepositorySetupNote(product) {
+    return [
+        `Dev repo: ${product}_dev`,
+        `Source repo: ${product}`,
+        `Local folder: ./${product}_dev`,
+        `Submodule path: odoo/custom/src/private/${product}`,
+    ].join('\n');
+}

package/dist/prompt-repositories.js

@@ -0,0 +1,34 @@
+import { confirmPrompt, isPromptCancel, textPrompt, } from './prompts/index.js';
+import { handlePromptCancel, menuPromptMessage } from './menu-navigation.js';
+const defaultPrompt = {
+    confirm: confirmPrompt,
+    text: textPrompt,
+};
+export async function promptRepositoryUrl({ label, suggestedUrl, placeholder, prompt = defaultPrompt, cancelAction = 'exit', }) {
+    if (suggestedUrl) {
+        const useSuggested = await prompt.confirm({
+            message: `${menuPromptMessage(`Use ${label}? (Y/n)`, cancelAction)}\n${suggestedUrl}`,
+            active: 'Y',
+            inactive: 'n',
+            initialValue: true,
+        });
+        if (isPromptCancel(useSuggested)) {
+            handlePromptCancel(true, cancelAction);
+        }
+        if (useSuggested) {
+            return suggestedUrl;
+        }
+    }
+    const value = await prompt.text({
+        message: menuPromptMessage(label, cancelAction),
+        placeholder,
+        validate: (input) => (input.trim() ? undefined : `Enter the ${label.toLowerCase()}.`),
+    });
+    if (isPromptCancel(value)) {
+        handlePromptCancel(true, cancelAction);
+    }
+    if (typeof value === 'string' && value.trim()) {
+        return value.trim();
+    }
+    throw new Error(`${label} is required`);
+}

package/dist/prompts/index.js

@@ -0,0 +1,174 @@
+import { emitKeypressEvents } from 'node:readline';
+import inquirerSelect, { Separator as InquirerSeparator } from '@inquirer/select';
+import inquirerSearch from '@inquirer/search';
+import { confirm as inquirerConfirm, input as inquirerInput } from '@inquirer/prompts';
+import { recordPromptCancelKey } from '../menu-navigation.js';
+export const promptCancelled = Symbol.for('wpmoo.prompt.cancelled');
+export function promptSeparator(label) {
+    return new InquirerSeparator(label);
+}
+function isPromptCancelError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return ['AbortError', 'CancelPromptError', 'AbortPromptError', 'ExitPromptError'].includes(error.name);
+}
+function markPromptCancel(error) {
+    if (error instanceof Error && error.name === 'ExitPromptError' && /SIGINT/.test(error.message)) {
+        recordPromptCancelKey({ ctrl: true, name: 'c', sequence: '\u0003' });
+        return promptCancelled;
+    }
+    return promptCancelled;
+}
+function mapSearchChoice(choice) {
+    if (choice.name !== undefined || choice.description !== undefined || choice.short !== undefined) {
+        return {
+            value: choice.value,
+            name: choice.name,
+            description: choice.description,
+            short: choice.short,
+        };
+    }
+    return {
+        value: choice.value,
+        name: choice.label,
+        description: choice.hint,
+    };
+}
+function asInquirerSearchConfig(options) {
+    return {
+        message: options.message,
+        source: async (term, signal) => {
+            const choices = await options.source(term, signal);
+            return choices.map((choice) => mapSearchChoice(choice));
+        },
+        pageSize: options.pageSize,
+    };
+}
+function installEscapeAbortController(controller) {
+    emitKeypressEvents(process.stdin);
+    const listener = (_value, key) => {
+        if (key.name !== 'escape' && key.sequence !== '\u001B') {
+            return;
+        }
+        recordPromptCancelKey(key);
+        if (!controller.signal.aborted) {
+            controller.abort();
+        }
+    };
+    process.stdin.on('keypress', listener);
+    return () => process.stdin.off('keypress', listener);
+}
+async function withPromptCancelGuard(callback) {
+    const controller = new AbortController();
+    const removeEscapeListener = installEscapeAbortController(controller);
+    try {
+        return await callback({ signal: controller.signal });
+    }
+    catch (error) {
+        if (!isPromptCancelError(error)) {
+            throw error;
+        }
+        return markPromptCancel(error);
+    }
+    finally {
+        removeEscapeListener();
+    }
+}
+function isClackSelectOptions(options) {
+    return 'options' in options;
+}
+function asInquirerSelectConfig(options) {
+    return {
+        message: options.message,
+        choices: options.options.map((option) => ({
+            value: option.value,
+            name: option.label,
+            description: option.hint,
+        })),
+        default: options.initialValue,
+        pageSize: options.pageSize,
+        loop: options.loop,
+        hideMessage: options.hideMessage,
+    };
+}
+function hiddenSelectTheme() {
+    return {
+        prefix: '',
+        icon: {
+            cursor: '\u001B[38;2;226;184;96m❯\u001B[39m',
+        },
+        style: {
+            message: () => '',
+            highlight: (text) => text,
+            keysHelpTip: () => '↑↓ navigate • ⏎ select • Ctrl+C exit',
+        },
+    };
+}
+function withHiddenSelectMessage(config) {
+    if (!config.hideMessage) {
+        return config;
+    }
+    const { hideMessage: _hideMessage, ...inquirerConfig } = config;
+    return {
+        ...inquirerConfig,
+        message: '',
+        theme: hiddenSelectTheme(),
+    };
+}
+function asInquirerConfirmConfig(options) {
+    const hasChoiceLabels = Boolean(options.active && options.inactive);
+    return {
+        message: hasChoiceLabels ? `${options.message} (${options.active}/${options.inactive})` : options.message,
+        default: options.initialValue,
+    };
+}
+function asInquirerInputConfig(options) {
+    return {
+        message: options.message,
+        default: options.defaultValue ?? options.initialValue,
+        validate: options.validate
+            ? (value) => {
+                const result = options.validate?.(value);
+                return result === undefined ? true : result;
+            }
+            : undefined,
+    };
+}
+export function isPromptCancel(value) {
+    return value === promptCancelled;
+}
+export async function selectPrompt(options) {
+    if (isClackSelectOptions(options)) {
+        return withPromptCancelGuard((context) => inquirerSelect(withHiddenSelectMessage(asInquirerSelectConfig(options)), context));
+    }
+    return withPromptCancelGuard((context) => inquirerSelect(withHiddenSelectMessage(options), context));
+}
+export async function inputPrompt(options) {
+    return withPromptCancelGuard((context) => inquirerInput(asInquirerInputConfig(options), context));
+}
+export async function textPrompt(options) {
+    return inputPrompt(options);
+}
+export async function confirmPrompt(options) {
+    return withPromptCancelGuard((context) => inquirerConfirm(asInquirerConfirmConfig(options), context));
+}
+export async function searchPrompt(options) {
+    return withPromptCancelGuard((context) => inquirerSearch(asInquirerSearchConfig(options), context));
+}
+export function introPrompt(title) {
+    const rule = '-'.repeat(Math.min(80, Math.max(title.length, 3)));
+    console.log('');
+    console.log(title);
+    console.log(rule);
+}
+export function notePrompt(message, title = 'Note') {
+    const lines = message.split('\n');
+    console.log(`[${title}]`);
+    for (const line of lines) {
+        console.log(`  ${line}`);
+    }
+}
+export function outroPrompt(message) {
+    console.log(`Done: ${message}`);
+}

package/dist/repo-actions.js

@@ -0,0 +1,158 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { addSourceRepoToAddonsYaml, removeSourceRepoFromAddonsYaml } from './addons-yaml.js';
+import { readEnvironmentMetadata, removeSourceRepoMetadata, upsertSourceRepoMetadata } from './environment.js';
+import { ensureRemoteHasBranch, ensureSubmodule, hasUncommittedChanges, realGit, removeSubmodule, stageAll, } from './git.js';
+import { isValidPathSegment, validateRepoPath } from './path-validation.js';
+import { inferRepoPath } from './repo-url.js';
+import { removeSourceManifestEntry, upsertSourceManifestEntry } from './source-manifest.js';
+export const addonsYamlHeader = `# Addons activated from source submodules.
+#
+# Source repos are managed as Git submodules under odoo/custom/src/private (product code).
+# OCA/external source repos can be placed under odoo/custom/src/oca and odoo/custom/src/external.
+# Do not duplicate these same repos in repos.yaml.
+`;
+const validSourceTypes = ['private', 'oca', 'external'];
+function normalizeSourceType(value) {
+    return validSourceTypes.includes(value) ? value : 'private';
+}
+function sourceSubmodulePath(sourceType, repoPath) {
+    return `odoo/custom/src/${sourceType}/${validateRepoPath(repoPath)}`;
+}
+function resolveSourceTypeFromSubmodulePath(submodulePath) {
+    const match = /^odoo\/custom\/src\/(private|oca|external)\//.exec(submodulePath);
+    if (!match)
+        return undefined;
+    return match[1];
+}
+async function listGitmoduleRepos(target) {
+    try {
+        const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
+        return [...gitmodules.matchAll(/^\s*path\s*=\s*odoo\/custom\/src\/(private|oca|external)\/(.+)$/gm)]
+            .map((match) => ({ sourceType: match[1], path: match[2].trim() }))
+            .filter((entry) => isValidPathSegment(entry.path));
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveSubmodulePathFromConfig(target, repoPath, sourceType) {
+    if (sourceType) {
+        return sourceSubmodulePath(sourceType, validateRepoPath(repoPath));
+    }
+    const repoMatches = (await listGitmoduleRepos(target)).filter((repo) => repo.path === repoPath);
+    if (repoMatches.length === 1) {
+        return sourceSubmodulePath(repoMatches[0].sourceType, repoPath);
+    }
+    if (repoMatches.length > 1) {
+        const sorted = repoMatches.map((repo) => repo.sourceType).sort();
+        throw new Error(`Source repo ${repoPath} exists in multiple source directories: ${sorted.join(', ')}. Provide --source-type to disambiguate.`);
+    }
+    return sourceSubmodulePath('private', repoPath);
+}
+export async function readAddonsYaml(target) {
+    try {
+        return await readFile(join(target, 'odoo/custom/src/addons.yaml'), 'utf8');
+    }
+    catch {
+        return `${addonsYamlHeader}\n`;
+    }
+}
+export async function writeAddonsYaml(target, content) {
+    const path = join(target, 'odoo/custom/src/addons.yaml');
+    await mkdir(join(path, '..'), { recursive: true });
+    await writeFile(path, content, 'utf8');
+}
+function composeAddonsPath() {
+    return '/usr/lib/python3/dist-packages/odoo/addons,/mnt/extra-addons,/mnt/wpmoo-addons';
+}
+async function isComposeEnvironment(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return metadata?.engine === 'compose';
+}
+export async function syncComposeOdooConfAddonsPath(target) {
+    if (!(await isComposeEnvironment(target))) {
+        return;
+    }
+    const configPath = join(target, 'etc/odoo.conf');
+    let content;
+    try {
+        content = await readFile(configPath, 'utf8');
+    }
+    catch {
+        return;
+    }
+    const addonsPathLine = `addons_path = ${composeAddonsPath()}`;
+    const nextContent = /^addons_path\s*=.*$/m.test(content)
+        ? content.replace(/^addons_path\s*=.*$/m, addonsPathLine)
+        : `${content.trimEnd()}\n${addonsPathLine}\n`;
+    if (nextContent !== content) {
+        await writeFile(configPath, nextContent, 'utf8');
+    }
+}
+export async function addModuleRepo(options, git = realGit) {
+    const repoPath = validateRepoPath(options.repoPath?.trim() || inferRepoPath(options.repoUrl));
+    const sourceType = normalizeSourceType(options.sourceType);
+    const submodulePath = sourceSubmodulePath(sourceType, repoPath);
+    await ensureRemoteHasBranch(git, options.target, options.repoUrl, options.odooVersion, options.initEmptyRepos);
+    await mkdir(join(options.target, 'odoo/custom/src', sourceType), { recursive: true });
+    await ensureSubmodule(git, options.target, options.repoUrl, options.odooVersion, submodulePath);
+    const listedRepos = await listModuleRepos(options.target);
+    if (!listedRepos.includes(repoPath)) {
+        throw new Error(`Source repo was added but is not registered in .gitmodules: ${repoPath}`);
+    }
+    await upsertSourceRepoMetadata(options.target, {
+        url: options.repoUrl,
+        path: repoPath,
+        addons: [repoPath],
+        sourceType,
+    });
+    await upsertSourceManifestEntry(options.target, {
+        type: sourceType,
+        path: repoPath,
+        url: options.repoUrl,
+        branch: options.odooVersion,
+        addons: [repoPath],
+    });
+    if (!(await isComposeEnvironment(options.target))) {
+        const addonsYaml = await readAddonsYaml(options.target);
+        if (sourceType === 'private') {
+            await writeAddonsYaml(options.target, addSourceRepoToAddonsYaml(addonsYaml, {
+                path: repoPath,
+                addons: [repoPath],
+            }));
+        }
+    }
+    await syncComposeOdooConfAddonsPath(options.target);
+    if (options.stage) {
+        await stageAll(git, options.target);
+    }
+}
+export async function listModuleRepos(target) {
+    return (await listGitmoduleRepos(target)).map((repo) => repo.path).sort();
+}
+export async function removeModuleRepo(options, git = realGit) {
+    const repoPath = validateRepoPath(options.repoPath);
+    const sourceType = options.sourceType ? normalizeSourceType(options.sourceType) : undefined;
+    const submodulePath = await resolveSubmodulePathFromConfig(options.target, repoPath, sourceType);
+    const fullSubmodulePath = join(options.target, submodulePath);
+    const resolvedSourceType = sourceType ?? resolveSourceTypeFromSubmodulePath(submodulePath);
+    if (await hasUncommittedChanges(git, fullSubmodulePath)) {
+        throw new Error(`Cannot remove ${repoPath}: submodule has uncommitted changes.`);
+    }
+    await removeSubmodule(git, options.target, submodulePath);
+    await removeSourceRepoMetadata(options.target, repoPath, resolvedSourceType);
+    if (resolvedSourceType) {
+        await removeSourceManifestEntry(options.target, resolvedSourceType, repoPath);
+    }
+    if (!(await isComposeEnvironment(options.target))) {
+        const addonsYaml = await readAddonsYaml(options.target);
+        if (resolvedSourceType === 'private') {
+            await writeAddonsYaml(options.target, removeSourceRepoFromAddonsYaml(addonsYaml, repoPath));
+        }
+    }
+    await syncComposeOdooConfAddonsPath(options.target);
+    if (options.stage) {
+        await stageAll(git, options.target);
+    }
+}

package/dist/repo-url.js

@@ -0,0 +1,27 @@
+import { basename } from 'node:path';
+export function normalizeRepositoryUrl(repoUrl) {
+    const trimmed = repoUrl.trim();
+    const withoutSuffix = trimmed.replace(/[?#].*$/, '').replace(/\/+$/, '').replace(/\.git$/, '');
+    const orgPageMatch = withoutSuffix.match(/^https:\/\/github\.com\/orgs\/([^/]+)\/([^/]+)$/);
+    if (orgPageMatch) {
+        return `https://github.com/${orgPageMatch[1]}/${orgPageMatch[2]}.git`;
+    }
+    return trimmed;
+}
+export function inferRepoPath(repoUrl) {
+    const trimmed = normalizeRepositoryUrl(repoUrl).replace(/[?#].*$/, '').replace(/\/+$/, '');
+    const lastSegment = basename(trimmed);
+    const withoutGit = lastSegment.replace(/\.git$/, '');
+    if (!withoutGit) {
+        throw new Error(`Cannot infer repository path from URL: ${repoUrl}`);
+    }
+    return withoutGit;
+}
+export function inferGitHubOwner(repoUrl) {
+    const normalized = normalizeRepositoryUrl(repoUrl);
+    const httpsMatch = normalized.match(/^https:\/\/github\.com\/([^/]+)\//);
+    if (httpsMatch)
+        return httpsMatch[1];
+    const sshMatch = normalized.match(/^git@github\.com:([^/]+)\//);
+    return sshMatch?.[1];
+}

package/dist/repository-preflight.js

@@ -0,0 +1,46 @@
+import { createGitHubRepository, getGitHubRepositoryStatus, githubSlug, isGitHubAuthenticated, isGitHubCliAvailable, realGitHub, } from './github.js';
+export function repositoryRequirements(options) {
+    return [
+        {
+            label: 'Dev environment repo',
+            url: options.devRepoUrl,
+            defaultVisibility: 'private',
+        },
+        ...options.sourceRepos.map((repo) => ({
+            label: `Source repo: ${repo.path}`,
+            url: repo.url,
+            defaultVisibility: 'private',
+        })),
+    ];
+}
+export async function findInaccessibleGitHubRepositories(options, runner = realGitHub) {
+    return (await checkGitHubRepositories(options, runner)).inaccessible;
+}
+export async function checkGitHubRepositories(options, runner = realGitHub) {
+    const accessible = [];
+    const inaccessible = [];
+    for (const requirement of repositoryRequirements(options)) {
+        const status = await getGitHubRepositoryStatus(runner, requirement.url);
+        if (status.status === 'accessible') {
+            accessible.push({ ...requirement, slug: status.slug });
+        }
+        if (status.status === 'inaccessible') {
+            inaccessible.push({ ...requirement, slug: status.slug });
+        }
+    }
+    return { accessible, inaccessible };
+}
+export async function createGitHubRepositories(repositories, visibility, runner = realGitHub) {
+    for (const repository of repositories) {
+        await createGitHubRepository(runner, repository.url, visibility);
+    }
+}
+export async function repositoryPreflightAvailable(runner = realGitHub) {
+    return (await isGitHubCliAvailable(runner)) && (await isGitHubAuthenticated(runner));
+}
+export function manualCreateCommands(repositories) {
+    return repositories.map((repository) => {
+        const slug = githubSlug(repository.url) ?? repository.url;
+        return `gh repo create ${slug} --${repository.defaultVisibility}`;
+    });
+}