tovuk 0.1.47

package/src/internal/json.ts

@@ -0,0 +1,103 @@
+import type { JsonObject, JsonValue } from './types.ts'
+
+function parseJson(text: string): JsonValue | null {
+  if (!text.trim()) {
+    return null
+  }
+  try {
+    return toJsonValue(JSON.parse(text)) ?? null
+  } catch {
+    return null
+  }
+}
+
+function toJsonValue(value: unknown): JsonValue | undefined {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+    return value
+  }
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : undefined
+  }
+  if (isUnknownArray(value)) {
+    return jsonArrayValue(value)
+  }
+  if (isUnknownRecord(value)) {
+    return jsonObjectValue(value)
+  }
+  return undefined
+}
+
+function jsonArrayValue(value: readonly unknown[]): JsonValue[] | undefined {
+  const items: JsonValue[] = []
+  for (const item of value) {
+    const parsed = toJsonValue(item)
+    if (parsed === undefined) {
+      return undefined
+    }
+    items.push(parsed)
+  }
+  return items
+}
+
+function jsonObjectValue(value: Record<string, unknown>): JsonObject | undefined {
+  const object: JsonObject = {}
+  for (const [key, item] of Object.entries(value)) {
+    const parsed = toJsonValue(item)
+    if (parsed === undefined) {
+      return undefined
+    }
+    object[key] = parsed
+  }
+  return object
+}
+
+function isUnknownArray(value: unknown): value is readonly unknown[] {
+  return Array.isArray(value)
+}
+
+function isUnknownRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isJsonObject(value: JsonValue | null): value is JsonObject {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function jsonObjectOrEmpty(value: JsonValue | null): JsonObject {
+  return isJsonObject(value) ? value : {}
+}
+
+function jsonObjectField(source: JsonObject, key: string): JsonObject {
+  return jsonObjectOrEmpty(source[key] ?? null)
+}
+
+function optionalJsonObjectField(source: JsonObject, key: string): JsonObject | null {
+  const value = source[key] ?? null
+  return isJsonObject(value) ? value : null
+}
+
+function jsonArrayField(source: JsonObject, key: string): JsonValue[] {
+  const value = source[key]
+  return Array.isArray(value) ? value : []
+}
+
+function stringField(source: JsonObject, key: string): string {
+  const value = source[key]
+  return typeof value === 'string' ? value : ''
+}
+
+function numberField(source: JsonObject, key: string): number {
+  const value = source[key]
+  return typeof value === 'number' ? value : Number(value ?? 0)
+}
+
+export {
+  parseJson,
+  isJsonObject,
+  jsonObjectOrEmpty,
+  jsonObjectField,
+  optionalJsonObjectField,
+  jsonArrayField,
+  stringField,
+  numberField
+}

package/src/internal/preview.ts

@@ -0,0 +1,116 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { createServer } from 'node:http'
+import path from 'node:path'
+import { parseTovukToml, validateConfig } from './config.ts'
+import { runDoctorWorkspace } from './doctor.ts'
+import { agentError } from './errors.ts'
+import { ensureDirectory } from './project.ts'
+
+function previewProject(projectDir: string, port: number): void {
+  const report = runDoctorWorkspace(projectDir)
+  if ('projects' in report) {
+    throw agentError('workspace_preview_unsupported', 'Preview one project at a time.', 'Run `npx tovuk preview api` or `npx tovuk preview web` from the workspace root.', false)
+  }
+  if (!report.ok) {
+    const firstFailure = report.checks.find((check) => !check.ok)
+    throw agentError('doctor_failed', 'Tovuk doctor failed.', firstFailure?.agent_instruction || 'Fix the failed checks and retry `npx tovuk preview`.', false)
+  }
+
+  const config = parseTovukToml(readFileSync(path.join(projectDir, 'tovuk.toml'), 'utf8'), projectDir)
+  validateConfig(config)
+  runShell(config.build.command, projectDir, 'Build failed before preview.')
+  if (config.kind === 'static_frontend') {
+    previewStatic(projectDir, config.build.output ?? 'dist', port)
+    return
+  }
+  previewRuntime(projectDir, config.run.command ?? '', port || config.run.port)
+}
+
+function previewStatic(projectDir: string, output: string, port: number): void {
+  serveStatic(path.join(projectDir, output), port || 4173)
+}
+
+function previewRuntime(projectDir: string, command: string, port: number): void {
+  console.log(`preview http://127.0.0.1:${port}`)
+  const result = spawnSync(command, {
+    cwd: projectDir,
+    env: { ...process.env, PORT: String(port) },
+    shell: true,
+    stdio: 'inherit'
+  })
+  if (result.error) {
+    throw agentError('preview_failed', 'Preview command failed.', result.error.message, false)
+  }
+  if (result.status !== 0) {
+    throw agentError('preview_failed', 'Preview command exited with an error.', 'Fix the local runtime command and retry `npx tovuk preview`.', false)
+  }
+}
+
+function runShell(command: string, projectDir: string, failureMessage: string): void {
+  console.log(command)
+  const result = spawnSync(command, {
+    cwd: projectDir,
+    env: process.env,
+    shell: true,
+    stdio: 'inherit'
+  })
+  if (result.error) {
+    throw agentError('command_failed', failureMessage, result.error.message, false)
+  }
+  if (result.status !== 0) {
+    throw agentError('command_failed', failureMessage, 'Fix the command output above, then retry.', false)
+  }
+}
+
+function serveStatic(root: string, port: number): void {
+  ensureDirectory(root)
+  const server = createServer((request, response) => {
+    const pathname = decodeURIComponent(new URL(request.url || '/', `http://127.0.0.1:${port}`).pathname)
+    const target = staticTarget(root, pathname)
+    if (!target) {
+      response.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' })
+      response.end('not found')
+      return
+    }
+    response.writeHead(200, { 'content-type': contentType(target) })
+    response.end(readFileSync(target))
+  })
+  server.listen(port, '127.0.0.1', () => {
+    console.log(`preview http://127.0.0.1:${port}`)
+  })
+}
+
+function staticTarget(root: string, pathname: string): string {
+  const safePath = pathname.replace(/^\/+/u, '')
+  const candidate = path.resolve(root, safePath || 'index.html')
+  if (!candidate.startsWith(path.resolve(root) + path.sep) && candidate !== path.resolve(root)) {
+    return ''
+  }
+  if (existsSync(candidate) && statSync(candidate).isFile()) {
+    return candidate
+  }
+  const index = path.join(root, 'index.html')
+  return existsSync(index) ? index : ''
+}
+
+function contentType(file: string): string {
+  if (file.endsWith('.html')) {
+    return 'text/html; charset=utf-8'
+  }
+  if (file.endsWith('.css')) {
+    return 'text/css; charset=utf-8'
+  }
+  if (file.endsWith('.js') || file.endsWith('.mjs')) {
+    return 'text/javascript; charset=utf-8'
+  }
+  if (file.endsWith('.json')) {
+    return 'application/json; charset=utf-8'
+  }
+  if (file.endsWith('.svg')) {
+    return 'image/svg+xml'
+  }
+  return 'application/octet-stream'
+}
+
+export { previewProject }

package/src/internal/project.ts

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { WALK_EXCLUDED_DIRS } from './constants.ts'
+import { agentError } from './errors.ts'
+import type { CliOptions, FileVisitor, JsonValue, PackageManifest, PathVisitor, ProjectKind } from './types.ts'
+
+function hasCommand(command: string): boolean {
+  return (process.env['PATH'] ?? '')
+    .split(path.delimiter)
+    .filter(Boolean)
+    .some((directory) => existsSync(path.join(directory, command)))
+}
+
+function isSafeRelativePath(value: string | undefined): value is string {
+  return typeof value === 'string'
+    && value.length > 0
+    && !path.isAbsolute(value)
+    && !value.includes('\\')
+    && value.split('/').every((part) => part && part !== '.' && part !== '..')
+}
+
+function walkProjectFiles(projectDir: string, visit: FileVisitor): void {
+  walk(projectDir, (file) => {
+    visit(file, path.relative(projectDir, file).replace(/\\/gu, '/'))
+  })
+}
+
+function walk(dir: string, visit: PathVisitor): void {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (WALK_EXCLUDED_DIRS.has(entry.name)) {
+      continue
+    }
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      walk(fullPath, visit)
+      continue
+    }
+    if (entry.isFile()) {
+      visit(fullPath)
+    }
+  }
+}
+
+function ensureDirectory(dir: string): void {
+  if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+    throw agentError('missing_project', 'Project directory does not exist.', 'Run Tovuk from the root of a Rust project or pass the project path.', false)
+  }
+}
+
+function serviceNameFromDir(projectDir: string): string {
+  const name = serviceNameFromValue(path.basename(projectDir))
+  return name || 'api'
+}
+
+function serviceNameFromCargo(projectDir: string): string {
+  try {
+    const source = readFileSync(path.join(projectDir, 'Cargo.toml'), 'utf8')
+    return serviceNameFromValue(source.match(/^\s*name\s*=\s*"([^"]+)"/mu)?.[1] || '')
+  } catch {
+    return ''
+  }
+}
+
+function serviceNameFromPackage(projectDir: string): string {
+  const manifest = readPackageJson(projectDir)
+  return serviceNameFromValue(typeof manifest?.name === 'string' ? manifest.name : '')
+}
+
+function serviceNameFromValue(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9-]+/gu, '-').replace(/^-+|-+$/gu, '').slice(0, 48)
+}
+
+function inferProjectKind(projectDir: string): ProjectKind {
+  if (existsSync(path.join(projectDir, 'Cargo.toml'))) {
+    return 'rust_backend'
+  }
+  if (existsSync(path.join(projectDir, 'package.json'))) {
+    return 'static_frontend'
+  }
+  return 'rust_backend'
+}
+
+function readPackageJson(projectDir: string): PackageManifest | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path.join(projectDir, 'package.json'), 'utf8'))
+    return isPackageManifest(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+function isPackageManifest(value: unknown): value is PackageManifest {
+  if (!isRecord(value)) {
+    return false
+  }
+  const name = value['name']
+  const scripts = value['scripts']
+  return (name === undefined || typeof name === 'string') &&
+    (scripts === undefined || isStringRecord(scripts))
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isStringRecord(value: unknown): value is Record<string, string | undefined> {
+  return isRecord(value) && Object.values(value).every((entry) => entry === undefined || typeof entry === 'string')
+}
+
+function printJson(value: JsonValue | null): void {
+  console.log(JSON.stringify(value, null, 2))
+}
+
+function openUrl(url: string): void {
+  const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open'
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url]
+  spawnSync(command, args, { stdio: 'ignore' })
+}
+
+function sleep(milliseconds: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds)
+  })
+}
+
+function progress(cli: CliOptions, message: string): void {
+  if (cli.json) {
+    console.error(message)
+    return
+  }
+  console.log(message)
+}
+
+export { hasCommand, isSafeRelativePath, walkProjectFiles, ensureDirectory, serviceNameFromDir, serviceNameFromCargo, serviceNameFromPackage, inferProjectKind, readPackageJson, printJson, openUrl, sleep, progress }

