@fuzdev/fuz_gitops 0.78.1 → 0.79.0

package/src/lib/operations.ts

@@ -2,7 +2,8 @@
  * Operations interfaces for dependency injection.
  *
  * This is the core pattern enabling testability without mocks.
- * All side effects (git, npm, fs, process) are abstracted into interfaces.
+ * All side effects (git, npm, fs, process, build, and the `repos` binary) are
+ * abstracted into interfaces.
  *
  * **Design principles:**
  * - All operations accept a single `options` object parameter
@@ -13,23 +14,30 @@
  *
  * **Production usage:**
  * ```typescript
- * import {default_gitops_operations} from './operations_defaults.js';
- * const result = await ops.git.current_branch_name({cwd: '/path'});
+ * import {default_gitops_operations} from './operations_defaults.ts';
+ * const ops = default_gitops_operations;
+ * const result = await ops.git.current_commit_hash({cwd: '/path'});
  * if (!result.ok) {
  *   throw new TaskError(result.message);
  * }
- * const branch = result.value;
+ * const commit = result.value;
  * ```
  *
  * **Test usage:**
  * ```typescript
- * const mock_ops = create_mock_operations();
- * const result = await publish_repos(repos, {...options, ops: mock_ops});
+ * import {create_mock_gitops_ops} from './test_helpers.ts';
+ * const ops = create_mock_gitops_ops({
+ *   changeset: {has_changesets: async () => ({ok: true, value: false})}
+ * });
+ * const result = await publish_repos(repos, {...options, ops});
  * // Assert on result without any real git/npm calls
  * ```
  *
- * See `operations_defaults.ts` for real implementations.
- * See test files (`*.test.ts`) for mock implementations.
+ * See `operations_defaults.ts` for real implementations, and the test-side mock
+ * factories: `create_mock_gitops_ops` in `src/test/test_helpers.ts` (plain
+ * objects with per-group overrides) and `create_fixture_gitops_ops` in
+ * `src/test/fixtures/mock_operations.ts` (a fixture's changesets over
+ * `create_mock_gitops_ops`, its fs empty).
  *
  * @module
  */
@@ -40,7 +48,7 @@ import type { Logger } from '@fuzdev/fuz_util/log.ts';
 import type { LocalRepo } from './local_repo.ts';
 import type { ChangesetInfo } from './changeset_reader.ts';
 import type { BumpType } from './version_utils.ts';
-import type { PreflightOptions, PreflightResult } from './preflight_checks.ts';
+import type { PreflightResult, RunPreflightChecksOptions } from './preflight_checks.ts';
 import type { WaitOptions } from './npm_registry.ts';
 
 /**
@@ -76,66 +84,19 @@ export interface ChangesetOperations {
 }
 
 /**
- * Git operations for branch management, commits, tags, and workspace state.
- * All operations return `Result` instead of throwing errors.
+ * Git operations the publishing executor authors with: staging and committing
+ * dependency updates and auto-changesets, and reading the commit it published.
+ * All operations return `Result` instead of throwing errors. Where each repo
+ * sits (branch, dirt, relation to origin) is `ReposOperations`'s to report.
  */
 export interface GitOperations {
-	/**
-	 * Gets the current branch name.
-	 */
-	current_branch_name: (options?: {
-		cwd?: string;
-	}) => Promise<Result<{ value: string }, { message: string }>>;
-
 	/**
 	 * Gets the current commit hash.
 	 */
 	current_commit_hash: (options?: {
-		branch?: string;
 		cwd?: string;
 	}) => Promise<Result<{ value: string }, { message: string }>>;
 
-	/**
-	 * Checks if the workspace is clean (no uncommitted changes).
-	 */
-	check_clean_workspace: (options?: {
-		cwd?: string;
-	}) => Promise<Result<{ value: boolean }, { message: string }>>;
-
-	/**
-	 * Checks out a branch.
-	 */
-	checkout: (options: {
-		branch: string;
-		cwd?: string;
-	}) => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Pulls changes from remote.
-	 */
-	pull: (options?: {
-		origin?: string;
-		branch?: string;
-		cwd?: string;
-	}) => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Switches to a branch, optionally pulling.
-	 */
-	switch_branch: (options: {
-		branch: string;
-		pull?: boolean;
-		cwd?: string;
-	}) => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Checks if a remote exists.
-	 */
-	has_remote: (options?: {
-		remote?: string;
-		cwd?: string;
-	}) => Promise<Result<{ value: boolean }, { message: string }>>;
-
 	/**
 	 * Stages files for commit.
 	 */
@@ -145,93 +106,72 @@ export interface GitOperations {
 	}) => Promise<Result<object, { message: string }>>;
 
 	/**
-	 * Creates a commit.
+	 * Commits `files` alone (`git commit -- <files>`), leaving anything else
+	 * staged out of the commit; `files` must be non-empty.
 	 */
 	commit: (options: {
 		message: string;
+		files: Array<string>;
 		cwd?: string;
 	}) => Promise<Result<object, { message: string }>>;
