@open-agent-toolkit/cli 0.1.19 → 0.1.21

package/dist/commands/project/archive/archive-utils.js

@@ -1,6 +1,6 @@
 import { execFile as execFileCallback } from 'node:child_process';
 import { rm, writeFile } from 'node:fs/promises';
-import { basename, dirname, isAbsolute, join, posix as path } from 'node:path';
+import { basename, dirname, isAbsolute, join, posix as path, relative, resolve, sep, } from 'node:path';
 import { promisify } from 'node:util';
 import { CliError } from '../../../errors/cli-error.js';
 import { copyDirectory, copySingleFile, dirExists, ensureDir, fileExists, } from '../../../fs/io.js';
@@ -112,8 +112,32 @@ export function resolveLocalArchiveProjectPath(projectsRoot, projectName) {
     const projectsBase = path.dirname(normalizedProjectsRoot);
     return path.join(projectsBase, 'archived', projectName);
 }
-function resolveCompletionArchivePath(archiveRepoRoot, projectsRoot, projectName) {
-    return join(archiveRepoRoot, resolveLocalArchiveProjectPath(projectsRoot, projectName));
+function normalizePathForConfig(pathValue) {
+    return pathValue.replaceAll('\\', '/');
+}
+function isInsidePath(parentPath, childPath) {
+    const relativePath = relative(parentPath, childPath);
+    return (relativePath === '' ||
+        (!relativePath.startsWith(`..${sep}`) &&
+            relativePath !== '..' &&
+            !isAbsolute(relativePath)));
+}
+function resolveArchiveProjectPath(repoRoot, projectsRoot, projectName) {
+    const archiveProjectPath = resolveLocalArchiveProjectPath(projectsRoot, projectName);
+    if (!isAbsolute(archiveProjectPath)) {
+        return archiveProjectPath;
+    }
+    const resolvedRepoRoot = resolve(repoRoot);
+    const resolvedArchiveProjectPath = resolve(archiveProjectPath);
+    if (!isInsidePath(resolvedRepoRoot, resolvedArchiveProjectPath)) {
+        return resolvedArchiveProjectPath;
+    }
+    return normalizePathForConfig(relative(resolvedRepoRoot, resolvedArchiveProjectPath));
+}
+function resolveCompletionArchivePath(archiveRepoRoot, archiveProjectPath) {
+    return isAbsolute(archiveProjectPath)
+        ? archiveProjectPath
+        : join(archiveRepoRoot, archiveProjectPath);
 }
 function resolveGitPath(repoRoot, gitPath) {
     const normalizedPath = gitPath.trim();
@@ -150,7 +174,7 @@ async function isGitignoredArchivePath(repoRoot, archiveProjectPath, dependencie
         throw error;
     }
 }
-export async function resolvePrimaryRepoRoot(repoRoot, dependencies = {}) {
+async function resolvePrimaryRepoRootResolution(repoRoot, dependencies = {}) {
     const execFile = dependencies.gitExecFile ?? execFileAsync;
     try {
         const [{ stdout: commonDir }, { stdout: gitDir }] = await Promise.all([
@@ -166,30 +190,22 @@ export async function resolvePrimaryRepoRoot(repoRoot, dependencies = {}) {
         const resolvedCommonDir = resolveGitPath(repoRoot, commonDir);
         const resolvedGitDir = resolveGitPath(repoRoot, gitDir);
         if (resolvedCommonDir === resolvedGitDir) {
-            return repoRoot;
+            return { repoRoot, available: true };
         }
         const primaryRepoRoot = dirname(resolvedCommonDir);
         const directoryExists = dependencies.dirExists ?? dirExists;
         if (await directoryExists(primaryRepoRoot)) {
-            return primaryRepoRoot;
+            return { repoRoot: primaryRepoRoot, available: true };
         }
+        return { repoRoot: primaryRepoRoot, available: false };
     }
     catch {
-        return repoRoot;
+        return { repoRoot, available: false };
     }
-    return repoRoot;
 }
-async function resolveArchiveRepoRoot(repoRoot, archiveProjectPath, dependencies) {
-    try {
-        const archivePathIsGitignored = await isGitignoredArchivePath(repoRoot, archiveProjectPath, dependencies);
-        if (!archivePathIsGitignored) {
-            return repoRoot;
-        }
-    }
-    catch {
-        return repoRoot;
-    }
-    return resolvePrimaryRepoRoot(repoRoot, dependencies);
+export async function resolvePrimaryRepoRoot(repoRoot, dependencies = {}) {
+    const resolution = await resolvePrimaryRepoRootResolution(repoRoot, dependencies);
+    return resolution.available ? resolution.repoRoot : repoRoot;
 }
 async function resolveUniqueArchivePath(archivePath, dependencies) {
     const directoryExists = dependencies.dirExists ?? dirExists;
@@ -200,6 +216,56 @@ async function resolveUniqueArchivePath(archivePath, dependencies) {
     const suffix = timestamp.replace(/[-:TZ.]/g, '').slice(0, 15);
     return `${archivePath}-${suffix}`;
 }
+function buildLocalOnlyArchiveWarning(projectName, archiveProjectPath, primaryRepoRoot) {
+    const primaryMessage = primaryRepoRoot
+        ? `the primary checkout \`${primaryRepoRoot}\` is unavailable`
+        : 'the primary checkout could not be resolved';
+    return `Refusing to archive project \`${projectName}\` because \`${archiveProjectPath}\` is gitignored in this worktree and ${primaryMessage}. Run \`oat project archive\` from the primary checkout or restore that checkout before retrying.`;
+}
+export async function resolveArchiveProjectTarget(options, dependencies = {}) {
+    const archiveProjectPath = resolveArchiveProjectPath(options.repoRoot, options.projectsRoot, options.projectName);
+    let archivePathIsGitignored = false;
+    let archiveRepoRoot = options.repoRoot;
+    let primaryRepoRoot = null;
+    let primaryRepoRootAvailable = true;
+    let localOnlyWarning = null;
+    try {
+        archivePathIsGitignored = await isGitignoredArchivePath(options.repoRoot, archiveProjectPath, dependencies);
+    }
+    catch {
+        archivePathIsGitignored = false;
+    }
+    if (archivePathIsGitignored) {
+        const primaryResolution = await resolvePrimaryRepoRootResolution(options.repoRoot, dependencies);
+        primaryRepoRoot = primaryResolution.repoRoot;
+        primaryRepoRootAvailable = primaryResolution.available;
+        if (primaryResolution.available) {
+            archiveRepoRoot = primaryResolution.repoRoot;
+        }
+        else {
+            localOnlyWarning = buildLocalOnlyArchiveWarning(options.projectName, archiveProjectPath, primaryRepoRoot);
+        }
+    }
+    const archiveBasePath = resolveCompletionArchivePath(archiveRepoRoot, archiveProjectPath);
+    const archivePath = await resolveUniqueArchivePath(archiveBasePath, {
+        dirExists: dependencies.dirExists,
+        timestamp: dependencies.timestamp,
+    });
+    return {
+        archiveProjectPath,
+        archiveRepoRoot,
+        archivePath,
+        archivePathIsGitignored,
+        primaryRepoRoot,
+        primaryRepoRootAvailable,
+        localOnlyWarning,
+    };
+}
+export function assertDurableArchiveProjectTarget(target) {
+    if (target.localOnlyWarning) {
+        throw new CliError(target.localOnlyWarning);
+    }
+}
 async function writeArchiveSnapshotMetadata(archivePath, metadata) {
     await writeFile(join(archivePath, ARCHIVE_SNAPSHOT_METADATA_FILENAME), `${JSON.stringify(metadata, null, 2)}\n`, 'utf8');
 }
@@ -223,10 +289,13 @@ export async function archiveProjectOnCompletion(options, dependencies = {}) {
     const execFile = dependencies.execFile ?? execFileAsync;
     const timestamp = dependencies.timestamp?.() ?? new Date().toISOString();
     const snapshotName = buildArchiveSnapshotName(options.projectName, timestamp);
-    const archiveProjectPath = resolveLocalArchiveProjectPath(options.projectsRoot, options.projectName);
-    const archiveRepoRoot = await resolveArchiveRepoRoot(options.repoRoot, archiveProjectPath, dependencies);
-    const archiveBasePath = resolveCompletionArchivePath(archiveRepoRoot, options.projectsRoot, options.projectName);
-    const archivePath = await resolveUniqueArchivePath(archiveBasePath, dependencies);
+    const archiveTarget = await resolveArchiveProjectTarget({
+        repoRoot: options.repoRoot,
+        projectsRoot: options.projectsRoot,
+        projectName: options.projectName,
+    }, dependencies);
+    assertDurableArchiveProjectTarget(archiveTarget);
+    const archivePath = archiveTarget.archivePath;
     await makeDir(dirname(archivePath));
     await copyProjectDirectory(options.projectPath, archivePath);
     await writeArchiveSnapshotMetadata(archivePath, {
@@ -310,7 +379,7 @@ export async function ensureS3ArchiveAccess(options, dependencies = {}) {
             if (options.mode === 'completion') {
                 return buildCompletionWarning('Archive S3 sync is enabled via `archive.s3SyncOnComplete`, but AWS CLI was not found on PATH. Skipping S3 archive sync.');
             }
-            throw buildSyncError('AWS CLI is required for `oat project archive sync`, but it was not found on PATH. Install `aws` and retry.');
+            throw buildSyncError('AWS CLI is required for `oat repo archive sync`, but it was not found on PATH. Install `aws` and retry.');
         }
         throw error;
     }
@@ -322,6 +391,6 @@ export async function ensureS3ArchiveAccess(options, dependencies = {}) {
         if (options.mode === 'completion') {
             return buildCompletionWarning('Archive S3 sync is enabled via `archive.s3SyncOnComplete` and `archive.s3Uri`, but AWS CLI is not configured for access. Skipping S3 archive sync.');
         }
-        throw buildSyncError('AWS CLI is required for `oat project archive sync`, but it is not configured for access to `archive.s3Uri`. Configure AWS credentials or profile settings and retry.');
+        throw buildSyncError('AWS CLI is required for `oat repo archive sync`, but it is not configured for access to `archive.s3Uri`. Configure AWS credentials or profile settings and retry.');
     }
 }

package/dist/commands/project/archive/index.d.ts

@@ -1,21 +1,8 @@
-import { rm } from 'node:fs/promises';
-import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
-import { type OatConfig } from '../../../config/oat-config.js';
 import { Command } from 'commander';
-import { buildProjectArchiveS3Uri, buildRepoArchiveS3Uri, ensureS3ArchiveAccess, type ExecFileLike, resolveLocalArchiveProjectPath, resolvePrimaryRepoRoot } from './archive-utils.js';
-export interface ProjectArchiveCommandDependencies {
-    buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
-    resolveProjectRoot: (cwd: string) => Promise<string>;
-    readOatConfig: (repoRoot: string) => Promise<OatConfig>;
-    resolveProjectsRoot: (repoRoot: string, env: NodeJS.ProcessEnv) => Promise<string>;
-    ensureS3ArchiveAccess: typeof ensureS3ArchiveAccess;
-    buildRepoArchiveS3Uri: typeof buildRepoArchiveS3Uri;
-    buildProjectArchiveS3Uri: typeof buildProjectArchiveS3Uri;
-    resolveLocalArchiveProjectPath: typeof resolveLocalArchiveProjectPath;
-    resolvePrimaryRepoRoot: typeof resolvePrimaryRepoRoot;
-    execFile: ExecFileLike;
-    removeDirectory: typeof rm;
-    processEnv: NodeJS.ProcessEnv;
-}
-export declare function createProjectArchiveCommand(overrides?: Partial<ProjectArchiveCommandDependencies>): Command;
+import { type ProjectArchivePushCommandDependencies } from './push-runner.js';
+import { type ProjectArchiveCommandDependencies } from './sync-runner.js';
+export type { ArchiveSyncOptions, ProjectArchiveCommandDependencies, } from './sync-runner.js';
+export type { ArchivePushOptions, ProjectArchivePushCommandDependencies, } from './push-runner.js';
+type ProjectArchiveDependencies = ProjectArchiveCommandDependencies & ProjectArchivePushCommandDependencies;
+export declare function createProjectArchiveCommand(overrides?: Partial<ProjectArchiveDependencies>): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/project/archive/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/archive/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAIhD,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGhF,OAAO,EAAE,KAAK,SAAS,EAAiB,MAAM,oBAAoB,CAAC;AAGnE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAIL,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,YAAY,EAEjB,8BAA8B,EAC9B,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AA8DzB,MAAM,WAAW,iCAAiC;IAChD,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,qBAAqB,EAAE,OAAO,qBAAqB,CAAC;IACpD,qBAAqB,EAAE,OAAO,qBAAqB,CAAC;IACpD,wBAAwB,EAAE,OAAO,wBAAwB,CAAC;IAC1D,8BAA8B,EAAE,OAAO,8BAA8B,CAAC;IACtE,sBAAsB,EAAE,OAAO,sBAAsB,CAAC;IACtD,QAAQ,EAAE,YAAY,CAAC;IACvB,eAAe,EAAE,OAAO,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B;AAoMD,wBAAgB,2BAA2B,CACzC,SAAS,GAAE,OAAO,CAAC,iCAAiC,CAAM,GACzD,OAAO,CA4LT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/archive/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAIL,KAAK,qCAAqC,EAC3C,MAAM,eAAe,CAAC;AACvB,OAAO,EAIL,KAAK,iCAAiC,EACvC,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,kBAAkB,EAClB,iCAAiC,GAClC,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,kBAAkB,EAClB,qCAAqC,GACtC,MAAM,eAAe,CAAC;AAEvB,KAAK,0BAA0B,GAAG,iCAAiC,GACjE,qCAAqC,CAAC;AAKxC,wBAAgB,2BAA2B,CACzC,SAAS,GAAE,OAAO,CAAC,0BAA0B,CAAM,GAClD,OAAO,CAyET"}

package/dist/commands/project/archive/index.js

@@ -1,269 +1,37 @@
-import { execFile as execFileCallback } from 'node:child_process';
-import { readFile, rm } from 'node:fs/promises';
-import { join, posix as path } from 'node:path';
-import { promisify } from 'node:util';
-import { buildCommandContext } from '../../../app/command-context.js';
-import { resolveProjectsRoot } from '../../shared/oat-paths.js';
 import { readGlobalOptions } from '../../shared/shared.utils.js';
-import { readOatConfig } from '../../../config/oat-config.js';
-import { CliError } from '../../../errors/cli-error.js';
-import { resolveProjectRoot } from '../../../fs/paths.js';
 import { Command } from 'commander';
-import { ARCHIVE_SNAPSHOT_METADATA_FILENAME, S3_ARCHIVE_SYNC_EXCLUDES, buildAwsEnv, buildProjectArchiveS3Uri, buildRepoArchiveS3Uri, ensureS3ArchiveAccess, parseArchiveSnapshotName, resolveLocalArchiveProjectPath, resolvePrimaryRepoRoot, } from './archive-utils.js';
-const execFileAsync = promisify(execFileCallback);
-/**
- * Resolve effective AWS profile/region for an archive sync invocation.
- *
- * Precedence (highest first): `--profile`/`--region` flag > `archive.awsProfile`/`archive.awsRegion`
- * config > parent shell `AWS_PROFILE`/`AWS_REGION` env. Repo config is treated
- * as deliberate, OAT-archive-scoped intent and wins over ambient shell state —
- * users who explicitly set `archive.awsProfile` for the repo don't have to
- * remember to unset `AWS_PROFILE` in every shell. Flag still beats config for
- * one-off overrides.
- *
- * The returned `env` is suitable for passing into every `aws` spawn in this
- * command. The returned `awsProfile`/`awsRegion` are also forwarded to
- * `ensureS3ArchiveAccess` so its preflight `aws sts get-caller-identity` runs
- * against the same identity.
- */
-function resolveSyncAwsEnv(processEnv, options, config) {
-    const flagProfile = typeof options.profile === 'string' && options.profile.trim().length > 0
-        ? options.profile.trim()
-        : undefined;
-    const flagRegion = typeof options.region === 'string' && options.region.trim().length > 0
-        ? options.region.trim()
-        : undefined;
-    const configProfile = config.archive?.awsProfile;
-    const configRegion = config.archive?.awsRegion;
-    // Flag beats config; either is forwarded to buildAwsEnv, which clobbers the
-    // parent env entry with the resolved value. When neither flag nor config is
-    // set, awsProfile/awsRegion stay undefined and the parent env passes through
-    // untouched — letting the AWS CLI's own resolution chain take over.
-    const awsProfile = flagProfile ?? configProfile ?? undefined;
-    const awsRegion = flagRegion ?? configRegion ?? undefined;
-    const env = buildAwsEnv(processEnv, {
-        awsProfile,
-        awsRegion,
-    });
-    return { env, awsProfile, awsRegion };
-}
-function defaultDependencies() {
-    return {
-        buildCommandContext,
-        resolveProjectRoot,
-        readOatConfig,
-        resolveProjectsRoot,
-        ensureS3ArchiveAccess,
-        buildRepoArchiveS3Uri,
-        buildProjectArchiveS3Uri,
-        resolveLocalArchiveProjectPath,
-        resolvePrimaryRepoRoot,
-        execFile: execFileAsync,
-        removeDirectory: rm,
-        processEnv: process.env,
-    };
-}
-function resolveLocalArchiveRoot(projectsRoot) {
-    return path.join(path.dirname(projectsRoot.replace(/\/+$/, '')), 'archived');
-}
-function buildArchiveSyncArgs(source, target, options) {
-    const args = ['s3', 'sync', source, target];
-    for (const pattern of S3_ARCHIVE_SYNC_EXCLUDES) {
-        args.push('--exclude', pattern);
-    }
-    if (options.dryRun) {
-        args.push('--dryrun');
-    }
-    return args;
-}
-async function runArchiveSync(repoRoot, source, target, options, awsEnv, dependencies) {
-    await dependencies.execFile('aws', buildArchiveSyncArgs(source, target, options), {
-        cwd: repoRoot,
-        env: awsEnv,
-    });
-}
-async function listArchiveSnapshots(repoRoot, projectsRoot, s3Uri, awsEnv, dependencies) {
-    const remoteRepoRoot = await dependencies.resolvePrimaryRepoRoot(repoRoot, {
-        gitExecFile: dependencies.execFile,
-        env: awsEnv,
-    });
-    const repoPrefix = `${dependencies.buildRepoArchiveS3Uri(s3Uri, remoteRepoRoot)}/`;
-    const { stdout } = await dependencies.execFile('aws', ['s3', 'ls', repoPrefix], {
-        cwd: repoRoot,
-        env: awsEnv,
-    });
-    return stdout
-        .split('\n')
-        .map((line) => line.match(/PRE\s+(.+?)\/?\s*$/)?.[1] ?? null)
-        .filter((snapshotName) => Boolean(snapshotName))
-        .map((snapshotName) => {
-        const parsed = parseArchiveSnapshotName(snapshotName);
-        return {
-            ...parsed,
-            source: dependencies.buildProjectArchiveS3Uri(s3Uri, remoteRepoRoot, snapshotName),
-            target: dependencies.resolveLocalArchiveProjectPath(projectsRoot, parsed.projectName),
-        };
-    });
-}
-function compareSnapshotEntries(left, right) {
-    if (left.dateStamp && right.dateStamp && left.dateStamp !== right.dateStamp) {
-        return left.dateStamp.localeCompare(right.dateStamp);
-    }
-    if (left.dateStamp && !right.dateStamp) {
-        return 1;
-    }
-    if (!left.dateStamp && right.dateStamp) {
-        return -1;
-    }
-    return left.snapshotName.localeCompare(right.snapshotName);
-}
-function selectLatestSnapshots(snapshots) {
-    const latestByProject = new Map();
-    for (const snapshot of snapshots) {
-        const current = latestByProject.get(snapshot.projectName);
-        if (!current || compareSnapshotEntries(snapshot, current) > 0) {
-            latestByProject.set(snapshot.projectName, snapshot);
-        }
-    }
-    return [...latestByProject.values()];
-}
-async function readLocalSnapshotName(repoRoot, target) {
-    try {
-        const content = await readFile(join(repoRoot, target, ARCHIVE_SNAPSHOT_METADATA_FILENAME), 'utf8');
-        const parsed = JSON.parse(content);
-        return typeof parsed.snapshotName === 'string' ? parsed.snapshotName : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function syncArchiveSnapshot(repoRoot, snapshot, options, awsEnv, dependencies) {
-    const currentSnapshotName = await readLocalSnapshotName(repoRoot, snapshot.target);
-    if (!options.force && currentSnapshotName === snapshot.snapshotName) {
-        return false;
-    }
-    if (!options.dryRun) {
-        await dependencies.removeDirectory(join(repoRoot, snapshot.target), {
-            recursive: true,
-            force: true,
-        });
-    }
-    await runArchiveSync(repoRoot, snapshot.source, snapshot.target, options, awsEnv, dependencies);
-    return true;
-}
+import { defaultProjectArchivePushCommandDependencies, runArchivePushCommand, } from './push-runner.js';
+import { defaultProjectArchiveCommandDependencies, runArchiveSyncCommand, } from './sync-runner.js';
+const PROJECT_ARCHIVE_SYNC_DEPRECATION_NOTICE = 'oat project archive sync is deprecated; use oat repo archive sync';
 export function createProjectArchiveCommand(overrides = {}) {
     const dependencies = {
-        ...defaultDependencies(),
+        ...defaultProjectArchiveCommandDependencies(),
+        ...defaultProjectArchivePushCommandDependencies(),
         ...overrides,
     };
     return new Command('archive')
         .description('Manage archived project data')
+        .argument('[project-path]', 'Project path to archive')
+        .option('--dry-run', 'Preview archive without moving files or syncing S3')
+        .addHelpText('afterAll', '\nPull archived project data with `oat repo archive sync [project-name]`; `oat project archive sync` is deprecated.')
+        .action(async (projectPath, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runArchivePushCommand(dependencies, projectPath, options, context);
+    })
         .addCommand(new Command('sync')
-        .description('Sync archived project data from S3 into the local archive')
+        .description('[deprecated] Sync archived project data from S3 into the local archive')
         .argument('[project-name]', 'Archived project name to sync')
         .option('--dry-run', 'Preview archive sync without downloading')
         .option('--force', 'Replace the named local archive before syncing it from S3')
         .option('--profile <profile>', 'AWS profile override for this sync')
         .option('--region <region>', 'AWS region override for this sync')
         .action(async (projectName, options, command) => {
+        process.stderr.write(`${PROJECT_ARCHIVE_SYNC_DEPRECATION_NOTICE}\n`);
         const context = dependencies.buildCommandContext(readGlobalOptions(command));
-        try {
-            if (options.force && !projectName) {
-                throw new CliError('`--force` requires a project name for `oat project archive sync`.');
-            }
-            const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
-            const config = await dependencies.readOatConfig(repoRoot);
-            const s3Uri = config.archive?.s3Uri;
-            if (!s3Uri) {
-                throw new CliError('Archive sync requires `archive.s3Uri` to be configured. Set it with `oat config set archive.s3Uri <s3://...>` and retry.');
-            }
-            const { env: awsEnv, awsProfile, awsRegion, } = resolveSyncAwsEnv(dependencies.processEnv, options, config);
-            await dependencies.ensureS3ArchiveAccess({
-                mode: 'sync',
-                s3Uri,
-                syncOnComplete: config.archive?.s3SyncOnComplete ?? false,
-                awsProfile,
-                awsRegion,
-            }, { env: awsEnv });
-            const projectsRoot = await dependencies.resolveProjectsRoot(repoRoot, dependencies.processEnv);
-            const snapshots = await listArchiveSnapshots(repoRoot, projectsRoot, s3Uri, awsEnv, dependencies);
-            const targets = projectName
-                ? snapshots.filter((snapshot) => snapshot.projectName === projectName ||
-                    snapshot.snapshotName === projectName)
-                : selectLatestSnapshots(snapshots);
-            if (projectName && targets.length === 0) {
-                throw new CliError(`No archived snapshot found in S3 for project \`${projectName}\`.`);
-            }
-            const latestTarget = projectName
-                ? targets.reduce((latest, snapshot) => {
-                    if (!latest) {
-                        return snapshot;
-                    }
-                    return compareSnapshotEntries(snapshot, latest) > 0
-                        ? snapshot
-                        : latest;
-                }, null)
-                : null;
-            const snapshotsToSync = projectName
-                ? latestTarget
-                    ? [latestTarget]
-                    : []
-                : targets;
-            const appliedTargets = [];
-            const appliedSources = [];
-            for (const snapshot of snapshotsToSync) {
-                if (!snapshot) {
-                    continue;
-                }
-                const synced = await syncArchiveSnapshot(repoRoot, snapshot, options, awsEnv, dependencies);
-                if (synced) {
-                    appliedTargets.push(snapshot.target);
-                    appliedSources.push(snapshot.source);
-                }
-            }
-            const subject = projectName
-                ? `archived project \`${projectName}\``
-                : 'archived projects';
-            const targetSummary = appliedTargets.length > 0
-                ? appliedTargets.join(', ')
-                : resolveLocalArchiveRoot(projectsRoot);
-            const sourceSummary = appliedSources.length > 0
-                ? appliedSources.join(', ')
-                : dependencies.buildRepoArchiveS3Uri(s3Uri, await dependencies.resolvePrimaryRepoRoot(repoRoot, {
-                    gitExecFile: dependencies.execFile,
-                    env: awsEnv,
-                }));
-            if (context.json) {
-                context.logger.json({
-                    status: 'ok',
-                    mode: options.dryRun ? 'dry-run' : 'apply',
-                    projectName: projectName ?? null,
-                    sources: appliedSources,
-                    targets: appliedTargets,
-                    skipped: appliedTargets.length === 0,
-                    force: options.force ?? false,
-                });
-            }
-            else if (options.dryRun) {
-                context.logger.info(`Dry-run: would sync ${subject} from ${sourceSummary} to ${targetSummary}.`);
-            }
-            else if (appliedTargets.length === 0) {
-                context.logger.info(`Skipped ${subject}; local archive is already using the latest remote snapshot.`);
-            }
-            else {
-                context.logger.info(`Synced ${subject} from ${sourceSummary} to ${targetSummary}.`);
-            }
-            process.exitCode = 0;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (context.json) {
-                context.logger.json({ status: 'error', message });
-            }
-            else {
-                context.logger.error(message);
-            }
-            process.exitCode = error instanceof CliError ? error.exitCode : 1;
-        }
+        const syncOptions = {
+            ...options,
+            dryRun: options.dryRun ?? context.dryRun,
+        };
+        await runArchiveSyncCommand(dependencies, projectName, syncOptions, context, 'oat project archive sync');
     }));
 }

package/dist/commands/project/archive/push-runner.d.ts

@@ -0,0 +1,21 @@
+import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
+import { type OatConfig, type OatLocalConfig } from '../../../config/oat-config.js';
+import { resolveArchiveProjectTarget, resolvePrimaryRepoRoot, type ArchiveProjectOnCompletionOptions, type ArchiveProjectOnCompletionResult } from './archive-utils.js';
+export interface ArchivePushOptions {
+    dryRun?: boolean;
+}
+export interface ProjectArchivePushCommandDependencies {
+    buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    readOatConfig: (repoRoot: string) => Promise<OatConfig>;
+    readOatLocalConfig: (repoRoot: string) => Promise<OatLocalConfig>;
+    resolveProjectsRoot: (repoRoot: string, env: NodeJS.ProcessEnv) => Promise<string>;
+    resolvePrimaryRepoRoot: typeof resolvePrimaryRepoRoot;
+    resolveArchiveProjectTarget: typeof resolveArchiveProjectTarget;
+    archiveProjectOnCompletion: (options: ArchiveProjectOnCompletionOptions) => Promise<ArchiveProjectOnCompletionResult>;
+    processEnv: NodeJS.ProcessEnv;
+    timestamp: () => string;
+}
+export declare function defaultProjectArchivePushCommandDependencies(): ProjectArchivePushCommandDependencies;
+export declare function runArchivePushCommand(dependencies: ProjectArchivePushCommandDependencies, projectPathArg: string | undefined, options: ArchivePushOptions, context: CommandContext): Promise<void>;
+//# sourceMappingURL=push-runner.d.ts.map

package/dist/commands/project/archive/push-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-runner.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/archive/push-runner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAKL,2BAA2B,EAC3B,sBAAsB,EAEtB,KAAK,iCAAiC,EACtC,KAAK,gCAAgC,EACtC,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,qCAAqC;IACpD,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAClE,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,sBAAsB,EAAE,OAAO,sBAAsB,CAAC;IACtD,2BAA2B,EAAE,OAAO,2BAA2B,CAAC;IAChE,0BAA0B,EAAE,CAC1B,OAAO,EAAE,iCAAiC,KACvC,OAAO,CAAC,gCAAgC,CAAC,CAAC;IAC/C,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,MAAM,CAAC;CACzB;AAkBD,wBAAgB,4CAA4C,IAAI,qCAAqC,CAapG;AA2ID,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,qCAAqC,EACnD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC,CAiEf"}