cloving 1.2.0 → 1.4.0

package/dist/tools/self-host-runtime.js

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import { link, mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { readRetainedWorkflowBundle } from "./workflow-bundles.js";
+export async function selectRuntimeDirectory(input) {
+    const { runtime, repository, legacyRuntime, adoptionRecord } = input;
+    if (legacyRuntime === undefined ||
+        adoptionRecord === undefined ||
+        runtime === legacyRuntime)
+        return { runtime, note: "" };
+    const directory = join(dirname(legacyRuntime), "workflow-bundles");
+    if (!(await belongsToRepository(directory, repository)))
+        return {
+            runtime,
+            note: `Legacy runtime ${legacyRuntime} was not adopted: retained bundles are absent, damaged or belong to another repository.`,
+        };
+    return { runtime: legacyRuntime, note: "", adoptionRecord };
+}
+export async function adoptRuntimeDirectory(input) {
+    const selected = await selectRuntimeDirectory(input);
+    const adoptionRecord = selected.adoptionRecord;
+    if (adoptionRecord === undefined)
+        return { runtime: selected.runtime, note: selected.note };
+    const { repository } = input;
+    const legacyRuntime = selected.runtime;
+    await mkdir(dirname(adoptionRecord), { recursive: true, mode: 0o700 });
+    const contents = JSON.stringify({
+        schemaVersion: 1,
+        repository,
+        runtimeDirectory: legacyRuntime,
+    });
+    const temporary = `${adoptionRecord}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, contents, {
+            flag: "wx",
+            mode: 0o600,
+            flush: true,
+        });
+        await link(temporary, adoptionRecord);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return { runtime: legacyRuntime, note: "" };
+}
+async function belongsToRepository(directory, repository) {
+    try {
+        const ids = (await readdir(directory)).filter((id) => id !== ".history" && id !== "node_modules");
+        if (ids.length === 0)
+            return false;
+        for (const id of ids)
+            if ((await readRetainedWorkflowBundle({ directory, repository, id }))
+                .kind !== "available")
+                return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/self-host-workflows.d.ts

@@ -12,4 +12,5 @@ interface HostManifest {
 export declare function workflowFiles(directory: string): Promise<string[]>;
 export declare function workflowDeclarations(directory: string, manifests: Readonly<Record<string, HostManifest>>): Promise<readonly DeclaredWorkflow[]>;
 export declare function workflowManifests(compiled: WorkflowManifest, declarations?: readonly DeclaredWorkflow[]): Readonly<Record<string, HostManifest>>;
+export declare function workflowBundleLoader(): string;
 export {};

package/dist/tools/self-host-workflows.js

@@ -6,7 +6,8 @@ export async function workflowFiles(directory) {
     return entries
         .filter((entry) => entry.isFile() &&
         /\.(?:ts|js)$/.test(entry.name) &&
-        !entry.name.endsWith(".d.ts"))
+        !entry.name.endsWith(".d.ts") &&
+        !entry.name.endsWith(".test.ts"))
         .map((entry) => entry.name)
         .sort();
 }
@@ -76,3 +77,37 @@ export function workflowManifests(compiled, declarations = []) {
         });
     }));
 }
+export function workflowBundleLoader() {
+    return `
+import { AsyncLocalStorage } from "node:async_hooks";
+import { pathToFileURL } from "node:url";
+const bundleRegistries = new AsyncLocalStorage();
+const registryKeys = ["@workflow/core//registeredSteps", "workflow-class-registry"].map(Symbol.for);
+for (const key of registryKeys) {
+  let current = globalThis[key] ?? new Map();
+  Object.defineProperty(globalThis, key, {
+    configurable: true,
+    get: () => bundleRegistries.getStore()?.get(key) ?? current,
+    set: (value) => {
+      const scope = bundleRegistries.getStore();
+      if (scope === undefined) current = value;
+      else scope.set(key, value);
+    },
+  });
+}
+const loadedBundles = new Map();
+const loadWorkflowBundle = (directory) => {
+  const known = loadedBundles.get(directory);
+  if (known !== undefined) return known;
+  const scope = new Map(registryKeys.map((key) => [key, new Map()]));
+  const loaded = bundleRegistries.run(scope, async () => {
+    const workflows = await import(pathToFileURL(directory + "/artifacts/client.mjs").href);
+    const { POST } = await import(pathToFileURL(directory + "/artifacts/flow.mjs").href);
+    if (typeof POST !== "function") throw new Error("pinned-workflow-unavailable");
+    return { workflows, handler: (request) => bundleRegistries.run(scope, () => POST(request)) };
+  });
+  loadedBundles.set(directory, loaded);
+  return loaded;
+};
+`;
+}

package/dist/tools/self-host.js

@@ -1,77 +1,75 @@
+import { turnHarness, harnessDefaults, nativeHarness, } from "../src/harness-defaults.js";
+import { absoluteWorkflowFolder } from "../src/project-settings.js";
+import { projectConfiguration, projectRoot, topLevel, } from "./project-configuration.js";
 import { isProfilesFile } from "../src/turn-profile.js";
+import { parseCommands, parseCommandSeconds, } from "../src/command-settings.js";
 import { parseFallbackModels, parseTokenPrices, } from "../src/token-prices.js";
-import { execFileSync } from "node:child_process";
-import { readFile, realpath, writeFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { preparedProject, } from "./self-host-project.js";
 import { selfUpdateMilliseconds } from "./self-update-host.js";
 import { hostedPrograms } from "./self-host-processes.js";
+import { workflowBundleLoader } from "./self-host-workflows.js";
+import { adoptRuntimeDirectory } from "./self-host-runtime.js";
+import { parseSchedulesSetting } from "../src/workflow-schedule.js";
+import { checkSubmission } from "../src/submission.js";
 const product = resolve(import.meta.dirname, "..");
 const flags = process.argv.slice(2);
 function flag(name) {
-    const index = flags.lastIndexOf(name);
-    return index === -1 ? undefined : flags[index + 1];
-}
-function topLevel(given) {
-    try {
-        return execFileSync("git", ["-C", given, "rev-parse", "--show-toplevel"], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-    }
-    catch {
-        return given;
-    }
+    const index = flags.findLastIndex((argument) => argument === name || argument.startsWith(`${name}=`));
+    const argument = flags[index];
+    return argument === name
+        ? flags[index + 1]
+        : argument?.slice(name.length + 1);
 }
 const runtimeArgument = flag("--runtime");
 if (runtimeArgument === undefined)
     throw new Error("The start program needs --runtime. Use: cloving start");
-const runtime = resolve(runtimeArgument);
+const repository = await projectRoot(flag("--repository") ?? process.cwd());
+const configuration = await projectConfiguration(repository, process.env);
+const environment = configuration.environment;
+const selectedRuntime = await adoptRuntimeDirectory({
+    runtime: resolve(runtimeArgument),
+    repository,
+    legacyRuntime: flag("--legacy-runtime"),
+    adoptionRecord: flag("--adoption-record"),
+});
+const runtime = selectedRuntime.runtime;
 const directory = dirname(runtime);
-const repository = await realpath(topLevel(resolve(flag("--repository") ?? process.cwd())));
 const updateMilliseconds = await selfUpdateMilliseconds({
-    seconds: process.env["CLOVING_SELF_UPDATE_SECONDS"],
+    seconds: environment["CLOVING_SELF_UPDATE_SECONDS"],
     repository,
     product: extname(import.meta.filename) === ".ts" ? topLevel(product) : product,
 });
 const client = flag("--client") ?? "cloving";
 const project = join(directory, "project");
-const concurrency = Number(process.env["CLOVING_HOST_BOUND"] ?? "8");
-const leaseText = process.env["CLOVING_OWNERSHIP_LEASE_SECONDS"];
+const concurrency = Number(environment["CLOVING_HOST_BOUND"] ?? "8");
+const leaseText = environment["CLOVING_OWNERSHIP_LEASE_SECONDS"];
 const leaseSeconds = leaseText === undefined ? undefined : Number(leaseText);
-const defaultCommand = [
-    "claude",
-    "-p",
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    "--permission-mode",
-    "acceptEdits",
-    "--allowedTools",
-    "Bash,Read,Edit,Write,Glob,Grep,WebSearch,WebFetch",
-    "--max-budget-usd",
-    "5",
-];
-const defaultCodexCommand = [
-    "codex",
-    "exec",
-    "--json",
-    "--dangerously-bypass-approvals-and-sandbox",
-    "--skip-git-repo-check",
-    "-",
-];
 function selectedWorker() {
-    const worker = process.env["CLOVING_WORKER"] ?? "claude";
-    if (worker === "claude" || worker === "codex")
-        return worker;
-    throw new Error(`The daemon did not start: invalid-worker: ${worker}`);
+    return checkedWorker(environment["CLOVING_WORKER"] ?? "claude");
+}
+function checkedWorker(name) {
+    try {
+        return turnHarness({
+            worker: name,
+            ...(configuration.harness === undefined
+                ? {}
+                : { harness: configuration.harness }),
+        }).worker;
+    }
+    catch (error) {
+        throw new Error(`The daemon did not start: harness-no-worker: ${name}`, {
+            cause: error,
+        });
+    }
 }
 async function profilesFile() {
-    const path = process.env["CLOVING_PROFILES"];
+    const path = environment["CLOVING_PROFILES"];
     if (path === undefined)
-        return {};
+        return configuration.profiles;
     try {
         const value = JSON.parse(await readFile(path, "utf8"));
         if (isProfilesFile(value))
@@ -83,17 +81,28 @@ async function profilesFile() {
     throw new Error("The daemon did not start: invalid-profiles");
 }
 function queueLanes() {
-    const value = process.env["CLOVING_QUEUE_LANES"];
+    const value = environment["CLOVING_QUEUE_LANES"];
     if (value === undefined)
         return 1;
     if (!/^[1-4]$/.test(value))
         throw new Error("The daemon did not start: invalid-queue-lanes");
-    if (process.env["CLOVING_QUEUE_SECONDS"] === undefined)
+    if (environment["CLOVING_QUEUE_SECONDS"] === undefined)
         throw new Error("The daemon did not start: queue-lanes-needs-queue");
     return Number(value);
 }
-function queueInterval(commands) {
-    const value = process.env["CLOVING_QUEUE_SECONDS"];
+function queueSpendLimit() {
+    const value = environment["CLOVING_QUEUE_DAILY_SPEND_USD"];
+    if (value === undefined)
+        return undefined;
+    const limit = Number(value);
+    if (!Number.isFinite(limit) || limit <= 0)
+        throw new Error("The daemon did not start: invalid-queue-spend-limit");
+    if (environment["CLOVING_QUEUE_SECONDS"] === undefined)
+        throw new Error("The daemon did not start: queue-spend-limit-needs-queue");
+    return limit;
+}
+function queueInterval() {
+    const value = environment["CLOVING_QUEUE_SECONDS"];
     if (value === undefined)
         return undefined;
     const seconds = Number(value);
@@ -102,14 +111,10 @@ function queueInterval(commands) {
         seconds < 10 ||
         seconds > 3600)
         throw new Error("The daemon did not start: invalid-queue-seconds");
-    if (!commands.nextCommand?.length)
-        throw new Error("The daemon did not start: queue-needs-next-command");
-    if (!commands.ticketCommand?.length)
-        throw new Error("The daemon did not start: queue-needs-ticket-command");
     return seconds * 1000;
 }
 function listed(name) {
-    const given = process.env[name];
+    const given = environment[name];
     if (given === undefined)
         return undefined;
     const list = JSON.parse(given);
@@ -121,6 +126,12 @@ function source(file) {
     return JSON.stringify(pathToFileURL(join(product, file.replace(/\.ts$/, extname(import.meta.filename)))).href);
 }
 async function launchers(commands, workflows) {
+    const queueEnabled = commands.queueMilliseconds !== undefined &&
+        workflows.declarations.some((declaration) => declaration.queue === true);
+    if (queueEnabled && !commands.nextCommand?.length)
+        throw new Error("The daemon did not start: queue-needs-next-command");
+    if (queueEnabled && !commands.ticketCommand?.length)
+        throw new Error("The daemon did not start: queue-needs-ticket-command");
     const settings = {
         ...commands,
         directory,
@@ -135,73 +146,119 @@ await import("./main.mjs");
     await writeFile(join(project, "main.mjs"), `import * as workflows from "./artifacts/client.mjs";
 import { POST } from "./artifacts/flow.mjs";
 import { startDaemon } from ${source("src/daemon/daemon.ts")};
-const opening = await startDaemon({ ...JSON.parse(${JSON.stringify(JSON.stringify(settings))}), workflows, handler: POST });
+${workflowBundleLoader()}
+const opening = await startDaemon({ ...JSON.parse(${JSON.stringify(JSON.stringify(settings))}), workflows, handler: POST, loadBundle: loadWorkflowBundle });
 if (opening.kind !== "started") {
   process.stderr.write("The daemon did not start: " + opening.reason + ": " + opening.detail + "\\n");
   process.exit(1);
 }
-process.stdout.write(${JSON.stringify(guide())});
+process.stdout.write(${JSON.stringify(guide(workflows))});
 const stop = async () => { await opening.daemon.close(); process.exit(0); };
 process.once("SIGINT", stop);
 process.once("SIGTERM", stop);
 `);
 }
-function guide() {
+function runCommand(declaration) {
+    const { workflowId, input } = declaration;
+    for (const [field, value, argument] of [
+        ["ticket", "ticket-id", "--ticket <ticket-id>"],
+        ["prompt", "task text", '--prompt "<text>"'],
+    ]) {
+        const checked = checkSubmission(input, {
+            workflowId,
+            source: field,
+            submission: { [field]: value },
+        });
+        if (checked.kind === "valid")
+            return `  ${client} run ${workflowId} ${argument}`;
+    }
+    return `  ${client} run ${workflowId} --input <json-file>`;
+}
+function guide(workflows) {
     return [
         "Cloving runs. Stop it with Control-C.",
         `Repository: ${repository}`,
+        `Runtime directory: ${runtime}`,
         `Work trees: ${join(directory, "worktrees")}`,
+        ...(selectedRuntime.note === "" ? [] : [selectedRuntime.note]),
+        ...Object.entries(configuration.sources).map(([field, source]) => `${field}: ${source}`),
+        ...workflows.workflowRefusals.map((refusal) => `Refused workflow ${refusal.scope} ${refusal.label}: ${refusal.codes.join(", ")}`),
         "Commands for a second terminal:",
-        `  ${client} run develop-ticket --ticket <ticket-id>`,
-        `  ${client} run develop-issue --ticket <ticket-id>`,
-        `  ${client} run develop-prompt --prompt "<the text of the task>"`,
-        `  ${client} run develop-prd --prompt "<the idea>"`,
+        ...(workflows.declarations.length === 0
+            ? ["No workflow. Run: cloving init"]
+            : workflows.declarations.map(runCommand)),
         `  ${client} status`,
         `  ${client} questions`,
         `  ${client} watch`,
         "",
     ].join("\n");
 }
-const tokenPrices = parseTokenPrices(process.env["CLOVING_TOKEN_PRICES"]);
-const fallbackModels = parseFallbackModels(process.env["CLOVING_FALLBACK_MODELS"]);
+const tokenPrices = parseTokenPrices(environment["CLOVING_TOKEN_PRICES"]);
+const commands = parseCommands(environment["CLOVING_COMMANDS"]);
+const commandSeconds = parseCommandSeconds(environment["CLOVING_COMMAND_SECONDS"]);
+const fallbackModels = parseFallbackModels(environment["CLOVING_FALLBACK_MODELS"]);
 const profiles = await profilesFile();
+const schedules = parseSchedulesSetting(environment["CLOVING_SCHEDULES"]);
 const worker = selectedWorker();
-const command = worker === "codex"
-    ? (listed("CLOVING_CODEX_COMMAND") ?? defaultCodexCommand)
-    : (listed("CLOVING_CLAUDE_COMMAND") ?? defaultCommand);
+function nativeCommands() {
+    const names = new Set([
+        worker,
+        ...Object.values(profiles).map((profile) => checkedWorker(profile.harness ?? worker)),
+    ]);
+    return Object.fromEntries([...names].filter(nativeHarness).flatMap((name) => {
+        const variable = harnessDefaults(name).variable;
+        const command = variable === undefined ? undefined : listed(variable);
+        return command === undefined ? [] : [[name, command]];
+    }));
+}
+const workerCommands = nativeCommands();
+const harness = configuration.harness ?? {};
+const command = turnHarness({ worker, workerCommands, harness }).command;
 const nextCommand = listed("CLOVING_NEXT_COMMAND");
 const ticketCommand = listed("CLOVING_TICKET_COMMAND");
+const queueDailySpendLimitUsd = queueSpendLimit();
 const lanes = queueLanes();
-const queueMilliseconds = queueInterval({ nextCommand, ticketCommand });
+const queueMilliseconds = queueInterval();
 const manifests = await preparedProject({
     product,
     project,
     repository,
     home: homedir(),
-    xdgConfigHome: process.env["XDG_CONFIG_HOME"],
+    xdgConfigHome: environment["XDG_CONFIG_HOME"],
+    userFolder: absoluteWorkflowFolder(environment["CLOVING_WORKFLOW_FOLDER"]),
 });
 await launchers({
+    commands,
+    commandSeconds,
+    schedules,
     tokenPrices,
     fallbackModels,
     worker,
+    workerCommands,
+    harness,
+    shell: environment["SHELL"] ?? "/bin/sh",
     profiles,
     command,
     ticketCommand,
     nextCommand,
     queueMilliseconds,
     queueLanes: lanes,
+    queueDailySpendLimitUsd,
     resetQueue: flags.includes("--reset-queue"),
     notifyCommand: listed("CLOVING_NOTIFY_COMMAND"),
     githubCommand: listed("CLOVING_GH_COMMAND"),
+    requiredChecks: listed("CLOVING_REQUIRED_CHECKS") ?? null,
     checkCommand: listed("CLOVING_CHECK_COMMAND"),
     privateTexts: listed("CLOVING_PRIVATE_TEXTS"),
 }, manifests);
 process.exitCode = await hostedPrograms({
+    environment,
     project,
     product,
     runtime,
     directory,
     repository,
     updateMilliseconds,
-    watchPort: process.env["CLOVING_WATCH_PORT"] ?? "3663",
+    watchPort: environment["CLOVING_WATCH_PORT"] ?? "3663",
+    phoneRelay: environment["CLOVING_PHONE_RELAY"] ?? "on",
 });

package/dist/tools/template-command.d.ts

@@ -0,0 +1 @@
+export declare function templateCommand(argumentsList: readonly string[]): Promise<number>;

package/dist/tools/template-command.js

@@ -0,0 +1,160 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+import { absoluteWorkflowFolder } from "../src/project-settings.js";
+import { record } from "../src/protocol.js";
+import { isCandidateDeclaration } from "../src/workflow-candidate.js";
+import { projectConfiguration, projectRoot } from "./project-configuration.js";
+import { copyTemplate } from "./template-copy.js";
+import { exportedFunctions, readTemplate, templateList, templateRoot, } from "./template-files.js";
+import { userLocation } from "./workflow-folders.js";
+const usage = "Usage: cloving templates list [--json]\n       cloving templates show <name> [--json]\n       cloving templates copy <name> [--id <workflow-id>] [--json] [--repository <directory>]\n";
+function invocation(argumentsList) {
+    const { values, positionals } = parseArgs({
+        args: [...argumentsList],
+        allowPositionals: true,
+        options: {
+            json: { type: "boolean" },
+            id: { type: "string" },
+            repository: { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    const [command, name, ...extra] = positionals;
+    if (values.help === true)
+        return { ...values, command: "help", name: "" };
+    if (!["list", "show", "copy"].includes(command ?? ""))
+        throw new Error("unknown-command");
+    if (extra.length > 0 || (command === "list") !== (name === undefined))
+        throw new Error("unexpected-argument");
+    if (command !== "copy" && (values.id !== undefined || values.repository))
+        throw new Error("unexpected-option");
+    return { ...values, command, name: name ?? "" };
+}
+export async function templateCommand(argumentsList) {
+    let selected;
+    try {
+        selected = invocation(argumentsList);
+    }
+    catch {
+        process.stderr.write("invalid-invocation: " + usage);
+        return 2;
+    }
+    if (selected.help) {
+        process.stdout.write(usage);
+        return 0;
+    }
+    try {
+        const root = templateRoot();
+        const json = selected.json === true;
+        if (selected.command === "list")
+            return await listed(root, { json });
+        if (selected.command === "show")
+            return await shown(root, { name: selected.name, json });
+        return await copied(root, {
+            name: selected.name,
+            id: selected.id ?? selected.name,
+            json,
+            repository: selected.repository ?? process.cwd(),
+        });
+    }
+    catch (error) {
+        process.stderr.write((error instanceof Error ? error.message : "template-command-failed") +
+            "\n");
+        return 1;
+    }
+}
+async function listed(root, input) {
+    const templates = await templateList(root);
+    if (input.json)
+        process.stdout.write(JSON.stringify(templates) + "\n");
+    else
+        for (const template of templates)
+            process.stdout.write(`${template.name}: ${template.summary} (${String(template.points)} decision points)\n`);
+    return 0;
+}
+async function shown(root, input) {
+    const template = await readTemplate(root, input.name);
+    if (input.json) {
+        process.stdout.write(JSON.stringify({
+            template: template.description,
+            files: template.files,
+        }) + "\n");
+        return 0;
+    }
+    process.stdout.write(`${template.name}: ${String(template.description["summary"])}\n${pointText(template.points)}Files:\n${template.files.map((file) => `  ${file}\n`).join("")}`);
+    return 0;
+}
+async function copied(root, input) {
+    const repository = await projectRoot(input.repository);
+    const folder = join(repository, ".cloving", "workflows");
+    const folders = [folder, await userFolder(repository)];
+    const packageRoot = dirname(root);
+    const takenNames = await exportedFunctions([
+        join(packageRoot, "workflows"),
+        join(packageRoot, "dist", "workflows"),
+        ...folders,
+    ]);
+    const result = await copyTemplate({ ...input, root, folder, takenNames });
+    const queued = (await Promise.all(folders.map(queuedIn))).flat().sort();
+    if (input.json)
+        process.stdout.write(JSON.stringify({
+            workflowId: input.id,
+            template: input.name,
+            files: result.files,
+            queueWorkflows: queued,
+        }) + "\n");
+    else
+        process.stdout.write(`Copied the template ${input.name} to .cloving/workflows as the workflow ${input.id}.\nDecision points:\n${pointText(result.template.points)}Next: cloving workflows test ${input.id}\n`);
+    if (queued.length > 1)
+        process.stderr.write(`queue-workflow-conflict: ${queued.join(", ")} have "queue": true. Select "a person" for the select point of one copy: remove workflow.queue from its declaration.\n`);
+    return 0;
+}
+function pointText(points) {
+    return points
+        .map((value) => {
+        const point = record(value);
+        const options = point?.["options"];
+        const lines = (Array.isArray(options) ? options : []).map((option, index) => {
+            const fields = record(option);
+            return `    - ${String(fields?.["id"])}: ${String(fields?.["label"])}${index === 0 ? " (default)" : ""}\n`;
+        });
+        return `  ${String(point?.["id"])}: ${String(point?.["question"])}\n${lines.join("")}`;
+    })
+        .join("");
+}
+async function userFolder(repository) {
+    const settings = await projectConfiguration(repository, process.env);
+    const user = userLocation({
+        home: homedir(),
+        xdgConfigHome: process.env["XDG_CONFIG_HOME"],
+        userFolder: absoluteWorkflowFolder(settings.environment["CLOVING_WORKFLOW_FOLDER"]),
+    });
+    return join(user.root, ...user.parts);
+}
+async function queuedIn(folder) {
+    const names = await readdir(folder).catch(() => []);
+    const ids = await Promise.all(names
+        .filter((name) => name.endsWith(".declaration.json"))
+        .map((name) => queuedId(folder, name)));
+    return ids.flatMap((id) => (id === undefined ? [] : [id]));
+}
+async function queuedId(folder, name) {
+    const text = await readFile(join(folder, name), "utf8").catch(() => "");
+    let declaration;
+    try {
+        declaration = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isCandidateDeclaration(declaration) ||
+        declaration.workflow.queue !== true)
+        return undefined;
+    const source = join(folder, name.replace(/\.declaration\.json$/, ".ts"));
+    const entry = await stat(source).catch(() => undefined);
+    return entry?.isFile() === true ? declaration.workflow.workflowId : undefined;
+}
+if (process.argv[1] === import.meta.filename)
+    process.exitCode = await templateCommand(process.argv.slice(2));

package/dist/tools/template-copy.d.ts

@@ -0,0 +1,11 @@
+import { type Template } from "./template-files.ts";
+export declare function copyTemplate(input: {
+    readonly root: string;
+    readonly name: string;
+    readonly id: string;
+    readonly folder: string;
+    readonly takenNames: ReadonlySet<string>;
+}): Promise<{
+    readonly template: Template;
+    readonly files: readonly string[];
+}>;