tovuk 0.1.47

package/src/internal/config-parser.ts

@@ -0,0 +1,215 @@
+import { DEFAULT_RUST_CHECK_COMMAND, PROJECT_KINDS } from './constants.ts'
+import { frontendBuildCommand, frontendCheckCommand } from './frontend-policy.ts'
+import type { BuildConfig, ProjectKind, ResourceConfig, RunConfig, TovukConfig } from './types.ts'
+
+type SectionName = 'build' | 'resources' | 'root' | 'run'
+type TomlValue = boolean | number | string
+type SectionAssigner = (config: MutableTovukConfig, key: string, value: TomlValue) => void
+
+interface MutableTovukConfig {
+  name?: string
+  kind?: ProjectKind
+  build: Partial<BuildConfig>
+  run: Partial<RunConfig>
+  resources: Partial<ResourceConfig>
+}
+
+const SECTION_ASSIGNERS: Readonly<Record<SectionName, SectionAssigner>> = {
+  build: (config, key, value): void => assignBuildValue(config.build, key, value),
+  resources: (config, key, value): void => assignResourceValue(config.resources, key, value),
+  root: assignRootValue,
+  run: (config, key, value): void => assignRunValue(config.run, key, value)
+}
+
+function parseTovukToml(source: string, projectDir: string): TovukConfig {
+  const config: MutableTovukConfig = {
+    build: {},
+    run: {},
+    resources: {}
+  }
+  let section: SectionName = 'root'
+
+  for (const rawLine of source.split(/\r?\n/u)) {
+    const parsedLine = parseTomlLine(rawLine)
+    if (parsedLine === null) {
+      continue
+    }
+    if (parsedLine.kind === 'section') {
+      section = parsedLine.section
+      continue
+    }
+    assignTomlValue(config, section, parsedLine.key, parsedLine.value)
+  }
+
+  return tovukConfig(config, projectDir)
+}
+
+function tovukConfig(config: MutableTovukConfig, projectDir: string): TovukConfig {
+  const kind = config.kind ?? 'rust_backend'
+  const result: TovukConfig = {
+    kind,
+    build: buildConfig(config, kind, projectDir),
+    run: runConfig(config),
+    resources: resourceConfig(config)
+  }
+  if (config.name) {
+    result.name = config.name
+  }
+  return result
+}
+
+function parseTomlLine(rawLine: string): { kind: 'section'; section: SectionName } | { kind: 'assignment'; key: string; value: TomlValue } | null {
+  const line = rawLine.trim()
+  if (!line || line.startsWith('#')) {
+    return null
+  }
+  const sectionMatch = line.match(/^\[([a-z_]+)\]$/u)
+  if (sectionMatch) {
+    return { kind: 'section', section: parseSection(sectionMatch[1] ?? '') }
+  }
+  const assignment = line.match(/^([a-z_]+)\s*=\s*(.+)$/u)
+  if (assignment) {
+    return { kind: 'assignment', key: assignment[1] ?? '', value: parseTomlValue(assignment[2] ?? '') }
+  }
+  throw new Error(`invalid line: ${line}`)
+}
+
+function parseSection(value: string): SectionName {
+  if (value === 'build' || value === 'run' || value === 'resources') {
+    return value
+  }
+  throw new Error(`unsupported section [${value}]`)
+}
+
+function assignTomlValue(config: MutableTovukConfig, section: SectionName, key: string, value: TomlValue): void {
+  SECTION_ASSIGNERS[section](config, key, value)
+}
+
+function assignRootValue(config: MutableTovukConfig, key: string, value: TomlValue): void {
+  if (key === 'name') {
+    config.name = expectString(key, value)
+    return
+  }
+  if (key === 'kind') {
+    config.kind = expectProjectKind(expectString(key, value))
+    return
+  }
+  throw new Error(`unsupported root key ${key}`)
+}
+
+function assignBuildValue(build: Partial<BuildConfig>, key: string, value: TomlValue): void {
+  if (key === 'command' || key === 'check' || key === 'output') {
+    build[key] = expectString(key, value)
+    return
+  }
+  throw new Error(`unsupported [build] key ${key}`)
+}
+
+function assignRunValue(run: Partial<RunConfig>, key: string, value: TomlValue): void {
+  if (key === 'command' || key === 'health') {
+    run[key] = expectString(key, value)
+    return
+  }
+  if (key === 'port') {
+    run.port = expectNumber(key, value)
+    return
+  }
+  throw new Error(`unsupported [run] key ${key}`)
+}
+
+function assignResourceValue(resources: Partial<ResourceConfig>, key: string, value: TomlValue): void {
+  if (key === 'memory' || key === 'cpu') {
+    resources[key] = expectString(key, value)
+    return
+  }
+  if (key === 'idle_timeout_minutes') {
+    resources.idle_timeout_minutes = expectNumber(key, value)
+    return
+  }
+  throw new Error(`unsupported [resources] key ${key}`)
+}
+
+function expectString(key: string, value: TomlValue): string {
+  if (typeof value === 'string') {
+    return value
+  }
+  throw new Error(`${key} must be a string`)
+}
+
+function expectNumber(key: string, value: TomlValue): number {
+  if (typeof value === 'number') {
+    return value
+  }
+  throw new Error(`${key} must be a number`)
+}
+
+function expectProjectKind(value: string): ProjectKind {
+  if (isProjectKind(value)) {
+    return value
+  }
+  throw new Error('kind must be rust_backend or static_frontend')
+}
+
+function isProjectKind(value: string): value is ProjectKind {
+  return PROJECT_KINDS.has(value)
+}
+
+function parseTomlValue(raw: string): TomlValue {
+  const value = raw.trim()
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1).replace(/\\"/gu, '"')
+  }
+  if (value === 'true') {
+    return true
+  }
+  if (value === 'false') {
+    return false
+  }
+  if (/^\d+$/u.test(value)) {
+    return Number(value)
+  }
+  throw new Error(`unsupported TOML value: ${value}`)
+}
+
+function buildConfig(config: MutableTovukConfig, kind: ProjectKind, projectDir: string): BuildConfig {
+  const build: BuildConfig = {
+    check: config.build.check ?? defaultCheckCommand(kind, projectDir),
+    command: config.build.command ?? defaultBuildCommand(kind, projectDir)
+  }
+  const output = kind === 'static_frontend'
+    ? config.build.output ?? 'dist'
+    : config.build.output
+  if (typeof output === 'string') {
+    build.output = output
+  }
+  return build
+}
+
+function defaultCheckCommand(kind: ProjectKind, projectDir: string): string {
+  return kind === 'static_frontend' ? frontendCheckCommand(projectDir) : DEFAULT_RUST_CHECK_COMMAND
+}
+
+function defaultBuildCommand(kind: ProjectKind, projectDir: string): string {
+  return kind === 'static_frontend' ? frontendBuildCommand(projectDir) : 'cargo build --release'
+}
+
+function runConfig(config: MutableTovukConfig): RunConfig {
+  const run: RunConfig = {
+    port: config.run.port ?? 3000,
+    health: config.run.health ?? '/healthz'
+  }
+  if (typeof config.run.command === 'string') {
+    run.command = config.run.command
+  }
+  return run
+}
+
+function resourceConfig(config: MutableTovukConfig): ResourceConfig {
+  return {
+    memory: config.resources.memory ?? '512mb',
+    cpu: config.resources.cpu ?? '0.25',
+    idle_timeout_minutes: config.resources.idle_timeout_minutes ?? 15
+  }
+}
+
+export { parseTovukToml }

