@vertile-ai/iac 0.0.1

package/schema/iac.schema.json

@@ -0,0 +1,266 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://vertile.ai/schemas/iac.schema.json",
+  "title": "Vertile AI IaC Manifest",
+  "description": "Portable app infrastructure intent for Vertile AI IaC.",
+  "type": "object",
+  "required": ["version", "project", "providers", "apps"],
+  "additionalProperties": true,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "version": {
+      "const": 1
+    },
+    "project": {
+      "oneOf": [
+        { "type": "string", "minLength": 1 },
+        {
+          "type": "object",
+          "required": ["name"],
+          "additionalProperties": true,
+          "properties": {
+            "key": { "type": "string", "minLength": 1 },
+            "name": { "type": "string", "minLength": 1 }
+          }
+        }
+      ]
+    },
+    "environments": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 },
+      "uniqueItems": true,
+      "default": ["development", "preview", "production"]
+    },
+    "providers": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#/$defs/providerConfig" },
+      "properties": {
+        "vercel": {
+          "allOf": [
+            { "$ref": "#/$defs/providerConfig" },
+            {
+              "type": "object",
+              "properties": {
+                "team": { "type": "string" },
+                "teamId": { "type": "string" },
+                "teamSlug": { "type": "string" },
+                "projectDefaults": { "$ref": "#/$defs/vercelProjectSettings" },
+                "projectSettingsDefaults": { "$ref": "#/$defs/vercelProjectSettings" }
+              }
+            }
+          ]
+        },
+        "aws": {
+          "allOf": [
+            { "$ref": "#/$defs/providerConfig" },
+            {
+              "type": "object",
+              "properties": {
+                "region": { "type": "string" },
+                "defaultTags": {
+                  "type": "object",
+                  "additionalProperties": { "type": ["string", "number", "boolean"] }
+                }
+              }
+            }
+          ]
+        },
+        "digitalocean": {
+          "allOf": [
+            { "$ref": "#/$defs/providerConfig" },
+            {
+              "type": "object",
+              "properties": {
+                "region": { "type": "string" },
+                "version": { "type": "string" }
+              }
+            }
+          ]
+        }
+      }
+    },
+    "env": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "sourceDir": { "type": "string" },
+        "dir": { "type": "string" },
+        "infraDir": { "type": "string" },
+        "sharedKey": { "type": "string" },
+        "sync": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "apps": {
+              "type": "array",
+              "items": { "type": "string", "minLength": 1 },
+              "uniqueItems": true
+            },
+            "sharedKey": { "type": "string" },
+            "skipInVercel": { "type": "boolean" }
+          }
+        }
+      }
+    },
+    "apps": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/app" }
+    },
+    "domains": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/domain" }
+    },
+    "objectStorage": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/keyedResource" }
+    },
+    "databases": {
+      "type": "array",
+      "items": {
+        "allOf": [
+          { "$ref": "#/$defs/keyedResource" },
+          {
+            "type": "object",
+            "properties": {
+              "engine": { "type": "string" }
+            }
+          }
+        ]
+      }
+    },
+    "queues": {
+      "type": "array",
+      "items": {
+        "allOf": [
+          { "$ref": "#/$defs/keyedResource" },
+          {
+            "type": "object",
+            "properties": {
+              "kind": { "type": "string" }
+            }
+          }
+        ]
+      }
+    },
+    "sandboxes": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/keyedResource" }
+    },
+    "clusters": {
+      "type": "array",
+      "items": {
+        "allOf": [
+          { "$ref": "#/$defs/keyedResource" },
+          {
+            "type": "object",
+            "properties": {
+              "size": { "type": "integer", "minimum": 1 },
+              "nodes": { "type": "integer", "minimum": 1 }
+            }
+          }
+        ]
+      }
+    }
+  },
+  "$defs": {
+    "providerConfig": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "resources": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/providerResource" }
+        }
+      }
+    },
+    "providerResource": {
+      "type": "object",
+      "required": ["type", "name"],
+      "additionalProperties": true,
+      "properties": {
+        "type": { "type": "string", "minLength": 1 },
+        "name": { "type": "string", "minLength": 1 },
+        "values": {
+          "type": "object",
+          "additionalProperties": true
+        }
+      }
+    },
+    "vercelProjectSettings": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "rootDirectory": { "type": ["string", "null"] },
+        "nodeVersion": { "type": ["string", "null"] },
+        "enableAffectedProjectsDeployments": { "type": ["boolean", "null"] }
+      }
+    },
+    "app": {
+      "type": "object",
+      "required": ["key"],
+      "additionalProperties": true,
+      "properties": {
+        "key": { "type": "string", "minLength": 1 },
+        "id": { "type": "string" },
+        "projectId": { "type": "string" },
+        "name": { "type": "string" },
+        "framework": { "type": "string" },
+        "rootDirectory": { "type": "string" },
+        "outputDir": { "type": "string" },
+        "sourceKey": { "type": "string" },
+        "nodeVersion": { "type": "string" },
+        "enableAffectedProjectsDeployments": { "type": "boolean" },
+        "domains": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/domain" }
+        },
+        "env": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "sourceKey": { "type": "string" },
+            "outputDir": { "type": "string" },
+            "sharedPrefix": { "type": "string" }
+          }
+        },
+        "providers": {
+          "type": "object",
+          "additionalProperties": true
+        }
+      }
+    },
+    "domain": {
+      "oneOf": [
+        { "type": "string", "minLength": 1 },
+        {
+          "type": "object",
+          "required": ["name"],
+          "additionalProperties": true,
+          "properties": {
+            "name": { "type": "string", "minLength": 1 },
+            "app": { "type": "string" },
+            "project": { "type": "string" },
+            "key": { "type": "string" },
+            "gitBranch": { "type": ["string", "null"] },
+            "verified": { "type": "boolean" }
+          }
+        }
+      ]
+    },
+    "keyedResource": {
+      "type": "object",
+      "required": ["key"],
+      "additionalProperties": true,
+      "properties": {
+        "key": { "type": "string", "minLength": 1 },
+        "name": { "type": "string" },
+        "providers": {
+          "type": "object",
+          "additionalProperties": true
+        }
+      }
+    }
+  }
+}

