@qulib/core 0.4.0 → 0.4.1

package/dist/schemas/config.schema.d.ts

@@ -367,67 +367,6 @@ export declare const HarnessConfigSchema: z.ZodObject<{
 }>;
 export type HarnessConfig = z.infer<typeof HarnessConfigSchema>;
 export declare function resolveMaxOutputTokensPerLlmCall(config: HarnessConfig): number;
-export declare const DetectedAuthSchema: z.ZodObject<{
-    hasAuth: z.ZodBoolean;
-    type: z.ZodEnum<["none", "form-login", "oauth", "magic-link", "unknown"]>;
-    provider: z.ZodNullable<z.ZodString>;
-    loginUrl: z.ZodNullable<z.ZodString>;
-    observedSelectors: z.ZodNullable<z.ZodObject<{
-        usernameSelector: z.ZodNullable<z.ZodString>;
-        passwordSelector: z.ZodNullable<z.ZodString>;
-        submitSelector: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        usernameSelector: string | null;
-        passwordSelector: string | null;
-        submitSelector: string | null;
-    }, {
-        usernameSelector: string | null;
-        passwordSelector: string | null;
-        submitSelector: string | null;
-    }>>;
-    oauthButtons: z.ZodArray<z.ZodObject<{
-        provider: z.ZodString;
-        text: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        provider: string;
-        text: string;
-    }, {
-        provider: string;
-        text: string;
-    }>, "many">;
-    recommendation: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: "unknown" | "form-login" | "none" | "oauth" | "magic-link";
-    loginUrl: string | null;
-    hasAuth: boolean;
-    provider: string | null;
-    observedSelectors: {
-        usernameSelector: string | null;
-        passwordSelector: string | null;
-        submitSelector: string | null;
-    } | null;
-    oauthButtons: {
-        provider: string;
-        text: string;
-    }[];
-    recommendation: string;
-}, {
-    type: "unknown" | "form-login" | "none" | "oauth" | "magic-link";
-    loginUrl: string | null;
-    hasAuth: boolean;
-    provider: string | null;
-    observedSelectors: {
-        usernameSelector: string | null;
-        passwordSelector: string | null;
-        submitSelector: string | null;
-    } | null;
-    oauthButtons: {
-        provider: string;
-        text: string;
-    }[];
-    recommendation: string;
-}>;
-export type DetectedAuth = z.infer<typeof DetectedAuthSchema>;
 export declare const AuthPathRequirementsSchema: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
     method: z.ZodLiteral<"storage-state">;
     instruction: z.ZodString;
@@ -543,10 +482,10 @@ export declare const AuthPathSchema: z.ZodObject<{
         instruction: string;
     }>]>;
 }, "strip", z.ZodTypeAny, {
-    type: "unknown" | "form-login" | "oauth" | "magic-link" | "oauth-unknown" | "form-multi";
-    provider: string | null;
+    type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
     label: string;
     id: string;
+    provider: string | null;
     source: "built-in" | "user-local" | "heuristic";
     automatable: boolean;
     confidence: "high" | "medium" | "low";
@@ -566,10 +505,10 @@ export declare const AuthPathSchema: z.ZodObject<{
         instruction: string;
     };
 }, {
-    type: "unknown" | "form-login" | "oauth" | "magic-link" | "oauth-unknown" | "form-multi";
-    provider: string | null;
+    type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
     label: string;
     id: string;
+    provider: string | null;
     source: "built-in" | "user-local" | "heuristic";
     automatable: boolean;
     confidence: "high" | "medium" | "low";
@@ -589,6 +528,223 @@ export declare const AuthPathSchema: z.ZodObject<{
         instruction: string;
     };
 }>;