+}
 
+/**
+ * Process operations for the commands the publishing executor runs in a repo
+ * (`gro publish`, `gro deploy`).
+ */
+export interface ProcessOperations {
 	/**
-	 * Stages files and creates a commit.
-	 */
-	add_and_commit: (options: {
-		files: string | Array<string>;
-		message: string;
-		cwd?: string;
-	}) => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Checks whether the working tree has any changes — staged, unstaged, or
-	 * untracked (`git status --porcelain`). Broader than `list_uncommitted_files`,
-	 * which reports only tracked working-tree changes relative to HEAD.
-	 */
-	has_changes: (options?: {
-		cwd?: string;
-	}) => Promise<Result<{ value: boolean }, { message: string }>>;
-
-	/**
-	 * Lists uncommitted files in the working tree (`git diff --name-only HEAD`),
-	 * i.e. working-tree changes relative to HEAD (not a diff between two refs).
-	 */
-	list_uncommitted_files: (options?: {
-		cwd?: string;
-	}) => Promise<Result<{ value: Array<string> }, { message: string }>>;
-
-	/**
-	 * Creates a git tag.
-	 */
-	tag: (options: {
-		tag_name: string;
-		message?: string;
-		cwd?: string;
-	}) => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Pushes a tag to remote.
-	 */
-	push_tag: (options: {
-		tag_name: string;
-		origin?: string;
-		cwd?: string;
-	}) => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Stashes uncommitted changes.
+	 * Runs a command in the foreground and waits for it to exit: stdin is the
+	 * terminal's, so a prompt (npm's 2FA one-time password) can be answered, and
+	 * the child's output shows live — its stdout on ours, or on our stderr when
+	 * `stdout` says so, and its stderr on ours. A failure carries the end of
+	 * what the child wrote to stderr, bounded in lines and characters.
 	 */
-	stash: (options?: {
-		message?: string;
+	run_interactive: (options: {
+		cmd: string;
+		args: Array<string>;
 		cwd?: string;
-	}) => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Pops the most recent stash.
-	 */
-	stash_pop: (options?: { cwd?: string }) => Promise<Result<object, { message: string }>>;
+		/**
+		 * Where the child's stdout goes: our stdout, or our stderr when our stdout
+		 * carries a machine-readable stream (JSON-lines events, a JSON or markdown
+		 * report) the child's output would corrupt.
+		 *
+		 * @default 'stdout'
+		 */
+		stdout?: 'stdout' | 'stderr';
+	}) => Promise<Result<object, { message: string; stderr_tail?: string }>>;
+}
 
-	/**
-	 * Checks if a specific file changed between two commits.
-	 */
-	has_file_changed: (options: {
-		from_commit: string;
-		to_commit: string;
-		file_path: string;
-		cwd?: string;
-	}) => Promise<Result<{ value: boolean }, { message: string }>>;
+/**
+ * What a `repos` command printed and how it exited, unparsed.
+ */
+export interface ReposCommandOutput {
+	stdout: string;
+	stderr: string;
+	/** `0` for a report, `2` for an error document, `1` for a fatal I/O error (maybe no JSON). */
+	exit_code: number;
 }
 
 /**
- * Process spawning operations for running shell commands.
+ * Operations running the Rust `repos` binary, which owns fleet git state.
+ * Parsing its output is `repos_status_load.ts`'s, not the runner's.
  */