package/src/apply.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+import process from 'node:process'
+import { hasFlag, parseTargetOption, readOption } from './core/args.mjs'
+import { resolvePlatformContext } from './core/context.mjs'
+import { assertEnvironment, readManifest } from './core/manifest.mjs'
+import { writeTargets } from './core/render.mjs'
+import { terraformApply } from './core/terraform.mjs'
+
+async function main() {
+  const argv = process.argv.slice(2)
+  const context = resolvePlatformContext(argv)
+  const manifest = readManifest(context.manifestPath)
+  const environment = readOption(argv, '--env') || 'production'
+  const targets = parseTargetOption(argv)
+  const autoApprove = hasFlag(argv, '--yes') || hasFlag(argv, '--auto-approve')
+
+  assertEnvironment(manifest, environment)
+
+  if (!autoApprove && !process.stdin.isTTY) {
+    throw new Error('Refusing non-interactive apply without --yes.')
+  }
+
+  const rendered = await writeTargets({ context, manifest, environment, targets })
+  for (const item of rendered) {
+    console.log(`Applying ${item.workspace}`)
+    terraformApply({
+      terraformBin: context.terraformBin,
+      workspace: item.workspace,
+      autoApprove,
+    })
+  }
+}
+
+main().catch((error) => {
+  console.error(error.message)
+  process.exit(1)
+})

