@jscad/cli 3.0.1-alpha.0 → 3.0.3-alpha.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.0.3-alpha.0](https://github.com/jscad/OpenJSCAD/compare/@jscad/cli@3.0.2-alpha.0...@jscad/cli@3.0.3-alpha.0) (2026-01-18)
+
+### Features
+
+* **cli:** reworked command line parameter parsing to use commander ([225b541](https://github.com/jscad/OpenJSCAD/commit/225b5412cb92e0faa50c3c67a50b6dc5c24f424e))
+
+## [3.0.2-alpha.0](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/cli@3.0.1-alpha.0...@jscad/cli@3.0.2-alpha.0) (2025-09-06)
+
+**Note:** Version bump only for package @jscad/cli
+
 ## [3.0.1-alpha.0](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/cli@2.2.24...@jscad/cli@3.0.1-alpha.0) (2025-01-03)
 
 ### Bug Fixes

package/README.md

@@ -40,8 +40,7 @@ npm install -g @jscad/cli
 ```
 Once installed, the CLI can be invoked using
 ```
-jscad -v
-jscad
+jscad --help
 ```
 
 ### Install the CLI as Part of a Project
@@ -54,45 +53,48 @@ npm install -D @jscad/cli
 
 This will add the CLI package as a development dependency. The CLI can be invoked using
 ```
-npx jscad -v
-npx jscad
+npx jscad --help
 ```
-These two commands will show the version of the CLI, and a general help message.
+These two commands will show the various options of the CLI, and a general usage example.
 
 ### Using the CLI
 
 Simply invoke 'jscad' using various options. Here are some examples.
 
+There is also an exmaple JSCAD design in the 'example' directory.
+
 Examples:
 
 ```jscad mydesign.js                            # -- convert mydesign.js to mydesign.stl as default```
 
-```jscad mydesign.js -o test.stl                # -- convert mydesign.js to test.stl```
+```jscad -o test.stl mydesign.js                # -- convert mydesign.js to test.stl```
 
 ```jscad frog.stl -o test.js                    # -- convert frog.stl to test.js```
 
-```jscad mydesign.js -of amf                    # -- convert mydesign.js into mydesign.amf```
+```jscad -f 3mf mydesign.js                     # -- convert mydesign.js into 3MF, i.e. mydesign.3mf```
 
 For multi-part models, you can pass the `generateParts` flag `-gp` to output each part as a separate, numbered file:
 
-```jscad mydesign.js -gp                         # -- convert mydesign.js into mydesign-part-1-of-2.stl and mydesign-part-2-of-2.stl```
+```jscad -p mydesign.js                         # -- convert mydesign.js into mydesign-part-1-of-2.stl and mydesign-part-2-of-2.stl```
 
 You may also pass the `zip` flag `-z` to zip generated files into one .zip file:
 
-```jscad mydesign.js -z                          # -- convert mydesign.js into mydesign.zip which contains: mydesign.stl```
+```jscad -z mydesign.js                         # -- convert mydesign.js into mydesign.zip which contains: mydesign.stl```
 
-```jscad mydesign.js -gp -z                      # -- convert mydesign.js into mydesign.zip which contains: mydesign-part-1-of-2.stl and mydesign-part-2-of-2.stl```
+```jscad -p -z mydesign.js                      # -- convert mydesign.js into mydesign.zip which contains: mydesign-part-1-of-2.stl and mydesign-part-2-of-2.stl```
 
 The '-o' option can be used to control where the output will be placed.
-While, the '-of' option can be used to control the format of the output.
+While, the '-f' option can be used to control the format of the output.
+
+You can also provide the parameters to a JSCAD design by passing --<paramName> <value> to the CLI.
 
-You can also provide the parameters to a design by passing --<paramName> <value> to the CLI.
+```jscad -o ouptput.stl mydesign.js -- --name "Just Me" --title "Geek"```
 
-```jscad mydesign.js --name "Just Me" --title "Geek" -o output.stl```
+NOTE: Be sure to seperate the JSCAD design parameters with '--'
 
 Also, design projects (directories) can be used as the input to the CLI.
 
-```jscad myproject/ -o ./test.stl               # -- convert the project mydesign to test.stl```
+```jscad -o test.stl example/                   # -- convert the project 'example' to test.stl```
 
 > Note: The CLI will search for the design entry point just like NPM.
 > - if there is a package.json file in the project, then try to load the 'main' property
@@ -118,7 +120,7 @@ ln -s node_modules/@jscad/examples ./examples
 The examples are just single file designs, or multiple file projects.
 ```
 npx jscad examples/core/booleans/basicBooleans.js -o ./test.stl
-npx jscad examples/module-design/ -of dxf
+npx jscad examples/module-design/ -f dxf
 ```
 
 ## Documentation

package/cli.conversions.test.js

@@ -96,7 +96,7 @@ test('cli (conversions STL)', (t) => {
 
   t.context.file3Path = file3Path
 
-  cmd = `node ${cliPath} ${file2Path} -o ${file3Path} -v -add-metadata false`
+  cmd = `node ${cliPath} ${file2Path} -o ${file3Path} -v --add-metadata`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file3Path))
 })
@@ -129,7 +129,7 @@ test('cli (conversions DXF)', (t) => {
 
   t.context.file3Path = file3Path
 
-  cmd = `node ${cliPath} ${file2Path} -of js`
+  cmd = `node ${cliPath} ${file2Path} -f js`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file3Path))
 })