-export interface ProcessOperations {
+export interface ReposOperations {
 	/**
-	 * Spawns a child process and waits for completion.
+	 * Runs `repos [--registry <path>] status [--fetch] <keys…> --json` in the
+	 * process's cwd and returns what it printed, whatever its exit code. With
+	 * `fetch`, `repos` fetches each entry from origin first, which writes
+	 * remote-tracking refs and nothing else. Fails only when the binary didn't
+	 * run to an exit: `not_found` when it isn't on `PATH`.
 	 */
-	spawn: (options: {
-		cmd: string;
-		args: Array<string>;
-		cwd?: string;
-	}) => Promise<Result<{ stdout?: string; stderr?: string }, { message: string; stderr?: string }>>;
+	status: (options: {
+		keys: Array<string>;
+		registry?: string;
+		fetch?: boolean;
+	}) => Promise<
+		Result<{ output: ReposCommandOutput }, { kind: 'not_found' | 'failed'; message: string }>
+	>;
 }
 
 /**
@@ -243,7 +183,6 @@ export interface BuildOperations {
 	 */
 	build_package: (options: {
 		repo: LocalRepo;
-		log?: Logger;
 	}) => Promise<Result<object, { message: string; output?: string }>>;
 }
 
@@ -261,7 +200,7 @@ export interface NpmOperations {
 		version: string;
 		wait_options?: WaitOptions;
 		log?: Logger;
-	}) => Promise<Result<object, { message: string; timeout?: boolean }>>;
+	}) => Promise<Result<object, { message: string }>>;
 
 	/**
 	 * Checks npm authentication status.
@@ -272,31 +211,18 @@ export interface NpmOperations {
 	 * Checks if npm registry is reachable.
 	 */
 	check_registry: () => Promise<Result<object, { message: string }>>;
-
-	/**
-	 * Installs npm dependencies.
-	 */
-	install: (options?: {
-		cwd?: string;
-	}) => Promise<Result<object, { message: string; stderr?: string }>>;
 }
 
 /**
- * Preflight validation operations to ensure repos are ready for publishing.
- * Validates workspace state, branches, builds, and npm authentication.
+ * Preflight validation operations run before publishing: building every
+ * package the plan publishes, and npm authentication. Repo git state is the
+ * readiness gate's, before preflight (see `repo_readiness.ts`).
  */
 export interface PreflightOperations {
 	/**
 	 * Runs preflight validation checks before publishing.
 	 */
-	run_preflight_checks: (options: {
-		repos: Array<LocalRepo>;
-		preflight_options: PreflightOptions;
-		git_ops?: GitOperations;
-		npm_ops?: NpmOperations;
-		build_ops?: BuildOperations;
-		changeset_ops?: ChangesetOperations;
-	}) => Promise<PreflightResult>;
+	run_preflight_checks: (options: RunPreflightChecksOptions) => Promise<PreflightResult>;
 }
 
 /**
@@ -343,4 +269,6 @@ export interface GitopsOperations {
 	preflight: PreflightOperations;
 	fs: FsOperations;
 	build: BuildOperations;
+	/** `repos status`, for the executor's re-check of each repo right before its publish. */
+	repos: ReposOperations;
 }

package/src/lib/operations_defaults.ts

@@ -1,38 +1,22 @@
 /**
  * Production implementations of operations interfaces.
  *
- * Provides real git, npm, fs, and build operations for production use.
+ * Provides real git, npm, fs, build, and `repos` operations for production use.
  * For interface definitions and dependency injection pattern, see `operations.ts`.
  *
  * @module
  */
 
-import { spawn_out } from '@fuzdev/fuz_util/process.ts';
+import { spawn_out, spawn_process, spawn_result_to_message } from '@fuzdev/fuz_util/process.ts';
 import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
