@cod3vil/trunk 0.1.1

package/dist/commands/new.js

@@ -0,0 +1,357 @@
+/**
+ * `trunk new <name> [dir]`: a project from nothing — a bare-layout repository,
+ * a first commit carrying `.config/wt.toml`, and optionally the GitHub
+ * repository behind it.
+ *
+ * The difference from clone and init is that there is no history to work from:
+ * the first worktree has to be created before any commit exists, and without a
+ * remote the generated config cannot use `remote_repo` at all.
+ */
+import { mkdir, readdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve as resolvePath } from 'node:path';
+import { compose } from '../core/generate/index.js';
+import { activeAccount, createRepository, deleteRepositoryCommand, listOwners, sshRemoteUrl, } from '../core/gh.js';
+import { addWorktree, commitPath, configureOriginFetch, runGit, setHeadBranch, } from '../core/git.js';
+import { confirmStep, createContext, errorMessage, finish, folderState, interrupted, outputOf, } from '../core/pipeline.js';
+import { loadSshAliases, parseRemote } from '../core/repo.js';
+import { setupFlagsFromCli } from '../core/resolve.js';
+import { badUsage, exitCodes } from '../core/result.js';
+import { validateGeneratedConfig } from '../core/validate.js';
+import { trunkVersion } from '../core/version.js';
+/** GitHub's rule for a repository name, checked before anything is created. */
+const validName = /^[\w.-]+$/;
+const gitignore = `node_modules/
+.env
+.env.*
+dist/
+build/
+.next/
+coverage/
+`;
+export async function runNew(arguments_, flags, tools, dependencies = {}) {
+    const [name, directory, ...extra] = arguments_;
+    if (!name) {
+        return badUsage('trunk new needs a project name');
+    }
+    if (extra.length > 0) {
+        return badUsage(`unexpected argument: ${extra[0]}`);
+    }
+    if (!validName.test(name)) {
+        return badUsage(`${name} is not a valid repository name; use letters, digits, dot, dash or underscore`);
+    }
+    const context = createContext(flags, tools, dependencies);
+    const projectDirectory = resolvePath(context.cwd, directory ?? name);
+    const emptiness = await folderState(projectDirectory);
+    if (emptiness === 'occupied') {
+        return badUsage(`${projectDirectory} already exists and is not empty; choose another folder`);
+    }
+    try {
+        return await create(context, { name, projectDirectory, emptiness });
+    }
+    catch (error) {
+        return interrupted(context, projectDirectory, errorMessage(error));
+    }
+}
+async function create(context, project) {
+    const { name, projectDirectory, emptiness } = project;
+    const gitDirectory = join(projectDirectory, '.git');
+    const branch = 'main';
+    const remote = await decideRemote(context, name, projectDirectory);
+    if (remote.kind === 'aborted') {
+        return interrupted(context, projectDirectory, 'aborted');
+    }
+    if (emptiness === 'missing') {
+        context.journal.record({ kind: 'folder', path: projectDirectory });
+    }
+    context.journal.record({ kind: 'bare-repo', path: gitDirectory });
+    await mkdir(projectDirectory, { recursive: true });
+    const initialised = await runGit(['init', '--bare', gitDirectory], context.git);
+    if (initialised.code !== 0) {
+        return interrupted(context, projectDirectory, 'git init --bare failed');
+    }
+    await setHeadBranch(gitDirectory, branch, context.git);
+    if (remote.kind === 'remote') {
+        const failure = await setUpRemote(context, remote, name, gitDirectory);
+        if (failure) {
+            return interrupted(context, projectDirectory, failure);
+        }
+    }
+    // A bare repository has no commits, so the first worktree starts an orphan
+    // branch rather than checking one out.
+    const worktree = join(projectDirectory, branch);
+    context.journal.record({ kind: 'worktree', path: worktree, branch });
+    const added = await addOrphanWorktree(context, gitDirectory, worktree, branch);
+    if (!added) {
+        return interrupted(context, projectDirectory, `could not create the ${branch} worktree`);
+    }
+    // No lockfile exists yet, so nothing can be detected; the form asks instead.
+    const collected = await context.collect({
+        folder: worktree,
+        resolveOptions: {
+            fixed: {
+                trunkVersion: trunkVersion(),
+                generatedOn: today(context.now()),
+                repoName: name,
+                hostLabel: name.toLowerCase(),
+            },
+            flags: setupFlagsFromCli(context.flags),
+            tools: context.tools,
+        },
+        invocation: context.invocation,
+        yes: context.flags.yes ?? false,
+        interactive: context.interactive,
+    });
+    if (collected.kind === 'outcome') {
+        return collected.outcome.code === exitCodes.userAborted
+            ? interrupted(context, projectDirectory, 'aborted')
+            : collected.outcome;
+    }
+    const settings = {
+        ...collected.settings,
+        noRemote: remote.kind !== 'remote',
+    };
+    await writeProjectFiles(worktree, settings);
+    context.report('success', 'wrote .config/wt.toml and .gitignore');
+    try {
+        const validation = await validateGeneratedConfig(worktree, settings, {
+            wtPath: context.wtPath,
+            env: context.env,
+        });
+        for (const [label, value] of [
+            ['session', validation.preview.session],
+            ['port', validation.preview.port],
+            ['url', validation.preview.url],
+        ]) {
+            if (value !== undefined) {
+                context.report('info', `${label} ${value}`);
+            }
+        }
+    }
+    catch (error) {
+        return interrupted(context, projectDirectory, errorMessage(error));
+    }
+    // The whole repository is new, so there is no setup branch to review: the
+    // first commit is the setup.
+    const committed = await commitAll(context, worktree);
+    if (committed) {
+        return interrupted(context, projectDirectory, committed);
+    }
+    context.journal.annotate(worktree, 'first commit');
+    context.report('success', 'committed the first commit');
+    if (remote.kind === 'remote') {
+        const pushed = await context.run(context.git.gitPath ?? 'git', ['-C', worktree, 'push', '-u', 'origin', branch], { env: context.env });
+        context.report(pushed.code === 0 ? 'success' : 'warning', pushed.code === 0
+            ? `pushed ${branch} to ${remote.url}`
+            : `push failed: ${pushed.stderr.trim() || pushed.stdout.trim()}`);
+    }
+    context.report('info', 'nothing to install yet; add dependencies first');
+    return finish(context, projectDirectory, worktree, branch);
+}
+/**
+ * Whether to create the GitHub repository, and under which account. `--yes`
+ * alone only says yes when gh can actually answer for an account, so a scripted
+ * run on a machine without gh quietly stays local instead of failing.
+ */
+async function decideRemote(context, name, projectDirectory) {
+    const ghPath = context.tools.gh.path;
+    const wanted = context.flags.remote;
+    if (wanted === false || !ghPath) {
+        if (wanted === true && !ghPath) {
+            context.report('warning', 'gh is not installed; creating a local repo');
+        }
+        return { kind: 'none' };
+    }
+    const account = await activeAccount({
+        ghPath,
+        run: context.run,
+        env: context.env,
+    });
+    if (!account) {
+        if (wanted === true) {
+            context.report('warning', 'gh is not signed in; run `gh auth login`, or `gh auth switch` to pick an account');
+        }
+        return { kind: 'none' };
+    }
+    if (wanted !== true) {
+        const answer = await confirmStep(context, `create the GitHub repository as ${account}?`);
+        if (answer === undefined) {
+            return { kind: 'aborted' };
+        }
+        if (!answer) {
+            return { kind: 'none' };
+        }
+    }
+    const owner = await chooseOwner(context, account);
+    if (!owner) {
+        return { kind: 'aborted' };
+    }
+    const aliases = await loadSshAliases(join(context.env?.['HOME'] ?? context.env?.['USERPROFILE'] ?? homedir(), '.ssh', 'config'));
+    const url = sshRemoteUrl(owner, name, {
+        realHost: 'github.com',
+        aliases,
+        siblingHosts: await siblingHosts(context, projectDirectory),
+    });
+    context.report('info', `remote will be ${url}`);
+    return {
+        kind: 'remote',
+        owner,
+        url,
+        visibility: context.flags.public ? 'public' : 'private',
+    };
+}
+async function chooseOwner(context, account) {
+    const flagged = context.flags.owner;
+    if (flagged) {
+        return flagged;
+    }
+    if (!context.interactive || (context.flags.yes ?? false)) {
+        return account;
+    }
+    const owners = await listOwners({
+        ghPath: context.tools.gh.path,
+        run: context.run,
+        env: context.env,
+    });
+    if (owners.length < 2) {
+        return account;
+    }
+    const answer = await context.prompts?.choose('which account should own the repository?', owners.map(owner => owner.login));
+    return answer ?? account;
+}
+/**
+ * The ssh hosts sibling projects already use. A folder full of projects reached
+ * through one alias is the best evidence of which account this one belongs to.
+ */
+async function siblingHosts(context, projectDirectory) {
+    const parent = dirname(projectDirectory);
+    let entries;
+    try {
+        entries = await readdir(parent, { withFileTypes: true });
+    }
+    catch {
+        return Object.freeze([]);
+    }
+    const hosts = await Promise.all(entries
+        .filter(entry => entry.isDirectory())
+        .map(async (entry) => {
+        const sibling = join(parent, entry.name);
+        if (sibling === projectDirectory) {
+            return undefined;
+        }
+        const listed = await context.run(context.git.gitPath ?? 'git', ['-C', sibling, 'config', '--get', 'remote.origin.url'], { env: context.env });
+        if (listed.code !== 0 || !listed.stdout.trim()) {
+            return undefined;
+        }
+        try {
+            const remote = parseRemote(listed.stdout.trim(), {}, sibling);
+            return remote.kind === 'hosted' ? remote.host : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }));
+    return Object.freeze([
+        ...new Set(hosts.filter((host) => host !== undefined)),
+    ]);
+}
+async function createRemote(context, remote, name) {
+    const result = await createRepository(remote.owner, name, {
+        ghPath: context.tools.gh.path,
+        run: context.run,
+        env: context.env,
+        visibility: remote.visibility,
+    });
+    if (result.code === 0) {
+        context.journal.record({
+            kind: 'github-repo',
+            path: `${remote.owner}/${name}`,
+            note: 'trunk will not delete it',
+        });
+        context.report('success', `created ${remote.owner}/${name} on GitHub`);
+        context.report('info', `trunk will not delete it; to undo: ${deleteRepositoryCommand(remote.owner, name)}`);
+        return undefined;
+    }
+    return `gh repo create failed: ${result.stderr.trim() || result.stdout.trim()}. Check the active account or run \`gh auth switch\``;
+}
+async function setUpRemote(context, remote, name, gitDirectory) {
+    const created = await createRemote(context, remote, name);
+    if (created) {
+        return created;
+    }
+    const origin = await runGit(['--git-dir', gitDirectory, 'remote', 'add', 'origin', remote.url], context.git);
+    if (origin.code !== 0) {
+        return `could not add origin: ${outputOf(origin)}`;
+    }
+    const configured = await configureOriginFetch(gitDirectory, context.git);
+    return configured.code === 0
+        ? undefined
+        : `could not configure origin: ${outputOf(configured)}`;
+}
+/**
+ * `--orphan` starts a branch with no history, which is what an empty bare
+ * repository needs. It arrived in git 2.42, so older versions get an empty root
+ * commit instead rather than a failure.
+ */
+async function addOrphanWorktree(context, gitDirectory, worktree, branch) {
+    const orphan = await runGit([
+        '--git-dir',
+        gitDirectory,
+        'worktree',
+        'add',
+        '--orphan',
+        '-b',
+        branch,
+        worktree,
+    ], context.git);
+    if (orphan.code === 0) {
+        return true;
+    }
+    const tree = await runGit(['--git-dir', gitDirectory, 'hash-object', '-t', 'tree', '/dev/null'], context.git);
+    if (tree.code !== 0) {
+        return false;
+    }
+    const commit = await runGit([
+        '--git-dir',
+        gitDirectory,
+        'commit-tree',
+        tree.stdout.trim(),
+        '-m',
+        'Initial commit',
+    ], context.git);
+    if (commit.code !== 0) {
+        return false;
+    }
+    const pointed = await runGit([
+        '--git-dir',
+        gitDirectory,
+        'update-ref',
+        `refs/heads/${branch}`,
+        commit.stdout.trim(),
+    ], context.git);
+    if (pointed.code !== 0) {
+        return false;
+    }
+    const added = await addWorktree(gitDirectory, worktree, branch, context.git);
+    return added.code === 0;
+}
+async function writeProjectFiles(worktree, settings) {
+    await mkdir(join(worktree, '.config'), { recursive: true });
+    await Promise.all([
+        writeFile(join(worktree, '.config', 'wt.toml'), compose(settings)),
+        writeFile(join(worktree, '.gitignore'), gitignore),
+    ]);
+}
+async function commitAll(context, worktree) {
+    const staged = await runGit(['-C', worktree, 'add', '--', '.config/wt.toml', '.gitignore'], context.git);
+    if (staged.code !== 0) {
+        return `could not stage the first commit: ${staged.stderr.trim()}`;
+    }
+    const committed = await commitPath(worktree, '.', 'Initial commit', context.git);
+    return committed.code === 0
+        ? undefined
+        : `commit failed: ${committed.stderr.trim() || committed.stdout.trim()}`;
+}
+function today(date) {
+    return date.toISOString().slice(0, 10);
+}

package/dist/core/adopt.d.ts

@@ -0,0 +1,14 @@
+import type { SetupValues } from './resolve.js';
+export type AdoptionNote = Readonly<{
+    field?: keyof SetupValues;
+    message: string;
+}>;
+export type Adoption = Readonly<{
+    values: Partial<SetupValues>;
+    /** `[step.copy-ignored] exclude`, carried over rather than regenerated. */
+    copyIgnoredExclude?: readonly string[];
+    /** What could not be read, for the report before the diff. */
+    notes: readonly AdoptionNote[];
+}>;
+/** Values recovered from an existing config, plus what could not be recovered. */
+export declare function adoptConfig(source: string): Adoption;

package/dist/core/adopt.js

@@ -0,0 +1,157 @@
+/**
+ * Reads what it can out of a `wt.toml` that already exists, so overwriting a
+ * configured repository starts from that repository's own choices instead of
+ * from trunk's defaults.
+ *
+ * Adoption is best-effort by design: a file trunk cannot parse, or a value it
+ * does not recognise, is simply not adopted. Nothing here ever fails a run —
+ * the caller falls back to detection and says so.
+ */
+import * as TOML from '@iarna/toml';
+import { isAgentId, maximumAgents } from './agents.js';
+const packageManagers = ['bun', 'pnpm', 'npm'];
+/** Values recovered from an existing config, plus what could not be recovered. */
+export function adoptConfig(source) {
+    const notes = [];
+    let document;
+    try {
+        document = TOML.parse(source);
+    }
+    catch (error) {
+        return Object.freeze({
+            values: Object.freeze({}),
+            notes: Object.freeze([
+                Object.freeze({
+                    message: `the existing config could not be parsed, so nothing was adopted: ${error instanceof Error ? error.message : String(error)}`,
+                }),
+            ]),
+        });
+    }
+    const hooks = collectCommands(document);
+    const values = {};
+    const tmuxBody = hooks.get('pre-start:tmux');
+    values.tmux = tmuxBody !== undefined;
+    if (tmuxBody) {
+        const prefix = readPrefix(tmuxBody);
+        if (prefix) {
+            values.prefix = prefix;
+        }
+        else {
+            notes.push({ field: 'prefix', message: 'could not read the tmux prefix' });
+        }
+        values.agents = readAgents(tmuxBody, notes);
+    }
+    const install = hooks.get('post-start:install');
+    const packageManager = install ? readPackageManager(install) : undefined;
+    if (packageManager) {
+        values.pm = packageManager;
+    }
+    else if (install) {
+        notes.push({
+            field: 'pm',
+            message: `could not tell which package manager ${JSON.stringify(install)} uses`,
+        });
+    }
+    values.copyIgnored = hooks.has('post-start:copy');
+    values.server = hooks.has('post-start:server');
+    values.caddy = hooks.has('post-start:proxy');
+    values.mcAlias = hooks.has('alias:mc');
+    const excludes = readExcludes(document);
+    return Object.freeze({
+        values: Object.freeze(values),
+        copyIgnoredExclude: excludes,
+        notes: Object.freeze(notes),
+    });
+}
+/** `P=<prefix>` in the tmux hook, with or without shell quoting. */
+function readPrefix(body) {
+    const match = /^P=(.+)$/m.exec(body);
+    if (!match) {
+        return undefined;
+    }
+    return unquote(match[1].trim()) || undefined;
+}
+/** The default list in `for a in ${WT_AGENTS-claude codex}`. */
+function readAgents(body, notes) {
+    const match = /\${WT_AGENTS-([^}]*)}/.exec(body);
+    if (!match) {
+        return Object.freeze([]);
+    }
+    const found = [];
+    for (const name of match[1].trim().split(/\s+/).filter(Boolean)) {
+        if (isAgentId(name)) {
+            found.push(name);
+        }
+        else {
+            notes.push({ field: 'agents', message: `unknown agent ${name}, skipped` });
+        }
+    }
+    if (found.length > maximumAgents) {
+        notes.push({
+            field: 'agents',
+            message: `the existing config starts ${found.length} agents; keeping the first ${maximumAgents}`,
+        });
+    }
+    return Object.freeze(found.slice(0, maximumAgents));
+}
+/**
+ * The install command names its package manager. Matched on a word boundary so
+ * a path such as `./node_modules/.bin/npm` does not turn pnpm into npm.
+ */
+function readPackageManager(command) {
+    return packageManagers.find(name => new RegExp(String.raw `(?:^|[\s/])${name}(?:\s|$)`).test(command));
+}
+function readExcludes(document) {
+    const { step } = document;
+    if (typeof step !== 'object' || step === null) {
+        return undefined;
+    }
+    const { 'copy-ignored': copyIgnored } = step;
+    if (typeof copyIgnored !== 'object' || copyIgnored === null) {
+        return undefined;
+    }
+    const { exclude } = copyIgnored;
+    if (!Array.isArray(exclude)) {
+        return undefined;
+    }
+    const values = exclude.filter((value) => typeof value === 'string');
+    return values.length > 0 ? Object.freeze(values) : undefined;
+}
+/**
+ * Every command body in the file, keyed `<table>:<name>`, so the presence of a
+ * step and the text of its command are one lookup.
+ */
+function collectCommands(document) {
+    const commands = new Map();
+    for (const table of ['pre-start', 'post-start', 'pre-remove']) {
+        for (const [name, body] of tableEntries(document[table])) {
+            commands.set(`${table}:${name}`, body);
+        }
+    }
+    for (const [name, body] of tableEntries(document['aliases'])) {
+        commands.set(`alias:${name}`, body);
+    }
+    return commands;
+}
+function tableEntries(value) {
+    const tables = Array.isArray(value) ? value : [value];
+    const entries = [];
+    for (const table of tables) {
+        if (typeof table !== 'object' || table === null) {
+            continue;
+        }
+        for (const [name, body] of Object.entries(table)) {
+            if (typeof body === 'string') {
+                entries.push([name, body]);
+            }
+        }
+    }
+    return entries;
+}
+function unquote(value) {
+    if ((value.startsWith("'") && value.endsWith("'")) ||
+        (value.startsWith('"') && value.endsWith('"'))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}

package/dist/core/agents.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The coding agents trunk knows how to start, and the commands that start them.
+ *
+ * This is deliberately a module of its own with no imports: both the tool probe
+ * and the wt.toml generator need it, and the generator has no business pulling
+ * in the filesystem and process machinery the probe depends on.
+ */
+/**
+ * Agent id as the user writes it in `--agents` and `WT_AGENTS`, mapped to the
+ * command that starts it. Most match; antigravity ships as `agy`. Keep this the
+ * only place that knows the difference.
+ */
+export declare const agentCommands: Readonly<{
+    claude: "claude";
+    codex: "codex";
+    opencode: "opencode";
+    copilot: "copilot";
+    antigravity: "agy";
+    pi: "pi";
+}>;
+export type AgentId = keyof typeof agentCommands;
+/** Every id, in the order they are offered and started. */
+export declare const agentIds: readonly AgentId[];
+/**
+ * How many agents a worktree starts at once. Beyond this the tmux panes are too
+ * small to be useful, so the generated hook stops and says so.
+ */
+export declare const maximumAgents = 4;
+/** Narrows an arbitrary string, for reading `--agents` and config files. */
+export declare function isAgentId(value: string): value is AgentId;

package/dist/core/agents.js

@@ -0,0 +1,31 @@
+/**
+ * The coding agents trunk knows how to start, and the commands that start them.
+ *
+ * This is deliberately a module of its own with no imports: both the tool probe
+ * and the wt.toml generator need it, and the generator has no business pulling
+ * in the filesystem and process machinery the probe depends on.
+ */
+/**
+ * Agent id as the user writes it in `--agents` and `WT_AGENTS`, mapped to the
+ * command that starts it. Most match; antigravity ships as `agy`. Keep this the
+ * only place that knows the difference.
+ */
+export const agentCommands = Object.freeze({
+    claude: 'claude',
+    codex: 'codex',
+    opencode: 'opencode',
+    copilot: 'copilot',
+    antigravity: 'agy',
+    pi: 'pi',
+});
+/** Every id, in the order they are offered and started. */
+export const agentIds = Object.freeze(Object.keys(agentCommands));
+/**
+ * How many agents a worktree starts at once. Beyond this the tmux panes are too
+ * small to be useful, so the generated hook stops and says so.
+ */
+export const maximumAgents = 4;
+/** Narrows an arbitrary string, for reading `--agents` and config files. */
+export function isAgentId(value) {
+    return Object.hasOwn(agentCommands, value);
+}

package/dist/core/arguments.d.ts

@@ -0,0 +1,92 @@
+import { type TypedFlags } from 'meow';
+/** Printed for `trunk` with no command and for `--help`. */
+export declare const helpText = "\n\tUsage\n\t  $ trunk clone <url> [dir]   set up a bare-layout project from a remote\n\t  $ trunk init [dir]          set up an existing bare-layout project\n\t  $ trunk new <name>          create a new project (optionally on GitHub)\n\n\tOptions\n\t  --yes                 accept detected defaults, no form (needed without a TTY)\n\t  --prefix <name>       tmux session prefix\n\t  --pm <npm|pnpm|bun>   package manager\n\t  --agents <a,b>        up to 4 of claude,codex,opencode,copilot,antigravity,pi\n\t  --server/--no-server  dev server step\n\t  --caddy/--no-caddy    Caddy route step\n\t  --tmux/--no-tmux      tmux session hooks\n\t  --copy/--no-copy      wt step copy-ignored\n\t  --mc/--no-mc          `wt mc` alias\n\t  --direct              commit on the current branch instead of chore/trunk-setup\n\n\tOptions for `trunk new`\n\t  --remote/--no-remote  create the GitHub repository too\n\t  --owner <name>        account or organisation that owns it\n\t  --public              create it public instead of private\n";
+/**
+ * Every flag is declared here even when a later phase is what reads it, so that
+ * an unknown flag is always an error rather than silently ignored.
+ */
+export declare const flagDefinitions: {
+    readonly yes: {
+        readonly type: "boolean";
+    };
+    readonly prefix: {
+        readonly type: "string";
+    };
+    readonly pm: {
+        readonly type: "string";
+    };
+    readonly agents: {
+        readonly type: "string";
+    };
+    readonly server: {
+        readonly type: "boolean";
+    };
+    readonly caddy: {
+        readonly type: "boolean";
+    };
+    readonly tmux: {
+        readonly type: "boolean";
+    };
+    readonly copyIgnored: {
+        readonly type: "boolean";
+        readonly alias: "copy";
+    };
+    readonly mc: {
+        readonly type: "boolean";
+    };
+    readonly direct: {
+        readonly type: "boolean";
+    };
+    readonly remote: {
+        readonly type: "boolean";
+    };
+    readonly owner: {
+        readonly type: "string";
+    };
+    readonly public: {
+        readonly type: "boolean";
+    };
+};
+export type CliFlags = TypedFlags<typeof flagDefinitions>;
+export declare function parseArguments(argv?: readonly string[]): import("meow").Result<{
+    readonly yes: {
+        readonly type: "boolean";
+    };
+    readonly prefix: {
+        readonly type: "string";
+    };
+    readonly pm: {
+        readonly type: "string";
+    };
+    readonly agents: {
+        readonly type: "string";
+    };
+    readonly server: {
+        readonly type: "boolean";
+    };
+    readonly caddy: {
+        readonly type: "boolean";
+    };
+    readonly tmux: {
+        readonly type: "boolean";
+    };
+    readonly copyIgnored: {
+        readonly type: "boolean";
+        readonly alias: "copy";
+    };
+    readonly mc: {
+        readonly type: "boolean";
+    };
+    readonly direct: {
+        readonly type: "boolean";
+    };
+    readonly remote: {
+        readonly type: "boolean";
+    };
+    readonly owner: {
+        readonly type: "string";
+    };
+    readonly public: {
+        readonly type: "boolean";
+    };
+}>;