dbdiagram 0.1.0

package/dist/actions/list/list-document.action.js

@@ -0,0 +1,130 @@
+import { log, spinner } from '@clack/prompts';
+import { DBDOCS_CONFIGS } from '../../config.staging.js';
+import { getCredential } from '../../config/credential-manager.js';
+import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { portalIntegration } from '../../integrations/portal/portal.integration.js';
+import { logConsole } from '../../utils/logger.util.js';
+import { printJson, printTable } from '../../utils/output.util.js';
+import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
+import { computeColWidths } from '../../utils/table.util.js';
+function mapRole(role) {
+    switch (role) {
+        case 'admin':
+            return 'Administrator';
+        case 'editor':
+            return 'View and edit';
+        case 'viewer':
+            return 'View only';
+        default:
+            return role;
+    }
+}
+function mapAccessControl(ac) {
+    switch (ac) {
+        case 'public':
+            return 'Public';
+        case 'protected':
+            return 'Password-protected';
+        case 'restricted':
+            return 'Private';
+        default:
+            return 'N/A';
+    }
+}
+export async function listDocumentAction(opts) {
+    const credential = getCredential();
+    if (!credential) {
+        log.error(NOT_LOGGED_IN_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    const s = spinner();
+    s.start('Fetching documents...');
+    try {
+        const currentUser = await portalIntegration.getCurrentUser();
+        let workspaceUrlNames;
+        if (opts.workspace) {
+            workspaceUrlNames = [opts.workspace];
+        }
+        else {
+            const workspaces = await portalIntegration.listWorkspaces();
+            workspaceUrlNames = [...workspaces.owned, ...workspaces.member, ...workspaces.guested].map((w) => w.urlName);
+        }
+        const results = await Promise.allSettled(workspaceUrlNames.map(async (urlName) => {
+            const data = await portalIntegration.listWorkspaceProjects(urlName);
+            const projects = [
+                ...data.projects,
+                ...(data.shared ?? []),
+                ...(data.private ?? []),
+            ];
+            return { urlName, projects };
+        }));
+        const workspacesWithProjects = [];
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result.status === 'fulfilled') {
+                if (result.value.projects.length > 0) {
+                    workspacesWithProjects.push(result.value);
+                }
+            }
+            else {
+                if (opts.workspace) {
+                    throw result.reason;
+                }
+                const urlName = workspaceUrlNames[i];
+                log.warn(`Failed to fetch documents for workspace "${urlName}". Skipping.`);
+            }
+        }
+        if (workspacesWithProjects.length === 0) {
+            s.stop('No documents found.');
+            return;
+        }
+        const totalCount = workspacesWithProjects.reduce((sum, w) => sum + w.projects.length, 0);
+        s.stop(`Fetched ${totalCount} documents.`);
+        if (opts.json) {
+            const allMappedData = workspacesWithProjects.flatMap((w) => w.projects.map((p) => {
+                const ownerLabel = p.owner.email === currentUser.email ? `${p.owner.email} (you)` : p.owner.email;
+                return {
+                    workspace: w.urlName,
+                    name: p.name,
+                    owner: ownerLabel,
+                    permission: mapRole(p.role),
+                    accessControl: mapAccessControl(p.accessControl),
+                    url: `${DBDOCS_CONFIGS.baseUrl}/${w.urlName}/${p.urlName}`,
+                    updatedAt: p.updatedAt,
+                };
+            }));
+            printJson(allMappedData);
+        }
+        else {
+            for (const w of workspacesWithProjects) {
+                logConsole(`\n${w.urlName}`);
+                printTable(w.projects, {
+                    head: ['Name', 'Owner', 'Permission', 'Access Control', 'Url', 'Last updated'],
+                    colWidths: computeColWidths([0.14, 0.22, 0.12, 0.14, 0.24, 0.14]),
+                    rowMapper: (p) => {
+                        const ownerLabel = p.owner.email === currentUser.email ? `${p.owner.email} (you)` : p.owner.email;
+                        return [
+                            p.name,
+                            ownerLabel,
+                            mapRole(p.role),
+                            mapAccessControl(p.accessControl),
+                            `${DBDOCS_CONFIGS.baseUrl}/${w.urlName}/${p.urlName}`,
+                            new Date(p.updatedAt).toLocaleString(),
+                        ];
+                    },
+                });
+            }
+        }
+    }
+    catch (error) {
+        s.stop('Failed to fetch documents.');
+        if (isPortalApiError(error)) {
+            log.error(getPortalApiErrorMessage(error));
+        }
+        else {
+            log.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/actions/list/list.action.js

@@ -0,0 +1,103 @@
+import { log, spinner } from '@clack/prompts';
+import { DBDIAGRAM_CONFIGS } from '../../config.staging.js';
+import { getCredential } from '../../config/credential-manager.js';
+import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { portalIntegration } from '../../integrations/portal/portal.integration.js';
+import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
+import { computeColWidths } from '../../utils/table.util.js';
+import { printJson, printTable } from '../../utils/output.util.js';
+function mapStatus(status) {
+    switch (status) {
+        case 'public':
+            return 'Public';
+        case 'protected':
+            return 'Password-protected';
+        case 'private':
+            return 'Private';
+        default:
+            return status;
+    }
+}
+function ownerLabel(owner, currentUserEmail) {
+    return owner.email === currentUserEmail ? `${owner.email} (you)` : owner.email;
+}
+export async function listAction(opts) {
+    const credential = getCredential();
+    if (!credential) {
+        log.error(NOT_LOGGED_IN_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    const s = spinner();
+    s.start('Fetching diagrams...');
+    try {
+        if (opts.workspace) {
+            const [currentUser, data] = await Promise.all([
+                portalIntegration.getCurrentUser(),
+                portalIntegration.listDiagrams(opts.workspace),
+            ]);
+            const allDiagrams = [
+                ...data.diagrams,
+                ...data.shared,
+                ...data.private,
+            ];
+            if (allDiagrams.length === 0) {
+                s.stop('No diagrams found.');
+                return;
+            }
+            s.stop(`Fetched ${allDiagrams.length} diagrams.`);
+            const mappedData = allDiagrams.map((d) => ({
+                name: d.name,
+                id: d.id,
+                owner: ownerLabel(d.owner, currentUser.email),
+                status: mapStatus(d.status),
+                url: `${DBDIAGRAM_CONFIGS.baseUrl}/d/${d.id}`,
+                updatedAt: new Date(d.updatedAt).toLocaleString(),
+            }));
+            if (opts.json) {
+                printJson(mappedData);
+            }
+            else {
+                printTable(mappedData, {
+                    head: ['Name', 'ID', 'Owner', 'Status', 'Url', 'Last updated'],
+                    colWidths: computeColWidths([0.18, 0.22, 0.14, 0.09, 0.26, 0.11]),
+                    rowMapper: (d) => [d.name, d.id, d.owner, d.status, d.url, d.updatedAt],
+                });
+            }
+        }
+        else {
+            const data = await portalIntegration.listDiagrams();
+            if (data.diagrams.length === 0) {
+                s.stop('No diagrams found.');
+                return;
+            }
+            s.stop(`Fetched ${data.diagrams.length} diagrams.`);
+            const mappedData = data.diagrams.map((d) => ({
+                name: d.name,
+                id: d.id,
+                url: `${DBDIAGRAM_CONFIGS.baseUrl}/d/${d.id}`,
+                updatedAt: new Date(d.updatedAt).toLocaleString(),
+            }));
+            if (opts.json) {
+                printJson(mappedData);
+            }
+            else {
+                printTable(mappedData, {
+                    head: ['Name', 'ID', 'Url', 'Last updated'],
+                    colWidths: computeColWidths([0.25, 0.18, 0.35, 0.22]),
+                    rowMapper: (d) => [d.name, d.id, d.url, d.updatedAt],
+                });
+            }
+        }
+    }
+    catch (error) {
+        s.stop('Failed to fetch diagrams.');
+        if (isPortalApiError(error)) {
+            log.error(getPortalApiErrorMessage(error));
+        }
+        else {
+            log.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/actions/pull.action.js

@@ -0,0 +1,58 @@
+import { log, spinner } from '@clack/prompts';
+import { NOT_LOGGED_IN_MESSAGE } from '../constants/auth-message.constant.js';
+import { getCredential } from '../config/credential-manager.js';
+import { writeFileWithDir } from '../services/file.service.js';
+import { portalIntegration } from '../integrations/portal/portal.integration.js';
+import { deriveDiagramVizPathFromDBML, readDiagramVizFile, writeDiagramVizFile, } from '../services/viz/diagram-viz-file.service.js';
+import { getVizReadErrorMessage } from '../utils/diagram-viz-error.util.js';
+import { fromServerFormat } from '../services/viz/diagram-viz-converter.service.js';
+import { logConsole } from '../utils/logger.util.js';
+import { getPortalApiErrorMessage, isPortalApiError } from '../utils/portal-error.util.js';
+export async function pullAction(options) {
+    const credential = getCredential();
+    if (!credential) {
+        log.error(NOT_LOGGED_IN_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    if (!options.diagramId) {
+        log.error('Missing required flag: --diagram-id');
+        process.exitCode = 1;
+        return;
+    }
+    const s = spinner();
+    s.start('Fetching diagram...');
+    try {
+        const diagram = await portalIntegration.getDiagram(options.diagramId);
+        if (options.outFile) {
+            await writeFileWithDir(options.outFile, diagram.content);
+            if (diagram.vizData) {
+                const vizPath = deriveDiagramVizPathFromDBML(options.outFile);
+                const existingResult = await readDiagramVizFile(vizPath);
+                if (!existingResult.ok) {
+                    const message = getVizReadErrorMessage(existingResult.errorCode, vizPath);
+                    log.warn(message);
+                }
+                const state = fromServerFormat(diagram.vizData, existingResult.ok ? existingResult.state : undefined);
+                await writeDiagramVizFile(vizPath, state);
+            }
+            const label = diagram.name ? `"${diagram.name}"` : 'your diagram';
+            s.stop(`Saved ${label} to ${options.outFile}`);
+        }
+        else {
+            s.stop('Diagram fetched successfully.');
+            logConsole(diagram.content);
+        }
+    }
+    catch (error) {
+        s.stop('Failed to fetch diagram.');
+        if (isPortalApiError(error)) {
+            log.error(getPortalApiErrorMessage(error));
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            log.error(message);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/actions/push.action.js

@@ -0,0 +1,91 @@
+import { readFile } from 'node:fs/promises';
+import { log, spinner } from '@clack/prompts';
+import { getCredential } from '../config/credential-manager.js';
+import { NOT_LOGGED_IN_MESSAGE } from '../constants/auth-message.constant.js';
+import { portalIntegration } from '../integrations/portal/portal.integration.js';
+import { deriveDiagramVizPathFromDBML, readDiagramVizFile } from '../services/viz/diagram-viz-file.service.js';
+import { getVizReadErrorMessage } from '../utils/diagram-viz-error.util.js';
+import { toServerFormat } from '../services/viz/diagram-viz-converter.service.js';
+import { preparePushDiagramData } from '../services/dbml/dbml.service.js';
+import { DBDIAGRAM_CONFIGS } from '../config.js';
+import { isPortalApiError, getPortalApiErrorMessage } from '../utils/portal-error.util.js';
+import { printJson } from '../utils/output.util.js';
+import { formatDbmlError } from '../utils/dbml.util.js';
+export async function pushAction(filepath, options, thisCommand) {
+    const credential = getCredential();
+    if (!credential) {
+        log.error(NOT_LOGGED_IN_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    const resolvedFilepath = thisCommand.args[0] || filepath;
+    if (!resolvedFilepath) {
+        log.error('Missing required argument: filepath. Provide it as an argument or set dbml.entry in settings.');
+        process.exitCode = 1;
+        return;
+    }
+    let dbml;
+    try {
+        dbml = await readFile(resolvedFilepath, 'utf8');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log.error(`Failed to read file: ${message}`);
+        process.exitCode = 1;
+        return;
+    }
+    let preparedPushData;
+    try {
+        preparedPushData = await preparePushDiagramData(dbml);
+    }
+    catch (error) {
+        log.error(`Failed to parse DBML: ${formatDbmlError(error)}`);
+        process.exitCode = 1;
+        return;
+    }
+    const vizPath = deriveDiagramVizPathFromDBML(resolvedFilepath);
+    const vizResult = await readDiagramVizFile(vizPath);
+    let vizData;
+    if (vizResult.ok) {
+        const { diagramViews } = preparedPushData;
+        vizData = toServerFormat(vizResult.state, diagramViews);
+    }
+    else {
+        const message = getVizReadErrorMessage(vizResult.errorCode, vizPath);
+        log.warn(message);
+    }
+    const s = spinner();
+    s.start('Pushing diagram to dbdiagram...');
+    try {
+        let diagramId;
+        if (!options.new && options.diagramId) {
+            ({ diagramId } = await portalIntegration.updateDiagram({
+                diagramId: options.diagramId, name: options.name, dbml, vizData,
+            }));
+        }
+        else {
+            ({ diagramId } = await portalIntegration.createDiagram({
+                name: options.name, dbml, workspaceId: options.workspace, vizData,
+            }));
+        }
+        const diagramUrl = `${DBDIAGRAM_CONFIGS.baseUrl}/d/${diagramId}`;
+        if (options.json) {
+            s.stop();
+            printJson({ diagramId, url: diagramUrl });
+        }
+        else {
+            s.stop(`Diagram pushed successfully. Open the following link to see your diagram: ${diagramUrl}`);
+        }
+    }
+    catch (error) {
+        s.stop('Failed to push diagram.');
+        if (isPortalApiError(error)) {
+            log.error(getPortalApiErrorMessage(error));
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            log.error(message);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/actions/tokens/token-delete.action.js

@@ -0,0 +1,50 @@
+import { confirm, isCancel, log, spinner } from '@clack/prompts';
+import { getCredential } from '../../config/credential-manager.js';
+import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { portalIntegration } from '../../integrations/portal/portal.integration.js';
+import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
+import { printJson } from '../../utils/output.util.js';
+export async function tokenDeleteAction(tokenId, options) {
+    const credential = getCredential();
+    if (!credential) {
+        log.error(NOT_LOGGED_IN_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    if (!options.force) {
+        if (!process.stdout.isTTY) {
+            log.error('Use -f to force delete in non-interactive environment.');
+            process.exitCode = 1;
+            return;
+        }
+        const shouldDelete = await confirm({
+            message: `Delete token '${tokenId}'?`,
+            initialValue: false,
+        });
+        if (isCancel(shouldDelete) || !shouldDelete) {
+            return;
+        }
+    }
+    const s = spinner();
+    s.start('Deleting token...');
+    try {
+        await portalIntegration.deleteToken(tokenId);
+        if (options.json) {
+            s.stop();
+            printJson({ id: tokenId, deleted: true });
+        }
+        else {
+            s.stop(`Token ${tokenId} deleted.`);
+        }
+    }
+    catch (error) {
+        s.stop('Failed to delete token.');
+        if (isPortalApiError(error)) {
+            log.error(getPortalApiErrorMessage(error));
+        }
+        else {
+            log.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/actions/tokens/token-generate.action.js

@@ -0,0 +1,52 @@
+import os from 'node:os';
+import { log, spinner } from '@clack/prompts';
+import packageJson from '../../../package.json' with { type: 'json' };
+import { getCredential } from '../../config/credential-manager.js';
+import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { portalIntegration } from '../../integrations/portal/portal.integration.js';
+import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
+import { printJson } from '../../utils/output.util.js';
+import { logConsole } from '../../utils/logger.util.js';
+const PLATFORM_NAMES = {
+    darwin: 'macOS',
+    win32: 'Windows',
+    linux: 'Linux',
+};
+export function generateDefaultTokenName() {
+    const osName = PLATFORM_NAMES[process.platform] ?? process.platform;
+    return `dbdiagram-cli (${os.hostname()}, ${osName} ${process.arch}, v${packageJson.version})`;
+}
+export async function tokenGenerateAction(opts) {
+    const credential = getCredential();
+    if (!credential) {
+        log.error(NOT_LOGGED_IN_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    const name = opts.name ?? generateDefaultTokenName();
+    const s = spinner();
+    s.start('Generating token...');
+    try {
+        const { id, name: tokenName, token } = await portalIntegration.generateToken({ name });
+        if (opts.json) {
+            s.stop();
+            printJson({ id, name: tokenName, token });
+        }
+        else {
+            s.stop('Success! Token created. Save the token value below — it will not be shown again.');
+            logConsole(`Value: ${token}`);
+            logConsole(`ID:    ${id}`);
+            logConsole(`Name:  ${tokenName}`);
+        }
+    }
+    catch (error) {
+        s.stop('Failed to generate token.');
+        if (isPortalApiError(error)) {
+            log.error(getPortalApiErrorMessage(error));
+        }
+        else {
+            log.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/actions/tokens/token-list.action.js

@@ -0,0 +1,52 @@
+import { log, spinner } from '@clack/prompts';
+import { DateTime } from 'luxon';
+import { getCredential } from '../../config/credential-manager.js';
+import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { portalIntegration } from '../../integrations/portal/portal.integration.js';
+import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
+import { computeColWidths } from '../../utils/table.util.js';
+import { printJson, printTable } from '../../utils/output.util.js';
+export async function tokenListAction(opts) {
+    const credential = getCredential();
+    if (!credential) {
+        log.error(NOT_LOGGED_IN_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    const s = spinner();
+    s.start('Fetching tokens...');
+    try {
+        const tokens = await portalIntegration.listTokens();
+        if (tokens.length === 0) {
+            s.stop('No tokens found. Generate one with `dbdiagram tokens generate`.');
+            return;
+        }
+        s.stop(`Fetched ${tokens.length} tokens.`);
+        const mappedData = tokens.map((t) => ({
+            id: t.id,
+            name: t.name,
+            createdAt: DateTime.fromISO(t.createdAt).toLocaleString(DateTime.DATETIME_SHORT),
+            lastUsedAt: t.lastUsedAt ? DateTime.fromISO(t.lastUsedAt).toLocaleString(DateTime.DATETIME_SHORT) : 'Never',
+        }));
+        if (opts.json) {
+            printJson(mappedData);
+        }
+        else {
+            printTable(mappedData, {
+                head: ['ID', 'Name', 'Created at', 'Last used'],
+                colWidths: computeColWidths([0.2, 0.45, 0.17, 0.18]),
+                rowMapper: (t) => [t.id, t.name, t.createdAt, t.lastUsedAt],
+            });
+        }
+    }
+    catch (error) {
+        s.stop('Failed to fetch tokens.');
+        if (isPortalApiError(error)) {
+            log.error(getPortalApiErrorMessage(error));
+        }
+        else {
+            log.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/assets/callback-error.html

@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>dbdiagram CLI - Authentication Failed</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        min-height: 100vh;
+        background: #f9fafb;
+      }
+
+      .container {
+        background: white;
+        border-radius: 6px;
+        border: 1px solid #eff0f3;
+        box-shadow: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+        padding: 32px;
+        width: 100%;
+        max-width: 400px;
+        text-align: center;
+      }
+
+      .logo-container {
+        margin-bottom: 16px;
+      }
+
+      .logo {
+        height: 48px;
+      }
+
+      h1 {
+        color: #ff4f46;
+        font-size: 24px;
+        font-weight: 600;
+        margin-bottom: 20px;
+      }
+
+      .error-box {
+        background: #ffeef1;
+        border: 1px solid #fea5a6;
+        border-radius: 6px;
+        padding: 16px;
+        text-align: left;
+      }
+
+      .error-title {
+        font-weight: 600;
+        color: #ff4f46;
+        margin-bottom: 8px;
+        font-size: 16px;
+      }
+
+      .error-message {
+        font-size: 14px;
+        color: #ff4f46;
+        line-height: 1.5;
+      }
+
+      p {
+        color: #718096;
+        line-height: 1.6;
+        font-size: 15px;
+      }
+
+      strong {
+        color: #2d3748;
+      }
+
+      .footer {
+        margin-top: 24px;
+        padding-top: 24px;
+        border-top: 1px solid #e2e8f0;
+        color: #a0aec0;
+        font-size: 13px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <div class="logo-container">
+        <svg class="logo" width="155" height="155" viewBox="0 0 155 155" fill="none" xmlns="http://www.w3.org/2000/svg">
+          <path d="M155 29C155 12.9837 142.016 0 126 0H29C12.9837 0 0 12.9837 0 29V126C0 142.016 12.9837 155 29 155H126C142.016 155 155 142.016 155 126V29Z" fill="#0246CC"/>
+          <path d="M77.5 54.6521C102.065 54.6521 121.978 47.8098 121.978 39.3694C121.978 30.929 102.065 24.0867 77.5 24.0867C52.9354 24.0867 33.0218 30.929 33.0218 39.3694C33.0218 47.8098 52.9354 54.6521 77.5 54.6521Z" fill="white"/>
+          <path d="M33.0399 76.4867V91.6759C33.0399 96.6868 50.3603 103.965 77.5001 103.965C104.64 103.965 121.96 96.6868 121.96 91.6759V76.4867C112.817 82.4469 95.0968 85.5314 77.5001 85.5314C59.9034 85.5314 42.1828 82.4469 33.0399 76.4867Z" fill="#287EFF"/>
+          <path d="M33.0399 50.5847V67.5282C33.0399 72.5391 50.3603 79.8172 77.5001 79.8172C104.64 79.8172 121.96 72.5391 121.96 67.5282V50.5847C113.453 57.1317 97.1229 61.3837 77.5001 61.3837C57.8772 61.3837 41.5476 57.1317 33.0399 50.5847Z" fill="#96C0FF"/>
+          <path d="M33.0399 101.065V116.254C33.0399 121.265 50.3603 128.543 77.5001 128.543C104.64 128.543 121.96 121.265 121.96 116.254V101.065C112.817 107.025 95.0968 110.11 77.5001 110.11C59.9034 110.11 42.1828 107.025 33.0399 101.065Z" fill="#0258ED"/>
+        </svg>
+      </div>
+
+      <h1>Authentication Failed</h1>
+
+      <div class="error-box">
+        <p class="error-title">Invalid redirect URL</p>
+        <p class="error-message">The authentication callback could not be completed.</p>
+      </div>
+    </div>
+  </body>
+</html>