@@ -162,7 +162,40 @@ test('cli (conversions JSON)', (t) => {
 
   t.context.file3Path = file3Path
 
-  cmd = `node ${cliPath} ${file2Path} -of js`
+  cmd = `node ${cliPath} ${file2Path} -f js`
+  execSync(cmd, { stdio: [0, 1, 2] })
+  t.true(fs.existsSync(file3Path))
+})
+
+test('cli (conversions OBJ)', (t) => {
+  const testID = 17
+
+  // convert from JSCAD to OBJ
+  const file1Path = createJscad(testID)
+  t.true(fs.existsSync(file1Path))
+
+  t.context.file1Path = file1Path
+
+  const file2Name = `./test${testID}.obj`
+  const file2Path = path.resolve(cwd(), file2Name)
+  t.false(fs.existsSync(file2Path))
+
+  t.context.file2Path = file2Path
+
+  const cliPath = t.context.cliPath
+
+  let cmd = `node ${cliPath} ${file1Path} -o ${file2Path}`
+  execSync(cmd, { stdio: [0, 1, 2] })
+  t.true(fs.existsSync(file2Path))
+
+  // convert from OBJ to JS
+  const file3Name = `./test${testID}.js`
+  const file3Path = path.resolve(cwd(), file3Name)
+  t.false(fs.existsSync(file3Path))
+
+  t.context.file3Path = file3Path
+
+  cmd = `node ${cliPath} ${file2Path} -f js`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file3Path))
 })
@@ -195,7 +228,7 @@ test('cli (conversions SVG)', (t) => {
 
   t.context.file3Path = file3Path
 
-  cmd = `node ${cliPath} ${file2Path} -of js`
+  cmd = `node ${cliPath} ${file2Path} -f js`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file3Path))
 })
@@ -228,7 +261,40 @@ test('cli (conversions X3D)', (t) => {
 
   t.context.file3Path = file3Path
 
-  cmd = `node ${cliPath} ${file2Path} -of js`
+  cmd = `node ${cliPath} ${file2Path} -f js`
+  execSync(cmd, { stdio: [0, 1, 2] })
+  t.true(fs.existsSync(file3Path))
+})
+
+test('cli (conversions 3MF)', (t) => {
+  const testID = 16
+
+  // convert from JSCAD to 3MF
+  const file1Path = createJscad(testID)
+  t.true(fs.existsSync(file1Path))
+
+  t.context.file1Path = file1Path
+
+  const file2Name = `./test${testID}.3mf`
+  const file2Path = path.resolve(cwd(), file2Name)
+  t.false(fs.existsSync(file2Path))
+
+  t.context.file2Path = file2Path
+
+  const cliPath = t.context.cliPath
+
+  let cmd = `node ${cliPath} ${file1Path} -o ${file2Path}`
+  execSync(cmd, { stdio: [0, 1, 2] })
+  t.true(fs.existsSync(file2Path))
+
+  // convert from 3MF to JS
+  const file3Name = `./test${testID}.js`
+  const file3Path = path.resolve(cwd(), file3Name)
+  t.false(fs.existsSync(file3Path))
+
+  t.context.file3Path = file3Path
+
+  cmd = `node ${cliPath} ${file2Path} -f js`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file3Path))
 })

package/cli.js

@@ -1,46 +1,22 @@
 #!/usr/bin/env node
 // --log_all
 