package/src/internal/config-validation.ts

@@ -0,0 +1,94 @@
+import { PROJECT_KINDS } from './constants.ts'
+import { commandTokens, hasFrontendInstallCommand, hasFrontendScriptRun, usesJavascriptLinter } from './frontend-policy.ts'
+import { isSafeRelativePath } from './project.ts'
+import type { ProjectKind, TovukConfig } from './types.ts'
+
+function validateConfig(config: TovukConfig): void {
+  validateIdentity(config)
+  validateBuildConfig(config)
+  if (config.kind === 'static_frontend') {
+    validateStaticFrontendConfig(config)
+    return
+  }
+  validateRustBackendConfig(config)
+}
+
+function validateIdentity(config: TovukConfig): void {
+  if (!/^[a-z0-9](?:[a-z0-9-]{0,46}[a-z0-9])?$/u.test(config.name ?? '')) {
+    throw new Error('name must be lowercase DNS-safe text up to 48 characters')
+  }
+  if (!PROJECT_KINDS.has(config.kind)) {
+    throw new Error('kind must be rust_backend or static_frontend')
+  }
+}
+
+function validateBuildConfig(config: TovukConfig): void {
+  if (!config.build.command.trim()) {
+    throw new Error('[build].command is required')
+  }
+  if (!config.build.check.trim()) {
+    throw new Error('[build].check is required')
+  }
+  validateCheckCommand(config.kind, config.build.check)
+}
+
+function validateStaticFrontendConfig(config: TovukConfig): void {
+  if (typeof config.build.output !== 'string' || !isSafeRelativePath(config.build.output)) {
+    throw new Error('[build].output must be a safe relative directory like dist')
+  }
+}
+
+function validateRustBackendConfig(config: TovukConfig): void {
+  if (config.build.output) {
+    throw new Error('[build].output is only valid for static_frontend')
+  }
+  if (!config.run.command?.trim()) {
+    throw new Error('[run].command is required')
+  }
+  if (!Number.isInteger(config.run.port) || config.run.port < 1 || config.run.port > 65535) {
+    throw new Error('[run].port must be between 1 and 65535')
+  }
+  if (!config.run.health.startsWith('/')) {
+    throw new Error('[run].health must be an absolute path')
+  }
+  validateResourceConfig(config)
+}
+
+function validateResourceConfig(config: TovukConfig): void {
+  if (!/^\d+\s*(mb|mib|gb|gib)$/iu.test(config.resources.memory)) {
+    throw new Error('[resources].memory must look like 512mb or 1gb')
+  }
+  if (!/^\d+(?:\.\d{1,3})?$/u.test(config.resources.cpu)) {
+    throw new Error('[resources].cpu must look like 0.25, 0.5, 1, or 2')
+  }
+}
+
+function validateCheckCommand(kind: ProjectKind, command: string): void {
+  if (kind === 'static_frontend') {
+    validateFrontendCheckCommand(command)
+    return
+  }
+
+  const required = ['cargo fmt --all --check', 'cargo check --locked', 'cargo clippy --locked', '--all-targets', '--all-features', '-D warnings']
+  if (required.every((fragment) => command.includes(fragment))) {
+    return
+  }
+  throw new Error('[build].check must include cargo fmt --all --check, cargo check --locked, and cargo clippy --locked --all-targets --all-features -- -D warnings')
+}
+
+function validateFrontendCheckCommand(command: string): void {
+  if (usesJavascriptLinter(command)) {
+    throw new Error('[build].check must not run JavaScript-based lint or format tooling; use oxlint, biome, or deno lint')
+  }
+  const tokens = commandTokens(command)
+  if (
+    hasFrontendInstallCommand(tokens) &&
+    hasFrontendScriptRun(tokens, 'typecheck') &&
+    hasFrontendScriptRun(tokens, 'lint')
+  ) {
+    return
+  }
+  throw new Error('[build].check must install dependencies and run package scripts, for example `bun ci && bun run typecheck && bun run lint` or `npm ci --prefer-offline --no-audit --fund=false && npm run typecheck && npm run lint`')
+}
+
+export { validateConfig }

