@uluops/setup 0.7.0 → 0.8.1

package/dist/steps/verify.js

@@ -4,130 +4,217 @@ import { loadManifest } from "../lib/manifest.js";
 import { getHealthTimeout } from "../lib/health.js";
 import { getProfile } from "../harnesses/index.js";
 import { readInstalledMetricsVersion } from "./metrics.js";
-/** Verify a single harness entry, appending results to checks. Returns false if any check fails. */
-async function verifyHarness(harnessName, hm, checks) {
-    let allOk = true;
-    let profile;
-    try {
-        profile = getProfile(harnessName);
-    }
-    catch {
-        checks.push({ label: `Harness: ${harnessName}`, passed: false, detail: "Unknown harness in manifest" });
-        return false;
-    }
-    // 1. Readiness Check (Harness Restart)
+import { extractEmail } from "../lib/json-guards.js";
+/**
+ * Readiness probe: did the harness pick up the config after install?
+ * The proxy signal is `configFile.mtimeMs > installedAt + 100ms` — a config
+ * touched after install means the harness wrote it back during startup.
+ * Always passes (true) — readiness state is reported in `detail`, not the
+ * boolean — so the caller never fails the run on this alone. Only the
+ * "installedAt is corrupt" branch returns false, because that indicates
+ * the manifest itself is broken.
+ */
+async function checkReadiness(profile, hm, checks) {
     try {
         const configStat = await stat(hm.mcpConfigPath);
         const installedTime = new Date(hm.installedAt).getTime();
         const configTime = configStat.mtimeMs;
-        // If config was modified AFTER install, it's a proxy for the harness having read it.
-        // We add a 100ms buffer to handle near-simultaneous writes.
-        const isReady = configTime > (installedTime + 100);
+        if (Number.isNaN(installedTime)) {
+            checks.push({
+                label: `[${profile.displayName}] Readiness`,
+                passed: false,
+                detail: `Cannot determine readiness — manifest installedAt is invalid (${hm.installedAt})`,
+            });
+            return false;
+        }
+        const isReady = configTime > installedTime + 100;
         checks.push({
             label: `[${profile.displayName}] Readiness`,
             passed: true,
             detail: isReady ? "Active (loaded)" : "Waiting for restart",
         });
+        return true;
     }
     catch {
-        // If we can't stat it, we'll catch the error in the MCP config check below.
+        // Stat failure surfaces in checkMcpConfig as a "cannot read" error;
+        // suppress here to avoid double-reporting.
+        return true;
     }
-    // 2. MCP config
+}
+/** MCP config present and contains UluOps server entries. */
+async function checkMcpConfig(profile, hm, checks) {
     try {
         const config = await profile.mcpConfig.read(hm.mcpConfigPath);
         if (profile.mcpConfig.check(config)) {
-            checks.push({ label: `[${profile.displayName}] MCP config present in ${hm.mcpConfigPath} (2 servers)`, passed: true });
-        }
-        else {
-            checks.push({ label: `[${profile.displayName}] MCP config`, passed: false, detail: "UluOps servers not found in config" });
-            allOk = false;
+            checks.push({
+                label: `[${profile.displayName}] MCP config present in ${hm.mcpConfigPath} (2 servers)`,
+                passed: true,
+            });
+            return true;
         }
+        checks.push({
+            label: `[${profile.displayName}] MCP config`,
+            passed: false,
+            detail: "UluOps servers not found in config",
+        });
+        return false;
     }
     catch {
-        checks.push({ label: `[${profile.displayName}] MCP config`, passed: false, detail: `Cannot read ${hm.mcpConfigPath}` });
-        allOk = false;
+        checks.push({
+            label: `[${profile.displayName}] MCP config`,
+            passed: false,
+            detail: `Cannot read ${hm.mcpConfigPath}`,
+        });
+        return false;
     }
-    // Agent files
+}
+/** Agent files: every file recorded in the manifest exists on disk. */
+async function checkAgents(profile, hm, checks) {
     const agentsDir = join(hm.defsPath, "agents");
     try {
         const agentFiles = await readdir(agentsDir);
         const found = hm.agents.filter((a) => agentFiles.includes(a)).length;
+        const ok = found === hm.agents.length;
         checks.push({
             label: `[${profile.displayName}] ${found}/${hm.agents.length} agents in ${agentsDir}`,
-            passed: found === hm.agents.length,
-            detail: found < hm.agents.length ? `Missing ${hm.agents.length - found} agent(s)` : undefined,
+            passed: ok,
+            detail: ok ? undefined : `Missing ${hm.agents.length - found} agent(s)`,
         });
-        if (found < hm.agents.length)
-            allOk = false;
+        return ok;
     }
     catch {
-        checks.push({ label: `[${profile.displayName}] Agent files`, passed: false, detail: `Directory not found: ${agentsDir}` });
-        allOk = false;
-    }
-    // Command files
-    if (hm.commands.length > 0) {
-        const commandsDir = join(hm.defsPath, "commands");
-        const cmdResults = await Promise.all(hm.commands.map(async (cmd) => {
-            try {
-                await access(join(commandsDir, cmd));
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }));
-        const found = cmdResults.filter(Boolean).length;
         checks.push({
-            label: `[${profile.displayName}] ${found}/${hm.commands.length} commands`,
-            passed: found === hm.commands.length,
-            detail: found < hm.commands.length ? `Missing ${hm.commands.length - found} command(s)` : undefined,
+            label: `[${profile.displayName}] Agent files`,
+            passed: false,
+            detail: `Directory not found: ${agentsDir}`,
         });
-        if (found < hm.commands.length)
-            allOk = false;
+        return false;
     }
-    // Hooks
-    if (hm.hooksInstalled && profile.hooks && profile.paths.settingsPath) {
-        const hookPresent = await profile.hooks.check(profile.paths.settingsPath);
-        let hookFilePresent = false;
-        if (profile.paths.toolsDir) {
-            try {
-                await access(join(profile.paths.toolsDir, "dist", "hook.js"));
-                hookFilePresent = true;
-            }
-            catch { /* Missing */ }
+}
+/**
+ * Command files: every command recorded in the manifest exists on disk.
+ * No-op (returns true) when the manifest records zero commands — keeps the
+ * "(0/0 commands)" noise out of the report for harnesses without commands.
+ */
+async function checkCommands(profile, hm, checks) {
+    if (hm.commands.length === 0)
+        return true;
+    const commandsDir = join(hm.defsPath, "commands");
+    const cmdResults = await Promise.all(hm.commands.map(async (cmd) => {
+        try {
+            await access(join(commandsDir, cmd));
+            return true;
         }
-        if (hookPresent && hookFilePresent) {
-            // Existence is necessary but not sufficient — check version drift against the
-            // currently-resolvable agent-metrics. Without this, verify cannot detect that
-            // a fresh setup release is shipping while the installed hook is stale.
-            const installedVersion = profile.paths.toolsDir
-                ? await readInstalledMetricsVersion(profile.paths.toolsDir)
-                : null;
-            const recordedVersion = hm.hooksInstalledVersion ?? null;
-            const detail = installedVersion
-                ? `v${installedVersion}${recordedVersion && recordedVersion !== installedVersion ? ` (manifest records v${recordedVersion} — out of sync)` : ""}`
-                : "version unknown";
-            checks.push({
-                label: `[${profile.displayName}] Agent metrics hook configured`,
-                passed: true,
-                detail,
-            });
-            if (recordedVersion && installedVersion && recordedVersion !== installedVersion) {
-                // Drift between manifest record and on-disk hook copy — not a hard failure
-                // because verify is read-only, but surface it so the user re-runs setup.
-                allOk = false;
-            }
+        catch {
+            return false;
         }
-        else {
-            const missing = [
-                ...(!hookPresent ? ["hook not in settings"] : []),
-                ...(!hookFilePresent ? ["hook.js not found"] : []),
-            ].join(", ");
-            checks.push({ label: `[${profile.displayName}] Agent metrics`, passed: false, detail: missing });
-            allOk = false;
+    }));
+    const found = cmdResults.filter(Boolean).length;
+    const ok = found === hm.commands.length;
+    checks.push({
+        label: `[${profile.displayName}] ${found}/${hm.commands.length} commands`,
+        passed: ok,
+        detail: ok ? undefined : `Missing ${hm.commands.length - found} command(s)`,
+    });
+    return ok;
+}
+/**
+ * Agent-metrics hook: present in settings + hook.js exists + manifest version
+ * matches on-disk version. Each piece is necessary; only all three together
+ * means the hook will actually run on the next harness invocation.
+ *
+ * No-op (returns true) when the manifest says hooks weren't installed or the
+ * profile doesn't expose a hook strategy. Version drift returns false even
+ * though hooks are technically "present" — drift means setup was upgraded
+ * but never re-ran, which silently ships a stale hook against a fresh CLI.
+ */
+async function checkHooks(profile, hm, checks) {
+    if (!hm.hooksInstalled || !profile.hooks || !profile.paths.settingsPath) {
+        return true;
+    }
+    const hookPresent = await profile.hooks.check(profile.paths.settingsPath);
+    let hookFilePresent = false;
+    if (profile.paths.toolsDir) {
+        try {
+            await access(join(profile.paths.toolsDir, "dist", "hook.js"));
+            hookFilePresent = true;
         }
+        catch {
+            /* Missing */
+        }
+    }
+    if (!hookPresent || !hookFilePresent) {
+        const missing = [
+            ...(!hookPresent ? ["hook not in settings"] : []),
+            ...(!hookFilePresent ? ["hook.js not found"] : []),
+        ].join(", ");
+        checks.push({
+            label: `[${profile.displayName}] Agent metrics`,
+            passed: false,
+            detail: missing,
+        });
+        return false;
+    }
+    const installedVersion = profile.paths.toolsDir
+        ? await readInstalledMetricsVersion(profile.paths.toolsDir)
+        : null;
+    const recordedVersion = hm.hooksInstalledVersion ?? null;
+    const drift = !!recordedVersion &&
+        !!installedVersion &&
+        recordedVersion !== installedVersion;
+    const detail = installedVersion
+        ? `v${installedVersion}${drift ? ` (manifest records v${recordedVersion} — out of sync)` : ""}`
+        : "version unknown";
+    checks.push({
+        label: `[${profile.displayName}] Agent metrics hook configured`,
+        passed: true,
+        detail,
+    });
+    // Drift is reported as passed=true (verify is read-only) but flips allOk
+    // so the user knows a re-run is needed.
+    return !drift;
+}
+/** Verify a single harness entry, appending results to checks. Returns false if any check fails. */
+async function verifyHarness(harnessName, hm, checks) {
+    let profile;
+    try {
+        profile = getProfile(harnessName);
+    }
+    catch {
+        checks.push({
+            label: `Harness: ${harnessName}`,
+            passed: false,
+            detail: "Unknown harness in manifest",
+        });
+        return false;
+    }
+    // Partial install gets surfaced before any per-file check runs. The
+    // recorded file lists are honest (post-Phase-0.5 contract) so the
+    // file-existence checks will pass, but the user needs to know the
+    // install never completed and a re-run is required. Reported as a
+    // failed check so verify exits 1 — partial state is not "passes". The
+    // remaining checks still run so the report shows exactly what landed
+    // before the step threw. (Spec §7.6.4.)
+    let partialOk = true;
+    if (hm.partial) {
+        checks.push({
+            label: `[${profile.displayName}] partial install — failed at "${hm.partial}"`,
+            passed: false,
+            detail: `Re-run: npx @uluops/setup --harness ${harnessName}`,
+        });
+        partialOk = false;
     }
-    return allOk;
+    // Run sequentially: the checks share a `checks` array and the user-visible
+    // report depends on insertion order (readiness → mcp → agents → commands →
+    // hooks). Promise.all would scramble that order. AND together at the end so
+    // any single failure flips the harness result while every check still gets
+    // to push its row.
+    const readinessOk = await checkReadiness(profile, hm, checks);
+    const mcpOk = await checkMcpConfig(profile, hm, checks);
+    const agentsOk = await checkAgents(profile, hm, checks);
+    const commandsOk = await checkCommands(profile, hm, checks);
+    const hooksOk = await checkHooks(profile, hm, checks);
+    return partialOk && readinessOk && mcpOk && agentsOk && commandsOk && hooksOk;
 }
 /** Run all verification checks against the current installation and return structured results. */
 export async function verify() {
@@ -162,9 +249,26 @@ export async function verify() {
                 signal: AbortSignal.timeout(getHealthTimeout()),
             });
             if (res.ok) {
-                const data = (await res.json());
+                // Decode via the shared envelope guard. Bare `as { email?: string }`
+                // would silently produce a "key valid (no user)" label on HTML error
+                // pages or schema drift. extractEmail throws when the body is not an
+                // object at all (surfaced below as a check failure) and returns null
+                // when data/email are absent or wrong-typed.
+                let email;
+                try {
+                    email = extractEmail(await res.json());
+                }
+                catch (err) {
+                    checks.push({
+                        label: "API key valid",
+                        passed: false,
+                        detail: err instanceof Error ? err.message : "Unexpected response shape",
+                    });
+                    allOk = false;
+                    return { ok: allOk, checks };
+                }
                 checks.push({
-                    label: `API key valid${data.email ? ` (user: ${data.email})` : ""}`,
+                    label: `API key valid${email ? ` (user: ${email})` : ""}`,
                     passed: true,
                 });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uluops/setup",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Zero-friction installer for UluOps agentic harnesses",
   "license": "MIT",
   "repository": {
@@ -29,6 +29,7 @@
   "files": [
     "dist/cli.js",
     "dist/cli.d.ts",
+    "dist/cli/**",
     "dist/lib/**",
     "dist/steps/**",
     "dist/harnesses/**",
@@ -57,6 +58,6 @@
     "@types/node": "22.19.15",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "vitest": "3.2.4"
+    "vitest": "4.1.8"
   }
 }