@lchase/kiln 0.0.0-stage → 0.3.0

package/dist/cli.js

@@ -0,0 +1,409 @@
+#!/usr/bin/env node
+import { addRepo, renderRepoList, resolveKilnConfig } from "./config.js";
+import { answerJob, runStatus, runTick } from "./driver.js";
+import { startServe } from "./serve.js";
+import { addFromFile } from "./intake/file.js";
+import { addFromJira } from "./intake/jira.js";
+import { addFromPrompt } from "./intake/prompt.js";
+import { importTickets } from "./intake/tickets.js";
+import { renderAddedJob } from "./jobs.js";
+function usage() {
+    console.error([
+        "Usage: kiln repo add <name> <path> [--test <cmd>] [--deliver local|pr] [--base <branch>] [--config <file>]",
+        "       kiln repo list [--config <file>]",
+        "       kiln add <workflow> --repo <name> (--spec <file.md> | --prompt <text> | --jira <KEY>) [--title <text>] [--after <jobId>]... [--stack] [--dry-run] [--config <file>]",
+        "       kiln import <dir> --repo <name> [--workflow <name>] [--context <file.md>] [--stack] [--dry-run] [--config <file>]",
+        "       kiln tick [--config <file>]",
+        "       kiln status [jobId] [--config <file>]",
+        "       kiln approve <jobId> [--config <file>]",
+        "       kiln reject <jobId> [--config <file>]",
+        "       kiln serve [--port 4100] [--tick <seconds>|--no-tick] [--config <file>]",
+        "",
+        "repo add registers a checkout. A relative path is stored absolute, resolved",
+        "from the working directory. ~ is expanded from the home directory.",
+        "",
+        "Config, jobs, logs, and deliveries live in one kiln home: --config <file>",
+        "if given, otherwise $KILN_HOME/kiln.config.json when KILN_HOME is set,",
+        "otherwise ~/.kiln/kiln.config.json. repo add creates that directory.",
+        "Run kiln repo add <name> <path> from any directory. A leftover",
+        "./.kiln/kiln.config.json is an error until you mv ./.kiln ~/.kiln,",
+        "pass --config <file>, or set KILN_HOME.",
+        "",
+        "add writes one job from a spec file, from --prompt text (--prompt - reads stdin),",
+        "or from a Jira Cloud issue (--jira PROJ-123). Pass one of those, not more.",
+        "The repo and the workflow (workflows/<name>.yaml) must already exist.",
+        "--after names jobs that must be done before this one launches. --stack waits",
+        "for one upstream to land and opens the pull request against that branch.",
+        "--stack cannot target an investigation job: that workflow does not land a branch.",
+        "A Jira Blocks link where this issue is blocked by another key is included",
+        "when a kiln job for that key already exists.",
+        "--dry-run with --jira prints the job and writes nothing. Running add again",
+        "for the same Jira key prints the existing job id and creates nothing.",
+        "",
+        "import reads a directory of NN-slug.md tickets and writes one job per file.",
+        "Blocked-by becomes dependsOn. Re-running the same directory does not duplicate jobs.",
+        "--dry-run prints the jobs and writes nothing.",
+        "",
+        "tick launches at most one ready job. After merged, dependencies must be done.",
+        "Stacked jobs launch once the upstream has landed. deliver=pr then pushes",
+        "yak/<run-id> and opens a draft pull request. An investigation is done when",
+        "its gate is approved. It does not open a pull request. status prints the",
+        "derived state, and the findings path once an investigation is approved.",
+        "approve and reject answer the human gate.",
+        "",
+        "serve listens on 127.0.0.1. The inbox lists needs-human jobs. The board",
+        "groups every job by the same derived state as status. Approve and reject",
+        "call the same functions as the CLI. POST from another origin is rejected.",
+        "A tick runs every 30 seconds unless --no-tick is set, using the tick lock.",
+    ].join("\n"));
+    process.exit(2);
+}
+function parseFlags(argv) {
+    const bag = { positionals: [], after: [], dryRun: false, stack: false, noTick: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const flag = argv[i];
+        const next = argv[i + 1];
+        if (flag === "--config") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.configPath = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--test") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.test = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--repo") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.repo = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--spec") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.spec = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--prompt") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.prompt = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--jira") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.jira = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--workflow") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.workflow = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--context") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.context = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--dry-run") {
+            bag.dryRun = true;
+            continue;
+        }
+        if (flag === "--title") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.title = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--after") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.after.push(next);
+            i += 1;
+            continue;
+        }
+        if (flag === "--stack") {
+            bag.stack = true;
+            continue;
+        }
+        if (flag === "--deliver") {
+            if (next !== "local" && next !== "pr")
+                usage();
+            bag.deliver = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--base") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.base = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--port") {
+            if (!next || !/^\d+$/.test(next))
+                usage();
+            const port = Number(next);
+            if (port > 65535)
+                usage();
+            bag.port = port;
+            i += 1;
+            continue;
+        }
+        if (flag === "--tick") {
+            if (!next || !/^[1-9]\d*$/.test(next))
+                usage();
+            const seconds = Number(next);
+            if (seconds > 86_400)
+                usage();
+            bag.tickSeconds = seconds;
+            i += 1;
+            continue;
+        }
+        if (flag === "--no-tick") {
+            bag.noTick = true;
+            continue;
+        }
+        if (flag?.startsWith("--"))
+            usage();
+        if (flag !== undefined)
+            bag.positionals.push(flag);
+    }
+    return bag;
+}
+function rejectServeFlags(flags) {
+    if (flags.port !== undefined || flags.tickSeconds !== undefined || flags.noTick)
+        usage();
+}
+function repoCommand(argv) {
+    const sub = argv[0];
+    const flags = parseFlags(argv.slice(1));
+    rejectServeFlags(flags);
+    if (sub === "list") {
+        if (flags.positionals.length !== 0 || hasIntakeFlags(flags) || flags.test || flags.deliver || flags.base)
+            usage();
+        const config = resolveKilnConfig({ configPath: flags.configPath });
+        process.stdout.write(renderRepoList(config));
+        return;
+    }
+    if (sub === "add") {
+        const name = flags.positionals[0];
+        const repoPath = flags.positionals[1];
+        if (!name || !repoPath || flags.positionals.length !== 2 || hasIntakeFlags(flags))
+            usage();
+        process.stdout.write(addRepo({
+            configPath: flags.configPath,
+            name,
+            repoPath,
+            ...(flags.test !== undefined ? { test: flags.test } : {}),
+            ...(flags.deliver !== undefined ? { deliver: flags.deliver } : {}),
+            ...(flags.base !== undefined ? { base: flags.base } : {}),
+        }));
+        return;
+    }
+    usage();
+}
+async function addCommand(argv) {
+    const flags = parseFlags(argv);
+    rejectServeFlags(flags);
+    const workflow = flags.positionals[0];
+    const selected = [flags.spec !== undefined, flags.prompt !== undefined, flags.jira !== undefined].filter(Boolean).length;
+    if (!workflow ||
+        flags.positionals.length !== 1 ||
+        !flags.repo ||
+        selected !== 1 ||
+        flags.test ||
+        flags.workflow ||
+        flags.context ||
+        flags.deliver ||
+        flags.base ||
+        (flags.dryRun && flags.jira === undefined)) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    if (flags.jira !== undefined) {
+        const result = await addFromJira(config, {
+            workflow,
+            repo: flags.repo,
+            key: flags.jira,
+            ...(flags.title !== undefined ? { title: flags.title } : {}),
+            dependsOn: flags.after,
+            ...(flags.stack ? { stack: true } : {}),
+            dryRun: flags.dryRun,
+        });
+        process.stdout.write(result.report);
+        if (result.warnings.length > 0)
+            process.stderr.write(`${result.warnings.join("\n")}\n`);
+        return;
+    }
+    const { job, jsonPath } = flags.spec !== undefined
+        ? addFromFile(config, {
+            workflow,
+            repo: flags.repo,
+            specPath: flags.spec,
+            ...(flags.title !== undefined ? { title: flags.title } : {}),
+            dependsOn: flags.after,
+            ...(flags.stack ? { stack: true } : {}),
+            cwd: process.cwd(),
+        })
+        : addFromPrompt(config, {
+            workflow,
+            repo: flags.repo,
+            prompt: flags.prompt ?? "",
+            ...(flags.title !== undefined ? { title: flags.title } : {}),
+            dependsOn: flags.after,
+            ...(flags.stack ? { stack: true } : {}),
+        });
+    process.stdout.write(renderAddedJob(job, jsonPath));
+}
+function importCommand(argv) {
+    const flags = parseFlags(argv);
+    rejectServeFlags(flags);
+    const dir = flags.positionals[0];
+    if (!dir ||
+        flags.positionals.length !== 1 ||
+        !flags.repo ||
+        flags.spec ||
+        flags.prompt ||
+        flags.title ||
+        flags.after.length > 0 ||
+        flags.test ||
+        flags.deliver ||
+        flags.base) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    const result = importTickets(config, {
+        dir,
+        repo: flags.repo,
+        ...(flags.workflow !== undefined ? { workflow: flags.workflow } : {}),
+        ...(flags.context !== undefined ? { contextPath: flags.context } : {}),
+        dryRun: flags.dryRun,
+        ...(flags.stack ? { stack: true } : {}),
+        cwd: process.cwd(),
+    });
+    process.stdout.write(result.report);
+    if (result.warnings.length > 0)
+        process.stderr.write(`${result.warnings.join("\n")}\n`);
+}
+function tickCommand(argv) {
+    const flags = parseFlags(argv);
+    rejectServeFlags(flags);
+    if (flags.positionals.length !== 0 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    process.stdout.write(runTick(config));
+}
+function statusCommand(argv) {
+    const flags = parseFlags(argv);
+    rejectServeFlags(flags);
+    if (flags.positionals.length > 1 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    process.stdout.write(runStatus(config, flags.positionals[0]));
+}
+function gateCommand(choice, argv) {
+    const flags = parseFlags(argv);
+    rejectServeFlags(flags);
+    const jobId = flags.positionals[0];
+    if (!jobId || flags.positionals.length !== 1 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    process.stdout.write(answerJob(config, jobId, choice));
+}
+async function serveCommand(argv) {
+    const flags = parseFlags(argv);
+    if (flags.positionals.length !== 0 ||
+        flags.test ||
+        hasIntakeFlags(flags) ||
+        flags.deliver ||
+        flags.base ||
+        flags.stack ||
+        (flags.noTick && flags.tickSeconds !== undefined)) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    const port = flags.port ?? 4100;
+    const tickSeconds = flags.noTick ? undefined : (flags.tickSeconds ?? 30);
+    await startServe({
+        config,
+        port,
+        ...(tickSeconds !== undefined ? { tickSeconds } : {}),
+    });
+}
+function hasIntakeFlags(flags) {
+    return Boolean(flags.repo ||
+        flags.spec ||
+        flags.prompt ||
+        flags.jira ||
+        flags.title ||
+        flags.workflow ||
+        flags.context ||
+        flags.dryRun ||
+        flags.stack ||
+        flags.after.length > 0);
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const command = argv[0];
+    if (!command || command === "--help" || command === "-h" || command === "help")
+        usage();
+    if (command === "repo") {
+        repoCommand(argv.slice(1));
+        return;
+    }
+    if (command === "add") {
+        await addCommand(argv.slice(1));
+        return;
+    }
+    if (command === "import") {
+        importCommand(argv.slice(1));
+        return;
+    }
+    if (command === "tick") {
+        tickCommand(argv.slice(1));
+        return;
+    }
+    if (command === "status") {
+        statusCommand(argv.slice(1));
+        return;
+    }
+    if (command === "approve") {
+        gateCommand("approve", argv.slice(1));
+        return;
+    }
+    if (command === "reject") {
+        gateCommand("reject", argv.slice(1));
+        return;
+    }
+    if (command === "serve") {
+        await serveCommand(argv.slice(1));
+        return;
+    }
+    usage();
+}
+try {
+    await main();
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+}

package/dist/config.js

@@ -0,0 +1,255 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { KilnConfigError } from "./errors.js";
+import { KilnConfigFileSchema } from "./schemas.js";
+const CONFIG_NAME = "kiln.config.json";
+const REPO_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function loadKilnConfig(configPath, options = {}) {
+    const home = options.home ?? homedir();
+    const resolvedPath = resolve(configPath);
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(resolvedPath, "utf8"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new KilnConfigError(`Could not read kiln config ${resolvedPath}: ${message}`);
+    }
+    const parsed = KilnConfigFileSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new KilnConfigError(`Kiln config ${resolvedPath} is invalid: ${parsed.error.message}`);
+    }
+    const configDir = dirname(resolvedPath);
+    const repos = {};
+    for (const [name, entry] of Object.entries(parsed.data.repos)) {
+        assertRepoName(name);
+        const checkout = resolveConfiguredPath(configDir, entry.path, home);
+        if (!existsSync(checkout) || !statSync(checkout).isDirectory()) {
+            throw new KilnConfigError(`Checkout for ${name} does not exist or is not a directory: ${checkout}. Set repos.${name}.path in the kiln config.`);
+        }
+        repos[name] = {
+            path: checkout,
+            ...(entry.test ? { test: entry.test } : {}),
+            deliver: entry.deliver ?? "local",
+            ...(entry.base ? { base: entry.base } : {}),
+        };
+    }
+    const kilnDir = configDir;
+    const jira = jiraFromFile(parsed.data.jira);
+    return {
+        configPath: resolvedPath,
+        configDir,
+        note: parsed.data.note,
+        repos,
+        kilnDir,
+        jobsDir: join(kilnDir, "jobs"),
+        maxConcurrent: parsed.data.maxConcurrent ?? 2,
+        adapter: parsed.data.adapter ?? "claude-code",
+        ...(jira ? { jira } : {}),
+    };
+}
+/**
+ * One kiln home: `--config <file>` if given, else `$KILN_HOME/kiln.config.json`
+ * when `KILN_HOME` is set, else `~/.kiln/kiln.config.json`.
+ */
+export function resolveKilnConfig(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    if (options.configPath) {
+        return loadKilnConfig(resolve(cwd, options.configPath), { cwd, home });
+    }
+    const configPath = defaultConfigPath(options);
+    assertNoStaleCwdConfig(cwd, configPath);
+    if (!existsSync(configPath)) {
+        throw new KilnConfigError([
+            "No kiln config found.",
+            `Run kiln repo add <name> <path> from any directory to create ${configPath}.`,
+            "Set KILN_HOME or pass --config <file> to use a different kiln home.",
+            "Do not commit checkout paths.",
+        ].join("\n"));
+    }
+    return loadKilnConfig(configPath, { cwd, home });
+}
+const BRANCH_NAME = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+/** Create or update one repo entry. Returns the text to print. */
+export function addRepo(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    assertRepoName(options.name);
+    if (options.test !== undefined && !options.test.trim()) {
+        throw new KilnConfigError("The test command is empty. Omit --test, or pass a command.");
+    }
+    if (options.base !== undefined)
+        assertBranchName(options.base);
+    const configPath = configPathForWrite(options);
+    const configDir = dirname(configPath);
+    const storedPath = pathToStore(options.repoPath, cwd, home);
+    const checkout = resolveConfiguredPath(configDir, storedPath, home);
+    if (!existsSync(checkout) || !statSync(checkout).isDirectory()) {
+        throw new KilnConfigError(`Checkout for ${options.name} does not exist or is not a directory: ${checkout}.`);
+    }
+    const raw = readConfigObject(configPath);
+    const repos = repoMap(raw);
+    const previous = repos[options.name];
+    const entry = { path: storedPath };
+    const previousTest = previousString(previous, "test");
+    const test = options.test ?? previousTest;
+    if (test)
+        entry.test = test;
+    const deliver = options.deliver ?? previousDeliver(previous);
+    if (deliver)
+        entry.deliver = deliver;
+    const base = options.base ?? previousString(previous, "base");
+    if (base)
+        entry.base = base;
+    repos[options.name] = entry;
+    raw.repos = repos;
+    const parsed = KilnConfigFileSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new KilnConfigError(`Kiln config ${configPath} is invalid: ${parsed.error.message}`);
+    }
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`);
+    const lines = [`added ${options.name}`, `path ${checkout}`];
+    if (entry.test)
+        lines.push(`test ${entry.test}`);
+    if (entry.deliver)
+        lines.push(`deliver ${entry.deliver}`);
+    if (entry.base)
+        lines.push(`base ${entry.base}`);
+    lines.push(`wrote ${configPath}`);
+    return `${lines.join("\n")}\n`;
+}
+export function renderRepoList(config) {
+    const names = Object.keys(config.repos).sort();
+    if (names.length === 0)
+        return "no repos\n";
+    const lines = names.map((name) => {
+        const repo = config.repos[name];
+        if (!repo)
+            return name;
+        const bits = [name, repo.path];
+        if (repo.test)
+            bits.push(`test ${repo.test}`);
+        if (repo.deliver === "pr")
+            bits.push("deliver pr");
+        if (repo.base)
+            bits.push(`base ${repo.base}`);
+        return bits.join("  ");
+    });
+    return `${lines.join("\n")}\n`;
+}
+export function assertBranchName(name) {
+    if (!BRANCH_NAME.test(name) || name.includes("..") || name.endsWith("/") || name.includes("//")) {
+        throw new KilnConfigError(`--base ${JSON.stringify(name)} must be a branch name (letters, digits, dots, underscores, hyphens, and slashes).`);
+    }
+}
+export function assertRepoName(name) {
+    if (!REPO_NAME.test(name)) {
+        throw new KilnConfigError(`Repo name ${JSON.stringify(name)} must start with a letter or digit and contain only letters, digits, dots, underscores, and hyphens.`);
+    }
+}
+function defaultConfigPath(options) {
+    return join(kilnHomeDirectory(options), CONFIG_NAME);
+}
+/** `$KILN_HOME` when set, otherwise `~/.kiln`. A relative `KILN_HOME` resolves from `cwd`. */
+function kilnHomeDirectory(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const fromEnv = process.env.KILN_HOME;
+    if (typeof fromEnv === "string" && fromEnv.trim().length > 0)
+        return resolve(cwd, fromEnv);
+    const home = options.home ?? homedir();
+    return join(home, ".kiln");
+}
+function configPathForWrite(options) {
+    const cwd = options.cwd ?? process.cwd();
+    if (options.configPath)
+        return resolve(cwd, options.configPath);
+    const configPath = defaultConfigPath(options);
+    assertNoStaleCwdConfig(cwd, configPath);
+    return configPath;
+}
+/**
+ * A leftover `./.kiln/kiln.config.json` used to be a second kiln home.
+ * Fail instead of ignoring it when the machine home has no config yet.
+ */
+function assertNoStaleCwdConfig(cwd, homeConfig) {
+    const cwdConfig = join(cwd, ".kiln", CONFIG_NAME);
+    if (!existsSync(cwdConfig))
+        return;
+    if (resolve(cwdConfig) === resolve(homeConfig))
+        return;
+    if (existsSync(homeConfig))
+        return;
+    throw new KilnConfigError(`Found ${cwdConfig} but no home config at ${homeConfig}. mv ./.kiln ~/.kiln or pass --config / set KILN_HOME.`);
+}
+function readConfigObject(configPath) {
+    if (!existsSync(configPath))
+        return { repos: {} };
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(configPath, "utf8"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new KilnConfigError(`Could not read kiln config ${configPath}: ${message}`);
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new KilnConfigError(`Kiln config ${configPath} must be a JSON object.`);
+    }
+    return raw;
+}
+function previousString(previous, key) {
+    if (typeof previous !== "object" || previous === null || !(key in previous))
+        return undefined;
+    const value = previous[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function previousDeliver(previous) {
+    const value = previousString(previous, "deliver");
+    if (value === "local" || value === "pr")
+        return value;
+    return undefined;
+}
+function repoMap(raw) {
+    const repos = raw.repos;
+    if (repos === undefined)
+        return {};
+    if (typeof repos !== "object" || repos === null || Array.isArray(repos)) {
+        throw new KilnConfigError("Kiln config repos must be an object.");
+    }
+    return repos;
+}
+export function resolveConfiguredPath(configDir, value, home) {
+    const expanded = expandHome(value, home);
+    return isAbsolute(expanded) ? expanded : resolve(configDir, expanded);
+}
+function pathToStore(userPath, cwd, home) {
+    if (userPath === "~" || userPath.startsWith("~/"))
+        return userPath;
+    if (isAbsolute(userPath))
+        return userPath;
+    return resolve(cwd, userPath);
+}
+function jiraFromFile(jira) {
+    if (!jira)
+        return undefined;
+    const baseUrl = jira.baseUrl?.trim();
+    const email = jira.email?.trim();
+    const apiToken = jira.apiToken?.trim();
+    if (!baseUrl && !email && !apiToken)
+        return undefined;
+    return {
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(email ? { email } : {}),
+        ...(apiToken ? { apiToken } : {}),
+    };
+}
+function expandHome(value, home) {
+    if (value === "~")
+        return home;
+    if (value.startsWith("~/"))
+        return join(home, value.slice(2));
+    return value;
+}