@celilo/cli 0.26.1 → 0.27.0

package/src/services/infrastructure-selector.test.ts

@@ -100,7 +100,6 @@ describe('infrastructure-selector', () => {
         hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const result = await selectInfrastructure(module);
@@ -143,7 +142,6 @@ describe('infrastructure-selector', () => {
         hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const result = await selectInfrastructure(module);
@@ -308,7 +306,6 @@ describe('infrastructure-selector', () => {
         hardware: { cpu_cores: 1, memory_mb: 4096, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       // Should throw InfrastructureError with resource details
@@ -350,7 +347,6 @@ describe('infrastructure-selector', () => {
         hardware: { cpu_cores: 4, memory_mb: 1024, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       await expect(selectInfrastructure(module)).rejects.toThrow(InfrastructureError);
@@ -390,7 +386,6 @@ describe('infrastructure-selector', () => {
         hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 10 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       await expect(selectInfrastructure(module)).rejects.toThrow(InfrastructureError);
@@ -430,7 +425,6 @@ describe('infrastructure-selector', () => {
         hardware: { cpu_cores: 8, memory_mb: 16384, disk_gb: 256 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const result = await selectInfrastructure(module);
@@ -473,7 +467,6 @@ describe('infrastructure-selector', () => {
         hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const result = await selectInfrastructure(module);

package/src/services/infrastructure-selector.ts

@@ -7,7 +7,7 @@ import type {
   ResourceRequirements,
 } from '../types/infrastructure';
 import { listContainerServices } from './container-service';
-import { getModuleResourcesOnMachine, listMachines } from './machine-pool';
+import { getModulesOnMachine, listMachines } from './machine-pool';
 
 /**
  * Infrastructure selection error
@@ -49,25 +49,24 @@ function getResourceRequirements(module: Module): ResourceRequirements {
 }
 
 /**
- * Check if a machine has capacity for the given requirements
+ * Is this machine big enough for the module at all?
+ *
+ * Deliberately NOT multi-tenant capacity accounting (celilo#773). It used to
+ * subtract an "already allocated" figure that was hard-coded to zero behind a
+ * TODO, so the subtraction never changed an answer and the check has always
+ * been exactly this comparison. Saying so is the honest version; a gate that
+ * cannot fail reads as protection that is not there (Rule 7.6).
+ *
+ * Real accounting needs a decision nobody has made — whether a module's draw is
+ * its manifest MINIMUM (`requires.system`) or its deployed size, which on a
+ * pool machine celilo does not own. Until then the occupancy filter, which IS
+ * now correct, is what keeps two modules off one box.
  */
-async function machineHasCapacity(
-  machine: Machine,
-  requirements: ResourceRequirements,
-): Promise<boolean> {
-  // Get already-allocated resources
-  const allocated = await getModuleResourcesOnMachine(machine.id);
-
-  // Calculate remaining capacity
-  const remainingCpu = machine.hardware.cpu_cores - allocated.cpu;
-  const remainingMemory = machine.hardware.memory_mb - allocated.memory;
-  const remainingDisk = machine.hardware.disk_gb - allocated.disk;
-
-  // Check if machine has enough remaining resources
+function machineHasCapacity(machine: Machine, requirements: ResourceRequirements): boolean {
   return (
-    remainingCpu >= requirements.cpu &&
-    remainingMemory >= requirements.memory &&
-    remainingDisk >= requirements.disk
+    machine.hardware.cpu_cores >= requirements.cpu &&
+    machine.hardware.memory_mb >= requirements.memory &&
+    machine.hardware.disk_gb >= requirements.disk
   );
 }
 
@@ -181,11 +180,12 @@ export async function selectInfrastructure(module: Module): Promise<Infrastructu
       continue;
     }
     // Skip machines already assigned to other modules
-    if (machine.assignedModuleIds.length > 0 && !machine.assignedModuleIds.includes(moduleId)) {
+    const occupants = getModulesOnMachine(machine.id);
+    if (occupants.length > 0 && !occupants.includes(moduleId)) {
       rejections.push({
         hostname: machine.hostname,
         ipAddress: machine.ipAddress,
-        reason: `already assigned to module(s): ${machine.assignedModuleIds.join(', ')}`,
+        reason: `already assigned to module(s): ${occupants.join(', ')}`,
       });
       continue;
     }
@@ -208,14 +208,13 @@ export async function selectInfrastructure(module: Module): Promise<Infrastructu
       });
       continue;
     }
-    if (await machineHasCapacity(machine, requirements)) {
+    if (machineHasCapacity(machine, requirements)) {
       availableMachines.push(machine);
     } else {
-      const allocated = await getModuleResourcesOnMachine(machine.id);
       const shortfalls: string[] = [];
-      const remainingCpu = machine.hardware.cpu_cores - allocated.cpu;
-      const remainingMemory = machine.hardware.memory_mb - allocated.memory;
-      const remainingDisk = machine.hardware.disk_gb - allocated.disk;
+      const remainingCpu = machine.hardware.cpu_cores;
+      const remainingMemory = machine.hardware.memory_mb;
+      const remainingDisk = machine.hardware.disk_gb;
 
       if (remainingCpu < requirements.cpu) {
         shortfalls.push(`CPU: ${remainingCpu} available, ${requirements.cpu} required`);

package/src/services/infrastructure-variable-resolver.test.ts

@@ -96,7 +96,6 @@ describe('resolveInfrastructureVariables - Machine Infrastructure', () => {
       sshKeyEncrypted: 'encrypted-key',
       hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 20 },
       zone: 'external',
-      assignedModuleIds: [],
     });
 
     // Create module infrastructure selection
@@ -169,7 +168,6 @@ describe('resolveInfrastructureVariables - Machine Infrastructure', () => {
       sshKeyEncrypted: 'encrypted',
       hardware: { cpu_cores: 1, memory_mb: 1024, disk_gb: 10 },
       zone: 'internal',
-      assignedModuleIds: [],
     });
 
     await db.insert(moduleInfrastructure).values({
@@ -468,7 +466,6 @@ describe('resolveInfrastructureVariables - User Override', () => {
       sshKeyEncrypted: 'encrypted',
       hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 20 },
       zone: 'external',
-      assignedModuleIds: [],
     });
 
     await db.insert(moduleInfrastructure).values({
@@ -526,7 +523,6 @@ describe('resolveInfrastructureVariables - Required vs Optional', () => {
       sshKeyEncrypted: 'encrypted',
       hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 20 },
       zone: 'internal',
-      assignedModuleIds: [],
     });
 
     await db.insert(moduleInfrastructure).values({
@@ -583,7 +579,6 @@ describe('resolveInfrastructureVariables - Required vs Optional', () => {
       sshKeyEncrypted: 'encrypted',
       hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 20 },
       zone: 'internal',
-      assignedModuleIds: [],
     });
 
     await db.insert(moduleInfrastructure).values({
@@ -694,7 +689,6 @@ describe('resolveInfrastructureVariables - Edge Cases', () => {
       sshKeyEncrypted: 'encrypted',
       hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 20 },
       zone: 'internal',
-      assignedModuleIds: [],
     });
 
     await db.insert(moduleInfrastructure).values({

package/src/services/infrastructure-variable-resolver.ts

@@ -90,9 +90,6 @@ export async function resolveInfrastructureVariables(
       hardware: machineRow.hardware || { cpu_cores: 0, memory_mb: 0, disk_gb: 0 },
       role: (machineRow.role as Machine['role']) || 'host',
       interfaces: (machineRow.interfaces || []) as Machine['interfaces'],
-      assignedModuleIds: Array.isArray(machineRow.assignedModuleIds)
-        ? machineRow.assignedModuleIds
-        : [],
       earmarkedModule: machineRow.earmarkedModule ?? undefined,
       createdAt: new Date(machineRow.createdAt),
       updatedAt: new Date(machineRow.updatedAt),

package/src/services/machine-pool.test.ts

@@ -7,18 +7,17 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { eq } from 'drizzle-orm';
-import { closeDb, createDbClient } from '../db/client';
+import { closeDb, createDbClient, getDb } from '../db/client';
 import { runMigrations } from '../db/migrate';
-import { machines } from '../db/schema';
+import { machines, moduleInfrastructure, modules } from '../db/schema';
 import {
   addMachine,
-  assignModuleToMachine,
   getMachine,
   getMachineByHostname,
   getMachineSshKey,
+  getModulesOnMachine,
   listMachines,
   removeMachine,
-  unassignModuleFromMachine,
 } from './machine-pool';
 
 describe('machine-pool', () => {
@@ -72,7 +71,6 @@ describe('machine-pool', () => {
         },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       expect(machine.id).toBeDefined();
@@ -80,7 +78,6 @@ describe('machine-pool', () => {
       expect(machine.zone).toBe('internal');
       expect(machine.ipAddress).toBe('192.168.1.100');
       expect(machine.hardware.cpu_cores).toBe(4);
-      expect(machine.assignedModuleIds).toEqual([]);
       expect(machine.createdAt).toBeInstanceOf(Date);
     });
 
@@ -94,7 +91,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       // Verify key is encrypted in database
@@ -115,7 +111,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const externalMachine = await addMachine({
@@ -127,7 +122,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 1, memory_mb: 1024, disk_gb: 25 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       expect(dmzMachine.zone).toBe('dmz');
@@ -146,7 +140,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const retrieved = await getMachine(created.id);
@@ -173,7 +166,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const retrieved = await getMachineByHostname('unique-hostname');
@@ -204,7 +196,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       await addMachine({
@@ -216,7 +207,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const result = await listMachines();
@@ -233,7 +223,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       await addMachine({
@@ -245,7 +234,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 1, memory_mb: 1024, disk_gb: 25 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const dmzMachines = await listMachines({ zone: 'dmz' });
@@ -269,7 +257,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       const decryptedKey = await getMachineSshKey(machine.id);
@@ -281,10 +268,19 @@ describe('machine-pool', () => {
     });
   });
 
-  describe('assignModuleToMachine', () => {
-    it('assigns module to machine', async () => {
+  /**
+   * celilo#773. `assignModuleToMachine` / `unassignModuleFromMachine` are gone
+   * along with the column they wrote — both were exported, neither had a single
+   * caller, and the column they maintained had an append-only writer elsewhere
+   * with no removal path at all.
+   *
+   * Occupancy is derived now, so these assert the two divergences that actually
+   * bit the fleet rather than that a setter sets.
+   */
+  describe('getModulesOnMachine', () => {
+    async function machineWithModuleDeployed(hostname: string, moduleId: string) {
       const machine = await addMachine({
-        hostname: 'test-machine',
+        hostname,
         zone: 'internal',
         ipAddress: '192.168.1.100',
         sshUser: 'ubuntu',
@@ -292,86 +288,59 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
+      const db = getDb();
+      db.insert(modules)
+        .values({
+          id: moduleId,
+          name: moduleId,
+          version: '1.0.0',
+          manifestData: {},
+          sourcePath: `/tmp/${moduleId}`,
+        })
+        .run();
+      db.insert(moduleInfrastructure)
+        .values({
+          id: `infra-${moduleId}`,
+          moduleId,
+          infrastructureType: 'machine',
+          machineId: machine.id,
+        })
+        .run();
+      return machine;
+    }
 
-      await assignModuleToMachine(machine.id, 'homebridge');
-
-      const updated = await getMachine(machine.id);
-      expect(updated?.assignedModuleIds).toEqual(['homebridge']);
+    it('reports a machine that is hosting a module as occupied', async () => {
+      // The live case: briq hosted a VERIFIED iptables and reported
+      // "None (available)", so a second module could be placed on top of it.
+      const machine = await machineWithModuleDeployed('briq', 'iptables');
+      expect(getModulesOnMachine(machine.id)).toEqual(['iptables']);
     });
 
-    it('supports multiple modules on same machine', async () => {
-      const machine = await addMachine({
-        hostname: 'multi-module-machine',
-        zone: 'internal',
-        ipAddress: '192.168.1.100',
-        sshUser: 'ubuntu',
-        sshKey: 'test-key',
-        hardware: { cpu_cores: 8, memory_mb: 16384, disk_gb: 256 },
-        role: 'host',
-        interfaces: [],
-        assignedModuleIds: [],
-      });
+    it('frees the machine when the module is removed, with no manual step', async () => {
+      // The other direction: the id used to survive the module forever, so
+      // placement rejected an empty box citing a module that no longer existed
+      // and `machine remove` refused to remove it. Nothing could clear it.
+      const machine = await machineWithModuleDeployed('rpi4-lr', 'homebridge');
+      expect(getModulesOnMachine(machine.id)).toEqual(['homebridge']);
 
-      await assignModuleToMachine(machine.id, 'module-1');
-      await assignModuleToMachine(machine.id, 'module-2');
-      await assignModuleToMachine(machine.id, 'module-3');
+      getDb().delete(modules).where(eq(modules.id, 'homebridge')).run();
 
-      const updated = await getMachine(machine.id);
-      expect(updated?.assignedModuleIds).toEqual(['module-1', 'module-2', 'module-3']);
+      expect(getModulesOnMachine(machine.id)).toEqual([]);
     });
 
-    it('throws error for non-existent machine', async () => {
-      await expect(assignModuleToMachine('non-existent-id', 'module-id')).rejects.toThrow(
-        /Machine not found/,
-      );
-    });
-  });
-
-  describe('unassignModuleFromMachine', () => {
-    it('removes module from machine', async () => {
+    it('reports an empty machine as empty', async () => {
       const machine = await addMachine({
-        hostname: 'test-machine',
+        hostname: 'spare',
         zone: 'internal',
-        ipAddress: '192.168.1.100',
+        ipAddress: '192.168.1.101',
         sshUser: 'ubuntu',
         sshKey: 'test-key',
-        hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
-        role: 'host',
-        interfaces: [],
-        assignedModuleIds: ['homebridge'],
-      });
-
-      await unassignModuleFromMachine(machine.id, 'homebridge');
-
-      const updated = await getMachine(machine.id);
-      expect(updated?.assignedModuleIds).toEqual([]);
-    });
-
-    it('removes specific module from multiple assignments', async () => {
-      const machine = await addMachine({
-        hostname: 'test-machine',
-        zone: 'internal',
-        ipAddress: '192.168.1.100',
-        sshUser: 'ubuntu',
-        sshKey: 'test-key',
-        hardware: { cpu_cores: 8, memory_mb: 16384, disk_gb: 256 },
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: ['module-1', 'module-2', 'module-3'],
       });
-
-      await unassignModuleFromMachine(machine.id, 'module-2');
-
-      const updated = await getMachine(machine.id);
-      expect(updated?.assignedModuleIds).toEqual(['module-1', 'module-3']);
-    });
-
-    it('throws error for non-existent machine', async () => {
-      await expect(unassignModuleFromMachine('non-existent-id', 'module-id')).rejects.toThrow(
-        /Machine not found/,
-      );
+      expect(getModulesOnMachine(machine.id)).toEqual([]);
     });
   });
 
@@ -386,7 +355,6 @@ describe('machine-pool', () => {
         hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
         role: 'host',
         interfaces: [],
-        assignedModuleIds: [],
       });
 
       await removeMachine(machine.id);