also expose internal shared functionality for external usage

packages/cli/src/cli.ts

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+import { Argument, Option, program } from '@commander-js/extra-typings'
+import { setBase, status } from '@cryptgeon/shared'
+import prettyBytes from 'pretty-bytes'
+
+import { download } from './download.js'
+import { parseFile, parseNumber } from './parsers.js'
+import { getStdin } from './stdin.js'
+import { upload } from './upload.js'
+import { checkConstrains, exit } from './utils.js'
+
+const defaultServer = process.env['CRYPTGEON_SERVER'] || 'https://cryptgeon.org'
+const server = new Option('-s --server <url>', 'the cryptgeon server to use').default(defaultServer)
+const files = new Argument('<file...>', 'Files to be sent').argParser(parseFile)
+const text = new Argument('<text>', 'Text content of the note')
+const password = new Option('-p --password <string>', 'manually set a password')
+const all = new Option('-a --all', 'Save all files without prompt').default(false)
+const url = new Argument('<url>', 'The url to open')
+const views = new Option('-v --views <number>', 'Amount of views before getting destroyed').argParser(parseNumber)
+const minutes = new Option('-m --minutes <number>', 'Minutes before the note expires').argParser(parseNumber)
+
+// Node 18 guard
+parseInt(process.version.slice(1).split(',')[0]) < 18 && exit('Node 18 or higher is required')
+
+// @ts-ignore
+const version: string = VERSION
+
+program.name('cryptgeon').version(version).configureHelp({ showGlobalOptions: true })
+
+program
+  .command('info')
+  .description('show information about the server')
+  .addOption(server)
+  .action(async (options) => {
+    setBase(options.server)
+    const response = await status()
+    const formatted = {
+      ...response,
+      max_size: prettyBytes(response.max_size),
+    }
+    for (const key of Object.keys(formatted)) {
+      if (key.startsWith('theme_')) delete formatted[key as keyof typeof formatted]
+    }
+    console.table(formatted)
+  })
+
+const send = program.command('send').description('send a note')
+send
+  .command('file')
+  .addArgument(files)
+  .addOption(server)
+  .addOption(views)
+  .addOption(minutes)
+  .addOption(password)
+  .action(async (files, options) => {
+    setBase(options.server!)
+    await checkConstrains(options)
+    options.password ||= await getStdin()
+    try {
+      const url = await upload(files, { views: options.views, expiration: options.minutes, password: options.password })
+      console.log(`Note created:\n\n${url}`)
+    } catch {
+      exit('Could not create note')
+    }
+  })
+send
+  .command('text')
+  .addArgument(text)
+  .addOption(server)
+  .addOption(views)
+  .addOption(minutes)
+  .addOption(password)
+  .action(async (text, options) => {
+    setBase(options.server!)
+    await checkConstrains(options)
+    options.password ||= await getStdin()
+    try {
+      const url = await upload(text, { views: options.views, expiration: options.minutes, password: options.password })
+      console.log(`Note created:\n\n${url}`)
+    } catch {
+      exit('Could not create note')
+    }
+  })
+
+program
+  .command('open')
+  .description('open a link with text or files inside')
+  .addArgument(url)
+  .addOption(password)
+  .addOption(all)
+  .action(async (note, options) => {
+    try {
+      const url = new URL(note)
+      options.password ||= await getStdin()
+      try {
+        await download(url, options.all, options.password)
+      } catch (e) {
+        exit(e instanceof Error ? e.message : 'Unknown error occurred')
+      }
+    } catch {
+      exit('Invalid URL')
+    }
+  })
+
+program.parse()

packages/cli/src/download.ts

@@ -5,12 +5,12 @@ import { basename, resolve } from 'node:path'
 import { AES, Hex } from 'occulto'
 import pretty from 'pretty-bytes'
 
