ds-01 1.0.5 → 1.0.6

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
 [?9001h[?1004h]0;C:\WINDOWS\system32\cmd.exe[?25h[?25l
-> ds-01@0.1.5 build C:\Web-dev 2.0\Personal Projects\ds01\packages\cli
+> ds-01@1.0.5 build C:\Web-dev 2.0\Personal Projects\ds01\packages\cli
 > tsc[?25h[?9001l[?1004l

package/dist/commands/login.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC,eAAO,MAAM,KAAK,SA2Id,CAAC"}
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwBpC,eAAO,MAAM,KAAK,SAuTd,CAAC"}

package/dist/commands/login.js

@@ -1,11 +1,12 @@
 import { Command } from "commander";
-import { intro, outro, spinner, note, cancel } from "@clack/prompts";
+import { intro, outro, spinner, note, cancel, } from "@clack/prompts";
 import pc from "picocolors";
 import open from "open";
 import machineIdPkg from "node-machine-id";
 import { saveToken } from "../utils/config.js";
 import { createDeviceKey, getDevicePublicKey, } from "../utils/secureKeyStore.js";
-const API_BASE_URL = process.env.DS01_API_URL || "https://ds-01.vercel.app";
+const API_BASE_URL = process.env.DS01_API_URL ||
+    "https://ds-01.vercel.app";
 const { machineIdSync } = machineIdPkg;
 export const login = new Command()
     .name("login")
@@ -20,10 +21,15 @@ export const login = new Command()
         // --------------------------------------------------
         s.start("Preparing secure device identity...");
         await createDeviceKey();
-        // Only the PUBLIC certificate/key leaves the machine.
+        // Only the PUBLIC key/certificate leaves
+        // the user's machine.
         const publicKey = await getDevicePublicKey();
         // Existing machine fingerprint.
         const hardwareId = machineIdSync();
+        // Detect the cryptographic key type.
+        const publicKeyType = process.platform === "win32"
+            ? "windows-rsa"
+            : "macos-ec";
         // --------------------------------------------------
         // 2. Start device authorization
         // --------------------------------------------------
@@ -36,7 +42,7 @@ export const login = new Command()
             body: JSON.stringify({
                 machineId: hardwareId,
                 publicKey,
-                publicKeyType: process.platform === "win32" ? "windows-rsa" : "macos-ec",
+                publicKeyType,
             }),
         });
         if (!initResponse.ok) {
@@ -44,8 +50,10 @@ export const login = new Command()
             cancel(`Server responded with HTTP ${initResponse.status}`);
             process.exit(1);
         }
-        const { deviceCode, userCode, verificationUrl, interval } = await initResponse.json();
-        if (!deviceCode || !userCode || !verificationUrl) {
+        const { deviceCode, userCode, verificationUrl, interval, } = await initResponse.json();
+        if (!deviceCode ||
+            !userCode ||
+            !verificationUrl) {
             throw new Error("Authorization server returned an invalid device response.");
         }
         s.stop(pc.green("Secure device identity registered."));
@@ -58,15 +66,16 @@ export const login = new Command()
             await open(verificationUrl);
         }
         catch {
-            // Browser launch failure is non-fatal.
+            // Browser launch failure
+            // is non-fatal.
         }
         // --------------------------------------------------
         // 4. Poll for authorization
         // --------------------------------------------------
         s.start("Waiting for web authorization...");
-        let token = null;
         const pollInterval = (interval || 5) * 1000;
-        while (!token) {
+        let token = null;
+        while (true) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
             const tokenResponse = await fetch(`${API_BASE_URL}/api/auth/device/token`, {
                 method: "POST",
@@ -78,27 +87,69 @@ export const login = new Command()
                     machineId: hardwareId,
                 }),
             });
-            const tokenData = await tokenResponse.json();
-            if (tokenResponse.ok && tokenData.accessToken) {
-                token = tokenData.accessToken;
+            let tokenData;
+            try {
+                tokenData =
+                    await tokenResponse.json();
             }
-            else if (tokenData.error !== "authorization_pending") {
-                s.stop(pc.red("Authorization failed or expired."));
-                cancel(`Reason: ${tokenData.error || "Unknown authorization error"}`);
+            catch {
+                s.stop(pc.red("Authorization server returned invalid JSON."));
+                cancel("Unable to read authorization response.");
                 process.exit(1);
             }
+            // --------------------------------------------------
+            // SUCCESS
+            // --------------------------------------------------
+            if (tokenResponse.ok &&
+                typeof tokenData.accessToken ===
+                    "string" &&
+                tokenData.accessToken.length > 0) {
+                token =
+                    tokenData.accessToken;
+                // IMPORTANT:
+                // Stop the spinner immediately.
+                s.stop(pc.green("Hardware signature linked & token verified!"));
+                // IMPORTANT:
+                // Leave the polling loop immediately.
+                break;
+            }
+            // --------------------------------------------------
+            // STILL WAITING
+            // --------------------------------------------------
+            if (tokenData.error ===
+                "authorization_pending") {
+                continue;
+            }
+            // --------------------------------------------------
+            // FAILED / EXPIRED
+            // --------------------------------------------------
+            s.stop(pc.red("Authorization failed or expired."));
+            cancel(`Reason: ${tokenData.error ||
+                "Unknown authorization error"}`);
+            process.exit(1);
         }
         // --------------------------------------------------
-        // 5. Save CLI token + machine ID
+        // 5. Make absolutely sure token exists
+        // --------------------------------------------------
+        if (!token) {
+            throw new Error("Authorization completed without receiving an access token.");
+        }
+        // --------------------------------------------------
+        // 6. Save CLI token + machine ID
         // --------------------------------------------------
         saveToken(token, hardwareId);
-        s.stop(pc.green("Hardware signature linked & token verified!"));
+        // --------------------------------------------------
+        // 7. Success
+        // --------------------------------------------------
         outro(`${pc.white("✔")} ${pc.bold("Terminal synced successfully")}\n` +
             pc.gray("Secure device key and session token are ready."));
     }
     catch (error) {
+        // Only stop the spinner if it is
+        // still running.
         s.stop(pc.red("An error occurred during login."));
-        cancel(pc.gray(error?.message || "Unknown CLI Error"));
+        cancel(pc.gray(error?.message ||
+            "Unknown CLI Error"));
         process.exit(1);
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ds-01",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Make your site best with DS01",
   "type": "module",
   "bin": {

package/src/commands/login.ts

@@ -1,5 +1,11 @@
 import { Command } from "commander";
-import { intro, outro, spinner, note, cancel } from "@clack/prompts";
+import {
+  intro,
+  outro,
+  spinner,
+  note,
+  cancel,
+} from "@clack/prompts";
 import pc from "picocolors";
 import open from "open";
 import machineIdPkg from "node-machine-id";
@@ -10,18 +16,26 @@ import {
   getDevicePublicKey,
 } from "../utils/secureKeyStore.js";
 
-const API_BASE_URL = process.env.DS01_API_URL || "https://ds-01.vercel.app";
+const API_BASE_URL =
+  process.env.DS01_API_URL ||
+  "https://ds-01.vercel.app";
 
 const { machineIdSync } = machineIdPkg;
 
 export const login = new Command()
   .name("login")
-  .description("Authenticate your terminal with DS01 via browser")
+  .description(
+    "Authenticate your terminal with DS01 via browser",
+  )
   .action(async () => {
     console.log();
 
     intro(
-      `${pc.bgWhite(pc.black(pc.bold(" DS01 ")))} ${pc.gray(
+      `${pc.bgWhite(
+        pc.black(
+          pc.bold(" DS01 "),
+        ),
+      )} ${pc.gray(
         "v1.0.0 — Terminal Authentication",
       )}`,
     );
@@ -32,125 +46,291 @@ export const login = new Command()
       // --------------------------------------------------
       // 1. Create / load the device's secure key
       // --------------------------------------------------
-      s.start("Preparing secure device identity...");
+
+      s.start(
+        "Preparing secure device identity...",
+      );
 
       await createDeviceKey();
 
-      // Only the PUBLIC certificate/key leaves the machine.
-      const publicKey = await getDevicePublicKey();
+      // Only the PUBLIC key/certificate leaves
+      // the user's machine.
+      const publicKey =
+        await getDevicePublicKey();
 
       // Existing machine fingerprint.
-      const hardwareId = machineIdSync();
+      const hardwareId =
+        machineIdSync();
+
+      // Detect the cryptographic key type.
+      const publicKeyType =
+        process.platform === "win32"
+          ? "windows-rsa"
+          : "macos-ec";
 
       // --------------------------------------------------
       // 2. Start device authorization
       // --------------------------------------------------
-      s.start("Requesting pairing code...");
-
-      const initResponse = await fetch(`${API_BASE_URL}/api/auth/device/code`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          machineId: hardwareId,
-          publicKey,
-          publicKeyType:
-            process.platform === "win32" ? "windows-rsa" : "macos-ec",
-        }),
-      });
+
+      s.start(
+        "Requesting pairing code...",
+      );
+
+      const initResponse =
+        await fetch(
+          `${API_BASE_URL}/api/auth/device/code`,
+          {
+            method: "POST",
+
+            headers: {
+              "Content-Type":
+                "application/json",
+            },
+
+            body: JSON.stringify({
+              machineId:
+                hardwareId,
+
+              publicKey,
+
+              publicKeyType,
+            }),
+          },
+        );
 
       if (!initResponse.ok) {
-        s.stop(pc.red("Failed to reach DS01 authorization server."));
+        s.stop(
+          pc.red(
+            "Failed to reach DS01 authorization server.",
+          ),
+        );
 
-        cancel(`Server responded with HTTP ${initResponse.status}`);
+        cancel(
+          `Server responded with HTTP ${initResponse.status}`,
+        );
 
         process.exit(1);
       }
 
-      const { deviceCode, userCode, verificationUrl, interval } =
-        await initResponse.json();
-
-      if (!deviceCode || !userCode || !verificationUrl) {
+      const {
+        deviceCode,
+        userCode,
+        verificationUrl,
+        interval,
+      } = await initResponse.json();
+
+      if (
+        !deviceCode ||
+        !userCode ||
+        !verificationUrl
+      ) {
         throw new Error(
           "Authorization server returned an invalid device response.",
         );
       }
 
-      s.stop(pc.green("Secure device identity registered."));
+      s.stop(
+        pc.green(
+          "Secure device identity registered.",
+        ),
+      );
 
       // --------------------------------------------------
       // 3. Ask user to approve in browser
       // --------------------------------------------------
+
       note(
-        `${pc.bold("Pairing Code:")}    ${pc.cyan(
-          pc.bold(` ${userCode} `),
+        `${pc.bold(
+          "Pairing Code:",
+        )}    ${pc.cyan(
+          pc.bold(
+            ` ${userCode} `,
+          ),
         )}\n` +
-          `${pc.bold("Verification URL:")} ${pc.underline(verificationUrl)}`,
+          `${pc.bold(
+            "Verification URL:",
+          )} ${pc.underline(
+            verificationUrl,
+          )}`,
         "Action Required",
       );
 
       try {
-        await open(verificationUrl);
+        await open(
+          verificationUrl,
+        );
       } catch {
-        // Browser launch failure is non-fatal.
+        // Browser launch failure
+        // is non-fatal.
       }
 
       // --------------------------------------------------
       // 4. Poll for authorization
       // --------------------------------------------------
-      s.start("Waiting for web authorization...");
 
-      let token: string | null = null;
+      s.start(
+        "Waiting for web authorization...",
+      );
 
-      const pollInterval = (interval || 5) * 1000;
+      const pollInterval =
+        (interval || 5) * 1000;
 
-      while (!token) {
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      let token: string | null =
+        null;
 
-        const tokenResponse = await fetch(
-          `${API_BASE_URL}/api/auth/device/token`,
-          {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-              deviceCode,
-              machineId: hardwareId,
-            }),
-          },
+      while (true) {
+        await new Promise(
+          (resolve) =>
+            setTimeout(
+              resolve,
+              pollInterval,
+            ),
         );
 
-        const tokenData = await tokenResponse.json();
+        const tokenResponse =
+          await fetch(
+            `${API_BASE_URL}/api/auth/device/token`,
+            {
+              method: "POST",
+
+              headers: {
+                "Content-Type":
+                  "application/json",
+              },
+
+              body: JSON.stringify({
+                deviceCode,
+                machineId:
+                  hardwareId,
+              }),
+            },
+          );
+
+        let tokenData: any;
 
-        if (tokenResponse.ok && tokenData.accessToken) {
-          token = tokenData.accessToken;
-        } else if (tokenData.error !== "authorization_pending") {
-          s.stop(pc.red("Authorization failed or expired."));
+        try {
+          tokenData =
+            await tokenResponse.json();
+        } catch {
+          s.stop(
+            pc.red(
+              "Authorization server returned invalid JSON.",
+            ),
+          );
 
-          cancel(`Reason: ${tokenData.error || "Unknown authorization error"}`);
+          cancel(
+            "Unable to read authorization response.",
+          );
 
           process.exit(1);
         }
+
+        // --------------------------------------------------
+        // SUCCESS
+        // --------------------------------------------------
+
+        if (
+          tokenResponse.ok &&
+          typeof tokenData.accessToken ===
+            "string" &&
+          tokenData.accessToken.length > 0
+        ) {
+          token =
+            tokenData.accessToken;
+
+          // IMPORTANT:
+          // Stop the spinner immediately.
+          s.stop(
+            pc.green(
+              "Hardware signature linked & token verified!",
+            ),
+          );
+
+          // IMPORTANT:
+          // Leave the polling loop immediately.
+          break;
+        }
+
+        // --------------------------------------------------
+        // STILL WAITING
+        // --------------------------------------------------
+
+        if (
+          tokenData.error ===
+          "authorization_pending"
+        ) {
+          continue;
+        }
+
+        // --------------------------------------------------
+        // FAILED / EXPIRED
+        // --------------------------------------------------
+
+        s.stop(
+          pc.red(
+            "Authorization failed or expired.",
+          ),
+        );
+
+        cancel(
+          `Reason: ${
+            tokenData.error ||
+            "Unknown authorization error"
+          }`,
+        );
+
+        process.exit(1);
       }
 
       // --------------------------------------------------
-      // 5. Save CLI token + machine ID
+      // 5. Make absolutely sure token exists
       // --------------------------------------------------
-      saveToken(token, hardwareId);
 
-      s.stop(pc.green("Hardware signature linked & token verified!"));
+      if (!token) {
+        throw new Error(
+          "Authorization completed without receiving an access token.",
+        );
+      }
+
+      // --------------------------------------------------
+      // 6. Save CLI token + machine ID
+      // --------------------------------------------------
+
+      saveToken(
+        token,
+        hardwareId,
+      );
+
+      // --------------------------------------------------
+      // 7. Success
+      // --------------------------------------------------
 
       outro(
-        `${pc.white("✔")} ${pc.bold("Terminal synced successfully")}\n` +
-          pc.gray("Secure device key and session token are ready."),
+        `${pc.white(
+          "✔",
+        )} ${pc.bold(
+          "Terminal synced successfully",
+        )}\n` +
+          pc.gray(
+            "Secure device key and session token are ready.",
+          ),
       );
     } catch (error: any) {
-      s.stop(pc.red("An error occurred during login."));
+      // Only stop the spinner if it is
+      // still running.
+      s.stop(
+        pc.red(
+          "An error occurred during login.",
+        ),
+      );
 
-      cancel(pc.gray(error?.message || "Unknown CLI Error"));
+      cancel(
+        pc.gray(
+          error?.message ||
+            "Unknown CLI Error",
+        ),
+      );
 
       process.exit(1);
     }
-  });
+  });