@dokebi/cli 0.4.0 → 0.4.2

package/dist/verify.js

@@ -61,10 +61,31 @@ export async function npmScript(root, script, timeoutMs) {
 export const VERIFY_TOKEN_ENV = 'DOKEBI_VERIFY_TOKEN';
 /** The response header @dokebi/web answers with when that variable is set. */
 export const VERIFY_HEADER = 'x-dokebi-verify';
-/** GET with a Host header (fetch cannot set one). */
+/**
+ * GET with a Host header (fetch cannot set one). Settles once: with the answer when the body
+ * ended, or with an error when the request fails, the response is aborted or its connection
+ * closes before the end (ISSUE-0006 A09), or nothing complete came within `timeoutMs` in all
+ * (the socket timeout alone never fires for a server that keeps trickling bytes).
+ */
 function get(url, host, timeoutMs = 5000) {
     return new Promise((resolve, reject) => {
         const target = new URL(url);
+        let settled = false;
+        const finish = (error, answer) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            if (error) {
+                // Frees the socket of a response that will never complete.
+                if (!req.destroyed)
+                    req.destroy();
+                reject(error);
+            }
+            else
+                resolve(answer);
+        };
+        const failed = (error) => finish(error);
         const req = request({
             host: target.hostname.replace(/^\[|\]$/g, ''),
             port: target.port,
@@ -73,14 +94,23 @@ function get(url, host, timeoutMs = 5000) {
             timeout: timeoutMs,
         }, (response) => {
             response.resume();
-            response.once('end', () => resolve({
+            response.once('end', () => finish(undefined, {
                 status: response.statusCode ?? 0,
                 type: String(response.headers['content-type'] ?? ''),
                 instance: response.headers[VERIFY_HEADER],
             }));
+            response.once('aborted', () => finish(new Error('The response was aborted')));
+            // Error listeners stay after settling: a late error (the destroy below) is then ignored
+            // by `finish` instead of being an unhandled 'error' event.
+            response.on('error', failed);
+            response.once('close', () => {
+                if (!response.complete)
+                    finish(new Error('The connection closed before the response ended'));
+            });
         });
+        const deadline = setTimeout(() => finish(new Error(`No complete answer within ${timeoutMs} ms`)), timeoutMs);
         req.once('timeout', () => req.destroy(new Error(`No answer within ${timeoutMs} ms`)));
-        req.once('error', reject);
+        req.on('error', failed);
         req.end();
     });
 }
@@ -123,18 +153,30 @@ async function settings(root) {
  * The HTTP check of verify: GET the readiness path, then `/` of each app domain, at `base`. An
  * answer counts only when it carries `token` in the x-dokebi-verify header (the instance verify
  * started); anything else is retried like a failed request and then reported FOREIGN_SERVER.
+ * With neither a readiness path (`healthRoutes: false`) nor an app domain, one identity probe
+ * runs instead (ISSUE-0006 A08: no request at all used to pass): `GET /`, which passes with any
+ * status below 500 that carries the token, a 404 included (the app may have no route at `/`).
+ * Each request must complete within `timeoutMs` (ISSUE-0006 A09).
  */
-export async function httpChecks(base, paths, token, delayMs = 250) {
+export async function httpChecks(base, paths, token, delayMs = 250, timeoutMs = 5000) {
     const requests = [];
-    const probe = async (path, host, attempts) => {
+    const probe = async (path, host, attempts, identity = false) => {
         const url = `${base}${path}`;
+        const kind = identity ? { identity: true } : {};
         for (let attempt = 1;; attempt++) {
             try {
-                const answer = await get(url, host);
+                const answer = await get(url, host, timeoutMs);
                 const instance = answer.instance === token ? 'ours' : 'other';
-                const ok = answer.status >= 200 && answer.status < 400 && instance === 'ours';
+                const ok = answer.status >= 200 && answer.status < (identity ? 500 : 400) && instance === 'ours';
                 if (ok || attempt >= attempts) {
-                    requests.push({ url, ...(host ? { host } : {}), status: answer.status, ok, instance });
+                    requests.push({
+                        url,
+                        ...(host ? { host } : {}),
+                        status: answer.status,
+                        ok,
+                        instance,
+                        ...kind,
+                    });
                     return;
                 }
                 if (instance === 'other')
@@ -151,6 +193,7 @@ export async function httpChecks(base, paths, token, delayMs = 250) {
                         status: 0,
                         ok: false,
                         error: error instanceof Error ? error.message : String(error),
+                        ...kind,
                     });
                     return;
                 }
@@ -163,6 +206,10 @@ export async function httpChecks(base, paths, token, delayMs = 250) {
         await probe(paths.ready, undefined, 20);
     for (const domain of paths.domains)
         await probe('/', domain, 4);
+    if (!paths.ready && !paths.domains.length) {
+        debug('verify: no readiness route and no app domain; probing GET / for this run', { base });
+        await probe('/', undefined, 20, true);
+    }
     const failed = requests.filter((item) => !item.ok);
     const foreign = failed.filter((item) => item.instance === 'other');
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dokebi/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Project scaffolding, plugin catalog, recipes, install and verification CLI for Dokebi.",
   "keywords": [
     "dokebi",