tovuk 0.1.47

package/src/internal/template-sources.ts

@@ -0,0 +1,197 @@
+import type { JsonObject } from './types.ts'
+
+function frontendPackageJson(name: string): string {
+  return jsonSource({
+    name,
+    private: true,
+    type: 'module',
+    scripts: {
+      typecheck: 'oxlint src vite.config.ts --deny-warnings --type-aware --type-check --tsconfig tsconfig.json',
+      lint: 'oxlint src vite.config.ts --deny-warnings && fallow dead-code --production --include-dupes --include-entry-exports --fail-on-issues && fallow dupes --production --mode semantic --threshold 1 --ignore-imports --fail-on-issues && fallow health --production --max-cyclomatic 10 --max-cognitive 15 --max-crap 20 --complexity',
+      build: 'vite build',
+      preview: 'vite preview --host 0.0.0.0'
+    },
+    dependencies: {
+      '@tanstack/react-router': '^1.170.8',
+      react: '^19.2.6',
+      'react-dom': '^19.2.6'
+    },
+    devDependencies: {
+      '@types/node': '^25.9.1',
+      '@types/react': '^19.2.15',
+      '@types/react-dom': '^19.2.3',
+      '@vitejs/plugin-react': '^6.0.2',
+      fallow: '^2.84.0',
+      oxlint: '^1.67.0',
+      'oxlint-tsgolint': '^0.23.0',
+      vite: '^8.0.14'
+    }
+  })
+}
+
+function frontendTsConfig(): string {
+  return jsonSource({
+    compilerOptions: {
+      allowUnreachableCode: false,
+      allowUnusedLabels: false,
+      alwaysStrict: true,
+      erasableSyntaxOnly: true,
+      exactOptionalPropertyTypes: true,
+      forceConsistentCasingInFileNames: true,
+      isolatedModules: true,
+      jsx: 'react-jsx',
+      lib: ['ESNext', 'DOM'],
+      module: 'ESNext',
+      moduleDetection: 'force',
+      moduleResolution: 'Bundler',
+      noEmit: true,
+      noFallthroughCasesInSwitch: true,
+      noImplicitAny: true,
+      noImplicitOverride: true,
+      noImplicitReturns: true,
+      noImplicitThis: true,
+      noPropertyAccessFromIndexSignature: true,
+      noUncheckedIndexedAccess: true,
+      noUncheckedSideEffectImports: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      skipLibCheck: false,
+      strict: true,
+      strictBindCallApply: true,
+      strictFunctionTypes: true,
+      strictNullChecks: true,
+      strictPropertyInitialization: true,
+      target: 'ES2022',
+      types: ['vite/client', 'node'],
+      useUnknownInCatchVariables: true,
+      verbatimModuleSyntax: true
+    },
+    include: ['src', 'vite.config.ts']
+  })
+}
+
+function rustApiSource(): string {
+  return `use std::{
+    io::{Read, Write},
+    net::{TcpListener, TcpStream},
+};
+
+fn main() -> std::io::Result<()> {
+    let port = std::env::var("PORT").unwrap_or_else(|_error| "3000".to_owned());
+    let listener = TcpListener::bind(format!("0.0.0.0:{port}"))?;
+
+    for stream in listener.incoming() {
+        handle(stream?)?;
+    }
+
+    Ok(())
+}
+
+fn handle(mut stream: TcpStream) -> std::io::Result<()> {
+    let mut buffer = [0_u8; 2048];
+    let size = stream.read(&mut buffer)?;
+    let request = String::from_utf8_lossy(&buffer[..size]);
+    let mut parts = request
+        .lines()
+        .next()
+        .unwrap_or_default()
+        .split_whitespace();
+    let method = parts.next().unwrap_or_default();
+    let path = parts.next().unwrap_or("/");
+    let origin = request
+        .lines()
+        .find_map(|line| line.strip_prefix("Origin: "))
+        .unwrap_or("*");
+    let cors_origin = allowed_origin(origin);
+
+    if method == "OPTIONS" {
+        return write_response(&mut stream, "204 No Content", "", &cors_origin);
+    }
+
+    let body = if path == "/healthz" {
+        r#"{"ok":true}"#
+    } else {
+        r#"{"message":"hello from tovuk","backend":"rust"}"#
+    };
+    write_response(&mut stream, "200 OK", body, &cors_origin)
+}
+
+fn allowed_origin(request_origin: &str) -> String {
+    let configured = std::env::var("FRONTEND_ORIGIN").unwrap_or_else(|_error| request_origin.to_owned());
+    if configured == "*" || configured == request_origin {
+        configured
+    } else {
+        "null".to_owned()
+    }
+}
+
+fn write_response(
+    stream: &mut TcpStream,
+    status: &str,
+    body: &str,
+    origin: &str,
+) -> std::io::Result<()> {
+    write!(
+        stream,
+        "HTTP/1.1 {status}\\r\\ncontent-type: application/json\\r\\ncontent-length: {}\\r\\naccess-control-allow-origin: {origin}\\r\\naccess-control-allow-methods: GET, OPTIONS\\r\\naccess-control-allow-headers: content-type, authorization\\r\\nconnection: close\\r\\n\\r\\n{body}",
+        body.len()
+    )
+}
+`
+}
+
+function frontendSource(apiBaseUrl: string): string {
+  return `import { createRootRoute, createRouter, RouterProvider } from '@tanstack/react-router'
+import { createRoot } from 'react-dom/client'
+import './styles.css'
+
+const apiBaseUrl = import.meta.env.VITE_API_URL ?? '${apiBaseUrl}'
+
+function App() {
+  return (
+    <main>
+      <section>
+        <h1>Tovuk TanStack Frontend</h1>
+        <p>Static runtime, dynamic Rust backend calls.</p>
+        <code>{apiBaseUrl}</code>
+      </section>
+    </main>
+  )
+}
+
+const rootRoute = createRootRoute({ component: App })
+const router = createRouter({ routeTree: rootRoute })
+
+declare module '@tanstack/react-router' {
+  interface Register {
+    router: typeof router
+  }
+}
+
+const rootElement = document.getElementById('root')
+if (rootElement === null) {
+  throw new Error('missing root element')
+}
+
+createRoot(rootElement).render(<RouterProvider router={router} />)
+`
+}
+
+function frontendViteEnvSource(): string {
+  return `/// <reference types="vite/client" />
+
+interface ViteTypeOptions {
+  strictImportMetaEnv: unknown
+}
+
+interface ImportMetaEnv {
+  readonly VITE_API_URL?: string
+}
+`
+}
+
+function jsonSource(value: JsonObject): string {
+  return `${JSON.stringify(value, null, 2)}\n`
+}
+
+export { frontendPackageJson, frontendSource, frontendTsConfig, frontendViteEnvSource, rustApiSource }