package/src/cli.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process'
+import path from 'node:path'
+import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+import { sharedOptionsHelp } from './shared.mjs'
+
+const command = process.argv[2]
+const args = process.argv.slice(3)
+const root = path.dirname(fileURLToPath(import.meta.url))
+
+const commands = new Map([
+  ['render', path.join(root, 'render.mjs')],
+  ['plan', path.join(root, 'plan.mjs')],
+  ['apply', path.join(root, 'apply.mjs')],
+  ['sync-env', path.join(root, 'sync-env.mjs')],
+  ['env', path.join(root, 'provision-env.mjs')],
+  ['projects', path.join(root, 'reconcile-project-settings.mjs')],
+  ['domains', path.join(root, 'reconcile-project-domains.mjs')],
+])
+
+function printHelp() {
+  console.log(`vertile-iac
+
+Usage:
+  vertile-iac render --target=vercel|aws|digitalocean|all --env=<name> [options]
+  vertile-iac plan --target=vercel|aws|digitalocean|all --env=<name> [options]
+  vertile-iac apply --target=vercel|aws|digitalocean|all --env=<name> [options]
+  vertile-iac sync-env [options]
+  vertile-iac env [options]
+  vertile-iac projects [options]
+  vertile-iac domains [options]
+
+Commands:
+  render     Render Terraform workspaces from infrastructure/iac/iac.json.
+  plan       Render Terraform workspaces and run terraform plan.
+  apply      Render Terraform workspaces and run terraform apply.
+  sync-env   Generate package .env files from the configured env source tree.
+  env        Compatibility: reconcile Vercel team and project environment variables.
+  projects   Compatibility: reconcile Vercel project settings.
+  domains    Compatibility: reconcile Vercel project domains.
+
+${sharedOptionsHelp()}
+  --out <path>                Generated Terraform root. Defaults to .vertile/terraform.
+  --target <name|all>         Target provider: vercel, aws, digitalocean, or all.
+  --env <name>                Environment to render, plan, or apply. Defaults to production.
+  --terraform-bin <path>      Terraform executable. Defaults to terraform.
+  --yes                       Allow non-interactive apply with Terraform auto-approve.
+`)
+}
+
+if (!command || command === '--help' || command === '-h') {
+  printHelp()
+  process.exit(0)
+}
+
+const script = commands.get(command)
+if (!script) {
+  console.error(`Unknown command: ${command}`)
+  printHelp()
+  process.exit(1)
+}
+
+const result = spawnSync(process.execPath, [script, ...args], {
+  stdio: 'inherit',
+})
+
+if (result.error) {
+  console.error(result.error.message)
+  process.exit(1)
+}
+
+process.exit(result.status ?? 0)

package/src/core/args.mjs

@@ -0,0 +1,36 @@
+export const supportedTargets = ['vercel', 'aws', 'digitalocean']
+
+export function readOption(argv, name) {
+  const prefix = `${name}=`
+  const inline = argv.find((arg) => arg.startsWith(prefix))
+  if (inline) return inline.slice(prefix.length)
+
+  const index = argv.indexOf(name)
+  if (index !== -1) return argv[index + 1] || ''
+
+  return ''
+}
+
+export function hasFlag(argv, name) {
+  return argv.includes(name)
+}
+
+export function parseTargetOption(argv) {
+  const target = readOption(argv, '--target') || 'all'
+  if (target === 'all') return supportedTargets
+
+  const targets = target
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean)
+
+  for (const value of targets) {
+    if (!supportedTargets.includes(value)) {
+      throw new Error(
+        `Invalid --target value "${value}". Use one of: ${supportedTargets.join(', ')}, all`,
+      )
+    }
+  }
+
+  return [...new Set(targets)]
+}

package/src/core/concepts.mjs

@@ -0,0 +1,26 @@
+import { sanitizeName } from './hcl.mjs'
+
+export function providerValues(item, provider) {
+  return {
+    ...(item.values || {}),
+    ...((item.providers && item.providers[provider]) || {}),
+  }
+}
+
+export function resourceName(...parts) {
+  return sanitizeName(parts.filter(Boolean).join('_'))
+}
+
+export function providerResourceName(manifest, environment, item) {
+  return resourceName(manifest.project.name, environment, item.key)
+}
+
+export function compactBody(body) {
+  return Object.fromEntries(
+    Object.entries(body).filter(([, value]) => value !== undefined && value !== ''),
+  )
+}
+
+export function terraformVariableName(...parts) {
+  return resourceName(...parts)
+}

package/src/core/context.mjs