+export declare const DetectedAuthSchema: z.ZodObject<{
+    hasAuth: z.ZodBoolean;
+    type: z.ZodEnum<["none", "form-login", "oauth", "magic-link", "unknown"]>;
+    provider: z.ZodNullable<z.ZodString>;
+    loginUrl: z.ZodNullable<z.ZodString>;
+    observedSelectors: z.ZodNullable<z.ZodObject<{
+        usernameSelector: z.ZodNullable<z.ZodString>;
+        passwordSelector: z.ZodNullable<z.ZodString>;
+        submitSelector: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        usernameSelector: string | null;
+        passwordSelector: string | null;
+        submitSelector: string | null;
+    }, {
+        usernameSelector: string | null;
+        passwordSelector: string | null;
+        submitSelector: string | null;
+    }>>;
+    oauthButtons: z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        provider: string;
+    }, {
+        text: string;
+        provider: string;
+    }>, "many">;
+    authOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<["oauth", "oauth-unknown", "form-login", "form-multi", "magic-link", "unknown"]>;
+        provider: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<["built-in", "user-local", "heuristic"]>;
+        automatable: z.ZodBoolean;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+        requirements: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+            method: z.ZodLiteral<"storage-state">;
+            instruction: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            method: "storage-state";
+            instruction: string;
+        }, {
+            method: "storage-state";
+            instruction: string;
+        }>, z.ZodObject<{
+            method: z.ZodLiteral<"credentials">;
+            fields: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodString;
+                type: z.ZodEnum<["text", "password", "email", "select", "checkbox"]>;
+                observedOptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions: string[];
+            }, {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions?: string[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            method: "credentials";
+            fields: {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions: string[];
+            }[];
+        }, {
+            method: "credentials";
+            fields: {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions?: string[] | undefined;
+            }[];
+        }>, z.ZodObject<{
+            method: z.ZodLiteral<"unknown">;
+            instruction: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            method: "unknown";
+            instruction: string;
+        }, {
+            method: "unknown";
+            instruction: string;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
+        label: string;
+        id: string;
+        provider: string | null;
+        source: "built-in" | "user-local" | "heuristic";
+        automatable: boolean;
+        confidence: "high" | "medium" | "low";
+        requirements: {
+            method: "storage-state";
+            instruction: string;
+        } | {
+            method: "credentials";
+            fields: {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions: string[];
+            }[];
+        } | {
+            method: "unknown";
+            instruction: string;
+        };
+    }, {
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
+        label: string;
+        id: string;
+        provider: string | null;
+        source: "built-in" | "user-local" | "heuristic";
+        automatable: boolean;
+        confidence: "high" | "medium" | "low";
+        requirements: {
+            method: "storage-state";
+            instruction: string;
+        } | {
+            method: "credentials";
+            fields: {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions?: string[] | undefined;
+            }[];
+        } | {
+            method: "unknown";
+            instruction: string;
+        };
+    }>, "many">>;
+    recommendation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "unknown" | "form-login" | "oauth" | "magic-link" | "none";
+    loginUrl: string | null;
+    provider: string | null;
+    hasAuth: boolean;
+    observedSelectors: {
+        usernameSelector: string | null;
+        passwordSelector: string | null;
+        submitSelector: string | null;
+    } | null;
+    oauthButtons: {
+        text: string;
+        provider: string;
+    }[];
+    recommendation: string;
+    authOptions?: {
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
+        label: string;
+        id: string;
+        provider: string | null;
+        source: "built-in" | "user-local" | "heuristic";
+        automatable: boolean;
+        confidence: "high" | "medium" | "low";
+        requirements: {
+            method: "storage-state";
+            instruction: string;
+        } | {
+            method: "credentials";
+            fields: {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions: string[];
+            }[];
+        } | {
+            method: "unknown";
+            instruction: string;
+        };
+    }[] | undefined;
+}, {
+    type: "unknown" | "form-login" | "oauth" | "magic-link" | "none";
+    loginUrl: string | null;
+    provider: string | null;
+    hasAuth: boolean;
+    observedSelectors: {
+        usernameSelector: string | null;
+        passwordSelector: string | null;
+        submitSelector: string | null;
+    } | null;
+    oauthButtons: {
+        text: string;
+        provider: string;
+    }[];
+    recommendation: string;
+    authOptions?: {
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
+        label: string;
+        id: string;
+        provider: string | null;
+        source: "built-in" | "user-local" | "heuristic";
+        automatable: boolean;
+        confidence: "high" | "medium" | "low";
+        requirements: {
+            method: "storage-state";
+            instruction: string;
+        } | {
+            method: "credentials";
+            fields: {
+                type: "password" | "text" | "email" | "select" | "checkbox";
+                name: string;
+                label: string;
+                observedOptions?: string[] | undefined;
+            }[];
+        } | {
+            method: "unknown";
+            instruction: string;
+        };
+    }[] | undefined;
+}>;
+export type DetectedAuth = z.infer<typeof DetectedAuthSchema>;
 export declare const AuthExplorationSchema: z.ZodObject<{
     url: z.ZodString;
     authRequired: z.ZodBoolean;
@@ -655,10 +811,10 @@ export declare const AuthExplorationSchema: z.ZodObject<{
             instruction: string;
         }>]>;
     }, "strip", z.ZodTypeAny, {
-        type: "unknown" | "form-login" | "oauth" | "magic-link" | "oauth-unknown" | "form-multi";
-        provider: string | null;
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
         label: string;
         id: string;
+        provider: string | null;
         source: "built-in" | "user-local" | "heuristic";
         automatable: boolean;
         confidence: "high" | "medium" | "low";
@@ -678,10 +834,10 @@ export declare const AuthExplorationSchema: z.ZodObject<{
             instruction: string;
         };
     }, {
-        type: "unknown" | "form-login" | "oauth" | "magic-link" | "oauth-unknown" | "form-multi";
-        provider: string | null;
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
         label: string;
         id: string;
+        provider: string | null;
         source: "built-in" | "user-local" | "heuristic";
         automatable: boolean;
         confidence: "high" | "medium" | "low";
@@ -718,10 +874,10 @@ export declare const AuthExplorationSchema: z.ZodObject<{
     authRequired: boolean;
     authScope: "none" | "site-wide" | "section-only" | "optional";
     authPaths: {
-        type: "unknown" | "form-login" | "oauth" | "magic-link" | "oauth-unknown" | "form-multi";
-        provider: string | null;
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
         label: string;
         id: string;
+        provider: string | null;
         source: "built-in" | "user-local" | "heuristic";
         automatable: boolean;
         confidence: "high" | "medium" | "low";
@@ -752,10 +908,10 @@ export declare const AuthExplorationSchema: z.ZodObject<{
     authRequired: boolean;
     authScope: "none" | "site-wide" | "section-only" | "optional";
     authPaths: {
-        type: "unknown" | "form-login" | "oauth" | "magic-link" | "oauth-unknown" | "form-multi";
-        provider: string | null;
+        type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
         label: string;
         id: string;
+        provider: string | null;
         source: "built-in" | "user-local" | "heuristic";
         automatable: boolean;
         confidence: "high" | "medium" | "low";

package/dist/schemas/config.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;AACpD,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,aAAa,GAAG,mBAAmB,GAAG,KAAK,GAAG,eAAe,CAAC;AAEvG,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBvB,CAAC;AAEH,QAAA,MAAM,sBAAsB;;;;;;;;;EAG1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA8E,CAAC;AAE5G,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAE9E;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAcrC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASzB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAehC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;AACpD,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,aAAa,GAAG,mBAAmB,GAAG,KAAK,GAAG,eAAe,CAAC;AAEvG,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBvB,CAAC;AAEH,QAAA,MAAM,sBAAsB;;;;;;;;;EAG1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA8E,CAAC;AAE5G,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAE9E;AAED,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAcrC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASzB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAehC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas/config.schema.js

@@ -65,24 +65,6 @@ export const HarnessConfigSchema = z.object({
 export function resolveMaxOutputTokensPerLlmCall(config) {
     return config.llmMaxOutputTokensPerCall ?? config.llmTokenBudget;
 }
-export const DetectedAuthSchema = z.object({
-    hasAuth: z.boolean(),
-    type: z.enum(['none', 'form-login', 'oauth', 'magic-link', 'unknown']),
-    provider: z.string().nullable(),
-    loginUrl: z.string().nullable(),
-    observedSelectors: z
-        .object({
-        usernameSelector: z.string().nullable(),
-        passwordSelector: z.string().nullable(),
-        submitSelector: z.string().nullable(),
-    })
-        .nullable(),
-    oauthButtons: z.array(z.object({
-        provider: z.string(),
-        text: z.string(),
-    })),
-    recommendation: z.string(),
-});
 export const AuthPathRequirementsSchema = z.discriminatedUnion('method', [
     z.object({ method: z.literal('storage-state'), instruction: z.string() }),
     z.object({
@@ -106,6 +88,25 @@ export const AuthPathSchema = z.object({
     confidence: z.enum(['high', 'medium', 'low']),
     requirements: AuthPathRequirementsSchema,
 });
+export const DetectedAuthSchema = z.object({
+    hasAuth: z.boolean(),
+    type: z.enum(['none', 'form-login', 'oauth', 'magic-link', 'unknown']),
+    provider: z.string().nullable(),
+    loginUrl: z.string().nullable(),
+    observedSelectors: z
+        .object({
+        usernameSelector: z.string().nullable(),
+        passwordSelector: z.string().nullable(),
+        submitSelector: z.string().nullable(),
+    })
+        .nullable(),
+    oauthButtons: z.array(z.object({
+        provider: z.string(),
+        text: z.string(),
+    })),
+    authOptions: z.array(AuthPathSchema).optional(),
+    recommendation: z.string(),
+});
 export const AuthExplorationSchema = z.object({
     url: z.string(),
     authRequired: z.boolean(),

package/dist/tools/auth-detector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-detector.d.ts","sourceRoot":"","sources":["../../src/tools/auth-detector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAgEtE,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,SAAS,SAAQ,EACjB,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,YAAY,CAAC,CA8HvB"}
+{"version":3,"file":"auth-detector.d.ts","sourceRoot":"","sources":["../../src/tools/auth-detector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAY,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAsPtE,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,SAAS,SAAQ,EACjB,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,YAAY,CAAC,CAkJvB"}

package/dist/tools/auth-detector.js

@@ -1,4 +1,5 @@
 import { launchBrowser } from './browser.js';
+import { BUILT_IN_OAUTH_PROVIDERS } from './oauth-providers.js';
 async function waitNetworkIdleBestEffort(page) {
     try {
         await page.waitForLoadState('networkidle', { timeout: 5000 });
@@ -7,27 +8,20 @@ async function waitNetworkIdleBestEffort(page) {
         // best-effort — analytics or polling can prevent networkidle
     }
 }
-const OAUTH_PROVIDERS = [
-    { provider: 'github', patterns: [/github/i, /sign in with github/i] },
-    {
-        provider: 'google',
-        patterns: [/google/i, /sign in with google/i, /accounts\.google\.com/i],
-    },
-    {
-        provider: 'microsoft',
-        patterns: [/microsoft/i, /sign in with microsoft/i, /login\.microsoftonline\.com/i],
-    },
-    { provider: 'apple', patterns: [/apple/i, /sign in with apple/i] },
-    { provider: 'auth0', patterns: [/auth0/i] },
-    { provider: 'okta', patterns: [/okta/i] },
-];
+const PROVIDER_LABELS = new Set(BUILT_IN_OAUTH_PROVIDERS.map((p) => p.label.toLowerCase()));
 function textLooksLikeOAuthIdpButton(text) {
     const t = text.trim();
     if (t.length === 0 || t.length > 120) {
         return false;
     }
-    return (/\b(sign in with|log in with|continue with|sign up with)\b/i.test(t) ||
-        /^(github|google|microsoft|apple)$/i.test(t));
+    if (/\b(sign in with|log in with|continue with|sign up with)\b/i.test(t)) {
+        return true;
+    }
+    // Accept single-word / short labels that exactly match a known provider name
+    if (PROVIDER_LABELS.has(t.toLowerCase())) {
+        return true;
+    }
+    return false;
 }
 const MAGIC_LINK_PATTERNS = [
     /email me a (sign[- ]?in )?link/i,
@@ -53,6 +47,177 @@ async function firstTextInputNameForLogin(page) {
 function debugAuth() {
     return process.env.QULIB_DEBUG === '1';
 }
+function slugify(label) {
+    const s = label
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]+/g, '')
+        .replace(/^-+|-+$/g, '');
+    return s.length > 0 ? s : 'custom';
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+async function resolveVisibleFieldLabel(page, el) {
+    const id = await el.getAttribute('id');
+    if (id) {
+        const lt = await page.locator(`label[for="${id.replace(/"/g, '\\"')}"]`).first().textContent().catch(() => null);
+        const fromLabel = (lt ?? '').trim();
+        if (fromLabel)
+            return fromLabel;
+    }
+    const placeholder = (await el.getAttribute('placeholder'))?.trim();
+    if (placeholder)
+        return placeholder;
+    const aria = (await el.getAttribute('aria-label'))?.trim();
+    if (aria)
+        return aria;
+    const name = (await el.getAttribute('name'))?.trim();
+    if (name)
+        return name;
+    const typ = (await el.getAttribute('type'))?.trim();
+    return typ && typ !== 'select' ? typ : 'text';
+}
+async function deriveCredentialFieldName(el) {
+    const name = (await el.getAttribute('name'))?.trim();
+    if (name)
+        return name;
+    const placeholder = (await el.getAttribute('placeholder'))?.trim();
+    if (placeholder)
+        return slugify(placeholder);
+    const aria = (await el.getAttribute('aria-label'))?.trim();
+    if (aria)
+        return slugify(aria);
+    const id = (await el.getAttribute('id'))?.trim();
+    if (id)
+        return slugify(id);
+    return 'field';
+}
+async function buildCredentialFieldsFromVisibleForm(page) {
+    const fields = [];
+    const seen = new Set();
+    const loc = page.locator('input[type="text"]:visible, input[type="email"]:visible, input[type="password"]:visible, select:visible');
+    const count = await loc.count();
+    for (let i = 0; i < count; i++) {
+        const el = loc.nth(i);
+        const tag = await el.evaluate((node) => node.tagName.toLowerCase()).catch(() => '');
+        if (tag === 'select') {
+            const name = await deriveCredentialFieldName(el);
+            const label = await resolveVisibleFieldLabel(page, el);
+            const opts = await el.locator('option').allInnerTexts();
+            const observedOptions = opts.map((o) => o.trim()).filter((x) => x.length > 0).slice(0, 20);
+            const dedupeKey = `select|${name}|${label}`;
+            if (seen.has(dedupeKey))
+                continue;
+            seen.add(dedupeKey);
+            fields.push({ name, label, type: 'select', observedOptions });
+            continue;
+        }
+        const rawType = ((await el.getAttribute('type')) ?? 'text').toLowerCase();
+        if (rawType === 'hidden')
+            continue;
+        const fieldType = rawType === 'email' ? 'email' : rawType === 'password' ? 'password' : 'text';
+        const name = await deriveCredentialFieldName(el);
+        const label = await resolveVisibleFieldLabel(page, el);
+        const placeholder = (await el.getAttribute('placeholder'))?.trim() ?? '';
+        const dedupeKey = `${name}|${placeholder}`;
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        fields.push({ name, label, type: fieldType, observedOptions: [] });
+    }
+    return fields;
+}
+function authPathsFromOauthButtons(oauthButtons, loginUrl) {
+    return oauthButtons.map((b) => {
+        const isUnknown = b.provider === 'unknown';
+        const id = isUnknown ? slugify(b.text) : b.provider;
+        return {
+            id,
+            label: b.text,
+            type: isUnknown ? 'oauth-unknown' : 'oauth',
+            provider: isUnknown ? slugify(b.text) : b.provider,
+            source: isUnknown ? 'heuristic' : 'built-in',
+            automatable: false,
+            confidence: isUnknown ? 'low' : 'high',
+            requirements: {
+                method: 'storage-state',
+                instruction: `Run qulib auth init --base-url ${loginUrl}`,
+            },
+        };
+    });
+}
+async function probeClickToRevealForms(page, loginUrl, alreadyMatchedTexts, timeoutMs, progress) {
+    const out = [];
+    const buttons = page.locator('button');
+    const n = await buttons.count();
+    const seenLabels = new Set();
+    const SUBMIT_RE = /^(sign in|log in|submit|continue|next|cancel|close)$/i;
+    let candidateAttempts = 0;
+    for (let i = 0; i < n && candidateAttempts < 4; i++) {
+        const label = ((await buttons.nth(i).textContent()) ?? '').trim();
+        if (!label || label.length > 80)
+            continue;
+        if (alreadyMatchedTexts.has(label))
+            continue;
+        if (SUBMIT_RE.test(label))
+            continue;
+        if (seenLabels.has(label))
+            continue;
+        seenLabels.add(label);
+        candidateAttempts += 1;
+        if (debugAuth()) {
+            progress?.debug(`detect_auth click-reveal try label="${label.slice(0, 80)}"`);
+        }
+        let clicked = false;
+        try {
+            await page.getByRole('button', { name: label, exact: true }).first().click({ timeout: 2000 });
+            clicked = true;
+        }
+        catch {
+            try {
+                await page
+                    .locator('button')
+                    .filter({ hasText: new RegExp(`^\\s*${escapeRegExp(label)}\\s*$`, 'i') })
+                    .first()
+                    .click({ timeout: 2000 });
+                clicked = true;
+            }
+            catch {
+                /* skip */
+            }
+        }
+        if (!clicked) {
+            continue;
+        }
+        try {
+            await page.locator('input[type="password"]').first().waitFor({ state: 'visible', timeout: 2000 });
+        }
+        catch {
+            await page.goto(loginUrl, { timeout: timeoutMs, waitUntil: 'domcontentloaded' });
+            await waitNetworkIdleBestEffort(page);
+            continue;
+        }
+        const fields = await buildCredentialFieldsFromVisibleForm(page);
+        const slug = slugify(label);
+        out.push({
+            id: slug,
+            label,
+            type: 'form-login',
+            provider: slug,
+            source: 'heuristic',
+            automatable: true,
+            confidence: 'medium',
+            requirements: {
+                method: 'credentials',
+                fields,
+            },
+        });
+        await page.goto(loginUrl, { timeout: timeoutMs, waitUntil: 'domcontentloaded' });
+        await waitNetworkIdleBestEffort(page);
+    }
+    return out;
+}
 export async function detectAuth(url, timeoutMs = 15000, progress) {
     const browser = await launchBrowser();
     try {
@@ -96,18 +261,27 @@ export async function detectAuth(url, timeoutMs = 15000, progress) {
                 }
                 continue;
             }
-            for (const { provider, patterns } of OAUTH_PROVIDERS) {
+            let matchedAny = false;
+            for (const { id, patterns } of BUILT_IN_OAUTH_PROVIDERS) {
                 const matched = patterns.some((p) => p.test(trimmed));
                 if (debugAuth()) {
-                    progress?.debug(`detect_auth oauth pattern try provider=${provider} matched=${matched}`);
+                    progress?.debug(`detect_auth oauth pattern try provider=${id} matched=${matched}`);
                 }
                 if (matched) {
-                    if (!oauthButtons.find((b) => b.provider === provider)) {
-                        oauthButtons.push({ provider, text: trimmed.slice(0, 100) });
+                    if (!oauthButtons.find((b) => b.provider === id)) {
+                        oauthButtons.push({ provider: id, text: trimmed.slice(0, 100) });
                     }
+                    matchedAny = true;
                 }
             }
+            // Capture unrecognized SSO-like buttons so they appear in the result
+            if (!matchedAny && !oauthButtons.find((b) => b.text === trimmed.slice(0, 100))) {
+                oauthButtons.push({ provider: 'unknown', text: trimmed.slice(0, 100) });
+            }
         }
+        // Only skip buttons already tied to a built-in IdP — leave `unknown` labels probe-able for click-to-reveal forms.
+        const skipProbeLabels = new Set(oauthButtons.filter((b) => b.provider !== 'unknown').map((b) => b.text.trim()));
+        const clickRevealForms = await probeClickToRevealForms(page, loginUrl, skipProbeLabels, timeoutMs, progress);
         const pageText = await page.locator('body').innerText().catch(() => '');
         const hasMagicLink = MAGIC_LINK_PATTERNS.some((p) => p.test(pageText));
         let type = 'none';
@@ -117,7 +291,7 @@ export async function detectAuth(url, timeoutMs = 15000, progress) {
         if (oauthButtons.length > 0) {
             type = 'oauth';
             provider = oauthButtons[0].provider;
-            recommendation = `OAuth detected (${oauthButtons.map((b) => b.provider).join(', ')}). OAuth cannot be automated. Run "qulib auth init --base-url ${url}" to log in manually once and save a reusable storage state file.`;
+            recommendation = `OAuth detected (${oauthButtons.map((b) => b.provider).join(', ')}). OAuth cannot be automated. Run "qulib auth init --base-url ${loginUrl}" to log in manually once and save a reusable storage state file.`;
         }
         else if (hasFormLogin) {
             type = 'form-login';
@@ -140,26 +314,31 @@ export async function detectAuth(url, timeoutMs = 15000, progress) {
         }
         else if (hasMagicLink) {
             type = 'magic-link';
-            recommendation = `Magic link / passwordless auth detected. Qulib cannot complete email-link flows. Run "qulib auth init --base-url ${url}" to log in manually once and save a storage state file.`;
+            recommendation = `Magic link / passwordless auth detected. Qulib cannot complete email-link flows. Run "qulib auth init --base-url ${loginUrl}" to log in manually once and save a storage state file.`;
         }
         else if (looksLikeLoginPage) {
             type = 'unknown';
-            recommendation = `Authentication required but the pattern is unrecognized. Use "qulib auth init --base-url ${url}" to capture a storage state by logging in manually.`;
+            recommendation = `Authentication required but the pattern is unrecognized. Use "qulib auth init --base-url ${loginUrl}" to capture a storage state by logging in manually.`;
         }
         else {
             type = 'none';
             recommendation = `No authentication required for the entry URL. Qulib can scan anonymously.`;
         }
+        if (clickRevealForms.length > 0) {
+            recommendation += `\nAutomatable form login detected via: ${clickRevealForms.map((f) => f.label).join(', ')}. Use type="form-login" with the observed selectors in authOptions.`;
+        }
         const providerList = oauthButtons.length > 0 ? oauthButtons.map((b) => b.provider).join(', ') : provider ?? 'none';
-        const automatable = type === 'form-login';
+        const automatable = type === 'form-login' || clickRevealForms.length > 0;
         progress?.info(`Auth detected: ${type} (${providerList}) automatable=${automatable}`);
+        const authOptions = [...authPathsFromOauthButtons(oauthButtons, loginUrl), ...clickRevealForms];
         return {
-            hasAuth: type !== 'none',
+            hasAuth: type !== 'none' || oauthButtons.length > 0 || clickRevealForms.length > 0,
             type,
             provider,
-            loginUrl: type === 'none' ? null : loginUrl,
+            loginUrl: type === 'none' && oauthButtons.length === 0 && clickRevealForms.length === 0 ? null : loginUrl,
             observedSelectors,
             oauthButtons,
+            ...(authOptions.length > 0 ? { authOptions } : {}),
             recommendation,
         };
     }

package/dist/tools/auth-surface-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-surface-analyzer.d.ts","sourceRoot":"","sources":["../../src/tools/auth-surface-analyzer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mCAAmC,CAAC;AAW7D,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,YAAY,EACvB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,EAAE,CAAC,CAuJhB"}
+{"version":3,"file":"auth-surface-analyzer.d.ts","sourceRoot":"","sources":["../../src/tools/auth-surface-analyzer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mCAAmC,CAAC;AAW7D,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,YAAY,EACvB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,EAAE,CAAC,CAwKhB"}

package/dist/tools/auth-surface-analyzer.js

@@ -110,16 +110,32 @@ export async function analyzeAuthSurfaceGaps(url, detection, timeoutMs) {
         const hasEmailLink = await page.getByText(/magic link|email.*link|passwordless/i).count();
         const hasOAuthUi = detection.oauthButtons.length > 0 ||
             (await page.getByText(/sign in with|continue with google|microsoft|github/i).count()) > 0;
-        if (hasOAuthUi && !hasPassword && !hasEmailLink) {
-            gaps.push({
-                id: randomUUID(),
-                path: '/',
-                severity: 'medium',
-                category: 'auth-surface',
-                reason: 'OAuth-only entry with no visible password or magic-link fallback.',
-                description: 'Users who cannot use a social IdP need another path (email/password, help, or support).',
-                recommendation: 'Add a documented fallback (email/password, help desk link, or alternate IdP).',
-            });
+        const formLoginFallbacks = (detection.authOptions ?? []).filter((o) => o.type === 'form-login');
+        const hasFormLoginFallback = formLoginFallbacks.length > 0;
+        if (detection.type === 'oauth' && hasOAuthUi && !hasPassword && !hasEmailLink) {
+            if (hasFormLoginFallback) {
+                const labels = formLoginFallbacks.map((o) => o.label).join(', ');
+                gaps.push({
+                    id: randomUUID(),
+                    path: '/',
+                    severity: 'low',
+                    category: 'auth-surface',
+                    reason: `OAuth-primary login with form-login fallback detected via: ${labels}`,
+                    description: 'A form-based login path exists alongside OAuth. Automate via type="form-login" using the selectors in authOptions.',
+                    recommendation: `Automatable form option(s): ${labels}. Configure type="form-login" with credentials and selectors from detectedAuth.authOptions.`,
+                });
+            }
+            else {
+                gaps.push({
+                    id: randomUUID(),
+                    path: '/',
+                    severity: 'medium',
+                    category: 'auth-surface',
+                    reason: 'OAuth-only entry with no visible password or magic-link fallback.',
+                    description: 'Users who cannot use a social IdP need another path (email/password, help, or support).',
+                    recommendation: 'Add a documented fallback (email/password, help desk link, or alternate IdP).',
+                });
+            }
         }
         const errorSelectors = '[role="alert"], [data-testid*="error" i], .error, .alert-danger, [class*="error" i]';
         const errCount = await page.locator(errorSelectors).count();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qulib/core",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Qulib — analyze deployed web apps for honest quality gaps (CLI + programmatic API)",
   "license": "MIT",
   "author": "Tapesh Nagarwal",
@@ -13,6 +13,16 @@
   "bugs": {
     "url": "https://github.com/TapeshN/qulib/issues"
   },
+  "keywords": [
+    "qa",
+    "quality",
+    "accessibility",
+    "gap-analysis",
+    "release-confidence",
+    "playwright",
+    "mcp",
+    "ai"
+  ],
   "publishConfig": {
     "access": "public"
   },