Give each endpoint its own credential and fix the review findings on the server

Per-PC credentials (replaces the 09-14 client-certificate attempt):
- POST /api/endpoints/enroll issues a credential to a PC that matches exactly
  one computer by hostname and BIOS serial and has none yet. Anything else
  (unknown or duplicate hostname, serial mismatch, already enrolled) waits as
  a request an admin approves or rejects. The agent's persisted nonce binds an
  approved request to the PC that asked.
- One auth helper serves every agent route. With X-Endpoint-Credential the
  asset comes from the credential and a request naming another PC gets 403
  ASSET_MISMATCH. The shared key still works for PCs that have not enrolled,
  is refused (401 SHARED_KEY_REFUSED) for any PC that has, and can be switched
  off. A revoked credential gets 401 CREDENTIAL_INVALID so the agent
  re-enrolls.
- The core collector accepts the credential for the computers, printers and
  endpoints collectors through two new plugin hooks exposed on shopdb.api
  (contract 0.33.0), and refuses the shared key for enrolled PCs.
- Admin API: enrollment list, approve, reject, revoke (un-enroll), settings.
  Migration API: per-PC readiness with blockers, and upgrade waves that
  package the agent once and queue the existing agent upgrade per PC.
- Migration 0023 creates endpointcredentials, endpointenrollrequests and
  endpointmigrationwaves, drops the certificate columns from assets where
  test databases have them, and renames app_fingerprint to appfingerprint.
  0021 and 0022 keep their ids but no longer alter the core assets table.
- Removed: client_cert.py, certificate renewal, the unauthenticated
  /test/client-cert route, nginx client certificate forwarding and the agent
  certificate script. The client-cert header could be forged on IIS, the key
  was readable by users, and the shared key remained a fallback.
- GET /settings/server-cert returns the SPKI SHA-256 pin for GE-Enforce.

Review fixes:
- report_command_result used g without importing it; every result was a 500.
- collect_log refuses setup answer files, appsettings, agent directories and
  key files at enqueue.
- Fleet alerts: alerttimeout and alertfleet agree with the migration, the
  scope is validated and a malformed scope no longer reaches the whole fleet,
  and the ack race no longer raises NameError.
- A refused break-glass override leaves no hold and no audit row.
- Agent upgrade checks locks and permissions before repackaging, and writes
  the package atomically.
- Server certificate upload validates the pair before replacing files;
  generation no longer builds an openssl config from user input; audit rows
  are actually written.
- Health evaluation runs in a savepoint so a caught error cannot lose the
  check-in.
- Required-app policies are found by appid, survive renames, and deleting an
  app deactivates policies that still name it. The UI and API now say such a
  policy only takes effect inside a business policy.
- Backfill handles duplicate fingerprints and rolls back a failed batch.
- Plugin settings routes skip a plugin whose hook raises.
- The setup token is no longer printed to the log.
- The naming gate checks top-level files again and handles odd file names.
- Removed root scratch scripts, one of which carried a token.
- Rewrote the fleet alert scheduling and app delta tests on real fixtures.

plugins/computers/services/apppolicy.py

@@ -15,6 +15,14 @@ kept. Deleting someone's customised enforcement rule because a checkbox changed
 on a different screen would be a genuinely destructive surprise, and the box is
 not a reliable signal that they wanted that.
 
+Not attached to a Business Policy
+---------------------------------
+The generated policy is NOT added to any Business Policy. The resolver only
+applies Configuration Policies reached through an active Business Policy, so
+until an admin adds it to one, the generated policy installs nothing. The API
+response and the acknowledgement text say so rather than promising a fleet
+install that will not happen.
+
 Scope
 -----
 Generated policies use the `allpcs` node, not `true`: "required on all PCs"
@@ -48,13 +56,58 @@ def auto_policy_name(application):
     return '{} {}'.format(AUTO_POLICY_PREFIX, application.appname)
 
 
+def _action_appid(action_row):
+    """The appid an action's params name, or None."""
+    params = action_row.params
+    if not isinstance(params, dict):
+        return None
+    try:
+        return int(params.get('appid'))
+    except (TypeError, ValueError):
+        return None
+
+
+def policies_referencing_app(appid):
+    """Every ConfigurationPolicy with an action whose params name this appid.
+
+    Params are a JSON text column (MySQL 5.6 has no JSON type to query), so the
+    match is done in Python over the actions that carry params at all.
+    """
+    if appid is None:
+        return []
+    found = {}
+    rows = (ConfigurationPolicyAction.query
+            .filter(ConfigurationPolicyAction.params.isnot(None))
+            .all())
+    for action_row in rows:
+        if _action_appid(action_row) == int(appid):
+            policy = action_row.configurationpolicy
+            if policy is not None:
+                found[policy.configurationpolicyid] = policy
+    return [found[key] for key in sorted(found)]
+
+
 def find_auto_policy(application):
     """Return the policy generated for this app, whoever owns it now.
 
-    Matches on name, since that is the only durable link - there is no FK from
-    a policy back to an application. Returns rows that have since been flipped
-    to 'local' too, so callers can tell "customised" from "absent".
+    Keyed on the appid in the generated update_app action's params, not on the
+    name: the name embeds appname, so renaming the application used to orphan
+    its policy (the next untick could not find it, and a re-tick generated a
+    second one). A policy counts as generated when it still carries the autoapp
+    source or the generated name prefix, so a row flipped to 'local' by an edit
+    is still found and callers can tell "customised" from "absent". The name
+    lookup stays as a fallback for a row whose params were edited away.
     """
+    candidates = [
+        policy for policy in policies_referencing_app(application.appid)
+        if policy.source == POLICY_SOURCE_AUTOAPP
+        or (policy.name or '').startswith(AUTO_POLICY_PREFIX)
+    ]
+    if candidates:
+        candidates.sort(key=lambda policy: (
+            policy.source != POLICY_SOURCE_AUTOAPP,
+            policy.configurationpolicyid))
+        return candidates[0]
     return ConfigurationPolicy.query.filter_by(
         name=auto_policy_name(application)
     ).first()
@@ -75,7 +128,13 @@ def sync_required_app_policy(application):
         if existing is not None:
             # Already enforced. Deliberately does NOT rewrite a customised row
             # back to our defaults; re-ticking a box should not silently revert
-            # an admin's edits.
+            # an admin's edits. A still-generated row does follow an app rename
+            # so its name keeps describing what it installs.
+            wanted = auto_policy_name(application)
+            if (existing.source == POLICY_SOURCE_AUTOAPP
+                    and existing.name != wanted
+                    and ConfigurationPolicy.query.filter_by(name=wanted).first() is None):
+                existing.name = wanted
             return 'unchanged'
 
         policy = ConfigurationPolicy(
@@ -122,3 +181,22 @@ def disown_if_generated(policy):
         policy.source = POLICY_SOURCE_LOCAL
         return True
     return False
+
+
+def deactivate_policies_for_app(appid):
+    """Deactivate every remaining policy whose actions name a deleted appid.
+
+    Called when an application is deleted, after the generated policy has been
+    withdrawn. What is left is either the customised ('kept') generated policy
+    or a hand-authored one; both would keep trying to install an application
+    that no longer exists. They are deactivated rather than deleted - they are
+    someone's work - and returned so the API can name them.
+    """
+    deactivated = []
+    for policy in policies_referencing_app(appid):
+        if policy in db.session.deleted:
+            continue
+        if policy.isactive:
+            policy.isactive = False
+            deactivated.append(policy.name)
+    return deactivated