package/src/internal/config.ts

@@ -0,0 +1,2 @@
+export { parseTovukToml } from './config-parser.ts'
+export { validateConfig } from './config-validation.ts'

package/src/internal/constants.ts

@@ -0,0 +1,153 @@
+import { readFileSync } from 'node:fs'
+
+interface PackageVersionManifest {
+  version: string
+}
+
+export const VERSION: string = packageVersion()
+export const DEFAULT_API_URL: string = 'https://api.tovuk.com'
+export const ARCHIVE_LIMIT_BYTES: number = 48 * 1024 * 1024
+export const DEFAULT_DEPLOY_WAIT_TIMEOUT_SECONDS: number = 900
+export const SESSION_DIR: string = '.tovuk'
+export const SESSION_FILE: string = 'session-token'
+export const SESSION_SERVICE: string = 'com.tovuk.cli'
+export const SESSION_ACCOUNT: string = 'session-token'
+export const SESSION_LABEL: string = 'Tovuk session'
+export const DEFAULT_LOGIN_EXPIRES_SECONDS: number = 600
+export const DEFAULT_LOGIN_INTERVAL_SECONDS: number = 5
+export const DEFAULT_RUST_CHECK_COMMAND: string = 'cargo fmt --all --check && cargo check --locked && cargo clippy --locked --all-targets --all-features -- -D warnings'
+export const DEFAULT_NPM_FRONTEND_CHECK_COMMAND: string = 'npm ci --prefer-offline --no-audit --fund=false && npm run typecheck && npm run lint'
+export const DEFAULT_BUN_FRONTEND_CHECK_COMMAND: string = 'bun ci && bun run typecheck && bun run lint'
+export const PROJECT_KINDS: ReadonlySet<string> = new Set(['rust_backend', 'static_frontend'])
+export const PROJECT_TEMPLATES: ReadonlySet<string> = new Set(['rust-api', 'tanstack-static-frontend', 'fullstack-rust-tanstack'])
+export const JAVASCRIPT_LINTERS: ReadonlySet<string> = new Set(['eslint', 'eslint_d', 'jscs', 'jshint', 'prettier', 'prettierd', 'standard', 'xo'])
+export const FRONTEND_SOURCE_ROOTS: ReadonlySet<string> = new Set(['src', 'app', 'pages', 'routes', 'components'])
+export const FRONTEND_JAVASCRIPT_EXTENSIONS: readonly string[] = ['.js', '.jsx', '.mjs', '.cjs']
+export const FRONTEND_PACKAGE_MANAGERS: ReadonlySet<string> = new Set(['npm', 'bun', 'pnpm', 'yarn'])
+export const FRONTEND_INSTALL_COMMANDS: ReadonlySet<string> = new Set(['npm ci', 'bun ci', 'bun install', 'pnpm install', 'yarn install'])
+export const ARCHIVE_EXCLUDES: readonly string[] = [
+  '.git',
+  'target',
+  'node_modules',
+  '.tovuk',
+  '.env',
+  '.env.*',
+  '.npmrc',
+  '.pypirc',
+  '.netrc',
+  '.docker',
+  '.gnupg',
+  '.terraform',
+  '.terraformrc',
+  '.ssh',
+  '.aws',
+  '.azure',
+  '.kube',
+  '.pulumi',
+  '.cargo/credentials',
+  '.cargo/credentials.toml',
+  '.config/gcloud',
+  '.config/gh',
+  '.config/hub',
+  '.config/heroku',
+  '.config/doctl',
+  '*.pem',
+  '*.key',
+  '*.p12',
+  '*.pfx',
+  '*.tfstate',
+  '*.tfstate.*',
+  'id_rsa',
+  'id_ed25519',
+  '*.sqlite',
+  '*.sqlite3',
+  '*.db',
+  '*.log',
+  '._*',
+  '.DS_Store'
+]
+export const WALK_EXCLUDED_DIRS: ReadonlySet<string> = new Set([
+  '.git',
+  'target',
+  'node_modules',
+  '.tovuk',
+  '.terraform',
+  '.docker',
+  '.gnupg',
+  '.ssh',
+  '.aws',
+  '.azure',
+  '.kube',
+  '.pulumi'
+])
+export const WORKSPACE_EXCLUDED_DIRS: ReadonlySet<string> = new Set([
+  ...WALK_EXCLUDED_DIRS,
+  '.cache',
+  '.next',
+  '.turbo',
+  'build',
+  'coverage',
+  'dist',
+  'vendor'
+])
+
+export const HELP: string = `Tovuk ${VERSION}
+
+Usage:
+  tovuk init [path] [--template rust-api|tanstack-static-frontend|fullstack-rust-tanstack]
+  tovuk install [path] [--template rust-api|tanstack-static-frontend|fullstack-rust-tanstack]
+  tovuk doctor [path] [--json]
+  tovuk preview [path] [--port <port>]
+  tovuk login [--token <token>] [--api <url>]
+  tovuk deploy [path] [--database] [--wait] [--wait-timeout <seconds>] [--api <url>] [--json]
+  tovuk capabilities [--api <url>] [--json]
+  tovuk me [--api <url>] [--json]
+  tovuk usage [--api <url>] [--json]
+  tovuk activity [--limit <n>] [--cursor <cursor>] [--api <url>] [--json]
+  tovuk apps [--api <url>] [--json]
+  tovuk overview --app <app> [--limit <n>] [--cursor <cursor>] [--api <url>] [--json]
+  tovuk deploys [--app <app>] [--limit <n>] [--cursor <cursor>] [--api <url>] [--json]
+  tovuk builds [--app <app>] [--limit <n>] [--cursor <cursor>] [--api <url>] [--json]
+  tovuk logs --app <app> [--deploy <deploy_id>] [--build <build_id>] [--limit <n>] [--cursor <cursor>] [--api <url>] [--json]
+  tovuk status --app <app> [--api <url>] [--json]
+  tovuk inspect --app <app> [--api <url>] [--json]
+  tovuk db --app <app> [--api <url>] [--json]
+  tovuk env list --app <app> [--api <url>] [--json]
+  tovuk env set --app <app> KEY=value [--api <url>] [--json]
+  tovuk env delete --app <app> KEY [--api <url>] [--json]
+  tovuk domains list --app <app> [--api <url>] [--json]
+  tovuk domains add --app <app> <domain> [--api <url>] [--json]
+  tovuk domains verify --app <app> <domain> [--api <url>] [--json]
+  tovuk domains delete --app <app> <domain> [--api <url>] [--json]
+  tovuk billing [checkout|portal] [reason] [--api <url>] [--json]
+  tovuk support list [--limit <n>] [--api <url>] [--json]
+  tovuk support create "Subject" "Details" [--app <app>] [--build <build_id>] [--deploy <deploy_id>] [--failing-command <command>] [--first-log-line <line>] [--severity low|normal|urgent] [--api <url>] [--json]
+  tovuk support resolve <ticket_id> [--api <url>] [--json]
+
+Agent contract:
+  - Rust backends keep Cargo.lock committed, pass rustfmt, listen on 0.0.0.0:$PORT, and return HTTP 200 from health.
+  - Static frontends set kind = "static_frontend", keep TypeScript source, a package lockfile, stable native typecheck, native lint, and Fallow quality gates.
+  - Frontends call Rust backends for APIs, managed Postgres, and server-side logic.
+  - Run deploy from a repo root with nested tovuk.toml files to deploy the whole workspace in one command.
+  - When a frontend calls a backend on another hostname, configure backend CORS or use a same-origin custom domain.
+  - When a plan limit blocks work, run tovuk billing checkout --json and show the returned URL to the human.
+  - Create support tickets only with command output, app id, build id, deploy id, and the first actionable log line.
+  - Resolve support tickets after the issue is fixed so later agents do not duplicate work.
+  - Keep direct unsafe out of Rust source.
+`
+
+function packageVersion(): string {
+  const manifest: unknown = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'))
+  if (isPackageVersionManifest(manifest)) {
+    return manifest.version
+  }
+  throw new Error('packages/tovuk/package.json must include a version string')
+}
+
+function isPackageVersionManifest(value: unknown): value is PackageVersionManifest {
+  return typeof value === 'object'
+    && value !== null
+    && !Array.isArray(value)
+    && 'version' in value
+    && typeof value.version === 'string'
+}