package/src/internal/templates.ts

@@ -0,0 +1,151 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { DEFAULT_RUST_CHECK_COMMAND, PROJECT_TEMPLATES } from './constants.ts'
+import { agentError } from './errors.ts'
+import { doctorProject } from './doctor.ts'
+import { frontendBuildCommand, frontendCheckCommand } from './frontend-policy.ts'
+import { ensureDirectory, inferProjectKind, serviceNameFromCargo, serviceNameFromDir, serviceNameFromPackage } from './project.ts'
+import { frontendPackageJson, frontendSource, frontendTsConfig, frontendViteEnvSource, rustApiSource } from './template-sources.ts'
+import type { TemplateName } from './types.ts'
+
+type TemplateWriter = (projectDir: string) => void
+type TemplateFile = readonly [relative: string, source: string]
+
+const TEMPLATE_WRITERS: Readonly<Record<TemplateName, TemplateWriter>> = {
+  'rust-api': (projectDir): void => writeRustApiTemplate(projectDir, serviceNameFromDir(projectDir)),
+  'tanstack-static-frontend': (projectDir): void => writeFrontendTemplate(projectDir, serviceNameFromDir(projectDir), '/api'),
+  'fullstack-rust-tanstack': (projectDir): void => {
+    writeRustApiTemplate(path.join(projectDir, 'api'), 'api')
+    writeFrontendTemplate(path.join(projectDir, 'web'), 'web', 'http://localhost:3000')
+  }
+}
+
+function initProject(projectDir: string, template = ''): void {
+  if (template) {
+    mkdirSync(projectDir, { recursive: true, mode: 0o755 })
+    createTemplate(projectDir, template)
+    return
+  }
+  ensureDirectory(projectDir)
+
+  const configPath = path.join(projectDir, 'tovuk.toml')
+  if (existsSync(configPath)) {
+    console.log('tovuk.toml already exists')
+    return
+  }
+
+  const kind = inferProjectKind(projectDir)
+  const source = kind === 'static_frontend'
+    ? frontendConfig(projectDir)
+    : rustBackendConfig(projectDir)
+
+  writeFileSync(configPath, source, { mode: 0o644 })
+  console.log(`created ${path.relative(process.cwd(), configPath)}`)
+  console.log(`detected ${kind}`)
+}
+
+function createTemplate(projectDir: string, template: string): void {
+  if (!isTemplateName(template)) {
+    throw agentError('invalid_template', 'Tovuk template is unknown.', `Use one of: ${[...PROJECT_TEMPLATES].join(', ')}.`, false)
+  }
+  TEMPLATE_WRITERS[template](projectDir)
+  console.log(`created ${template} template`)
+}
+
+function writeRustApiTemplate(projectDir: string, name: string): void {
+  mkdirSync(path.join(projectDir, 'src'), { recursive: true, mode: 0o755 })
+  const files: readonly TemplateFile[] = [
+    ['Cargo.toml', `[package]
+name = "${name}"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lints.rust]
+unsafe_code = "forbid"
+warnings = "deny"
+`],
+    ['Cargo.lock', `# This file is automatically @generated by Cargo.
+version = 4
+
+[[package]]
+name = "${name}"
+version = "0.1.0"
+`],
+    ['src/main.rs', rustApiSource()],
+    ['tovuk.toml', rustBackendConfig(projectDir)]
+  ]
+  writeTemplateFiles(projectDir, files)
+}
+
+function writeFrontendTemplate(projectDir: string, name: string, apiBaseUrl: string): void {
+  mkdirSync(path.join(projectDir, 'src'), { recursive: true, mode: 0o755 })
+  const files: readonly TemplateFile[] = [
+    ['package.json', frontendPackageJson(name)],
+    ['index.html', '<div id="root"></div><script type="module" src="/src/main.tsx"></script>\n'],
+    ['src/styles.css', 'body{margin:0;font-family:system-ui,sans-serif}main{min-height:100svh;display:grid;place-items:center;padding:2rem}code{font-family:ui-monospace,monospace}\n'],
+    ['src/vite-env.d.ts', frontendViteEnvSource()],
+    ['src/main.tsx', frontendSource(apiBaseUrl)],
+    ['tsconfig.json', frontendTsConfig()],
+    ['vite.config.ts', 'import react from "@vitejs/plugin-react";\nimport { defineConfig } from "vite";\n\nexport default defineConfig({ plugins: [react()] });\n'],
+    ['tovuk.toml', frontendConfig(projectDir)]
+  ]
+  writeTemplateFiles(projectDir, files)
+  console.log('run package install in the frontend directory before doctor: bun install or npm install')
+}
+
+function writeTemplateFiles(projectDir: string, files: readonly TemplateFile[]): void {
+  for (const [relative, source] of files) {
+    writeNewFile(path.join(projectDir, relative), source)
+  }
+}
+
+function writeNewFile(file: string, source: string): void {
+  if (existsSync(file)) {
+    throw agentError('file_exists', `Refusing to overwrite ${path.relative(process.cwd(), file)}.`, 'Move the existing file or choose an empty directory, then retry.', false)
+  }
+  writeFileSync(file, source, { mode: 0o644 })
+}
+
+function rustBackendConfig(projectDir: string): string {
+  const name = serviceNameFromCargo(projectDir) || serviceNameFromDir(projectDir)
+  return `name = "${name}"
+
+[build]
+check = "${DEFAULT_RUST_CHECK_COMMAND}"
+command = "cargo build --release"
+
+[run]
+command = "./target/release/${name}"
+port = 3000
+health = "/healthz"
+
+[resources]
+memory = "512mb"
+cpu = "0.25"
+idle_timeout_minutes = 15
+`
+}
+
+function frontendConfig(projectDir: string): string {
+  const name = serviceNameFromPackage(projectDir) || serviceNameFromDir(projectDir)
+  return `name = "${name}"
+kind = "static_frontend"
+
+[build]
+check = "${frontendCheckCommand(projectDir)}"
+command = "${frontendBuildCommand(projectDir)}"
+output = "dist"
+`
+}
+
+function installProject(projectDir: string, template = ''): void {
+  initProject(projectDir, template)
+  doctorProject(projectDir, false)
+}
+
+function isTemplateName(value: string): value is TemplateName {
+  return PROJECT_TEMPLATES.has(value)
+}
+
+export { initProject, installProject }