-import { git_checkout, type GitBranch, type GitOrigin } from '@fuzdev/fuz_util/git.ts';
+import { stripVTControlCharacters } from 'node:util';
 import { fs_classify_error } from '@fuzdev/fuz_util/fs.ts';
 import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.ts';
 
 import { has_changesets, read_changesets, predict_next_version } from './changeset_reader.ts';
 import { wait_for_package } from './npm_registry.ts';
 import { run_preflight_checks } from './preflight_checks.ts';
-import {
-	git_add,
-	git_commit,
-	git_add_and_commit,
-	git_tag,
-	git_push_tag,
-	git_has_changes,
-	git_list_uncommitted_files,
-	git_has_file_changed,
-	git_stash,
-	git_stash_pop,
-	git_switch_branch,
-	git_current_branch_name_required,
-	git_current_commit_hash_required,
-	git_check_clean_workspace_as_boolean,
-	git_has_remote
-} from './git_operations.ts';
+import { git_add, git_commit, git_current_commit_hash_required } from './git_operations.ts';
 import type {
 	ChangesetOperations,
 	GitOperations,
@@ -41,7 +25,8 @@ import type {
 	PreflightOperations,
 	FsOperations,
 	BuildOperations,
-	GitopsOperations
+	GitopsOperations,
+	ReposOperations
 } from './operations.ts';
 
 /** Wrap an async function that returns a value */
@@ -94,141 +79,120 @@ export const default_changeset_operations: ChangesetOperations = {
 };
 
 export const default_git_operations: GitOperations = {
-	// Core git info
-	current_branch_name: async (options) => {
-		const { cwd } = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_current_branch_name_required(cwd ? { cwd } : undefined));
-	},
-
 	current_commit_hash: async (options) => {
-		const { branch, cwd } = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() =>
-			git_current_commit_hash_required(branch, cwd ? { cwd } : undefined)
-		);
-	},
-
-	check_clean_workspace: async (options) => {
 		const { cwd } = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_check_clean_workspace_as_boolean(cwd ? { cwd } : undefined));
-	},
-
-	// Branch operations
-	checkout: async (options) => {
-		const { branch, cwd } = options;
-		return wrap_void(() => git_checkout(branch, cwd ? { cwd } : undefined));
-	},
-
-	pull: async (options) => {
-		const { origin, branch, cwd } = options ?? EMPTY_OBJECT;
-		try {
-			// Omit the branch arg when absent: a trailing `''` makes git pull the remote's
-			// default branch (origin/HEAD) instead of the current branch's upstream.
-			const spawned = await spawn_out(
-				'git',
-				['pull', origin || 'origin', ...(branch ? [branch] : [])],
-				cwd ? { cwd } : undefined
-			);
-			if (spawned.result.ok) {
-				return { ok: true };
-			} else {
-				return { ok: false, message: spawned.stderr || 'Pull failed' };
-			}
-		} catch (error) {
-			return { ok: false, message: String(error) };
-		}
-	},
-
-	switch_branch: async (options) => {
-		const { branch, pull, cwd } = options;
-		return wrap_void(() => git_switch_branch(branch as GitBranch, pull, cwd ? { cwd } : undefined));
+		return wrap_with_value(() => git_current_commit_hash_required(cwd ? { cwd } : undefined));
 	},
 
-	has_remote: async (options) => {
-		const { remote, cwd } = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_has_remote(remote, cwd ? { cwd } : undefined));
-	},
-
-	// Staging and committing
 	add: async (options) => {
 		const { files, cwd } = options;
 		return wrap_void(() => git_add(files, cwd ? { cwd } : undefined));
 	},
 
 	commit: async (options) => {
-		const { message, cwd } = options;
-		return wrap_void(() => git_commit(message, cwd ? { cwd } : undefined));
-	},
-
-	add_and_commit: async (options) => {
-		const { files, message, cwd } = options;
-		return wrap_void(() => git_add_and_commit(files, message, cwd ? { cwd } : undefined));
-	},
-
-	has_changes: async (options) => {
-		const { cwd } = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_has_changes(cwd ? { cwd } : undefined));
-	},
-
-	list_uncommitted_files: async (options) => {
-		const { cwd } = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_list_uncommitted_files(cwd ? { cwd } : undefined));
-	},
-
-	// Tagging
-	tag: async (options) => {
-		const { tag_name, message, cwd } = options;
-		return wrap_void(() => git_tag(tag_name, message, cwd ? { cwd } : undefined));
-	},
+		const { message, files, cwd } = options;
+		return wrap_void(() => git_commit(message, files, cwd ? { cwd } : undefined));
+	}
+};
 
