@plainconceptsplatform/workflows 0.5.1 → 0.16.0

package/dist/catalog-installation.js

@@ -0,0 +1,485 @@
+import { execFile } from "node:child_process";
+import { access, copyFile, cp, mkdtemp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { parse as parseYaml } from "yaml";
+import { catalogTemplates, mandatoryFiles, routeNames, templateNames, workflowRoutes } from "./workflow-catalog.js";
+import { processRoutes, excludedWorkerFiles } from "./route-processing.js";
+import { generateOpencodeCi, generateOpencodeConfig, generateStackDefaults, injectStackEnv } from "./stack-defaults.js";
+import { mergeRouter, mergeWorker } from "./worker-env.js";
+import { fetchBaseline, hasOwnershipHeader, installedVersion, packageVersion, stampVersion } from "./package-baseline.js";
+const execFileAsync = promisify(execFile);
+const sourceMappings = [
+    ["actions", ".github/actions"],
+    ["workflows", ".github/workflows"],
+    ["scripts", "scripts"],
+];
+export function mandatoryFileSpecs(sourcePath) {
+    return mandatoryFiles.map((spec) => ({
+        source: join(sourcePath, spec.source),
+        target: spec.target,
+        managed: true,
+    }));
+}
+export function catalogSourcePath(modulePath = fileURLToPath(import.meta.url)) {
+    return resolve(dirname(modulePath), "..", "loops");
+}
+const isWorker = (target) => target.startsWith(".github/workflows/agent-") && target.endsWith(".md");
+const isRouter = (target) => target === ".github/workflows/work-router.yml";
+const carriesHeader = (target) => /\.(ya?ml|md|sh|mjs|cjs)$/.test(target);
+const normalizeEol = (text) => text.replaceAll("\r\n", "\n");
+export async function installCatalog(repositoryPath, options = {}) {
+    const version = options.packageVersion ?? await packageVersion();
+    const sourcePath = options.sourcePath ?? catalogSourcePath();
+    const selectedRoutes = options.selectedRoutes ?? routeNames;
+    const allFiles = [...await catalogFiles(sourcePath), ...mandatoryFileSpecs(sourcePath)];
+    const deduplicated = allFiles.filter((file, index) => allFiles.findIndex((f) => f.target === file.target) === index).sort((left, right) => left.target.localeCompare(right.target));
+    const excluded = excludedWorkerFiles(selectedRoutes);
+    const filtered = deduplicated.filter((file) => !excluded.has(file.target.split("/").pop() ?? ""));
+    const packageContents = new Map();
+    for (const file of filtered) {
+        packageContents.set(file.target, normalizeEol(await readFile(file.source, "utf8")));
+    }
+    let processed = processRoutes(packageContents, selectedRoutes);
+    // Read and write LF, always. Every one of these files ends up on a Linux runner, the package
+    // and every consumer declare `* text=auto eol=lf`, and a shell script with CRLF fails on its
+    // shebang. Preserving whatever a file happened to have instead only carried legacy CRLF
+    // forward, which git then reported as needing normalisation on every later commit.
+    const existing = new Map();
+    for (const target of processed.keys()) {
+        const path = join(repositoryPath, target);
+        if (!await exists(path))
+            continue;
+        existing.set(target, normalizeEol(await readFile(path, "utf8")));
+    }
+    if (options.inspection !== undefined) {
+        processed = applyStackDefaults(processed, options.inspection, existing);
+    }
+    const fetcher = options.baseline ?? fetchBaseline;
+    const baselineDirectories = new Map();
+    const baselineFor = (installed) => {
+        let pending = baselineDirectories.get(installed);
+        if (pending === undefined) {
+            pending = fetcher(installed);
+            baselineDirectories.set(installed, pending);
+        }
+        return pending;
+    };
+    const changes = [];
+    const updates = [];
+    const installedVersions = new Set();
+    for (const [target, packageText] of processed) {
+        const current = existing.get(target);
+        let text = packageText;
+        let change = { target, status: "added" };
+        if (current !== undefined) {
+            const recorded = carriesHeader(target) ? installedVersion(current) : undefined;
+            if (recorded !== undefined)
+                installedVersions.add(recorded);
+            if (isWorker(target) || isRouter(target)) {
+                const baselineText = recorded === undefined ? undefined : await baselineSource(await baselineFor(recorded), target);
+                const merge = isRouter(target) ? mergeRouter : mergeWorker;
+                const merged = merge(packageText, current, baselineText);
+                text = merged.content;
+                change = {
+                    target,
+                    status: "updated",
+                    ...(recorded === undefined ? {} : { installedVersion: recorded }),
+                    ...(merged.report.keptEnv.length > 0 ? { keptEnv: merged.report.keptEnv } : {}),
+                    ...(merged.report.updatedDefaults.length > 0 ? { updatedDefaults: merged.report.updatedDefaults } : {}),
+                    ...(merged.report.consumerOnlyEnv.length > 0 ? { consumerOnlyEnv: merged.report.consumerOnlyEnv } : {}),
+                    ...(merged.report.droppedEnv.length > 0 ? { droppedEnv: merged.report.droppedEnv } : {}),
+                };
+            }
+            else {
+                change = { target, status: "updated", ...(recorded === undefined ? {} : { installedVersion: recorded }) };
+            }
+        }
+        text = stampVersion(text, version);
+        if (current !== undefined && text === current) {
+            change = { ...change, status: "unchanged" };
+        }
+        else if (current !== undefined && carriesHeader(target) && !hasOwnershipHeader(current) && !options.force) {
+            // Removing the ownership header is how a consumer takes a file over.
+            change = { target, status: "skipped", reason: "consumer-owned: the ownership header was removed; pass --force to reclaim it" };
+        }
+        else {
+            updates.push({ target, content: text });
+        }
+        changes.push(change);
+    }
+    const removals = await orphanedManagedFiles(repositoryPath, new Set(processed.keys()));
+    for (const target of removals)
+        changes.push({ target, status: "removed" });
+    const baselines = [];
+    for (const [requested, pending] of baselineDirectories) {
+        baselines.push({ version: requested, status: (await pending) === undefined ? "unavailable" : "used" });
+    }
+    const result = {
+        installed: [...processed.keys()].sort(),
+        conflicts: [],
+        changes,
+        packageVersion: version,
+        installedVersions: [...installedVersions].sort(),
+        baselines,
+        upToDate: updates.length === 0 && removals.length === 0,
+        dryRun: options.dryRun ?? false,
+    };
+    if (options.dryRun)
+        return result;
+    // Deletions go first: a pruned action must be gone before the compile reads the tree, or a
+    // worker still referencing it would compile against a file that is about to disappear.
+    await removeFiles(repositoryPath, removals);
+    if (updates.length > 0) {
+        const stagedLocks = await validateStagedCatalog(repositoryPath, updates, options.compile);
+        await applyTransaction(repositoryPath, [...updates, ...stagedLocks, await preCommitHookUpdate(repositoryPath)]);
+    }
+    else {
+        await applyTransaction(repositoryPath, [await preCommitHookUpdate(repositoryPath)]);
+    }
+    return result;
+}
+// Stack defaults are derived from the repository, not chosen by a person, so the derived files
+// (the shared CI setup and the OpenCode config) get them on every run and stay stable. A worker
+// gets its VERIFY_COMMANDS default once, when it is first installed: after that the value is the
+// consumer's, and the env merge keeps it.
+function applyStackDefaults(files, inspection, existing) {
+    const defaults = generateStackDefaults(inspection);
+    const result = new Map(files);
+    for (const [target, content] of result) {
+        if (isWorker(target) && !existing.has(target)) {
+            result.set(target, injectStackEnv(content, defaults));
+        }
+        else if (target.endsWith("opencode-ci.md")) {
+            result.set(target, generateOpencodeCi(content, inspection));
+        }
+        else if (target === "opencode.ci.json") {
+            result.set(target, generateOpencodeConfig(content, inspection));
+        }
+    }
+    return result;
+}
+// Directories that belong wholly to the package. A file here that carries our ownership header
+// and is no longer in the package was deleted upstream, and without this it would sit in every
+// consumer forever: that is how `stale-recovery` and `update-changelog` outlived the code that
+// called them. Deliberately not `.github/workflows/`, where a worker's absence means the route
+// is not installed rather than gone, and never anything without a header, which is a fork.
+const pruneRoots = [".github/actions", ".github/workflows/shared"];
+async function orphanedManagedFiles(repositoryPath, keep) {
+    const orphans = [];
+    for (const root of pruneRoots) {
+        const directory = join(repositoryPath, root);
+        if (!await exists(directory))
+            continue;
+        for (const file of await filesIn(directory)) {
+            const target = `${root}/${file.replaceAll("\\", "/")}`;
+            if (keep.has(target))
+                continue;
+            if (!carriesHeader(target) && !target.endsWith(".cjs") && !target.endsWith(".js"))
+                continue;
+            const content = await readFile(join(directory, file), "utf8");
+            if (hasOwnershipHeader(content))
+                orphans.push(target);
+        }
+    }
+    return orphans.sort();
+}
+async function removeFiles(repositoryPath, targets) {
+    for (const target of targets) {
+        await rm(join(repositoryPath, target), { force: true });
+        // An action is a directory with one manifest in it; leaving the empty shell behind is litter.
+        const directory = dirname(join(repositoryPath, target));
+        try {
+            if ((await readdir(directory)).length === 0)
+                await rm(directory, { recursive: true, force: true });
+        }
+        catch {
+            // the directory is gone or not empty, either of which is fine
+        }
+    }
+}
+async function baselineSource(loops, target) {
+    if (loops === undefined)
+        return undefined;
+    const path = join(loops, "workflows", target.slice(".github/workflows/".length));
+    if (!await exists(path))
+        return undefined;
+    return normalizeEol(await readFile(path, "utf8"));
+}
+// Templates that need a companion config beside the workflow file. actionlint only
+// knows GitHub-hosted runner labels, so every workflow naming a self-hosted label is an
+// error without this file; it belongs wherever the lint workflow that reads it lives.
+const templateCompanions = {
+    "agentics-checks": [{ source: "templates/agentics/actionlint.yaml", target: ".github/actionlint.yaml" }],
+};
+export async function installTemplate(repositoryPath, template, options = {}) {
+    const sourcePath = options.sourcePath ?? catalogSourcePath();
+    const meta = catalogTemplateMeta(template);
+    const source = join(sourcePath, "templates", meta.directory, meta.file);
+    const target = meta.target;
+    const companions = templateCompanions[template] ?? [];
+    const destinations = [
+        { source, target, companion: false },
+        ...companions.map((companion) => ({
+            source: join(sourcePath, companion.source),
+            target: companion.target,
+            companion: true,
+        })),
+    ];
+    const conflicts = (await Promise.all(destinations.map(async (entry) => await exists(join(repositoryPath, entry.target)) && await exists(entry.source) && !(await filesMatch(entry.source, join(repositoryPath, entry.target)))
+        ? entry.target
+        : undefined))).filter((file) => file !== undefined);
+    if (conflicts.length > 0 && !options.force)
+        return { installed: [], conflicts };
+    for (const entry of destinations) {
+        if (!(await exists(entry.source)))
+            continue; // companion files may not exist for every template version
+        const destination = join(repositoryPath, entry.target);
+        await mkdir(dirname(destination), { recursive: true });
+        await copyFile(entry.source, destination);
+    }
+    if (options.inspection !== undefined && template === "opencode.ci.json") {
+        const baseContent = await readFile(source, "utf8");
+        const transformed = generateOpencodeConfig(baseContent, options.inspection);
+        await writeFile(join(repositoryPath, target), transformed, "utf8");
+    }
+    try {
+        await runCompileIfAvailable(repositoryPath);
+    }
+    catch {
+        // compile failure is non-fatal
+    }
+    return { installed: (await Promise.all(destinations.map(async (entry) => await exists(entry.source) ? entry.target : undefined))).filter((file) => file !== undefined), conflicts };
+}
+export async function installedRoutes(repositoryPath) {
+    const found = await Promise.all(workflowRoutes.map(async (route) => (await exists(join(repositoryPath, ".github", "workflows", route.worker))) ? route.name : undefined));
+    return found.filter((name) => name !== undefined);
+}
+export async function removeRouteFiles(repositoryPath, routes) {
+    const workerByRoute = new Map(workflowRoutes.map((route) => [route.name, route.worker]));
+    const removed = [];
+    for (const route of routes) {
+        const worker = workerByRoute.get(route);
+        if (worker === undefined)
+            continue;
+        const lock = worker.replace(/\.md$/, ".lock.yml");
+        for (const file of [worker, lock]) {
+            const destination = join(repositoryPath, ".github", "workflows", file);
+            if (await exists(destination)) {
+                await rm(destination, { force: true });
+                removed.push(`.github/workflows/${file}`);
+            }
+        }
+    }
+    return removed.sort();
+}
+export function isTemplateName(value) {
+    return templateNames.includes(value);
+}
+export async function ensurePreCommitHook(repositoryPath) {
+    const update = await preCommitHookUpdate(repositoryPath);
+    await applyTransaction(repositoryPath, [update]);
+}
+async function preCommitHookUpdate(repositoryPath) {
+    const target = ".husky/pre-commit";
+    const hookPath = join(repositoryPath, target);
+    const compileLine = "node scripts/compile-agent-workflows.mjs";
+    const stageLine = "git add -- .github/workflows/*.lock.yml";
+    const actionLockLine = "[ ! -f .github/actions/actions-lock.json ] || git add -- .github/actions/actions-lock.json";
+    const managedLines = `if git diff --cached --name-only -- .github | grep -q .; then\n  ${compileLine}\n  ${stageLine}\n  ${actionLockLine}\nfi\n`;
+    if (!await exists(hookPath)) {
+        return { target, content: managedLines };
+    }
+    const content = (await readFile(hookPath, "utf8"))
+        .replace("pnpm exec if git diff --cached --name-only -- .github | grep -q .; then", "if git diff --cached --name-only -- .github | grep -q .; then");
+    if (content.includes("compile-agent-workflows")) {
+        const legacyLines = `${compileLine}\n${stageLine}\n${actionLockLine}\n`;
+        if (content.includes(managedLines))
+            return { target, content };
+        if (content.includes(legacyLines))
+            return { target, content: content.replace(legacyLines, managedLines) };
+        const suffix = content.endsWith("\n") || content === "" ? "" : "\n";
+        return { target, content: `${content}${suffix}${managedLines}` };
+    }
+    return { target, content: content.endsWith("\n") || content === ""
+            ? `${content}${managedLines}`
+            : `${content}\n${managedLines}` };
+}
+export async function runCompileIfAvailable(repositoryPath) {
+    const script = join(repositoryPath, "scripts", "compile-agent-workflows.mjs");
+    if (await exists(script)) {
+        await execFileAsync("node", [script, "--force"], { cwd: repositoryPath });
+    }
+}
+async function validateStagedCatalog(repositoryPath, updates, compileOverride) {
+    const temporaryRoot = join(repositoryPath, ".opencode", ".tmp");
+    await mkdir(temporaryRoot, { recursive: true });
+    const stagingPath = await mkdtemp(join(temporaryRoot, "workflows-"));
+    try {
+        await copyCompilationInputs(repositoryPath, stagingPath);
+        await writeUpdates(stagingPath, updates);
+        await initializeStagingRepository(stagingPath);
+        const compiler = compileOverride ?? await packageCompiler(stagingPath);
+        if (compiler === undefined)
+            return [];
+        await compiler(stagingPath);
+        return await generatedFiles(stagingPath);
+    }
+    finally {
+        await rm(stagingPath, { force: true, recursive: true });
+    }
+}
+// The compile needs the workflows and the compile script. An update that changes neither still
+// recompiles against the consumer's current copies, so both come along.
+async function copyCompilationInputs(repositoryPath, stagingPath) {
+    const githubPath = join(repositoryPath, ".github");
+    if (await exists(githubPath))
+        await cp(githubPath, join(stagingPath, ".github"), { recursive: true });
+    const script = join(repositoryPath, "scripts", "compile-agent-workflows.mjs");
+    if (await exists(script)) {
+        await mkdir(join(stagingPath, "scripts"), { recursive: true });
+        await copyFile(script, join(stagingPath, "scripts", "compile-agent-workflows.mjs"));
+    }
+}
+async function initializeStagingRepository(stagingPath) {
+    await execFileAsync("git", ["init", "--quiet"], { cwd: stagingPath, windowsHide: true });
+}
+async function packageCompiler(repositoryPath) {
+    const scriptPath = join(repositoryPath, "scripts", "compile-agent-workflows.mjs");
+    if (!await exists(scriptPath))
+        return undefined;
+    const content = await readFile(scriptPath, "utf8");
+    return content.includes("gh aw compile") ? runCompileIfAvailable : undefined;
+}
+async function generatedFiles(repositoryPath) {
+    const workflowPath = join(repositoryPath, ".github", "workflows");
+    const updates = [];
+    if (await exists(workflowPath)) {
+        for (const file of await filesIn(workflowPath)) {
+            if (!file.endsWith(".lock.yml"))
+                continue;
+            updates.push({ target: `.github/workflows/${file.replaceAll("\\", "/")}`, content: await readFile(join(workflowPath, file), "utf8") });
+        }
+    }
+    const actionsLock = join(repositoryPath, ".github", "actions", "actions-lock.json");
+    if (await exists(actionsLock)) {
+        updates.push({ target: ".github/actions/actions-lock.json", content: await readFile(actionsLock, "utf8") });
+    }
+    return updates.sort((left, right) => left.target.localeCompare(right.target));
+}
+function validateActionManifests(updates) {
+    for (const { target, content } of updates) {
+        if (!target.endsWith("action.yml"))
+            continue;
+        let manifest;
+        try {
+            manifest = parseYaml(content);
+        }
+        catch {
+            throw new Error(`${target}: invalid YAML — failed to parse action manifest`);
+        }
+        if (manifest?.runs?.using !== "composite")
+            continue;
+        const steps = manifest.runs?.steps;
+        if (!Array.isArray(steps) || steps.length === 0) {
+            throw new Error(`${target}: composite action has no steps — file may be truncated`);
+        }
+        for (const [index, step] of steps.entries()) {
+            const label = step.name ?? step.id ?? `step ${index}`;
+            if (step.shell !== undefined && (typeof step.run !== "string" || step.run.trim() === "")) {
+                throw new Error(`${target}: step "${label}" has shell: but no run: — manifest is invalid or truncated`);
+            }
+        }
+    }
+}
+async function applyTransaction(repositoryPath, updates) {
+    const uniqueUpdates = [...new Map(updates.map((update) => [update.target, update])).values()];
+    const rollback = await Promise.all(uniqueUpdates.map(async ({ target }) => {
+        const path = join(repositoryPath, target);
+        return { target, existed: await exists(path), content: await exists(path) ? await readFile(path, "utf8") : undefined };
+    }));
+    try {
+        await writeUpdates(repositoryPath, uniqueUpdates);
+        validateActionManifests(uniqueUpdates);
+    }
+    catch (error) {
+        await Promise.all(rollback.map(async ({ target, existed, content }) => {
+            if (existed && content !== undefined) {
+                await writeUpdates(repositoryPath, [{ target, content }]);
+            }
+            else {
+                await rm(join(repositoryPath, target), { force: true });
+            }
+        }));
+        throw error;
+    }
+}
+async function writeUpdates(repositoryPath, updates) {
+    await Promise.all(updates.map(async ({ target, content }) => {
+        const destination = join(repositoryPath, target);
+        await mkdir(dirname(destination), { recursive: true });
+        await writeFile(destination, content, "utf8");
+    }));
+}
+function catalogTemplateMeta(template) {
+    const entry = catalogTemplates.find((item) => item.name === template);
+    if (entry === undefined)
+        throw new Error(`Unknown template: ${template}`);
+    // The directory is a field on the entry now. It used to be inferred from the name by a chain
+    // of ternaries ending in "agentics", so a new template in any other directory installed the
+    // wrong file or none at all, and the default hid it.
+    const directory = entry.directory ?? (template.startsWith("opencode") ? "opencode" : template.startsWith("app-ci-") ? "ci" : template === "github-release" ? "release" : template === "bug-report" || template === "feature-request" ? "issues" : "agentics");
+    const isWorkflow = entry.file.endsWith(".yml");
+    const inferredTarget = template === "app-ci-dotnet-next"
+        ? ".github/workflows/app-ci.yml"
+        : isWorkflow ? `.github/workflows/${entry.file}` : entry.file;
+    const target = entry.target ?? inferredTarget;
+    return { directory, file: entry.file, target };
+}
+async function catalogFiles(sourcePath) {
+    const files = [];
+    for (const [sourceDirectory, targetDirectory] of sourceMappings) {
+        if (!await exists(join(sourcePath, sourceDirectory)))
+            continue;
+        for (const file of await filesIn(join(sourcePath, sourceDirectory))) {
+            if (isGeneratedFile(file))
+                continue;
+            files.push({
+                source: join(sourcePath, sourceDirectory, file),
+                target: `${targetDirectory}/${file.replaceAll("\\", "/")}`,
+                managed: true,
+            });
+        }
+    }
+    return files.sort((left, right) => left.target.localeCompare(right.target));
+}
+function isGeneratedFile(file) {
+    const normalized = file.replaceAll("\\", "/");
+    return normalized.endsWith(".lock.yml") || normalized.endsWith("actions-lock.json");
+}
+async function filesIn(path) {
+    const entries = await readdir(path, { recursive: true, withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.parentPath === undefined ? entry.name : relative(path, join(entry.parentPath, entry.name)));
+}
+async function filesMatch(source, destination) {
+    try {
+        const [sourceContent, destinationContent] = await Promise.all([readFile(source), readFile(destination)]);
+        return sourceContent.equals(destinationContent);
+    }
+    catch {
+        return false;
+    }
+}
+export async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/catalog-listing.d.ts

@@ -0,0 +1,13 @@
+export interface CatalogEntry {
+    readonly kind: "route" | "template";
+    readonly name: string;
+    readonly description: string;
+    readonly file: string;
+    readonly installed: boolean;
+}
+export interface ListOptions {
+    readonly installedPath?: string;
+}
+export declare function listCatalog(options?: ListOptions): Promise<readonly CatalogEntry[]>;
+export declare function searchCatalog(entries: readonly CatalogEntry[], query: string): readonly CatalogEntry[];
+export declare function formatCatalog(entries: readonly CatalogEntry[]): string;

package/dist/catalog-listing.js

@@ -0,0 +1,70 @@
+import { access, constants } from "node:fs/promises";
+import { join } from "node:path";
+import { catalogTemplates, workflowRoutes } from "./workflow-catalog.js";
+export async function listCatalog(options = {}) {
+    const basePath = options.installedPath ?? process.cwd();
+    const routes = await Promise.all(workflowRoutes.map(async (route) => ({
+        kind: "route",
+        name: route.name,
+        description: route.description,
+        file: route.worker,
+        installed: await isFileInstalled(basePath, route.worker),
+    })));
+    const templates = await Promise.all(catalogTemplates.map(async (template) => ({
+        kind: "template",
+        name: template.name,
+        description: template.description,
+        file: template.file,
+        installed: await isFileInstalled(basePath, template.file, template.target),
+    })));
+    return [...routes, ...templates];
+}
+export function searchCatalog(entries, query) {
+    const normalized = query.toLowerCase().trim();
+    if (normalized === "")
+        return [];
+    return entries.filter((entry) => entry.name.toLowerCase().includes(normalized) ||
+        entry.description.toLowerCase().includes(normalized));
+}
+export function formatCatalog(entries) {
+    if (entries.length === 0)
+        return "No workflows matched the search query.";
+    const routes = entries.filter((entry) => entry.kind === "route");
+    const templates = entries.filter((entry) => entry.kind === "template");
+    const lines = [];
+    if (routes.length > 0) {
+        lines.push("Workflows:");
+        for (const entry of routes) {
+            lines.push(formatEntry(entry));
+        }
+    }
+    if (templates.length > 0) {
+        if (lines.length > 0)
+            lines.push("");
+        lines.push("Templates:");
+        for (const entry of templates) {
+            lines.push(formatEntry(entry));
+        }
+    }
+    return lines.join("\n");
+}
+function formatEntry(entry) {
+    const mark = entry.installed ? "[x]" : "[ ]";
+    return `  ${mark} ${entry.name} — ${entry.description}`;
+}
+async function isFileInstalled(basePath, workerOrTemplateFile, explicitTarget) {
+    const installedPath = templateInstallPath(basePath, workerOrTemplateFile, explicitTarget);
+    try {
+        await access(installedPath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function templateInstallPath(basePath, file, explicitTarget) {
+    if (explicitTarget !== undefined)
+        return join(basePath, ...explicitTarget.split("/"));
+    const isRootTemplate = file.endsWith(".json");
+    return isRootTemplate ? join(basePath, file) : join(basePath, ".github", "workflows", file);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function run(arguments_: readonly string[], repositoryPath?: string): Promise<number>;