@@ -0,0 +1,39 @@
+import path from 'node:path'
+import { findProjectRoot } from '../shared.mjs'
+import { readOption } from './args.mjs'
+
+function resolveFrom(rootDir, value) {
+  if (!value) return ''
+  return path.isAbsolute(value) ? value : path.join(rootDir, value)
+}
+
+export function resolvePlatformContext(argv) {
+  const repoRootArg = readOption(argv, '--repo-root')
+  const repoRoot = repoRootArg
+    ? path.resolve(repoRootArg)
+    : findProjectRoot(process.cwd())
+  const iacDir = resolveFrom(
+    repoRoot,
+    readOption(argv, '--iac-dir') || 'infrastructure/iac',
+  )
+  const manifestPath = resolveFrom(
+    repoRoot,
+    readOption(argv, '--iac-manifest') || path.relative(repoRoot, path.join(iacDir, 'iac.json')),
+  )
+  const generatedRoot = resolveFrom(
+    repoRoot,
+    readOption(argv, '--out') || '.vertile/terraform',
+  )
+
+  return {
+    repoRoot,
+    iacDir,
+    manifestPath,
+    generatedRoot,
+    terraformBin: readOption(argv, '--terraform-bin') || 'terraform',
+  }
+}
+
+export function targetWorkspace(context, target) {
+  return path.join(context.generatedRoot, target)
+}

package/src/core/hcl.mjs

@@ -0,0 +1,110 @@
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function quote(value) {
+  return JSON.stringify(String(value))
+}
+
+function formatKey(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) ? key : quote(key)
+}
+
+function formatValue(value, indent = 0) {
+  const pad = ' '.repeat(indent)
+  const nestedPad = ' '.repeat(indent + 2)
+
+  if (typeof value === 'string') return quote(value)
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value)
+  if (value === null) return 'null'
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[]'
+    return `[\n${value.map((item) => `${nestedPad}${formatValue(item, indent + 2)},`).join('\n')}\n${pad}]`
+  }
+
+  if (isPlainObject(value)) {
+    if (value.__raw) return value.value
+    const entries = Object.entries(value)
+    if (entries.length === 0) return '{}'
+    return `{\n${entries.map(([key, item]) => `${nestedPad}${formatKey(key)} = ${formatValue(item, indent + 2)}`).join('\n')}\n${pad}}`
+  }
+
+  return quote(value)
+}
+
+export function block(type, labels = [], body = {}) {
+  const labelText = labels.map((label) => ` ${quote(label)}`).join('')
+  const lines = [`${type}${labelText} {`]
+
+  for (const [key, value] of Object.entries(body)) {
+    if (value === undefined) continue
+    if (value && typeof value === 'object' && value.__raw) {
+      lines.push(`  ${key} = ${value.value}`)
+      continue
+    }
+    lines.push(`  ${key} = ${formatValue(value, 2)}`)
+  }
+
+  lines.push('}')
+  return lines.join('\n')
+}
+
+export function nestedBlock(type, body = {}, indent = 0) {
+  const pad = ' '.repeat(indent)
+  const lines = [`${pad}${type} {`]
+
+  for (const [key, value] of Object.entries(body)) {
+    if (value === undefined) continue
+    lines.push(`${pad}  ${key} = ${formatValue(value, indent + 2)}`)
+  }
+
+  lines.push(`${pad}}`)
+  return lines.join('\n')
+}
+
+export function raw(value) {
+  return { __raw: true, value }
+}
+
+export function sanitizeName(value) {
+  const sanitized = String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+  return sanitized || 'resource'
+}
+
+export function renderGenericResources(resources = []) {
+  return resources
+    .map((resource) => block('resource', [resource.type, resource.name], resource.values || {}))
+    .join('\n\n')
+}
+
+export function renderLocals(manifest, environment) {
+  return block('locals', [], {
+    project_name: manifest.project.name,
+    environment,
+  })
+}
+
+export function renderRequiredProvider(name, source, version) {
+  return [
+    'terraform {',
+    '  required_providers {',
+    `    ${name} = {`,
+    `      source  = ${quote(source)}`,
+    `      version = ${quote(version)}`,
+    '    }',
+    '  }',
+    '}',
+  ].join('\n')
+}
+
+export function renderVariable(name, options = {}) {
+  return block('variable', [name], options)
+}
+
+export function renderOutput(name, options = {}) {
+  return block('output', [name], options)
+}