move shared package to cli

packages/cli/build.js

@@ -1,13 +1,14 @@
-import pkg from './package.json' with { type: 'json' }
 import { build } from 'tsup'
+import pkg from './package.json' with { type: 'json' }
 
 const watch = process.argv.slice(2)[0] === '--watch'
 
 await build({
-  entry: ['src/index.ts', 'src/cli.ts'],
+  entry: ['src/index.ts', 'src/cli.ts', 'src/shared/shared.ts'],
   dts: true,
   minify: true,
   format: ['esm', 'cjs'],
+  target: 'es2020',
   clean: true,
   define: { VERSION: `"${pkg.version}"` },
   watch,

packages/cli/package.json

@@ -9,7 +9,11 @@
   },
   "type": "module",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./shared": {
+      "import": "./dist/shared/shared.js",
+      "types": "./dist/shared/shared.d.ts"
+    }
   },
   "types": "./dist/index.d.ts",
   "bin": {
@@ -25,15 +29,14 @@
     "prepublishOnly": "run-s build"
   },
   "devDependencies": {
-    "@commander-js/extra-typings": "^12.0.1",
-    "@cryptgeon/shared": "workspace:*",
+    "@commander-js/extra-typings": "^12.1.0",
     "@types/inquirer": "^9.0.7",
-    "@types/mime": "^3.0.4",
+    "@types/mime": "^4.0.0",
     "@types/node": "^20.11.24",
-    "commander": "^12.0.0",
+    "commander": "^12.1.0",
     "inquirer": "^9.2.15",
     "mime": "^4.0.1",
-    "occulto": "^2.0.3",
+    "occulto": "^2.0.6",
     "pretty-bytes": "^6.1.1",
     "tsup": "^8.2.4",
     "typescript": "^5.3.3"

packages/cli/src/actions/download.ts

@@ -1,14 +1,15 @@
-import { Adapters, get, info, setOptions } from '@cryptgeon/shared'
 import inquirer from 'inquirer'
 import { access, constants, writeFile } from 'node:fs/promises'
 import { basename, resolve } from 'node:path'
 import { AES, Hex } from 'occulto'
 import pretty from 'pretty-bytes'
+import { Adapters } from '../shared/adapters.js'
+import { API } from '../shared/api.js'
 
 export async function download(url: URL, all: boolean, suggestedPassword?: string) {
-  setOptions({ server: url.origin })
+  API.setOptions({ server: url.origin })
   const id = url.pathname.split('/')[2]
-  const preview = await info(id).catch(() => {
+  const preview = await API.info(id).catch(() => {
     throw new Error('Note does not exist or is expired')
   })
 
@@ -33,7 +34,7 @@ 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 note = await API.get(id)
 
   const couldNotDecrypt = new Error('Could not decrypt note. Probably an invalid password')
   switch (note.meta.type) {

packages/cli/src/actions/upload.ts

@@ -1,9 +1,10 @@
 import { readFile, stat } from 'node:fs/promises'
 import { basename } from 'node:path'
 
-import { Adapters, create, getOptions, FileDTO, Note, NoteMeta } from '@cryptgeon/shared'
 import mime from 'mime'
 import { AES, Hex } from 'occulto'
+import { Adapters } from '../shared/adapters.js'
+import { API, FileDTO, Note, NoteMeta } from '../shared/api.js'
 
 export type UploadOptions = Pick<Note, 'views' | 'expiration'> & { password?: string }
 
@@ -38,8 +39,8 @@ export async function upload(input: string | string[], options: UploadOptions):
 
   // Create the actual note and upload it.
   const note: Note = { ...noteOptions, contents, meta: { type, derivation: derived?.[1] } }
-  const result = await create(note)
-  let url = `${getOptions().server}/note/${result.id}`
+  const result = await API.create(note)
+  let url = `${API.getOptions().server}/note/${result.id}`
   if (!derived) url += `#${Hex.encode(key)}`
   return url
 }

packages/cli/src/cli.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 import { Argument, Option, program } from '@commander-js/extra-typings'
-import { setOptions, 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'
+import { download } from './actions/download.js'
+import { upload } from './actions/upload.js'
+import { API } from './shared/api.js'
+import { parseFile, parseNumber } from './utils/parsers.js'
+import { getStdin } from './utils/stdin.js'
+import { checkConstrains, exit } from './utils/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)
@@ -33,8 +33,8 @@ program
   .description('show information about the server')
   .addOption(server)
   .action(async (options) => {
-    setOptions({ server: options.server })
-    const response = await status()
+    API.setOptions({ server: options.server })
+    const response = await API.status()
     const formatted = {
       ...response,
       max_size: prettyBytes(response.max_size),
@@ -54,7 +54,7 @@ send
   .addOption(minutes)
   .addOption(password)
   .action(async (files, options) => {
-    setOptions({ server: options.server })
+    API.setOptions({ server: options.server })
     await checkConstrains(options)
     options.password ||= await getStdin()
     try {
@@ -72,7 +72,7 @@ send
   .addOption(minutes)
   .addOption(password)
   .action(async (text, options) => {
-    setOptions({ server: options.server })
+    API.setOptions({ server: options.server })
     await checkConstrains(options)
     options.password ||= await getStdin()
     try {

packages/cli/src/index.ts

@@ -1,4 +1,4 @@
-export * from '@cryptgeon/shared'
-export * from './download.js'
-export * from './upload.js'
-export * from './utils.js'
+export * from './actions/download.js'
+export * from './actions/upload.js'
+export * from './shared/adapters.js'
+export * from './shared/api.js'

packages/cli/src/shared/adapters.ts

@@ -0,0 +1,61 @@
+import { AES, Bytes, type TypedArray } from 'occulto'
+import type { EncryptedFileDTO, FileDTO } from './api'
+
+abstract class CryptAdapter<T> {
+  abstract encrypt(plaintext: T, key: TypedArray): Promise<string>
+  abstract decrypt(ciphertext: string, key: TypedArray): Promise<T>
+}
+
+class CryptTextAdapter implements CryptAdapter<string> {
+  async encrypt(plaintext: string, key: TypedArray) {
+    return await AES.encrypt(Bytes.encode(plaintext), key)
+  }
+  async decrypt(ciphertext: string, key: TypedArray) {
+    return Bytes.decode(await AES.decrypt(ciphertext, key))
+  }
+}
+
+class CryptBlobAdapter implements CryptAdapter<TypedArray> {
+  async encrypt(plaintext: TypedArray, key: TypedArray) {
+    return await AES.encrypt(plaintext, key)
+  }
+
+  async decrypt(ciphertext: string, key: TypedArray) {
+    return await AES.decrypt(ciphertext, key)
+    // const plaintext = await AES.decrypt(ciphertext, key)
+    // return new Blob([plaintext], { type: 'application/octet-stream' })
+  }
+}
+
+class CryptFilesAdapter implements CryptAdapter<FileDTO[]> {
+  async encrypt(plaintext: FileDTO[], key: TypedArray) {
+    const adapter = new CryptBlobAdapter()
+    const data: Promise<EncryptedFileDTO>[] = plaintext.map(async (file) => ({
+      name: file.name,
+      size: file.size,
+      type: file.type,
+      contents: await adapter.encrypt(file.contents, key),
+    }))
+    return JSON.stringify(await Promise.all(data))
+  }
+
+  async decrypt(ciphertext: string, key: TypedArray) {
+    const adapter = new CryptBlobAdapter()
+    const data: EncryptedFileDTO[] = JSON.parse(ciphertext)
+    const files: FileDTO[] = await Promise.all(
+      data.map(async (file) => ({
+        name: file.name,
+        size: file.size,
+        type: file.type,
+        contents: await adapter.decrypt(file.contents, key),
+      }))
+    )
+    return files
+  }
+}
+
+export const Adapters = {
+  Text: new CryptTextAdapter(),
+  Blob: new CryptBlobAdapter(),
+  Files: new CryptFilesAdapter(),
+}

packages/cli/src/shared/api.ts

@@ -0,0 +1,138 @@
+import type { KeyData, TypedArray } from 'occulto'
+
+export type NoteMeta = {
+  type: 'text' | 'file'
+  derivation?: KeyData
+}
+
+export type Note = {
+  contents: string
+  meta: NoteMeta
+  views?: number
+  expiration?: number
+}
+export type NoteInfo = Pick<Note, 'meta'>
+export type NotePublic = Pick<Note, 'contents' | 'meta'>
+export type NoteCreate = Omit<Note, 'meta'> & { meta: string }
+
+export type FileDTO = Pick<File, 'name' | 'size' | 'type'> & {
+  contents: TypedArray
+}
+
+export type EncryptedFileDTO = Omit<FileDTO, 'contents'> & {
+  contents: string
+}
+
+type ClientOptions = {
+  server: string
+}
+
+type CallOptions = {
+  url: string
+  method: string
+  body?: any
+}
+
+export class PayloadToLargeError extends Error {}
+
+export let client: ClientOptions = {
+  server: '',
+}
+
+function setOptions(options: Partial<ClientOptions>) {
+  client = { ...client, ...options }
+}
+
+function getOptions(): ClientOptions {
+  return client
+}
+
+async function call(options: CallOptions) {
+  const url = client.server + '/api/' + options.url
+  const response = await fetch(url, {
+    method: options.method,
+    body: options.body === undefined ? undefined : JSON.stringify(options.body),
+    mode: 'cors',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  })
+
+  if (!response.ok) {
+    if (response.status === 413) throw new PayloadToLargeError()
+    else throw new Error('API call failed')
+  }
+  return response.json()
+}
+
+async function create(note: Note) {
+  const { meta, ...rest } = note
+  const body: NoteCreate = {
+    ...rest,
+    meta: JSON.stringify(meta),
+  }
+  const data = await call({
+    url: 'notes/',
+    method: 'post',
+    body,
+  })
+  return data as { id: string }
+}
+
+async function get(id: string): Promise<NotePublic> {
+  const data = await call({
+    url: `notes/${id}`,
+    method: 'delete',
+  })
+  const { contents, meta } = data
+  const note = {
+    contents,
+    meta: JSON.parse(meta),
+  } satisfies NotePublic
+  if (note.meta.derivation) note.meta.derivation.salt = new Uint8Array(Object.values(note.meta.derivation.salt))
+  return note
+}
+
+async function info(id: string): Promise<NoteInfo> {
+  const data = await call({
+    url: `notes/${id}`,
+    method: 'get',
+  })
+  const { meta } = data
+  const note = {
+    meta: JSON.parse(meta),
+  } satisfies NoteInfo
+  if (note.meta.derivation) note.meta.derivation.salt = new Uint8Array(Object.values(note.meta.derivation.salt))
+  return note
+}
+
+export type Status = {
+  version: string
+  max_size: number
+  max_views: number
+  max_expiration: number
+  allow_advanced: boolean
+  allow_files: boolean
+  theme_image: string
+  theme_text: string
+  theme_favicon: string
+  theme_page_title: string
+  theme_new_note_notice: boolean
+}
+
+async function status() {
+  const data = await call({
+    url: 'status/',
+    method: 'get',
+  })
+  return data as Status
+}
+
+export const API = {
+  setOptions,
+  getOptions,
+  create,
+  get,
+  info,
+  status,
+}

packages/cli/src/shared/shared.ts

@@ -0,0 +1,2 @@
+export * from './adapters.js'
+export * from './api.js'

packages/cli/src/utils/parsers.ts

@@ -21,7 +21,7 @@ export function parseURL(value: string, _: URL): URL {
 }
 
 export function parseNumber(value: string, _: number): number {
-  const n = parseInt(value, 10)
-  if (isNaN(n)) throw new InvalidOptionArgumentError('invalid number')
+  const n = Number.parseInt(value, 10)
+  if (Number.isNaN(n)) throw new InvalidOptionArgumentError('invalid number')
   return n
 }

packages/cli/src/utils/stdin.ts

@@ -18,6 +18,7 @@ export function getStdin(timeout: number = 10): Promise<string> {
       resolve('')
     }, timeout)
 
+    process.stdin.on('error', reject)
     process.stdin.on('data', dataHandler)
     process.stdin.on('end', endHandler)
   })

packages/cli/src/utils/utils.ts

@@ -1,5 +1,5 @@
-import { status } from '@cryptgeon/shared'
 import { exit as exitNode } from 'node:process'
+import { API } from '../shared/api.js'
 
 export function exit(message: string) {
   console.error(message)
@@ -11,7 +11,7 @@ export async function checkConstrains(constrains: { views?: number; minutes?: nu
   if (views && minutes) exit('cannot set view and minutes constrains simultaneously')
   if (!views && !minutes) constrains.views = 1
 
-  const response = await status()
+  const response = await API.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)

packages/cli/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "es2022",
     "module": "es2022",
-    "moduleResolution": "node",
+    "moduleResolution": "Bundler",
     "declaration": true,
     "emitDeclarationOnly": true,
     "strict": true,