#!/usr/bin/env node // Copyright Daytona Platforms Inc. // SPDX-License-Identifier: Apache-2.0 const fs = require('fs') const path = require('path') const SDK_SOURCE_DIR = path.resolve(__dirname, '../src/main/java/io/daytona/sdk') const DOCS_OUTPUT_DIR = path.resolve(__dirname, '../../../apps/docs/src/content/docs/en/java-sdk') const DOC_TARGETS = [ { outputFile: 'daytona.mdx', logName: 'Daytona', classes: [{ file: 'Daytona.java', className: 'Daytona' }] }, { outputFile: 'config.mdx', logName: 'DaytonaConfig', classes: [{ file: 'DaytonaConfig.java', className: 'DaytonaConfig', includeInner: ['Builder'] }], }, { outputFile: 'sandbox.mdx', logName: 'Sandbox', classes: [{ file: 'Sandbox.java', className: 'Sandbox' }] }, { outputFile: 'process.mdx', logName: 'Process', classes: [{ file: 'Process.java', className: 'Process' }], }, { outputFile: 'file-system.mdx', logName: 'FileSystem', classes: [{ file: 'FileSystem.java', className: 'FileSystem' }], }, { outputFile: 'git.mdx', logName: 'Git', classes: [{ file: 'Git.java', className: 'Git' }] }, { outputFile: 'snapshot.mdx', logName: 'SnapshotService', classes: [{ file: 'SnapshotService.java', className: 'SnapshotService' }], }, { outputFile: 'volume-service.mdx', logName: 'VolumeService', classes: [{ file: 'VolumeService.java', className: 'VolumeService' }], }, { outputFile: 'image.mdx', logName: 'Image', classes: [{ file: 'Image.java', className: 'Image' }] }, { outputFile: 'code-interpreter.mdx', logName: 'CodeInterpreter', classes: [ { file: 'CodeInterpreter.java', className: 'CodeInterpreter' }, { file: 'RunCodeOptions.java', className: 'RunCodeOptions' }, ], }, { outputFile: 'lsp-server.mdx', logName: 'LspServer', classes: [{ file: 'LspServer.java', className: 'LspServer' }], }, { outputFile: 'computer-use.mdx', logName: 'ComputerUse', classes: [{ file: 'ComputerUse.java', className: 'ComputerUse' }], }, { outputFile: 'pty-handle.mdx', logName: 'PtyHandle', classes: [{ file: 'PtyHandle.java', className: 'PtyHandle' }], }, { outputFile: 'pty.mdx', logName: 'PtyCreateOptions, PtyResult', title: 'Pty', classes: [ { file: 'PtyCreateOptions.java', className: 'PtyCreateOptions' }, { file: 'PtyResult.java', className: 'PtyResult' }, ], }, { outputFile: 'errors.mdx', logName: 'Exception Classes', title: 'Errors', classes: [ { file: 'exception/DaytonaException.java', className: 'DaytonaException' }, { file: 'exception/DaytonaAuthenticationException.java', className: 'DaytonaAuthenticationException' }, { file: 'exception/DaytonaBadRequestException.java', className: 'DaytonaBadRequestException' }, { file: 'exception/DaytonaConflictException.java', className: 'DaytonaConflictException' }, { file: 'exception/DaytonaConnectionException.java', className: 'DaytonaConnectionException' }, { file: 'exception/DaytonaForbiddenException.java', className: 'DaytonaForbiddenException' }, { file: 'exception/DaytonaNotFoundException.java', className: 'DaytonaNotFoundException' }, { file: 'exception/DaytonaRateLimitException.java', className: 'DaytonaRateLimitException' }, { file: 'exception/DaytonaServerException.java', className: 'DaytonaServerException' }, { file: 'exception/DaytonaTimeoutException.java', className: 'DaytonaTimeoutException' }, { file: 'exception/DaytonaValidationException.java', className: 'DaytonaValidationException' }, ], }, ] function ensureDir(dir) { fs.mkdirSync(dir, { recursive: true }) } function readUtf8(filePath) { return fs.readFileSync(filePath, 'utf8') } function normalizeWhitespace(value) { return String(value || '') .replace(/\s+/g, ' ') .trim() } function escapeType(type) { if (!type) return 'Object' return String(type).replace(//g, '\\>') } function splitTopLevel(value, separator) { const parts = [] const source = String(value || '') if (!source.trim()) return parts let buffer = '' let angle = 0 let paren = 0 let square = 0 for (let i = 0; i < source.length; i += 1) { const c = source[i] if (c === '<') angle += 1 if (c === '>') angle = Math.max(0, angle - 1) if (c === '(') paren += 1 if (c === ')') paren = Math.max(0, paren - 1) if (c === '[') square += 1 if (c === ']') square = Math.max(0, square - 1) if (c === separator && angle === 0 && paren === 0 && square === 0) { parts.push(buffer.trim()) buffer = '' continue } buffer += c } if (buffer.trim()) parts.push(buffer.trim()) return parts } function cleanJavadocInline(text) { return String(text || '') .replace(/\{@code\s+([^}]*)\}/g, '`$1`') .replace(/\{@link\s+([^}]*)\}/g, '`$1`') .replace(/<\/?code>/g, '`') .trim() } function parseJavadoc(raw) { if (!raw) return { description: '', params: {}, returns: '', throws: [] } const lines = raw .replace(/^\s*\/\*\*/, '') .replace(/\*\/\s*$/, '') .split('\n') .map((line) => line.replace(/^\s*\*\s?/, '').trimEnd()) const descriptionLines = [] const params = {} let returns = '' const throws = [] let currentTag = null for (const rawLine of lines) { const line = rawLine.trim() if (!line) { if (!currentTag) descriptionLines.push('') continue } if (line.startsWith('@param ')) { const body = line.replace(/^@param\s+/, '') const idx = body.indexOf(' ') const name = idx === -1 ? body.trim() : body.slice(0, idx).trim() const text = idx === -1 ? '' : body.slice(idx + 1).trim() params[name] = text currentTag = { kind: 'param', name } continue } if (line.startsWith('@return')) { returns = line.replace(/^@return\s*/, '').trim() currentTag = { kind: 'return' } continue } if (line.startsWith('@throws ') || line.startsWith('@exception ')) { const body = line.replace(/^@(throws|exception)\s+/, '') const idx = body.indexOf(' ') const type = idx === -1 ? body.trim() : body.slice(0, idx).trim() const text = idx === -1 ? '' : body.slice(idx + 1).trim() throws.push({ type, description: text }) currentTag = { kind: 'throws', index: throws.length - 1 } continue } if (line.startsWith('@')) { currentTag = null continue } if (!currentTag) { descriptionLines.push(line) continue } if (currentTag.kind === 'param') { const prev = params[currentTag.name] || '' params[currentTag.name] = prev ? `${prev} ${line}` : line continue } if (currentTag.kind === 'return') { returns = returns ? `${returns} ${line}` : line continue } if (currentTag.kind === 'throws') { const prev = throws[currentTag.index].description throws[currentTag.index].description = prev ? `${prev} ${line}` : line } } const description = descriptionLines .join('\n') .replace(/\r/g, '') .replace(/\n{3,}/g, '\n\n') .replace(/[ \t]+$/gm, '') .replace(/
\s*\{@code\s*/g, '\n```java\n')
.replace(/\s*\}\s*<\/pre>/g, '\n```\n')
.replace(//g, '\n```java\n')
.replace(/<\/pre>/g, '\n```\n')
.replace(/\{@code\s+([^}]*)\}/g, '`$1`')
.replace(/\{@link\s+([^}]*)\}/g, '`$1`')
.replace(/<\/?p>/g, '\n')
.replace(/<\/?code>/g, '`')
.trim()
return {
description,
params: Object.fromEntries(Object.entries(params).map(([k, v]) => [k, cleanJavadocInline(v)])),
returns: cleanJavadocInline(returns),
throws: throws.map((item) => ({
type: String(item.type || '').trim(),
description: cleanJavadocInline(item.description || ''),
})),
}
}
function findMatchingBrace(source, openBraceIndex) {
let depth = 0
for (let i = openBraceIndex; i < source.length; i += 1) {
if (source[i] === '{') depth += 1
if (source[i] === '}') depth -= 1
if (depth === 0) return i
}
return -1
}
function findClassBlock(source, className) {
const rx = new RegExp(
`((?:\\s*\/\\*\\*[\\s\\S]*?\\*\\/\\s*)?)\\s*public\\s+(?:static\\s+)?(?:final\\s+)?class\\s+${className}\\b[^\\{]*\\{`,
'm',
)
const match = rx.exec(source)
if (!match) return null
const start = match.index
const declaration = match[0]
const openBrace = start + declaration.lastIndexOf('{')
const closeBrace = findMatchingBrace(source, openBrace)
if (closeBrace < 0) return null
return {
className,
javadoc: parseJavadoc(match[1] || ''),
bodyStart: openBrace + 1,
bodyEnd: closeBrace,
body: source.slice(openBrace + 1, closeBrace),
}
}
function parseParameters(paramList) {
const params = []
for (const part of splitTopLevel(paramList || '', ',')) {
let token = normalizeWhitespace(part)
if (!token) continue
token = token.replace(/@[A-Za-z_][A-Za-z0-9_]*(?:\([^)]*\))?\s*/g, '')
token = token.replace(/\bfinal\b\s+/g, '').trim()
if (!token) continue
const items = token.split(/\s+/)
if (items.length < 2) {
params.push({ type: token, name: token })
continue
}
const name = items[items.length - 1].replace(/,$/, '').trim()
const type = items.slice(0, -1).join(' ').trim()
params.push({ type, name })
}
return params
}
function parsePublicMembers(classBlock) {
const fields = []
const constructors = []
const methods = []
const lines = classBlock.body.split('\n')
let depth = 1
let collecting = false
let commentBuffer = []
let pendingJavadocRaw = ''
for (const line of lines) {
const trimmed = line.trim()
const currentDepth = depth
if (!collecting && currentDepth === 1 && trimmed.startsWith('/**')) {
collecting = true
commentBuffer = [line]
if (trimmed.includes('*/')) {
collecting = false
pendingJavadocRaw = commentBuffer.join('\n')
}
} else if (collecting) {
commentBuffer.push(line)
if (trimmed.includes('*/')) {
collecting = false
pendingJavadocRaw = commentBuffer.join('\n')
}
} else if (currentDepth === 1) {
// Strip single-line method bodies: "public Type foo() { return x; }" → "public Type foo() {"
const normalized = normalizeWhitespace(trimmed).replace(/\{[^{}]*\}\s*$/, '{')
if (normalized.startsWith('public static class ') || normalized.startsWith('public class ')) {
pendingJavadocRaw = ''
} else if (
normalized.startsWith('public ') &&
!normalized.startsWith('public enum ') &&
!normalized.startsWith('public interface ')
) {
if (normalized.includes('(')) {
const constructorRx = new RegExp(
`^public\\s+${classBlock.className}\\s*\\(([^)]*)\\)\\s*(?:throws\\s+([^\\{]+))?\\s*\\{?$`,
)
const cMatch = normalized.match(constructorRx)
if (cMatch) {
constructors.push({
signature: `public ${classBlock.className}(${(cMatch[1] || '').trim()})${cMatch[2] ? ` throws ${normalizeWhitespace(cMatch[2])}` : ''}`,
parameters: parseParameters(cMatch[1]),
throwsTypes: splitTopLevel(cMatch[2] || '', ',').map((v) => normalizeWhitespace(v)),
javadoc: parseJavadoc(pendingJavadocRaw),
})
pendingJavadocRaw = ''
} else {
const mMatch = normalized.match(
/^public\s+(static\s+)?([\w<>, ?\[\].]+?)\s+(\w+)\s*\(([^)]*)\)\s*(?:throws\s+([^\{]+))?\s*\{?$/,
)
if (mMatch) {
methods.push({
name: mMatch[3],
returnType: normalizeWhitespace(mMatch[2]),
signature:
`public ${mMatch[1] || ''}${mMatch[2]} ${mMatch[3]}(${(mMatch[4] || '').trim()})${mMatch[5] ? ` throws ${normalizeWhitespace(mMatch[5])}` : ''}`
.replace(/\s+/g, ' ')
.trim(),
parameters: parseParameters(mMatch[4]),
throwsTypes: splitTopLevel(mMatch[5] || '', ',').map((v) => normalizeWhitespace(v)),
javadoc: parseJavadoc(pendingJavadocRaw),
})
pendingJavadocRaw = ''
}
}
} else if (normalized.endsWith(';')) {
const fMatch = normalized.match(
/^public\s+(?:static\s+)?(?:final\s+)?([\w<>, ?\[\].]+?)\s+(\w+)\s*(?:=.*)?;$/,
)
if (fMatch) {
fields.push({
name: fMatch[2],
type: normalizeWhitespace(fMatch[1]),
javadoc: parseJavadoc(pendingJavadocRaw),
})
pendingJavadocRaw = ''
}
}
}
}
for (const c of line) {
if (c === '{') depth += 1
if (c === '}') depth -= 1
}
}
return { fields, constructors, methods }
}
function collectThrows(declaredThrows, javadocThrows) {
const merged = []
for (const type of declaredThrows || []) {
const match = (javadocThrows || []).find((t) => t.type.endsWith(type) || type.endsWith(t.type))
merged.push({ type, description: match ? match.description : '' })
}
for (const tag of javadocThrows || []) {
if (!merged.some((item) => item.type === tag.type)) merged.push(tag)
}
return merged
}
function pushParamsSection(lines, parameters, javadocParams) {
if (!parameters.length) return
lines.push('**Parameters**:')
lines.push('')
for (const param of parameters) {
const desc = (javadocParams && javadocParams[param.name]) || ''
lines.push(`- \`${param.name}\` _${escapeType(param.type)}_ - ${desc}`.trimEnd())
}
lines.push('')
}
function pushThrowsSection(lines, throwsList) {
if (!throwsList.length) return
lines.push('**Throws**:')
lines.push('')
for (const item of throwsList) {
lines.push(`- \`${escapeType(item.type)}\` - ${item.description || ''}`.trimEnd())
}
lines.push('')
}
function buildClassDoc(classData) {
const lines = []
lines.push(`## ${classData.className}`)
lines.push('')
const classDescription = classData.javadoc.description || `${classData.className} class for Daytona SDK.`
lines.push(classDescription)
lines.push('')
if (classData.fields.length) {
lines.push('**Properties**:')
lines.push('')
for (const field of classData.fields) {
lines.push(`- \`${field.name}\` _${escapeType(field.type)}_ - ${field.javadoc.description || ''}`.trimEnd())
}
lines.push('')
}
if (classData.constructors.length) {
lines.push('### Constructors')
lines.push('')
for (const ctor of classData.constructors) {
lines.push(`#### new ${classData.className}()`)
lines.push('')
lines.push('```java')
lines.push(ctor.signature)
lines.push('```')
lines.push('')
if (ctor.javadoc.description) {
lines.push(ctor.javadoc.description)
lines.push('')
}
pushParamsSection(lines, ctor.parameters, ctor.javadoc.params)
pushThrowsSection(lines, collectThrows(ctor.throwsTypes, ctor.javadoc.throws))
}
}
if (classData.methods.length) {
lines.push('### Methods')
lines.push('')
for (const method of classData.methods) {
lines.push(`#### ${method.name}()`)
lines.push('')
lines.push('```java')
lines.push(method.signature)
lines.push('```')
lines.push('')
if (method.javadoc.description) {
lines.push(method.javadoc.description)
lines.push('')
}
pushParamsSection(lines, method.parameters, method.javadoc.params)
if (method.returnType && method.returnType !== 'void') {
lines.push('**Returns**:')
lines.push('')
lines.push(`- \`${escapeType(method.returnType)}\` - ${method.javadoc.returns || ''}`.trimEnd())
lines.push('')
}
pushThrowsSection(lines, collectThrows(method.throwsTypes, method.javadoc.throws))
}
}
return lines.join('\n')
}
function renderFrontmatter(title) {
return `---\ntitle: "${title}"\nhideTitleOnPage: true\n---\n\n`
}
function postProcess(content) {
return (
String(content)
.replace(/\r/g, '')
.replace(/\n{3,}/g, '\n\n')
.replace(/```java\n\n/g, '```java\n')
.replace(/\n\n```/g, '\n```')
.replace(/[ \t]+$/gm, '')
.trim() + '\n'
)
}
function parseTopClass(fileRelativePath, className) {
const sourcePath = path.join(SDK_SOURCE_DIR, fileRelativePath)
if (!fs.existsSync(sourcePath)) throw new Error(`Source file not found: ${sourcePath}`)
const source = readUtf8(sourcePath)
const classBlock = findClassBlock(source, className)
if (!classBlock) throw new Error(`Class ${className} not found in ${fileRelativePath}`)
const members = parsePublicMembers(classBlock)
return {
className,
javadoc: classBlock.javadoc,
fields: members.fields,
constructors: members.constructors,
methods: members.methods,
source,
}
}
function parseInnerClass(parentSource, parentClassName, innerClassName) {
const parent = findClassBlock(parentSource, parentClassName)
if (!parent) return null
const classRx = new RegExp(`public\\s+(?:static\\s+)?class\\s+${innerClassName}\\b[^\\{]*\\{`, 'm')
const classMatch = classRx.exec(parent.body)
if (!classMatch) return null
const textBefore = parent.body.slice(0, classMatch.index)
const javadocRx = /\/\*\*(?:(?!\/\*\*)[\s\S])*?\*\/\s*$/
const javadocMatch = textBefore.match(javadocRx)
const relativeStart = classMatch.index
const declaration = classMatch[0]
const openBrace = parent.bodyStart + relativeStart + declaration.lastIndexOf('{')
const closeBrace = findMatchingBrace(parentSource, openBrace)
if (closeBrace < 0) return null
const body = parentSource.slice(openBrace + 1, closeBrace)
const block = { className: innerClassName, body }
const members = parsePublicMembers(block)
return {
className: `${parentClassName}.${innerClassName}`,
javadoc: parseJavadoc(javadocMatch ? javadocMatch[0] : ''),
fields: members.fields,
constructors: members.constructors,
methods: members.methods,
}
}
function generateTarget(target) {
console.log(`📝 Generating docs for ${target.logName}...`)
const classDocs = []
for (const classTarget of target.classes) {
const parsed = parseTopClass(classTarget.file, classTarget.className)
classDocs.push(parsed)
if (classTarget.includeInner && classTarget.includeInner.length) {
for (const innerName of classTarget.includeInner) {
const innerParsed = parseInnerClass(parsed.source, classTarget.className, innerName)
if (!innerParsed) throw new Error(`Inner class ${innerName} not found in ${classTarget.className}`)
classDocs.push(innerParsed)
}
}
}
const title = target.title || classDocs[0].className
const body = classDocs.map((item) => buildClassDoc(item)).join('\n\n')
const content = renderFrontmatter(title) + postProcess(body)
const outputPath = path.join(DOCS_OUTPUT_DIR, target.outputFile)
fs.writeFileSync(outputPath, content)
console.log(`✅ Generated: ${target.outputFile}`)
}
function main() {
console.log('🚀 Starting documentation generation...')
console.log(`📂 Output directory: ${DOCS_OUTPUT_DIR}`)
console.log('')
ensureDir(DOCS_OUTPUT_DIR)
for (const target of DOC_TARGETS) generateTarget(target)
console.log('')
console.log('✨ Documentation generation complete!')
}
if (require.main === module) main()