package/src/internal/types.ts

@@ -0,0 +1,74 @@
+type JsonPrimitive = string | number | boolean | null
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[]
+export interface JsonObject {
+  [key: string]: JsonValue | undefined
+}
+
+export type ApiMethod = 'DELETE' | 'GET' | 'POST' | 'PUT'
+export type ProjectKind = 'rust_backend' | 'static_frontend'
+export type DiscoveredProjectKind = ProjectKind | 'unknown'
+export type TemplateName = 'fullstack-rust-tanstack' | 'rust-api' | 'tanstack-static-frontend'
+
+export interface AgentErrorPayload extends JsonObject {
+  code: string
+  message: string
+  agent_instruction: string | null
+  docs_url: string | null
+  checkout_url: string | null
+}
+
+export interface CliOptions {
+  command: string
+  args: string[]
+  apiUrl: string
+  app: string
+  build: string
+  deploy: string
+  limit: string
+  cursor: string
+  failingCommand: string
+  firstLogLine: string
+  token: string
+  template: string
+  severity: string
+  port: number
+  waitTimeoutSeconds: number
+  json: boolean
+  database: boolean
+  wait: boolean
+  help: boolean
+  version: boolean
+}
+
+export interface PackageManifest {
+  name?: string
+  scripts?: Record<string, string | undefined>
+}
+
+export type BuildConfig = JsonObject & { command: string; check: string; output?: string }
+export type RunConfig = JsonObject & { command?: string; port: number; health: string }
+export type ResourceConfig = JsonObject & { memory: string; cpu: string; idle_timeout_minutes: number }
+export type TovukConfig = JsonObject & { name?: string; kind: ProjectKind; build: BuildConfig; run: RunConfig; resources: ResourceConfig }
+export type DoctorCheck = JsonObject & { name: string; ok: boolean; message: string; agent_instruction: string | null }
+export type DoctorReport = JsonObject & { ok: boolean; project: string; config: TovukConfig | null; checks: DoctorCheck[] }
+export type ProjectDoctorReport = DoctorReport & { relative: string }
+export type WorkspaceDoctorReport = JsonObject & { ok: boolean; workspace: string; projects: ProjectDoctorReport[] }
+export type DeployProjectInfo = { dir: string; relative: string; name: string; kind: DiscoveredProjectKind }
+export type DeployPlanProject = { project: DeployProjectInfo; wantsDatabase: boolean }
+export type FrontendSourceReport = { typescript: string[]; javascript: string[] }
+export type LoginStartResponse = JsonObject & { loginUrl?: string; userCode?: string; deviceCode?: string; expiresInSeconds?: number; intervalSeconds?: number }
+export type LoginPollResponse = JsonObject & { status?: string; token?: string; email?: string; intervalSeconds?: number }
+export type AppSummary = JsonObject & { id?: string; name?: string; url?: string; databaseStorageMib?: number }
+export type AppsResponse = JsonObject & { apps: AppSummary[] }
+export type BuildJob = JsonObject & { id: string }
+export type AppDeployTarget = JsonObject & { id: string; url: string }
+export type BuildRecord = JsonObject & { id: string; status: string }
+export type BuildStatusResponse = JsonObject & { build?: BuildRecord }
+export type DeployResponse = JsonObject & { app: AppDeployTarget; build_job: BuildJob; final_build?: BuildRecord | null }
+export type WorkspaceDeployResult = { project: DeployProjectInfo; wantsDatabase: boolean; response: DeployResponse; finalBuild?: BuildRecord }
+export type LogLine = JsonObject & { timestamp: string; stream: string; message: string }
+export type LogsResponse = JsonObject & { lines: LogLine[]; has_more: boolean; next_cursor: string }
+export type CheckoutResponse = JsonObject & { checkout: { reason?: string; url: string } }
+
+export type FileVisitor = (file: string, relative: string) => void
+export type PathVisitor = (file: string) => void