-// NOTE: this will only run on Node > 6 or needs to be transpiled
-
-// == JSCAD CLI interface, written by Rene K. Mueller <spiritdude@gmail.com>, Licensed under MIT License
-//
-// Description:
-//   jscad <file> [-of <format>] [-o <output>]
-// e.g.
-//   jscad test.jscad
-//   jscad test.jscad -o test.stl
-//   jscad test.jscad -o test.amf
-//   jscad test.jscad -o test.dxf
-//   jscad test.scad -o testFromSCAD.jscad
-//   jscad test.scad -o test.stl
-//   jscad test.stl -o test2.stl      # reprocessed: stl -> jscad -> stl
-//   jscad test.amf -o test2.jscad
-//   jscad test.jscad -of amf
-//   jscad test.jscad -of dxf
-//   jscad test.jscad -of stl
-//   jscad name_plate.jscad --name "Just Me" --title "CEO" -o amf test.amf
-//
+/*
+ * Command Line Interface (CLI) for converting JSCAD designs to differnt external formats.
+ *
+ * Example:
+ *   node ./cli.js --help
+ */
 import fs from 'fs'
+import path from 'path'
+
 import JSZip from 'jszip'
 
 import { supportedFormats } from '@jscad/io'
 
+import { parseArgs } from './src/parseArgs.js'
 import { generateOutputData } from './src/generateOutputData.js'
-import { determineOutputNameAndFormat } from './src/determineOutputNameAndFormat.js'
 import { writeOutput } from './src/writeOutput.js'
-import { parseArgs } from './src/parseArgs.js'
-
-const version = '[VI]{version}[/VI]' // version is injected by rollup
-
-// handle arguments (inputs, outputs, etc)
-const args = process.argv.splice(2)
-let { inputFile, inputFormat, outputFile, outputFormat, generateParts, zip, params, addMetaData, inputIsDirectory } = parseArgs(args)
-
-// outputs
-const output = determineOutputNameAndFormat(outputFormat, outputFile, inputFile)
-outputFormat = output.outputFormat
-outputFile = output.outputFile
 
 const clicolors = {
   red: '\u{1b}[31m',
@@ -50,10 +26,30 @@ const clicolors = {
   black: '\u{1b}[0m'
 }
 
-const logFileOutput = (outputFile) => {
+const version = '[VI]{version}[/VI]' // version is injected by rollup
+
+// handle arguments (inputs, outputs, etc)
+let { filepaths, outputFile, outputFormat, generateParts, zip, params, addMetaData, inputIsDirectory } = parseArgs()
+
+// FIXME handle N input files
+const inputFile = filepaths[0]
+const inputFormat = path.extname(inputFile).substring(1)
+
+// outputs
+if (!outputFile) {
+  // create a base name from the input file
+  const fileElements = path.parse(inputFile)
+  fileElements.ext = '.' + outputFormat
+  if (fileElements.ext === '.stla') fileElements.ext = '.stl'
+  if (fileElements.ext === '.stlb') fileElements.ext = '.stl'
+  fileElements.base = undefined
+  outputFile = path.format(fileElements)
+}
+
+const logFileOutput = (inputPath, outputPath) => {
   console.log(`${clicolors.blue}JSCAD: generating output ${clicolors.red}
-    from: ${clicolors.green} ${inputFile} ${clicolors.red}
-    to: ${clicolors.green} ${outputFile} ${clicolors.yellow}(${supportedFormats[outputFormat].description}) ${clicolors.black}
+    from: ${clicolors.green} ${inputPath} ${clicolors.red}
+    to: ${clicolors.green} ${outputPath} ${clicolors.yellow}(${supportedFormats[outputFormat].description}) ${clicolors.black}
   `)
 }
 
@@ -81,14 +77,14 @@ generateOutputData(src, params, { outputFile, outputFormat, inputFile, inputForm
             if (err) {
               console.error(err)
             } else {
-              logFileOutput(zipFilename)
+              logFileOutput(inputFile, zipFilename)
             }
           })
         })
       } else {
         for (let i = 0; i < outputData.length; i++) {
           const filename = outputFile.replace(/\.(\w+)$/, `-part-${i + 1}-of-${outputData.length}.$1`)
-          logFileOutput(filename)
+          logFileOutput(inputFile, filename)
           writeOutput(filename, outputData[i])
         }
       }