package/src/internal/deploy-plan.ts

@@ -0,0 +1,89 @@
+import { agentError } from './errors.ts'
+import { paymentRequiredAgentError } from './agent-error-enrichment.ts'
+import { apiRequest } from './api.ts'
+import { appsResponseFromJson } from './api-models.ts'
+import { jsonObjectField, jsonObjectOrEmpty, numberField } from './json.ts'
+import type { AppSummary, CliOptions, DeployPlanProject, DeployProjectInfo } from './types.ts'
+
+async function createDeployPlan(projects: DeployProjectInfo[], cli: CliOptions, token: string): Promise<DeployPlanProject[]> {
+  const plan = projects.map((project) => ({
+    project,
+    wantsDatabase: cli.database && project.kind === 'rust_backend'
+  }))
+  rejectInvalidDatabaseTargets(plan, cli)
+  await preflightDeployLimits(plan, cli, token)
+  return plan
+}
+
+function rejectInvalidDatabaseTargets(plan: DeployPlanProject[], cli: CliOptions): void {
+  if (cli.database && plan.length === 1 && plan[0]?.project.kind === 'static_frontend') {
+    throw agentError('invalid_database_target', 'Static frontends cannot attach managed Postgres directly.', 'Deploy a Rust backend with managed Postgres and call it from the frontend.', cli.json)
+  }
+}
+
+async function preflightDeployLimits(plan: DeployPlanProject[], cli: CliOptions, token: string): Promise<void> {
+  const [usageResponse, appsResponse] = await Promise.all([
+    apiRequest(cli, 'GET', '/v1/usage', token, null),
+    apiRequest(cli, 'GET', '/v1/apps', token, null)
+  ])
+  const usageRoot = jsonObjectOrEmpty(usageResponse)
+  const usage = jsonObjectField(usageRoot, 'usage')
+  const limits = jsonObjectField(usageRoot, 'limits')
+  const existingApps = appNameMap(appsResponseFromJson(appsResponse).apps)
+  const requested = requestedNewResources(plan, existingApps)
+
+  const usedProjects = numberField(usage, 'appCount')
+  const projectLimit = numberField(limits, 'projects')
+  const usedDatabases = numberField(usage, 'databaseCount')
+  const databaseLimit = numberField(limits, 'managedDatabases')
+
+  if (requested.projects > 0 && usedProjects + requested.projects > projectLimit) {
+    throw await paymentRequiredAgentError(
+      cli,
+      token,
+      `Project limit reached: ${usedProjects}/${projectLimit} projects are already used.`,
+      'Redeploy an existing app by reusing its `name` in tovuk.toml, or open the returned Stripe Checkout URL before creating another project.'
+    )
+  }
+
+  if (requested.databases > 0 && usedDatabases + requested.databases > databaseLimit) {
+    throw await paymentRequiredAgentError(
+      cli,
+      token,
+      `Managed Postgres limit reached: ${usedDatabases}/${databaseLimit} databases are already used.`,
+      'Redeploy an app that already has managed Postgres, deploy without `--database`, or open the returned Stripe Checkout URL.'
+    )
+  }
+}
+
+function appNameMap(apps: AppSummary[]): Map<string, AppSummary> {
+  const existingApps = new Map<string, AppSummary>()
+  for (const app of apps) {
+    if (app.name) {
+      existingApps.set(app.name, app)
+    }
+  }
+  return existingApps
+}
+
+function requestedNewResources(plan: DeployPlanProject[], existingApps: Map<string, AppSummary>): { projects: number; databases: number } {
+  let projects = 0
+  let databases = 0
+
+  for (const target of plan) {
+    if (!target.project.name || target.project.kind === 'unknown') {
+      continue
+    }
+    const existing = existingApps.get(target.project.name)
+    if (!existing) {
+      projects += 1
+    }
+    if (target.wantsDatabase && existing?.databaseStorageMib === undefined) {
+      databases += 1
+    }
+  }
+
+  return { projects, databases }
+}
+
+export { createDeployPlan }