-import { exit } from './utils'
-
 export async function download(url: URL, all: boolean, suggestedPassword?: string) {
   setBase(url.origin)
   const id = url.pathname.split('/')[2]
-  const preview = await info(id).catch(() => exit('Note does not exist or is expired'))
+  const preview = await info(id).catch(() => {
+    throw new Error('Note does not exist or is expired')
+  })
 
   // Password
   let password: string
@@ -35,13 +35,14 @@ export async function download(url: URL, all: boolean, suggestedPassword?: strin
   const key = derivation ? (await AES.derive(password, derivation))[0] : Hex.decode(password)
   const note = await get(id)
 
-  const couldNotDecrypt = () => exit('Could not decrypt note. Probably an invalid password')
+  const couldNotDecrypt = new Error('Could not decrypt note. Probably an invalid password')
   switch (note.meta.type) {
     case 'file':
-      const files = await Adapters.Files.decrypt(note.contents, key).catch(couldNotDecrypt)
+      const files = await Adapters.Files.decrypt(note.contents, key).catch(() => {
+        throw couldNotDecrypt
+      })
       if (!files) {
-        exit('No files found in note')
-        return
+        throw new Error('No files found in note')
       }
 
       let selected: typeof files
@@ -63,7 +64,7 @@ export async function download(url: URL, all: boolean, suggestedPassword?: strin
         selected = files.filter((file) => names.includes(file.name))
       }
 
-      if (!selected.length) exit('No files selected')
+      if (!selected.length) throw new Error('No files selected')
       await Promise.all(
         selected.map(async (file) => {
           let filename = resolve(file.name)
@@ -79,7 +80,9 @@ export async function download(url: URL, all: boolean, suggestedPassword?: strin
 
       break
     case 'text':
-      const plaintext = await Adapters.Text.decrypt(note.contents, key).catch(couldNotDecrypt)
+      const plaintext = await Adapters.Text.decrypt(note.contents, key).catch(() => {
+        throw couldNotDecrypt
+      })
       console.log(plaintext)
       break
   }

packages/cli/src/index.ts

@@ -1,104 +1,4 @@
-#!/usr/bin/env node
-
-import { Argument, Option, program } from '@commander-js/extra-typings'
-import { setBase, status } from '@cryptgeon/shared'
-import prettyBytes from 'pretty-bytes'
-
-import { download } from './download.js'
-import { parseFile, parseNumber } from './parsers.js'
-import { getStdin } from './stdin.js'
-import { upload } from './upload.js'
-import { exit } from './utils.js'
-
-const defaultServer = process.env['CRYPTGEON_SERVER'] || 'https://cryptgeon.org'
-const server = new Option('-s --server <url>', 'the cryptgeon server to use').default(defaultServer)
-const files = new Argument('<file...>', 'Files to be sent').argParser(parseFile)
-const text = new Argument('<text>', 'Text content of the note')
-const password = new Option('-p --password <string>', 'manually set a password')
-const all = new Option('-a --all', 'Save all files without prompt').default(false)
-const url = new Argument('<url>', 'The url to open')
-const views = new Option('-v --views <number>', 'Amount of views before getting destroyed').argParser(parseNumber)
-const minutes = new Option('-m --minutes <number>', 'Minutes before the note expires').argParser(parseNumber)
-
-// Node 18 guard
-parseInt(process.version.slice(1).split(',')[0]) < 18 && exit('Node 18 or higher is required')
-
-// @ts-ignore
-const version: string = VERSION
-
-async function checkConstrains(constrains: { views?: number; minutes?: number }) {
-  const { views, minutes } = constrains
-  if (views && minutes) exit('cannot set view and minutes constrains simultaneously')
-  if (!views && !minutes) constrains.views = 1
-
-  const response = await status()
-  if (views && views > response.max_views)
-    exit(`Only a maximum of ${response.max_views} views allowed. ${views} given.`)
-  if (minutes && minutes > response.max_expiration)
-    exit(`Only a maximum of ${response.max_expiration} minutes allowed. ${minutes} given.`)
-}
-
-program.name('cryptgeon').version(version).configureHelp({ showGlobalOptions: true })
-
-program
-  .command('info')
-  .description('show information about the server')
-  .addOption(server)
-  .action(async (options) => {
-    setBase(options.server)
-    const response = await status()
-    const formatted = {
-      ...response,
-      max_size: prettyBytes(response.max_size),
-    }
-    for (const key of Object.keys(formatted)) {
-      if (key.startsWith('theme_')) delete formatted[key as keyof typeof formatted]
-    }
-    console.table(formatted)
-  })
-
-const send = program.command('send').description('send a note')
-send
-  .command('file')
-  .addArgument(files)
-  .addOption(server)
-  .addOption(views)
-  .addOption(minutes)
-  .addOption(password)
-  .action(async (files, options) => {
-    setBase(options.server!)
-    await checkConstrains(options)
-    options.password ||= await getStdin()
-    await upload(files, { views: options.views, expiration: options.minutes, password: options.password })
-  })
-send
-  .command('text')
-  .addArgument(text)
-  .addOption(server)
-  .addOption(views)
-  .addOption(minutes)
-  .addOption(password)
-  .action(async (text, options) => {
-    setBase(options.server!)
-    await checkConstrains(options)
-    options.password ||= await getStdin()
-    await upload(text, { views: options.views, expiration: options.minutes, password: options.password })
-  })
-
-program
-  .command('open')
-  .description('open a link with text or files inside')
-  .addArgument(url)
-  .addOption(password)
-  .addOption(all)
-  .action(async (note, options) => {
-    try {
-      const url = new URL(note)
-      options.password ||= await getStdin()
-      await download(url, options.all, options.password)
-    } catch {
-      exit('Invalid URL')
-    }
-  })
-
-program.parse()
+export * from '@cryptgeon/shared'
+export * from './download.js'
+export * from './upload.js'
+export * from './utils.js'

packages/cli/src/upload.ts

@@ -3,49 +3,43 @@ import { basename } from 'node:path'
 
 import { Adapters, BASE, create, FileDTO, Note, NoteMeta } from '@cryptgeon/shared'
 import mime from 'mime'
-import { AES, Hex, TypedArray } from 'occulto'
-
-import { exit } from './utils.js'
+import { AES, Hex } from 'occulto'
 
 type UploadOptions = Pick<Note, 'views' | 'expiration'> & { password?: string }
 
-export async function upload(input: string | string[], options: UploadOptions) {
-  try {
-    const { password, ...noteOptions } = options
-    const derived = options.password ? await AES.derive(options.password) : undefined
-    const key = derived ? derived[0] : await AES.generateKey()
+export async function upload(input: string | string[], options: UploadOptions): Promise<string> {
+  const { password, ...noteOptions } = options
+  const derived = options.password ? await AES.derive(options.password) : undefined
+  const key = derived ? derived[0] : await AES.generateKey()
 
-    let contents: string
-    let type: NoteMeta['type']
-    if (typeof input === 'string') {
-      contents = await Adapters.Text.encrypt(input, key)
-      type = 'text'
-    } else {
-      const files: FileDTO[] = await Promise.all(
-        input.map(async (path) => {
-          const data = new Uint8Array(await readFile(path))
-          const stats = await stat(path)
-          const extension = path.substring(path.indexOf('.') + 1)
-          const type = mime.getType(extension) ?? 'application/octet-stream'
-          return {
-            name: basename(path),
-            size: stats.size,
-            contents: data,
-            type,
-          } satisfies FileDTO
-        })
-      )
-      contents = await Adapters.Files.encrypt(files, key)
-      type = 'file'
-    }
-
-    // Create the actual note and upload it.
-    const note: Note = { ...noteOptions, contents, meta: { type, derivation: derived?.[1] } }
-    const result = await create(note)
-    let url = `${BASE}/note/${result.id}`
-    if (!derived) url += `#${Hex.encode(key)}`
-    console.log(`Note created:\n\n${url}`)
-  } catch {
-    exit('Could not create note')
+  let contents: string
+  let type: NoteMeta['type']
+  if (typeof input === 'string') {
+    contents = await Adapters.Text.encrypt(input, key)
+    type = 'text'
+  } else {
+    const files: FileDTO[] = await Promise.all(
+      input.map(async (path) => {
+        const data = new Uint8Array(await readFile(path))
+        const stats = await stat(path)
+        const extension = path.substring(path.indexOf('.') + 1)
+        const type = mime.getType(extension) ?? 'application/octet-stream'
+        return {
+          name: basename(path),
+          size: stats.size,
+          contents: data,
+          type,
+        } satisfies FileDTO
+      })
+    )
+    contents = await Adapters.Files.encrypt(files, key)
+    type = 'file'
   }
+
+  // Create the actual note and upload it.
+  const note: Note = { ...noteOptions, contents, meta: { type, derivation: derived?.[1] } }
+  const result = await create(note)
+  let url = `${BASE}/note/${result.id}`
+  if (!derived) url += `#${Hex.encode(key)}`
+  return url
 }

packages/cli/src/utils.ts

@@ -1,6 +1,19 @@
+import { status } from '@cryptgeon/shared'
 import { exit as exitNode } from 'node:process'
 
 export function exit(message: string) {
   console.error(message)
   exitNode(1)
 }
+
+export async function checkConstrains(constrains: { views?: number; minutes?: number }) {
+  const { views, minutes } = constrains
+  if (views && minutes) exit('cannot set view and minutes constrains simultaneously')
+  if (!views && !minutes) constrains.views = 1
+
+  const response = await status()
+  if (views && views > response.max_views)
+    exit(`Only a maximum of ${response.max_views} views allowed. ${views} given.`)
+  if (minutes && minutes > response.max_expiration)
+    exit(`Only a maximum of ${response.max_expiration} minutes allowed. ${minutes} given.`)
+}