package/src/internal/rust-doctor.ts

@@ -0,0 +1,157 @@
+import { spawnSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { walkProjectFiles } from './project.ts'
+import type { DoctorCheck } from './types.ts'
+
+interface CargoCheckSpec {
+  name: string
+  args: string[]
+  missing: string
+  failed: string
+}
+
+function rustDoctorChecks(projectDir: string, configValid: boolean): DoctorCheck[] {
+  const checks = [cargoLints(projectDir), unsafeCheck(projectDir)]
+  if (configValid) {
+    checks.push(cargoFmt(projectDir), cargoCheck(projectDir), cargoClippy(projectDir))
+  }
+  return checks
+}
+
+function unsafeCheck(projectDir: string): DoctorCheck {
+  const unsafeHits = scanUnsafe(projectDir)
+  return {
+    name: 'unsafe',
+    ok: unsafeHits.length === 0,
+    message: unsafeHits.length === 0 ? 'no direct unsafe found' : unsafeHits.slice(0, 5).join(', '),
+    agent_instruction: unsafeHits.length === 0 ? null : 'Remove direct unsafe usage from workspace Rust source before deploying.'
+  }
+}
+
+function scanUnsafe(projectDir: string): string[] {
+  const hits: string[] = []
+  walkProjectFiles(projectDir, (file, relative) => {
+    if (!file.endsWith('.rs')) {
+      return
+    }
+    const source = readFileSync(file, 'utf8')
+    if (/\bunsafe\b/u.test(source)) {
+      hits.push(relative)
+    }
+  })
+  return hits
+}
+
+function cargoCheck(projectDir: string): DoctorCheck {
+  return cargoCommandCheck(projectDir, {
+    name: 'cargo check',
+    args: ['check', '--locked', '--quiet'],
+    missing: 'Install Rust and Cargo, then run `cargo check --locked` locally before deploying.',
+    failed: 'Run `cargo check --locked`, fix every compiler error and warning, then redeploy.'
+  })
+}
+
+function cargoFmt(projectDir: string): DoctorCheck {
+  return cargoCommandCheck(projectDir, {
+    name: 'cargo fmt',
+    args: ['fmt', '--all', '--check'],
+    missing: 'Install rustfmt with Rust, then run `cargo fmt --all --check` before deploying.',
+    failed: 'Run `cargo fmt --all`, then redeploy.'
+  })
+}
+
+function cargoClippy(projectDir: string): DoctorCheck {
+  return cargoCommandCheck(projectDir, {
+    name: 'cargo clippy',
+    args: ['clippy', '--locked', '--all-targets', '--all-features', '--quiet', '--', '-D', 'warnings'],
+    missing: 'Install Rust clippy, then run `cargo clippy --locked --all-targets --all-features -- -D warnings` before deploying.',
+    failed: 'Run `cargo clippy --locked --all-targets --all-features -- -D warnings`, fix every warning, then redeploy.'
+  })
+}
+
+function cargoCommandCheck(projectDir: string, check: CargoCheckSpec): DoctorCheck {
+  const cargo = spawnSync('cargo', check.args, {
+    cwd: projectDir,
+    encoding: 'utf8',
+    env: { ...process.env, CARGO_TERM_COLOR: 'never' },
+    stdio: ['ignore', 'pipe', 'pipe']
+  })
+
+  if (cargo.error) {
+    return {
+      name: check.name,
+      ok: false,
+      message: cargo.error.message,
+      agent_instruction: check.missing
+    }
+  }
+
+  return {
+    name: check.name,
+    ok: cargo.status === 0,
+    message: cargo.status === 0 ? 'passed' : (cargo.stderr || cargo.stdout || `${check.name} failed`).trim().slice(0, 240),
+    agent_instruction: cargo.status === 0 ? null : check.failed
+  }
+}
+
+function cargoLints(projectDir: string): DoctorCheck {
+  const cargoToml = path.join(projectDir, 'Cargo.toml')
+  let source = ''
+  try {
+    source = readFileSync(cargoToml, 'utf8')
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    return {
+      name: 'cargo lints',
+      ok: false,
+      message,
+      agent_instruction: 'Create Cargo.toml with strict Rust lints, then retry.'
+    }
+  }
+
+  const ok = cargoLintLevel(source, 'unsafe_code') === 'forbid' &&
+    cargoLintLevel(source, 'warnings') === 'deny'
+  return {
+    name: 'cargo lints',
+    ok,
+    message: ok ? 'strict' : 'missing unsafe_code=forbid or warnings=deny',
+    agent_instruction: ok ? null : 'Add `[lints.rust]` with `unsafe_code = "forbid"` and `warnings = "deny"`, then retry.'
+  }
+}
+
+function cargoLintLevel(source: string, lintName: string): string {
+  let section = ''
+  for (const rawLine of source.split(/\r?\n/u)) {
+    const line = rawLine.replace(/#.*/u, '').trim()
+    const nextSection = tomlSection(line)
+    if (nextSection !== null) {
+      section = nextSection
+      continue
+    }
+    if (!isRustLintSection(section)) {
+      continue
+    }
+    const level = lintAssignmentLevel(line, lintName)
+    if (level) {
+      return level
+    }
+  }
+
+  return ''
+}
+
+function tomlSection(line: string): string | null {
+  return line.match(/^\[([^\]]+)\]$/u)?.[1] ?? null
+}
+
+function isRustLintSection(section: string): boolean {
+  return section === 'lints.rust' || section === 'workspace.lints.rust'
+}
+
+function lintAssignmentLevel(line: string, lintName: string): string {
+  const assignment = line.match(/^([A-Za-z0-9_]+)\s*=\s*(?:"([^"]+)"|\{[^}]*level\s*=\s*"([^"]+)")/u)
+  return assignment?.[1] === lintName ? assignment[2] ?? assignment[3] ?? '' : ''
+}
+
+export { rustDoctorChecks, unsafeCheck }