-	push_tag: async (options) => {
-		const { tag_name, origin, cwd } = options;
-		return wrap_void(() => git_push_tag(tag_name, origin as GitOrigin, cwd ? { cwd } : undefined));
-	},
+/** The most lines of a child's stderr a failure carries. */
+export const OUTPUT_TAIL_MAX_LINES = 20;
 
-	// Stashing
-	stash: async (options) => {
-		const { message, cwd } = options ?? EMPTY_OBJECT;
-		return wrap_void(() => git_stash(message, cwd ? { cwd } : undefined));
-	},
+/** The most characters of a child's stderr a failure carries. */
+export const OUTPUT_TAIL_MAX_CHARS = 4096;
 
-	stash_pop: async (options) => {
-		const { cwd } = options ?? EMPTY_OBJECT;
-		return wrap_void(() => git_stash_pop(cwd ? { cwd } : undefined));
-	},
-
-	// File change detection
-	has_file_changed: async (options) => {
-		const { from_commit, to_commit, file_path, cwd } = options;
-		return wrap_with_value(() =>
-			git_has_file_changed(from_commit, to_commit, file_path, cwd ? { cwd } : undefined)
-		);
-	}
+/**
+ * The end of a process's output, for a failure message: its last lines, then
+ * its last characters, with terminal escape sequences stripped and trailing
+ * whitespace trimmed.
+ *
+ * @param text - the output, or as much of its end as was kept
+ * @param max_lines - the most lines to keep
+ * @param max_chars - the most characters to keep, applied after `max_lines`
+ */
+export const output_tail = (
+	text: string,
+	max_lines: number = OUTPUT_TAIL_MAX_LINES,
+	max_chars: number = OUTPUT_TAIL_MAX_CHARS
+): string => {
+	const lines = stripVTControlCharacters(text).replace(/\r\n?/g, '\n').trimEnd().split('\n');
+	const tail = lines.slice(-max_lines).join('\n');
+	if (tail.length <= max_chars) return drop_leading_blank_lines(tail);
+	// a character cut can split a line, and with it a secret masking would no longer
+	// recognize, so the partial first line goes
+	const cut = tail.slice(-max_chars);
+	if (tail[tail.length - max_chars - 1] === '\n') return drop_leading_blank_lines(cut);
+	const nl = cut.indexOf('\n');
+	return nl === -1 ? '' : drop_leading_blank_lines(cut.slice(nl + 1));
 };
 