package/src/internal/workspace.ts

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import path from 'node:path'
+import { WORKSPACE_EXCLUDED_DIRS } from './constants.ts'
+import { parseTovukToml } from './config.ts'
+import { ensureDirectory } from './project.ts'
+import type { DeployProjectInfo, DiscoveredProjectKind } from './types.ts'
+
+function discoverDeployProjects(rootDir: string): DeployProjectInfo[] {
+  ensureDirectory(rootDir)
+  if (existsSync(path.join(rootDir, 'tovuk.toml'))) {
+    return [deployProjectInfo(rootDir, rootDir)]
+  }
+
+  const projectDirs: string[] = []
+  discoverProjectDirs(rootDir, projectDirs)
+  return projectDirs
+    .map((dir) => deployProjectInfo(dir, rootDir))
+    .toSorted(compareDeployProjects)
+}
+
+function discoverProjectDirs(dir: string, projectDirs: string[]): void {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || WORKSPACE_EXCLUDED_DIRS.has(entry.name)) {
+      continue
+    }
+
+    const child = path.join(dir, entry.name)
+    if (existsSync(path.join(child, 'tovuk.toml'))) {
+      projectDirs.push(child)
+      continue
+    }
+    discoverProjectDirs(child, projectDirs)
+  }
+}
+
+function deployProjectInfo(dir: string, rootDir: string): DeployProjectInfo {
+  const relative = path.relative(rootDir, dir).replace(/\\/gu, '/') || '.'
+  try {
+    const config = parseTovukToml(readFileSync(path.join(dir, 'tovuk.toml'), 'utf8'), dir)
+    return { dir, relative, name: config.name || '', kind: config.kind }
+  } catch {
+    return { dir, relative, name: '', kind: 'unknown' }
+  }
+}
+
+function compareDeployProjects(left: DeployProjectInfo, right: DeployProjectInfo): number {
+  return kindOrder(left.kind) - kindOrder(right.kind)
+    || left.relative.localeCompare(right.relative)
+}
+
+function kindOrder(kind: DiscoveredProjectKind): number {
+  if (kind === 'rust_backend') {
+    return 0
+  }
+  if (kind === 'static_frontend') {
+    return 1
+  }
+  return 2
+}
+
+export { discoverDeployProjects }

