@celilo/cli 0.3.30-alpha.0 → 0.4.0-alpha.0

package/src/variables/resolver.ts

@@ -1,3 +1,6 @@
+import { evaluateComputed } from './computed/evaluate';
+import { asComputedExpression } from './computed/marker';
+import { buildProviderLookup } from './computed/provider-lookup';
 import { applyIndex, parsePath, parseVariables } from './parser';
 import type {
   ResolutionContext,
@@ -70,6 +73,40 @@ export async function resolveVariable(
       return { success: true, value };
     }
 
+    case 'infra': {
+      // Format: $infra:<system-name>.<field> — references a deployed system by
+      // its stable handle (requires.systems[].name). v2/MODULE_SYSTEMS_ADDRESSING.md.
+      const dot = variable.path.indexOf('.');
+      if (dot === -1) {
+        return {
+          success: false,
+          variable: variable.raw,
+          error: `Infra variable must be '$infra:<system-name>.<field>' (e.g. $infra:main.ipv4_address); got '${variable.path}'`,
+        };
+      }
+      const systemName = variable.path.slice(0, dot);
+      const field = variable.path.slice(dot + 1);
+      const systems = context.systems ?? {};
+      const system = systems[systemName];
+      if (!system) {
+        const known = Object.keys(systems);
+        return {
+          success: false,
+          variable: variable.raw,
+          error: `No deployed system named '${systemName}' for module ${context.moduleId}${known.length ? ` (known: ${known.join(', ')})` : ' (none recorded yet)'}`,
+        };
+      }
+      const value = (system as unknown as Record<string, unknown>)[field];
+      if (value === undefined || value === '') {
+        return {
+          success: false,
+          variable: variable.raw,
+          error: `Infra field '${field}' not available on system '${systemName}' (fields: name, hostname, ipv4_address, zone, cidr, vmid)`,
+        };
+      }
+      return { success: true, value: value as string };
+    }
+
     case 'system_secret': {
       const value = context.systemSecrets[variable.path];
       if (value === undefined) {
@@ -171,6 +208,50 @@ export async function resolveVariable(
         };
       }
 
+      // Computed field (v2/INTERNAL_DNS_DHCP_AND_SPLIT_HORIZON.md D1):
+      // evaluate the DSL expression in the PROVIDER's context. Like the
+      // lazy $self: block below, we look up the provider module, but here
+      // we build a typed lookup over its config/secrets/system data.
+      const computedExpr = asComputedExpression(value);
+      if (computedExpr !== null) {
+        // Find the provider module (raw SQL, matching the lazy $self: block).
+        const providerResult = db.$client
+          .prepare(
+            `SELECT p.id FROM modules p
+             JOIN capabilities c ON p.id = c.module_id
+             WHERE c.capability_name = ?
+             LIMIT 1`,
+          )
+          .get(capabilityName) as { id: string } | undefined;
+
+        if (!providerResult) {
+          return {
+            success: false,
+            variable: variable.raw,
+            error: `Capability '${capabilityName}' has a computed field '${fieldPath}' but no provider module was found`,
+          };
+        }
+
+        try {
+          const lookup = await buildProviderLookup(providerResult.id, db);
+          const result = evaluateComputed(computedExpr, lookup);
+          // Computed results are often arrays/objects (e.g. domain_list).
+          // In a string-template context we serialize non-scalars as JSON;
+          // structured consumers read the evaluated value directly.
+          const serialized =
+            typeof result === 'string' || typeof result === 'number' || typeof result === 'boolean'
+              ? String(result)
+              : JSON.stringify(result);
+          return { success: true, value: serialized };
+        } catch (error) {
+          return {
+            success: false,
+            variable: variable.raw,
+            error: `Failed to evaluate computed field '${fieldPath}' of '${capabilityName}': ${error instanceof Error ? error.message : 'Unknown error'}`,
+          };
+        }
+      }
+
       // Check if value contains unresolved $self: variable (lazy resolution)
       if (typeof value === 'string' && value.startsWith('$self:')) {
         // Get provider module's config to resolve the variable.

package/src/variables/types.ts

@@ -7,7 +7,7 @@
  * Example: $self:target_ip -> { type: 'self', path: 'target_ip', raw: '$self:target_ip' }
  */
 export interface VariableReference {
-  type: 'self' | 'system' | 'system_secret' | 'secret' | 'capability';
+  type: 'self' | 'system' | 'system_secret' | 'secret' | 'capability' | 'infra';
   path: string;
   raw: string;
 }
@@ -22,6 +22,28 @@ export interface ResolutionContext {
   systemSecrets: Record<string, string>;
   secrets: Record<string, string>;
   capabilities: Record<string, Record<string, unknown>>;
+  /**
+   * The module's deployed systems, keyed by name, for `$infra:<name>.<field>`
+   * resolution at generate time (v2/MODULE_SYSTEMS_ADDRESSING.md). Each value
+   * exposes the snake_cased fields a template can reference: `ipv4_address`,
+   * `hostname`, `zone`, `vmid`, `cidr`. Optional only so the many test-stub
+   * `ResolutionContext` literals need no churn — production (buildResolutionContext)
+   * always populates it; the resolver treats undefined as the empty map.
+   */
+  systems?: Record<string, InfraSystemFields>;
+}
+
+/**
+ * The `$infra:<name>.<field>` fields a template can read for one deployed
+ * system. `cidr` is derived (ipv4_address + the zone's prefix length).
+ */
+export interface InfraSystemFields {
+  name: string;
+  hostname: string;
+  ipv4_address: string;
+  zone: string;
+  cidr: string;
+  vmid: string;
 }
 
 /**

package/src/services/dns-auto-register.ts

@@ -1,211 +0,0 @@
-/**
- * Automatic DNS registration for deployed modules.
- *
- * After any module deploys successfully, registers its hostname as an
- * A record in the internal DNS server (if dns_internal capability is
- * available). When the dns_internal provider itself deploys, backfills
- * records for all previously-deployed modules.
- */
-
-import type { HookLogger } from '@celilo/capabilities';
-import type { DnsInternalCapability } from '@celilo/capabilities';
-import { eq } from 'drizzle-orm';
-import type { DbClient } from '../db/client';
-import {
-  capabilities as capabilitiesTable,
-  moduleConfigs,
-  moduleInfrastructure,
-  modules,
-  systemConfig,
-} from '../db/schema';
-import { loadCapabilityFunctions } from '../hooks/capability-loader';
-
-/**
- * Get a module's hostname and IP for DNS registration.
- * Returns null if the module doesn't have both.
- */
-async function getModuleHostAndIp(
-  moduleId: string,
-  db: DbClient,
-): Promise<{ hostname: string; ip: string } | null> {
-  // Get hostname from module config
-  const hostnameConfig = db
-    .select()
-    .from(moduleConfigs)
-    .where(eq(moduleConfigs.moduleId, moduleId))
-    .all()
-    .find((c) => c.key === 'hostname');
-
-  if (!hostnameConfig?.value) return null;
-
-  // Get IP: try target_ip first, then machine IP
-  const targetIpConfig = db
-    .select()
-    .from(moduleConfigs)
-    .where(eq(moduleConfigs.moduleId, moduleId))
-    .all()
-    .find((c) => c.key === 'target_ip');
-
-  let ip = targetIpConfig?.value;
-
-  if (!ip) {
-    // Try machine IP from infrastructure assignment
-    const infra = db
-      .select()
-      .from(moduleInfrastructure)
-      .where(eq(moduleInfrastructure.moduleId, moduleId))
-      .all();
-
-    if (infra.length > 0 && infra[0].machineId) {
-      const { machines } = await import('../db/schema');
-      const machine = db.select().from(machines).where(eq(machines.id, infra[0].machineId)).get();
-      if (machine) {
-        ip = machine.ipAddress;
-      }
-    }
-  }
-
-  if (!ip) return null;
-
-  // Strip CIDR notation
-  const bareIp = ip.split('/')[0];
-
-  return { hostname: hostnameConfig.value, ip: bareIp };
-}
-
-/**
- * Get the system's primary domain.
- */
-function getPrimaryDomain(db: DbClient): string | null {
-  const record = db.select().from(systemConfig).where(eq(systemConfig.key, 'primary_domain')).get();
-
-  return record?.value || null;
-}
-
-/**
- * Load the dns_internal capability if it's available.
- * Returns null if no dns_internal provider is registered.
- */
-async function loadDnsInternal(
-  db: DbClient,
-  logger: HookLogger,
-): Promise<DnsInternalCapability | null> {
-  const providers = db
-    .select()
-    .from(capabilitiesTable)
-    .where(eq(capabilitiesTable.capabilityName, 'dns_internal'))
-    .all();
-
-  if (providers.length === 0) return null;
-
-  // Load capability functions using the provider's own module ID as context
-  const caps = await loadCapabilityFunctions(providers[0].moduleId, db, logger);
-  return (caps.dns_internal as DnsInternalCapability) || null;
-}
-
-/**
- * Auto-register a module's hostname in internal DNS after successful deploy.
- *
- * If the deployed module IS the dns_internal provider, also backfills
- * records for all previously-deployed modules.
- */
-export async function autoRegisterDns(
-  moduleId: string,
-  db: DbClient,
-  logger: HookLogger,
-): Promise<void> {
-  const primaryDomain = getPrimaryDomain(db);
-  if (!primaryDomain) {
-    return; // No domain configured, skip silently
-  }
-
-  const dnsInternal = await loadDnsInternal(db, logger);
-  if (!dnsInternal) {
-    return; // No dns_internal provider, skip silently
-  }
-
-  // Check if the module being deployed IS the dns_internal provider
-  const providers = db
-    .select()
-    .from(capabilitiesTable)
-    .where(eq(capabilitiesTable.capabilityName, 'dns_internal'))
-    .all();
-  const isProvider = providers.some((p) => p.moduleId === moduleId);
-
-  if (isProvider) {
-    // Backfill: register all deployed modules
-    logger.info('dns_internal provider deployed -- backfilling DNS records for all modules');
-    const allModules = db
-      .select()
-      .from(modules)
-      .all()
-      .filter((m) => m.id !== moduleId); // Skip self
-
-    for (const mod of allModules) {
-      const hostInfo = await getModuleHostAndIp(mod.id, db);
-      if (!hostInfo) continue;
-
-      const fqdn = `${hostInfo.hostname}.${primaryDomain}`;
-      try {
-        await dnsInternal.registerRecord({
-          host: fqdn,
-          type: 'A',
-          value: hostInfo.ip,
-        });
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logger.warn(`Failed to register ${fqdn}: ${msg}`);
-      }
-    }
-  }
-
-  // Register the deployed module itself
-  const hostInfo = await getModuleHostAndIp(moduleId, db);
-  if (!hostInfo) return;
-
-  const fqdn = `${hostInfo.hostname}.${primaryDomain}`;
-  try {
-    await dnsInternal.registerRecord({
-      host: fqdn,
-      type: 'A',
-      value: hostInfo.ip,
-    });
-    logger.success(`Registered DNS: ${fqdn} → ${hostInfo.ip}`);
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    logger.warn(`DNS registration failed for ${fqdn}: ${msg}`);
-    // Non-fatal -- deployment still succeeded
-  }
-}
-
-/**
- * Remove a module's DNS record when the module is removed.
- */
-export async function autoDeregisterDns(
-  moduleId: string,
-  db: DbClient,
-  logger: HookLogger,
-): Promise<void> {
-  const primaryDomain = getPrimaryDomain(db);
-  if (!primaryDomain) return;
-
-  const dnsInternal = await loadDnsInternal(db, logger);
-  if (!dnsInternal) return;
-
-  const hostInfo = await getModuleHostAndIp(moduleId, db);
-  if (!hostInfo) return;
-
-  const fqdn = `${hostInfo.hostname}.${primaryDomain}`;
-  try {
-    await dnsInternal.deleteRecord({
-      host: fqdn,
-      type: 'A',
-      value: hostInfo.ip,
-    });
-    logger.success(`Removed DNS: ${fqdn}`);
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    logger.warn(`DNS cleanup failed for ${fqdn}: ${msg}`);
-    // Non-fatal
-  }
-}