add script for uploading a file to a project (#33874)

* add script for uploading a file to a project

* fix default source name in script

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* reject folders as an upload destination

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* validate destination path when normalizing

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
GitOrigin-RevId: 4a6ce79652074475fc2065156718a23156e8b0bd
This commit is contained in:
Brian Gough
2026-06-11 08:05:29 +00:00
committed by Copybot
co-authored by Copilot Autofix powered by AI
parent be5f8b425a
commit da85973cca
2 changed files with 524 additions and 0 deletions
+260
View File
@@ -0,0 +1,260 @@
import minimist from 'minimist'
import fs from 'node:fs/promises'
import Path from 'node:path'
import readline from 'node:readline/promises'
import { stdin as input, stdout as output } from 'node:process'
import { ObjectId } from '../app/src/infrastructure/mongodb.mjs'
import Errors from '../app/src/Features/Errors/Errors.js'
import ProjectLocator from '../app/src/Features/Project/ProjectLocator.mjs'
import ProjectEntityUpdateHandler from '../app/src/Features/Project/ProjectEntityUpdateHandler.mjs'
import SafePath from '../app/src/Features/Project/SafePath.mjs'
import { scriptRunner } from './lib/ScriptRunner.mjs'
function usage() {
console.error(`Upload a local file into a project path
Usage: node scripts/upload_file.mjs [options] FILE
Required:
FILE Local filesystem path to file to upload
--project-id ID Project id
--user-id ID User id performing the action
Optional:
--dest PATH Destination project path (default: basename of FILE)
--source VALUE Source label for history
(default: script-upload-file)
--force Allow overwrite when destination already exists
-y Skip interactive confirmation prompt
--dry-run Show what would happen without mutating the project
--help Show this help
Example:
node scripts/upload_file.mjs /tmp/plot.png --project-id=... --user-id=... \
--dest=/figures/plot.png --dry-run`)
}
function parseArgs() {
let unknownArg
const argv = minimist(process.argv.slice(2), {
boolean: ['dry-run', 'force', 'help', 'y'],
string: ['project-id', 'user-id', 'dest', 'source'],
alias: { y: 'yes' },
unknown: arg => {
if (arg.startsWith('-')) {
unknownArg = arg
return false
}
return true
},
})
if (unknownArg) {
throw new Error(`unknown argument: ${unknownArg}`)
}
if (argv._.length === 0) {
throw new Error('provide a local file path as FILE argument')
}
if (argv._.length > 1) {
throw new Error('only one FILE argument is supported')
}
return {
localPath: argv._[0],
projectId: argv['project-id'],
userId: argv['user-id'],
destPath: argv.dest,
source: argv.source || 'script-upload-file',
force: argv.force === true,
dryRun: argv['dry-run'] === true,
assumeYes: argv.y === true || argv.yes === true,
help: argv.help === true,
}
}
function normalizeTargetPath(targetPath) {
if (typeof targetPath !== 'string') {
throw new TypeError('destination path must be a string')
}
if (targetPath.trim().length === 0) {
throw new Error('destination path must not be empty')
}
return targetPath.startsWith('/') ? targetPath : `/${targetPath}`
}
async function validateInputs(opts) {
const { projectId, userId, localPath } = opts
if (!projectId || !ObjectId.isValid(projectId)) {
throw new Error('provide a valid object id as --project-id')
}
if (!userId || !ObjectId.isValid(userId)) {
throw new Error('provide a valid object id as --user-id')
}
if (!localPath || typeof localPath !== 'string') {
throw new Error('provide a local file path as FILE argument')
}
let fileStat
try {
fileStat = await fs.stat(localPath)
} catch (error) {
throw new Error(`local file not found: ${localPath}`)
}
if (!fileStat.isFile()) {
throw new Error(`local path is not a file: ${localPath}`)
}
const rawDestPath = opts.destPath ?? Path.basename(localPath)
let targetPath
try {
targetPath = normalizeTargetPath(rawDestPath)
} catch (error) {
const invalidValue =
opts.destPath !== undefined
? `--dest=${JSON.stringify(opts.destPath)}`
: `derived basename ${rawDestPath} from FILE ${localPath}`
throw new Error(
`provide a non-empty destination project path; invalid value ${invalidValue}`
)
}
if (!SafePath.isCleanPath(targetPath)) {
throw new Errors.InvalidNameError('invalid --dest value')
}
const fileName = Path.posix.basename(targetPath)
if (!fileName || fileName === '.' || fileName === '..') {
throw new Error('destination path must include a file name')
}
return { ...opts, targetPath }
}
async function confirmUpload(projectId, localPath, targetPath, assumeYes) {
if (assumeYes) {
return true
}
const rl = readline.createInterface({ input, output })
try {
const answer = await rl.question(
`Upload ${localPath} to ${targetPath} in project ${projectId}? [y/N] `
)
return /^y(es)?$/i.test(answer.trim())
} finally {
rl.close()
}
}
async function getExistingEntity(projectId, targetPath) {
try {
return await ProjectLocator.promises.findElementByPath({
project_id: projectId,
path: targetPath,
exactCaseMatch: true,
})
} catch (error) {
if (error instanceof Errors.NotFoundError) {
return null
}
throw error
}
}
async function main(trackProgress) {
let opts = parseArgs()
if (opts.help) {
usage()
return
}
opts = await validateInputs(opts)
const {
projectId,
userId,
targetPath,
localPath,
source,
force,
dryRun,
assumeYes,
} = opts
await trackProgress(
`Starting upload for project=${projectId} path=${targetPath} dryRun=${dryRun} force=${force}`
)
const existing = await getExistingEntity(projectId, targetPath)
if (existing?.type === 'folder') {
throw new Error(
`destination is a folder at ${targetPath}. Choose a file path within that folder.`
)
}
if (existing && !force) {
throw new Error(
`destination already exists at ${targetPath} (type=${existing.type}). Re-run with --force to overwrite.`
)
}
const intendedAction = existing ? 'overwrite' : 'create'
console.log(
`${dryRun ? 'DRY RUN: would' : 'Applying: will'} ${intendedAction} file at ${targetPath}`
)
if (dryRun) {
return
}
const confirmed = await confirmUpload(
projectId,
localPath,
targetPath,
assumeYes
)
if (!confirmed) {
console.log('Upload cancelled.')
return
}
const { fileRef, isNew } =
await ProjectEntityUpdateHandler.promises.upsertFileWithPath(
projectId,
targetPath,
localPath,
null,
userId,
source
)
const outcome = existing
? `overwrote existing ${existing.type}`
: isNew
? 'created file'
: 'updated existing file'
console.log(
`Success: ${outcome}. fileId=${fileRef?._id} fileName=${fileRef?.name} projectId=${projectId} path=${targetPath}`
)
}
try {
await scriptRunner(main)
console.log('Done.')
process.exit(0)
} catch (error) {
if (error instanceof Errors.InvalidNameError) {
console.error(`Invalid name/path: ${error.message}`)
} else {
console.error(error)
}
usage()
process.exit(1)
}