package/src/tovuk.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env tsx
+import { VERSION, HELP } from './internal/constants.ts'
+import { parseArgs, projectPath } from './internal/args.ts'
+import { agentError, printAgentError, TovukError } from './internal/errors.ts'
+import { initProject, installProject } from './internal/templates.ts'
+import { doctorProject } from './internal/doctor.ts'
+import { previewProject } from './internal/preview.ts'
+import { login } from './internal/auth.ts'
+import { deploy } from './internal/deploy.ts'
+import { apps, builds, activity, billing, capabilities, database, deploys, domainsCommand, envCommand, inspect, logs, me, overview, status, support, usage } from './internal/commands.ts'
+import type { CliOptions } from './internal/types.ts'
+
+type CommandHandler = (cli: CliOptions) => Promise<void> | void
+
+const COMMANDS = new Map<string, CommandHandler>([
+  ['init', (cli): void => initProject(projectPath(cli.args[0]), cli.template)],
+  ['install', (cli): void => installProject(projectPath(cli.args[0]), cli.template)],
+  ['doctor', (cli): void => doctorProject(projectPath(cli.args[0]), cli.json)],
+  ['preview', (cli): void => previewProject(projectPath(cli.args[0]), cli.port)],
+  ['login', login],
+  ['deploy', (cli): Promise<void> => deploy(projectPath(cli.args[0]), cli)],
+  ['capabilities', capabilities],
+  ['me', me],
+  ['usage', usage],
+  ['activity', activity],
+  ['apps', apps],
+  ['overview', overview],
+  ['deploys', deploys],
+  ['builds', builds],
+  ['logs', logs],
+  ['status', status],
+  ['inspect', inspect],
+  ['db', database],
+  ['database', database],
+  ['env', envCommand],
+  ['domains', domainsCommand],
+  ['billing', billing],
+  ['support', support]
+])
+
+async function main(): Promise<void> {
+  const cli = parseArgs(process.argv.slice(2))
+
+  if (cli.help) {
+    console.log(HELP)
+    return
+  }
+
+  if (cli.version) {
+    console.log(VERSION)
+    return
+  }
+
+  const command = COMMANDS.get(cli.command)
+  if (!command) {
+    throw agentError('unknown_command', 'Unknown Tovuk command.', 'Run `npx tovuk --help` and retry with a supported command.', cli.json)
+  }
+  await command(cli)
+}
+
+main().catch((error: unknown): void => {
+  if (error instanceof TovukError) {
+    printAgentError(error.payload, error.json)
+    process.exitCode = error.exitCode
+    return
+  }
+
+  const message = error instanceof Error ? error.message : String(error)
+  console.error(`tovuk failed: ${message}`)
+  process.exitCode = 1
+})

package/tsconfig.json

@@ -0,0 +1,48 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "lib": ["ES2023", "DOM"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "allowImportingTsExtensions": true,
+    "allowJs": false,
+    "checkJs": false,
+    "declaration": true,
+    "noEmit": true,
+    "noEmitOnError": true,
+    "strict": true,
+    "strictBuiltinIteratorReturn": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "useUnknownInCatchVariables": true,
+    "alwaysStrict": true,
+    "exactOptionalPropertyTypes": true,
+    "noUncheckedIndexedAccess": true,
+    "noUncheckedSideEffectImports": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "isolatedDeclarations": true,
+    "erasableSyntaxOnly": true,
+    "moduleDetection": "force",
+    "resolvePackageJsonExports": true,
+    "resolvePackageJsonImports": true,
+    "maxNodeModuleJsDepth": 0,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": false,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}