@@ -102,12 +98,12 @@ generateOutputData(src, params, { outputFile, outputFormat, inputFile, inputForm
             if (err) {
               console.error(err)
             } else {
-              logFileOutput(zipFilename)
+              logFileOutput(inputFile, zipFilename)
             }
           })
         })
       } else {
-        logFileOutput(outputFile)
+        logFileOutput(inputFile, outputFile)
         writeOutput(outputFile, outputData)
       }
     }

package/cli.parameters.test.js

@@ -111,7 +111,7 @@ test('cli (single input file, output format)', (t) => {
 
   const cliPath = t.context.cliPath
 
-  const cmd = `node ${cliPath} ${inputPath} -of dxf`
+  const cmd = `node ${cliPath} ${inputPath} -f dxf`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(outputPath))
 })
@@ -167,7 +167,7 @@ test('cli (folder, output format)', (t) => {
 
   const cliPath = t.context.cliPath
 
-  const cmd = `node ${cliPath} ${folderPath} -of dxf`
+  const cmd = `node ${cliPath} ${folderPath} -f dxf`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(outputPath))
 })
@@ -188,7 +188,7 @@ test('cli (single input file, parameters)', (t) => {
 
   const cliPath = t.context.cliPath
 
-  const cmd = `node ${cliPath} ${inputPath} --segments 32 --nothing "Yes"`
+  const cmd = `node ${cliPath} ${inputPath} -- --segments 32 --nothing "Yes"`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(outputPath))
 })