+// not `trimStart`, which would strip the first line's indentation
+const drop_leading_blank_lines = (text: string): string => text.replace(/^\n+/, '');
+
 export const default_process_operations: ProcessOperations = {
-	spawn: async (options) => {
-		const { cmd, args, cwd } = options;
+	run_interactive: async (options) => {
+		const { cmd, args, cwd, stdout = 'stdout' } = options;
 		try {
-			const spawned = await spawn_out(cmd, args, cwd ? { cwd } : undefined);
-			if (spawned.result.ok) {
-				return {
-					ok: true,
-					stdout: spawned.stdout || undefined,
-					stderr: spawned.stderr || undefined
-				};
-			} else {
-				return {
-					ok: false,
-					message: 'Command failed',
-					stderr: spawned.stderr || undefined
-				};
-			}
+			// stdin and stdout go straight to the child (fd 2 for stdout routed to our stderr), so
+			// they stay a TTY when ours are — npm prompts for a one-time password only on a TTY.
+			// Only stderr is piped, to keep its end for the failure message while echoing it live.
+			const { child, closed } = spawn_process(cmd, args, {
+				cwd,
+				stdio: ['inherit', stdout === 'stderr' ? 2 : 'inherit', 'pipe']
+			});
+			// a rolling window over stderr's end, bounded however much the child writes
+			let kept = '';
+			child.stderr?.setEncoding('utf8');
+			child.stderr?.on('data', (chunk: string) => {
+				process.stderr.write(chunk);
+				kept += chunk;
+				if (kept.length > OUTPUT_TAIL_MAX_CHARS * 4) kept = kept.slice(-OUTPUT_TAIL_MAX_CHARS * 2);
+			});
+			const result = await closed;
+			if (result.ok) return { ok: true };
+			const stderr_tail = output_tail(kept);
+			return {
+				ok: false,
+				message: `\`${[cmd, ...args].join(' ')}\` failed (${spawn_result_to_message(result)})`,
+				stderr_tail: stderr_tail || undefined
+			};
 		} catch (error) {
 			return { ok: false, message: String(error) };
 		}
 	}
 };
 
+export const default_repos_operations: ReposOperations = {
+	status: async (options) => {
+		const { keys, registry, fetch } = options;
+		const args = [...(registry === undefined ? [] : ['--registry', registry]), 'status'];
+		if (fetch) args.push('--fetch');
+		// `--` so a key can never read as a flag
+		args.push('--json', '--', ...keys);
+		const spawned = await spawn_out('repos', args);
+		const { result } = spawned;
+		if (result.kind === 'error') {
+			const not_found = (result.error as NodeJS.ErrnoException).code === 'ENOENT';
+			return {
+				ok: false,
+				kind: not_found ? 'not_found' : 'failed',
+				message: result.error.message
+			};
+		}
+		if (result.kind === 'signaled') {
+			return { ok: false, kind: 'failed', message: `repos was killed by ${result.signal}` };
+		}
+		return {
+			ok: true,
+			output: {
+				stdout: spawned.stdout ?? '',
+				stderr: spawned.stderr ?? '',
+				exit_code: result.code
+			}
+		};
+	}
+};
+
 export const default_npm_operations: NpmOperations = {
 	wait_for_package: async (options) => {
 		const { pkg, version, wait_options, log } = options;
@@ -236,7 +200,7 @@ export const default_npm_operations: NpmOperations = {
 			await wait_for_package(pkg, version, { ...wait_options, log });
 			return { ok: true };
 		} catch (error) {
-			return { ok: false, message: String(error), timeout: true };
+			return { ok: false, message: String(error) };
 		}
 	},
 
@@ -257,25 +221,15 @@ export const default_npm_operations: NpmOperations = {
 
 	check_registry: async () => {
 		try {
-			const result = await spawn_out('npm', ['ping']);
-			if (result.stdout) {
-				return { ok: true };
-			}
-			return { ok: false, message: 'Failed to ping npm registry' };
-		} catch (error) {
-			return { ok: false, message: String(error) };
-		}
-	},
-
-	install: async (options) => {
-		const { cwd } = options ?? EMPTY_OBJECT;
-		try {
-			const spawned = await spawn_out('npm', ['install'], cwd ? { cwd } : undefined);
-			if (spawned.result.ok) {
+			// the exit status alone: `npm ping` reports on stderr, writing nothing to stdout
+			const { result } = await spawn_out('npm', ['ping']);
+			if (result.ok) {
 				return { ok: true };
-			} else {
-				return { ok: false, message: 'Install failed', stderr: spawned.stderr || undefined };
 			}
+			return {
+				ok: false,
+				message: `Failed to ping npm registry (${spawn_result_to_message(result)})`
+			};
 		} catch (error) {
 			return { ok: false, message: String(error) };
 		}
@@ -331,9 +285,8 @@ export const default_fs_operations: FsOperations = {
 
 export const default_build_operations: BuildOperations = {
 	build_package: async (options) => {
-		const { repo, log } = options;
+		const { repo } = options;
 		try {
-			log?.info(`  Building ${repo.library.name}...`);
 			const spawned = await spawn_out('gro', ['build'], { cwd: repo.repo_dir });
 			if (spawned.result.ok) {
 				return { ok: true };
@@ -360,5 +313,6 @@ export const default_gitops_operations: GitopsOperations = {
 	npm: default_npm_operations,
 	preflight: default_preflight_operations,
 	fs: default_fs_operations,
-	build: default_build_operations
+	build: default_build_operations,
+	repos: default_repos_operations
 };