@@ -241,7 +241,7 @@ test('cli (single input file, multiple output files)', (t) => {
 
   const cliPath = t.context.cliPath
 
-  const cmd = `node ${cliPath} ${inputPath} -gp`
+  const cmd = `node ${cliPath} -p ${inputPath}`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(outputPath1))
   t.true(fs.existsSync(outputPath2))
@@ -265,7 +265,7 @@ test('cli (single multipart input file, zipped output file)', async (t) => {
 
   const cliPath = t.context.cliPath
 
-  const cmd = `node ${cliPath} ${inputPath} -gp -z`
+  const cmd = `node ${cliPath} ${inputPath} -p -z`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(outputPath))
 

package/example/main.js

@@ -0,0 +1,23 @@
+// example JSCAD script
+import { flatten } from '@jscad/array-utils'
+import { arc, ellipse } from '@jscad/modeling'
+
+import { createPart } from './part.js'
+
+export const getParameterDefinitions = () => {
+  return flatten([
+    { name: 'segments', caption: 'Segments:', type: 'int', initial: 10, min: 5, max: 20, step: 1 }
+  ])
+}
+
+export const main = (params) => {
+  // parameters
+  const segments = params.segments || 16
+
+  // shapes
+  const apath2 = arc({ segments })
+  const ageom2 = ellipse({ segments, center: [5, 5] })
+  const ageom3 = createPart(segments)
+
+  return [apath2, ageom2, ageom3]
+}

package/example/part.js

@@ -0,0 +1,7 @@
+import { ellipsoid } from '@jscad/modeling'
+
+export const createPart = (segments) => {
+  const center = [10, 10, 10]
+
+  return ellipsoid({ segments, center })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/cli",
-  "version": "3.0.1-alpha.0",
+  "version": "3.0.3-alpha.0",
   "description": "Command Line Interface (CLI) for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -37,10 +37,11 @@
   "license": "MIT",
   "dependencies": {
     "@jscad/array-utils": "3.0.1-alpha.0",
-    "@jscad/core": "3.0.1-alpha.0",
-    "@jscad/io": "3.0.1-alpha.0",
-    "@jscad/io-utils": "3.0.1-alpha.0",
-    "@jscad/modeling": "3.0.1-alpha.0",
+    "@jscad/core": "3.0.3-alpha.0",
+    "@jscad/io": "3.0.3-alpha.0",
+    "@jscad/io-utils": "3.0.3-alpha.0",
+    "@jscad/modeling": "3.0.3-alpha.0",
+    "commander": "^14.0.0",
     "jszip": "^3.10.1"
   },
   "devDependencies": {
@@ -52,5 +53,5 @@
     "url": "https://opencollective.com/openjscad",
     "logo": "https://opencollective.com/openjscad/logo.txt"
   },
-  "gitHead": "0660b5c1f1a5faf54d4cfae1cb85bb94182a8d32"
+  "gitHead": "b0a83db054ec02ccddd9e19e51f86bf30f72a69e"
 }

package/src/env.js

@@ -1,9 +1,12 @@
 import os from 'os'
+import process from 'process'
 
 const version = '[VI]{version}[/VI]' // version is injected by rollup
 
 export const env = () => {
-  let env = 'JSCAD ' + version
+  const nodeVersion = process.version
+
+  let env = 'JSCAD CLI ' + version + ', Node.js ' + nodeVersion
   if (typeof document !== 'undefined') {
     const w = document.defaultView
     env = env + ' [' + w.navigator.userAgent + ']'

package/src/parseArgs.js

@@ -1,121 +1,115 @@
 import fs from 'fs'
 import path from 'path'
 
+import { Command, Option } from 'commander'
+
 import { loading } from '@jscad/core'
 
-import { supportedInputExtensions, supportedOutputExtensions, supportedOutputFormats } from '@jscad/io'
+import { supportedInputExtensions, supportedOutputFormats } from '@jscad/io'
 
 import { env } from './env.js'
 
 const { getDesignEntryPoint } = loading
 
-export const parseArgs = (args) => {
-  const inputExtensions = supportedInputExtensions()
-  const outputExtensions = supportedOutputExtensions()
-  const outputFormats = supportedOutputFormats()
-
-  // hint: https://github.com/substack/node-optimist
-  //       https://github.com/visionmedia/commander.js
-  if (args.length < 1) {
-    console.log('USAGE:\n\njscad [-v]\n\n')
-    console.log('jscad [-gp] [-z] <file> [-of <format>] [-o <output>]')
-    console.log(`\t<file>  :\tinput (Supported types: folder, .${inputExtensions.join(', .')})`)
-    console.log(`\t<output>:\toutput (Supported types: folder, .${outputExtensions.join(', .')})`)
-    console.log(`\t<format>:\t${outputFormats.join(', ')}`)
-    process.exit(1)
+const outputFormats = supportedOutputFormats()
+const inputExtensions = supportedInputExtensions()
+
+const isValidInputFileFormat = (input) => {
+  if (input === undefined || input === null || !(typeof input === 'string')) {
+    return false
+  }
+  return inputExtensions.reduce((acc, format) => input.toLowerCase().endsWith('.' + format) || acc, false)
+}
+
+export const parseArgs = () => {
+  const filepaths = [] // list of input file paths
+  const parameters = [] // parameter values for main(parameters) and serialize(parameters)
+
+  /*
+   * Setup command line arguments
+   */
+  const program = new Command()
+  program.name('cli.js')
+  program.usage('[options] <files...> -- parameter values')
+  program.argument('[files...]')
+  program.addOption(new Option('-f, --output-format <format>', 'output format').choices(outputFormats).default('stla'))
+  program.option('-p, --generate-parts', 'generate unique parts from the files', false)
+  program.option('-z, --zip', 'zip the output file contents', false)
+  program.option('-o, --output-file <filepath>', 'output file name (optional)')
+  program.option('-m, --add-metadata', 'add metadata to output format', false)
+  program.option('-v, --version', 'show version and environment information', false)
+  program.action((args) => {
+    // handle the provided arguments
+    args.forEach((arg) => {
+      try {
+        fs.statSync(arg)
+        filepaths.push(arg)
+      } catch (e) {
+        parameters.push(arg)
+      }
+    })
+  })
+  program.parse()
+
+  const options = program.opts()
+
+  // show the runtime environment if requested
+  if (options.version) {
+    env()
   }
 
-  let inputFile
-  let inputFormat
-  let outputFile
-  let outputFormat
-  let generateParts = false
-  let zip = false
-  const params = {} // parameters to feed the script if applicable
-  let addMetaData = false // wether to add metadata to outputs or not : ie version info, timestamp etc
-  let inputIsDirectory = false // did we pass in a folder or a file ?
-
-  const isValidInputFileFormat = (input) => {
-    if (input === undefined || input === null || !(typeof input === 'string')) {
-      return false
+  // console.log(options)
+  // console.log(filepaths)
+  // console.log(parameters)
+
+  if (filepaths.length === 0) process.exit(1)
+
+  if (options.outputFile) {
+    // check that the output file name implies a valid output format
+    let outputFormat = path.extname(options.outputFile).substring(1)
+    if (outputFormat === 'stl') outputFormat = 'stla'
+    if (!outputFormats.includes(outputFormat)) {
+      console.log('ERROR: invalid output file format <' + outputFormat + '>')
+      process.exit(1)
     }
-    return inputExtensions.reduce((acc, format) => input.toLowerCase().endsWith('.' + format) || acc, false)
+    // check for toxic combinations
+    if (filepaths.length !== 1) {
+      console.log('ERROR: multiple inputs cannot be converted to a single output file.')
+      process.exit(1)
+    }
+    options.outputFormat = outputFormat
+  } else {
+    options.outputFile = undefined
   }
-  const getFileExtensionFromString = (input) => (input.substring(input.lastIndexOf('.') + 1)).toLowerCase()
-
-  const parseBool = (input) => input.toLowerCase() === 'true'
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '-of') { // -of <format>
-      outputFormat = args[++i]
-    } else if (args[i] === '-gp') {
-      generateParts = true
-    } else if (args[i] === '-z') {
-      zip = true
-    } else if (args[i].match(/^-o(\S.+)/)) { // -o<output>
-      outputFile = args[i]
-      outputFile = outputFile.replace(/^-o(\S+)$/, '$1')
-    } else if (args[i] === '-o') { // -o <output>
-      outputFile = args[++i]
-    } else if (args[i] === '-add-metadata') { // -metadata true/false
-      addMetaData = parseBool(args[++i])
-    } else if (args[i].match(/^--(\w+)=(.*)/)) { // params for main()
-      params[RegExp.$1] = RegExp.$2
-    } else if (args[i].match(/^--(\w+)$/)) { // params for main()
-      params[RegExp.$1] = args[++i]
-    } else if (isValidInputFileFormat(args[i])) {
-      inputFile = args[i]
-      inputFormat = getFileExtensionFromString(args[i])
-      if (!fs.statSync(inputFile).isFile()) {
-        console.log('ERROR: cannot open input file/directory <' + inputFile + '>')
-        process.exit(1)
-      }
-    } else if (args[i].match(/^-v$/)) { // show the version and the environment information
-      env()
-    } else {
-      inputFile = args[i]
-      if (fs.statSync(inputFile).isDirectory()) {
-        inputIsDirectory = true
-        // get actual design entry point if applicable (if passed a folder as input etc)
-        inputFile = getDesignEntryPoint(fs, inputFile)
-        if (!inputFile) {
-          console.log('ERROR: could not determine entry point of project.')
-          console.log('Verify main or index exists')
-          process.exit(1)
-        }
-        inputFormat = path.extname(inputFile).substring(1)
-      } else {
-        console.log('ERROR: invalid file name or argument <' + args[i] + '>')
-        console.log("Type 'jscad' for a list of supported types")
+
+  // check for use of a directory, and determine the design entry point
+  options.inputIsDirectory = false
+  if (filepaths.length === 1) {
+    if (fs.statSync(filepaths[0]).isDirectory()) {
+      options.inputIsDirectory = true
+      // get actual design entry point
+      const filepath = getDesignEntryPoint(fs, filepaths[0])
+      if (!filepath) {
+        console.log('ERROR: could not determine entry point of project <' + filepaths[0] + '>')
+        console.log('Verify project main or index exists')
         process.exit(1)
       }
+      filepaths[0] = filepath // use the entry point for conversion
     }
   }
-  // exit if a input file was not provided
-  if (!inputFile) process.exit(1)
 
-  if (!outputFormat && !outputFile) {
-    outputFormat = 'stla'
-  }
-  if (!outputFormat && outputFile) {
-    outputFormat = path.extname(outputFile).substring(1)
-    if (outputFormat === 'stl') outputFormat = 'stla'
-  }
-  if (!outputFormats.includes(outputFormat)) {
-    console.log('ERROR: invalid output format <' + outputFormat + '>')
-    console.log("Type 'jscad' for a list of supported types")
-    process.exit(1)
-  }
+  // check that all input files are valid formats for conversion
+  filepaths.forEach((filepath) => {
+    if (!isValidInputFileFormat(filepath)) {
+      console.log('ERROR: invalid input file format <' + filepath + '>')
+      process.exit(1)
+    }
+  })
 
-  return {
-    inputFile,
-    inputFormat,
-    outputFile,
-    outputFormat,
-    generateParts,
-    zip,
-    params,
-    addMetaData,
-    inputIsDirectory
-  }
+  options.filepaths = filepaths
+  options.params = parameters
+
+  // console.log('RETURN',options)
+
+  return options
 }