@dreamlake/ml-dash 0.1.0

package/dist/commands/list.js

@@ -0,0 +1,341 @@
+import { makeClient, notAuthenticatedMessage, resolveContext } from "../cli/context.js";
+import { hasWildcard } from "../util/glob.js";
+import { cyan, dim, green, red, renderTable, yellow } from "../util/ansi.js";
+export const PAGE_SIZE = 50;
+export const spec = {
+    name: "list",
+    help: "List projects and experiments on remote server",
+    description: "Discover projects and experiments available on the remote ML-Dash server.",
+    options: [
+        { flags: ["--dash-url", "--api-url"], dest: "dash_url", metavar: "URL", help: "ML-Dash server URL (defaults to config or https://api.dash.ml)" },
+        { flags: ["-n", "--namespace"], dest: "namespace", metavar: "NS", help: "Namespace slug for all queries (defaults to authenticated user's namespace)" },
+        { flags: ["-p", "--pref", "--prefix", "--proj", "--project"], dest: "project", metavar: "PROJECT", help: "List experiments in this project. Supports glob patterns — always quote them: -p 'tom/tut*'" },
+        { flags: ["--status"], dest: "status", metavar: "STATUS", choices: ["COMPLETED", "RUNNING", "FAILED", "ARCHIVED"], help: "Filter experiments by status" },
+        { flags: ["--tags"], dest: "tags", metavar: "TAGS", help: "Filter experiments by tags (comma-separated)" },
+        { flags: ["--tracks"], dest: "tracks", boolean: true, help: "List tracks in experiment (requires --project as 'namespace/project/experiment')" },
+        { flags: ["--topic-filter"], dest: "topic_filter", metavar: "TOPIC", help: "Filter tracks by topic (e.g., 'robot/*')" },
+        { flags: ["--detailed"], dest: "detailed", boolean: true, help: "Show detailed information" },
+        { flags: ["-v", "--verbose"], dest: "verbose", boolean: true, help: "Verbose output" },
+    ],
+};
+// ── formatting ───────────────────────────────────────────────────────────────
+export function formatTimestamp(iso) {
+    const then = new Date(iso);
+    if (Number.isNaN(then.getTime()))
+        return iso;
+    const seconds = Math.floor((Date.now() - then.getTime()) / 1000);
+    const days = Math.floor(seconds / 86400);
+    if (days > 365) {
+        const y = Math.floor(days / 365);
+        return `${y} year${y > 1 ? "s" : ""} ago`;
+    }
+    if (days > 30) {
+        const m = Math.floor(days / 30);
+        return `${m} month${m > 1 ? "s" : ""} ago`;
+    }
+    if (days > 0)
+        return `${days} day${days > 1 ? "s" : ""} ago`;
+    const rest = seconds % 86400;
+    if (rest > 3600) {
+        const h = Math.floor(rest / 3600);
+        return `${h} hour${h > 1 ? "s" : ""} ago`;
+    }
+    if (rest > 60) {
+        const m = Math.floor(rest / 60);
+        return `${m} minute${m > 1 ? "s" : ""} ago`;
+    }
+    return "just now";
+}
+const styleStatus = (status) => {
+    if (status === "COMPLETED")
+        return green(status);
+    if (status === "RUNNING")
+        return yellow(status);
+    if (status === "FAILED")
+        return red(status);
+    if (status === "ARCHIVED")
+        return dim(status);
+    return status;
+};
+const truncate = (s, n) => (s.length > n ? `${s.slice(0, n - 3)}...` : s);
+const summariseTags = (tags) => {
+    const shown = tags.slice(0, 3).join(", ");
+    return (tags.length > 3 ? `${shown} +${tags.length - 3}` : shown) || "-";
+};
+const caption = (offset, total, noun) => {
+    const totalPages = Math.max(1, Math.ceil(total / PAGE_SIZE));
+    const page = Math.floor(offset / PAGE_SIZE) + 1;
+    return `Page ${page}/${totalPages}  ·  ${total} ${noun}${total !== 1 ? "s" : ""} total`;
+};
+// ── paging ───────────────────────────────────────────────────────────────────
+/** One keypress, no Enter. 'next' | 'prev' | 'quit'. */
+function readKey() {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.once("data", (buf) => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            const s = buf.toString("utf8");
+            if (s === "\u001b[C" || s === "n" || s === "\r" || s === "\n" || s === " ")
+                return resolve("next");
+            if (s === "\u001b[D" || s === "p" || s === "b")
+                return resolve("prev");
+            resolve("quit");
+        });
+    });
+}
+/** Fetch → print → wait for a key, until the user leaves or the pages run out. */
+async function paginate(fetchPage, emptyMessage) {
+    let offset = 0;
+    for (;;) {
+        const { total, table } = await fetchPage(offset);
+        if (!table) {
+            if (offset === 0)
+                console.log(yellow(emptyMessage));
+            return 0;
+        }
+        console.log(table);
+        const hasNext = offset + PAGE_SIZE < total;
+        const hasPrev = offset > 0;
+        if (!hasNext && !hasPrev)
+            return 0;
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            if (hasNext) {
+                console.log(dim("More results available — run in a terminal to page, or narrow with -p/--status."));
+            }
+            return 0;
+        }
+        const nav = [hasPrev ? "[b/←] prev" : "", hasNext ? "[n/→] next" : "", "[q] quit"].filter(Boolean);
+        process.stdout.write(`${dim(nav.join("  "))}  `);
+        const key = await readKey();
+        process.stdout.write("\n");
+        if (key === "next" && hasNext)
+            offset += PAGE_SIZE;
+        else if (key === "prev" && hasPrev)
+            offset -= PAGE_SIZE;
+        else
+            return 0;
+    }
+}
+// ── modes ────────────────────────────────────────────────────────────────────
+const EXPERIMENT_COLUMNS = [
+    { header: "Experiment" },
+    { header: "Status", align: "center" },
+    { header: "Metrics", align: "right" },
+    { header: "Logs", align: "right" },
+    { header: "Tracks", align: "right" },
+    { header: "Files", align: "right" },
+];
+function experimentRow(exp, detailed, timeField) {
+    const row = [
+        cyan(exp.displayPath || exp.name),
+        styleStatus(exp.status ?? "UNKNOWN"),
+        String((exp.metrics ?? []).length),
+        String(exp.logMetadata?.totalLogs ?? 0),
+        String(exp.trackCount ?? 0),
+        String((exp.files ?? []).length),
+    ];
+    if (detailed) {
+        row.push(summariseTags(exp.tags ?? []));
+        row.push(exp[timeField] ? formatTimestamp(exp[timeField]) : "-");
+    }
+    return row;
+}
+const matchesTags = (exp, tags) => !tags || (exp.tags ?? []).some((t) => tags.includes(t));
+export async function listTracks(client, experimentPath, topicFilter, verbose) {
+    const parts = experimentPath.replace(/^\/+|\/+$/g, "").split("/");
+    if (parts.length < 3) {
+        console.error(`${red("Error:")} Experiment path must be 'namespace/project/experiment'`);
+        return 1;
+    }
+    const [, project, experiment] = parts;
+    try {
+        const exp = await client.getExperimentGraphql(project, experiment);
+        if (!exp) {
+            console.error(`${red("Error:")} Experiment '${experiment}' not found in project '${project}'`);
+            return 1;
+        }
+        const tracks = await client.listTracks(String(exp.id), topicFilter);
+        if (tracks.length === 0) {
+            console.log(yellow("No tracks found"));
+            return 0;
+        }
+        const rows = tracks.map((track) => {
+            const cols = track.columns ?? [];
+            const columns = cols.slice(0, 5).join(", ") + (cols.length > 5 ? `, ... (+${cols.length - 5})` : "");
+            const first = track.firstTimestamp;
+            const last = track.lastTimestamp;
+            const range = first != null && last != null ? `${Number(first).toFixed(3)} - ${Number(last).toFixed(3)}` : "N/A";
+            return [cyan(track.topic), String(track.totalEntries ?? 0), dim(columns), dim(range)];
+        });
+        console.log(renderTable([{ header: "Topic" }, { header: "Entries", align: "right" }, { header: "Columns" }, { header: "Time Range" }], rows, { title: `\nTracks in ${experimentPath}\n` }));
+        return 0;
+    }
+    catch (e) {
+        console.error(`${red("Error listing tracks:")} ${e.message}`);
+        if (verbose)
+            console.error(e.stack);
+        return 1;
+    }
+}
+async function listProjects(client, namespaceSlug, verbose) {
+    try {
+        return await paginate(async (offset) => {
+            const { projects, totalCount } = await client.listProjectsGraphql(namespaceSlug, PAGE_SIZE, offset);
+            if (projects.length === 0)
+                return { total: totalCount, table: null };
+            const rows = projects.map((p) => [
+                cyan(p.slug),
+                String(p.experimentCount ?? 0),
+                dim(truncate(p.description ?? "", 50)),
+            ]);
+            return {
+                total: totalCount,
+                table: renderTable([{ header: "Project" }, { header: "Experiments", align: "right" }, { header: "Description" }], rows, { title: "\nProjects", caption: caption(offset, totalCount, "project") }),
+            };
+        }, "No projects found");
+    }
+    catch (e) {
+        console.error(`${red("Error listing projects:")} ${e.message}`);
+        if (verbose)
+            console.error(e.stack);
+        return 1;
+    }
+}
+async function listExperiments(client, project, opts) {
+    try {
+        return await paginate(async (offset) => {
+            const { experiments, totalCount } = await client.listExperimentsGraphql(project, {
+                status: opts.status,
+                namespaceSlug: opts.namespaceSlug,
+                limit: PAGE_SIZE,
+                offset,
+            });
+            const filtered = experiments.filter((e) => matchesTags(e, opts.tags));
+            if (filtered.length === 0)
+                return { total: totalCount, table: null };
+            const columns = opts.detailed
+                ? [...EXPERIMENT_COLUMNS, { header: "Tags" }, { header: "Created" }]
+                : EXPERIMENT_COLUMNS;
+            return {
+                total: totalCount,
+                table: renderTable(columns, filtered.map((e) => experimentRow(e, opts.detailed, "createdAt")), {
+                    title: `\nExperiments in project: ${project}`,
+                    caption: caption(offset, totalCount, "experiment"),
+                }),
+            };
+        }, `No experiments found in project: ${project}`);
+    }
+    catch (e) {
+        console.error(`${red("Error listing experiments:")} ${e.message}`);
+        if (opts.verbose)
+            console.error(e.stack);
+        return 1;
+    }
+}
+/** Expand a one- or two-segment pattern to the three-segment path the server matches. */
+export function searchPattern(project, namespace) {
+    if (!project.includes("/"))
+        return `${namespace}/${project}/*`;
+    if (project.split("/").length === 2)
+        return `${project}/*`;
+    return project;
+}
+async function searchExperiments(client, pattern, opts) {
+    try {
+        return await paginate(async (offset) => {
+            const { experiments, totalCount } = await client.searchExperimentsGraphql(pattern, PAGE_SIZE, offset);
+            // The search endpoint does not filter on status or tags, so both are
+            // applied here — which means they narrow the page, not the total.
+            const filtered = experiments
+                .filter((e) => !opts.status || e.status === opts.status)
+                .filter((e) => matchesTags(e, opts.tags));
+            if (filtered.length === 0)
+                return { total: totalCount, table: null };
+            const columns = [
+                { header: "Project" },
+                ...EXPERIMENT_COLUMNS,
+                ...(opts.detailed ? [{ header: "Tags" }, { header: "Started" }] : []),
+            ];
+            const rows = filtered.map((e) => [
+                dim(e.project?.slug ?? ""),
+                ...experimentRow(e, opts.detailed, "startedAt"),
+            ]);
+            return {
+                total: totalCount,
+                table: renderTable(columns, rows, {
+                    title: `\nSearch results for: ${pattern}`,
+                    caption: caption(offset, totalCount, "experiment"),
+                }),
+            };
+        }, `No experiments match pattern: ${pattern}`);
+    }
+    catch (e) {
+        console.error(`${red("Error searching experiments:")} ${e.message}`);
+        if (opts.verbose)
+            console.error(e.stack);
+        return 1;
+    }
+}
+// ── entry point ──────────────────────────────────────────────────────────────
+export async function run(args) {
+    const ctx = resolveContext(args);
+    if (!ctx.apiKey) {
+        console.error(`${red("Error:")} ${notAuthenticatedMessage(ctx)}`);
+        return 1;
+    }
+    const verbose = args.verbose === true;
+    const detailed = args.detailed === true;
+    const project = typeof args.project === "string" ? args.project : undefined;
+    const tags = typeof args.tags === "string" ? args.tags.split(",").map((t) => t.trim()) : null;
+    const status = typeof args.status === "string" ? args.status : undefined;
+    if (args.tracks) {
+        if (!project) {
+            console.error(`${red("Error:")} --project is required for listing tracks`);
+            console.error("Example: ml-dash list --tracks --project namespace/project/experiment");
+            return 1;
+        }
+        const parts = project.replace(/^\/+|\/+$/g, "").split("/");
+        if (parts.length < 3) {
+            console.error(`${red("Error:")} For tracks, --project must be 'namespace/project/experiment'`);
+            return 1;
+        }
+        return listTracks(makeClient(ctx, parts[0]), project, typeof args.topic_filter === "string" ? args.topic_filter : undefined, verbose);
+    }
+    const wildcard = project ? hasWildcard(project) : false;
+    let namespace;
+    let projectSlug;
+    if (project) {
+        const parts = project.replace(/^\/+|\/+$/g, "").split("/");
+        if (project.includes("/")) {
+            namespace = parts[0];
+            projectSlug = parts[1];
+        }
+        else if (!wildcard) {
+            projectSlug = project;
+        }
+    }
+    const client = makeClient(ctx, namespace);
+    let effectiveNamespace;
+    try {
+        effectiveNamespace =
+            (typeof args.namespace === "string" ? args.namespace : undefined) ||
+                namespace ||
+                (await client.namespace());
+    }
+    catch (e) {
+        console.error(`${red("Error connecting to remote:")} ${e.message}`);
+        if (verbose)
+            console.error(e.stack);
+        return 1;
+    }
+    if (!project)
+        return listProjects(client, effectiveNamespace, verbose);
+    if (wildcard) {
+        return searchExperiments(client, searchPattern(project, effectiveNamespace), { status, tags, detailed, verbose });
+    }
+    console.log(dim(`Using namespace: ${effectiveNamespace}`));
+    return listExperiments(client, projectSlug, { namespaceSlug: effectiveNamespace, status, tags, detailed, verbose });
+}

package/dist/commands/login.js

@@ -0,0 +1,128 @@
+/**
+ * `ml-dash login` — OAuth 2.0 device authorization against vuer-auth, then a
+ * token exchange with the ml-dash server.
+ *
+ * The user never types a password here: the CLI shows a short code (and a QR
+ * for a phone), the browser does the authorization, and polling picks up a
+ * short-lived vuer-auth JWT which is immediately traded for the long-lived
+ * ml-dash token that actually gets stored.
+ *
+ * The stored token is printed nowhere — only where it was stored — so a shared
+ * terminal or a pasted transcript never leaks a credential.
+ */
+import { spawn } from "node:child_process";
+import { AuthorizationDeniedError, AuthorizationTimeoutError, DeviceFlowClient, TokenExchangeError, VUER_AUTH_URL, DeviceCodeExpiredError, } from "../auth/device-flow.js";
+import { getOrCreateDeviceSecret } from "../auth/device-secret.js";
+import { TokenStore } from "../auth/token-storage.js";
+import { Config, DEFAULT_API_URL } from "../config.js";
+import { bold, blue, cyan, dim, green, red, renderPanel } from "../util/ansi.js";
+export const spec = {
+    name: "login",
+    help: "Authenticate with ml-dash using device authorization flow",
+    description: `Login to ml-dash server using the OAuth2 device authorization flow.
+
+After logging in, you can:
+  • Upload/download experiments via CLI
+  • View projects, experiments, and statistics at https://dash.ml
+  • Create interactive plots and dashboards`,
+    options: [
+        { flags: ["--dash-url", "--api-url"], dest: "dash_url", metavar: "URL", help: "ML-Dash server URL (e.g., https://api.dash.ml)" },
+        { flags: ["--auth-url"], dest: "auth_url", metavar: "URL", help: "OAuth authorization server URL (e.g., https://auth.vuer.ai)" },
+        { flags: ["--no-browser"], dest: "no_browser", boolean: true, help: "Don't automatically open browser for authorization" },
+    ],
+};
+/** Block-character QR, the shape the Python CLI drew. null when unavailable. */
+async function qrCodeAscii(url) {
+    try {
+        const { create } = await import("qrcode");
+        const { modules } = create(url, {});
+        const size = modules.size;
+        const lines = [];
+        // A one-module quiet zone, matching `qrcode.QRCode(border=1)`.
+        lines.push("  ".repeat(size + 2));
+        for (let y = 0; y < size; y++) {
+            let line = "  ";
+            for (let x = 0; x < size; x++)
+                line += modules.data[y * size + x] ? "██" : "  ";
+            lines.push(line + "  ");
+        }
+        lines.push("  ".repeat(size + 2));
+        return lines.join("\n");
+    }
+    catch {
+        return null;
+    }
+}
+function openBrowser(url) {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    try {
+        const child = spawn(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function run(args) {
+    const config = new Config();
+    const remoteUrl = (typeof args.dash_url === "string" ? args.dash_url : undefined) || config.remoteUrl || DEFAULT_API_URL;
+    const authUrl = (typeof args.auth_url === "string" ? args.auth_url : undefined) || config.authUrl || VUER_AUTH_URL;
+    try {
+        console.log(`${bold("Initializing device authorization...")}\n`);
+        const deviceSecret = getOrCreateDeviceSecret(config);
+        const client = new DeviceFlowClient(deviceSecret, remoteUrl, authUrl);
+        const flow = await client.startDeviceFlow();
+        let body = `${cyan(bold("1. Visit this URL:"))}\n\n   ${flow.verificationUri}\n\n` +
+            `${cyan(bold("2. Enter this code:"))}\n\n   ${green(bold(flow.userCode))}\n`;
+        const qr = await qrCodeAscii(flow.verificationUriComplete);
+        if (qr)
+            body += `\n${cyan(bold("Or scan QR code:"))}\n\n${qr}\n`;
+        body += `\n${dim(`Code expires in ${Math.floor(flow.expiresIn / 60)} minutes`)}`;
+        console.log(renderPanel(body, { title: blue(bold("DEVICE AUTHORIZATION REQUIRED")) }));
+        console.log();
+        if (!args.no_browser && openBrowser(flow.verificationUriComplete)) {
+            console.log(`${dim("✓ Opened browser automatically")}\n`);
+        }
+        console.log(bold("Waiting for authorization..."));
+        const vuerAuthToken = await client.pollForToken(120, (elapsed) => {
+            if (process.stdout.isTTY)
+                process.stdout.write(`\r${dim(`Waiting (${elapsed}s)`)}   `);
+        });
+        if (process.stdout.isTTY)
+            process.stdout.write("\r\u001b[K");
+        console.log(`${green("✓ Authorization successful!")}\n`);
+        console.log(bold("Exchanging token with ml-dash server..."));
+        const mlDashToken = await client.exchangeToken(vuerAuthToken);
+        const where = new TokenStore(config.configDir).store(mlDashToken);
+        console.log(`${green("✓ Token exchanged successfully!")}\n`);
+        console.log(`${green(bold("✓ Logged in successfully!"))}\n\n` +
+            `Your authentication token has been stored (${where}).\n\n` +
+            `${cyan(bold("View your data online:"))}\n  https://dash.ml\n\n` +
+            "Access your projects, experiments, statistics, and interactive plots.\n\n" +
+            `${bold("CLI Commands:")}\n  ml-dash list\n  ml-dash profile`);
+        return 0;
+    }
+    catch (e) {
+        if (e instanceof DeviceCodeExpiredError) {
+            console.error(`\n${red("✗ Device code expired")}\n\nThe authorization code expired after 10 minutes.\n` +
+                "Please run 'ml-dash login' again.");
+            return 1;
+        }
+        if (e instanceof AuthorizationDeniedError) {
+            console.error(`\n${red("✗ Authorization denied")}\n\nYou declined the authorization request in your browser.\n\n` +
+                "To try again:\n  ml-dash login");
+            return 1;
+        }
+        if (e instanceof AuthorizationTimeoutError) {
+            console.error(`\n${red("✗ Authorization timed out")}\n\nNo response after 10 minutes.\n\nPlease run 'ml-dash login' again.`);
+            return 1;
+        }
+        if (e instanceof TokenExchangeError) {
+            console.error(`\n${red("✗ Token exchange failed:")} ${e.message}\n`);
+            return 1;
+        }
+        console.error(`\n${red("✗ Unexpected error:")} ${e.message}`);
+        return 1;
+    }
+}

package/dist/commands/logout.js

@@ -0,0 +1,22 @@
+/** Clear the stored token from every backend it might live in. */
+import { TokenStore } from "../auth/token-storage.js";
+import { Config } from "../config.js";
+import { green, red } from "../util/ansi.js";
+export const spec = {
+    name: "logout",
+    help: "Clear stored authentication token",
+    description: "Logout from ml-dash by clearing the stored authentication token.",
+    options: [],
+};
+export function run() {
+    try {
+        new TokenStore(new Config().configDir).delete();
+        console.log(green("✓ Logged out successfully!") +
+            "\n\nYour authentication token has been cleared.\n\nTo log in again:\n  ml-dash login");
+        return 0;
+    }
+    catch (e) {
+        console.error(`${red("✗ Storage error:")} ${e.message}`);
+        return 1;
+    }
+}

package/dist/commands/profile.js

@@ -0,0 +1,143 @@
+/**
+ * `ml-dash profile` — who am I, according to the token and to the server.
+ *
+ * The token is a JWT, so the identity it carries can be shown without a
+ * network round trip (`--cached`). By default the server is asked instead,
+ * because a username can change after the token was issued; if that call
+ * fails the token's own claims are shown with a warning rather than an error,
+ * matching the Python CLI.
+ *
+ * One deliberate divergence: the Python CLI embedded rich markup
+ * (`[red]Token expired[/red]`) inside `--json` output. Here `--json` carries
+ * plain text, so the output can be consumed by a script; the styled form is
+ * used only in the human table.
+ */
+import { userInfo } from "node:os";
+import { decodeJwtPayload } from "../auth/jwt.js";
+import { TokenStore } from "../auth/token-storage.js";
+import { RemoteClient } from "../client.js";
+import { Config, DEFAULT_API_URL } from "../config.js";
+import { bold, cyan, dim, green, renderPanel, yellow } from "../util/ansi.js";
+export const spec = {
+    name: "profile",
+    help: "Show current user profile",
+    description: "Display the current authenticated user profile and configuration.",
+    options: [
+        { flags: ["--dash-url", "--api-url"], dest: "dash_url", metavar: "URL", help: "ML-Dash server URL (default: from config)" },
+        { flags: ["--json"], dest: "json", boolean: true, help: "Output as JSON" },
+        { flags: ["--cached"], dest: "cached", boolean: true, help: "Use cached token data (default: fetch fresh from server)" },
+    ],
+};
+/** (expired, human status) for a JWT `exp` claim. */
+export function checkTokenExpiration(payload) {
+    const exp = payload.exp;
+    if (!exp)
+        return [false, null];
+    const timeLeft = Number(exp) - Math.floor(Date.now() / 1000);
+    if (timeLeft < 0)
+        return [true, "Token expired"];
+    if (timeLeft < 86400)
+        return [false, `Token expires in ${Math.floor(timeLeft / 3600)} hours`];
+    return [false, `Expires in ${Math.floor(timeLeft / 86400)} days`];
+}
+async function fetchFreshProfile(remoteUrl, token) {
+    try {
+        const user = await new RemoteClient(remoteUrl, undefined, token).getCurrentUser();
+        if (!user)
+            return null;
+        return {
+            sub: user.id,
+            username: user.username,
+            name: user.name,
+            email: user.email,
+            given_name: user.given_name,
+            family_name: user.family_name,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function run(args) {
+    const config = new Config();
+    const store = new TokenStore(config.configDir);
+    const loaded = store.load();
+    const token = loaded.token;
+    const remoteUrl = (typeof args.dash_url === "string" ? args.dash_url : undefined) || config.remoteUrl;
+    const info = {
+        authenticated: false,
+        remote_url: remoteUrl,
+        local_user: safeUsername(),
+    };
+    if (!token && loaded.unreadableReason)
+        info.warning = loaded.unreadableReason;
+    if (token) {
+        info.authenticated = true;
+        const payload = decodeJwtPayload(token);
+        const [expired, expiryMessage] = checkTokenExpiration(payload);
+        if (expired) {
+            info.authenticated = false;
+            info.error = "Token expired. Please run 'ml-dash login' to re-authenticate.";
+        }
+        else {
+            if (args.cached) {
+                info.user = payload;
+                info.source = "token";
+            }
+            else {
+                const fresh = await fetchFreshProfile(remoteUrl, token);
+                if (fresh) {
+                    info.user = fresh;
+                    info.source = "server";
+                }
+                else {
+                    info.user = payload;
+                    info.source = "token";
+                    info.warning = "Could not fetch fresh profile from server, using cached token data";
+                }
+            }
+            if (expiryMessage)
+                info.token_status = expiryMessage;
+        }
+    }
+    if (args.json) {
+        console.log(JSON.stringify(info, null, 2));
+        return 0;
+    }
+    if (!info.authenticated) {
+        console.log(renderPanel(`${cyan(bold("OS Username:"))}  ${info.local_user}\n\n` +
+            `${yellow(info.error ?? "Not authenticated")}\n\n` +
+            `Run ${cyan("ml-dash login")} to authenticate.`, { title: bold("ML-Dash Info") }));
+        return 0;
+    }
+    const user = info.user ?? {};
+    const rows = [];
+    rows.push(["Username", user.username ?? "Unavailable"]);
+    if (user.sub)
+        rows.push(["User ID", String(user.sub)]);
+    rows.push(["Name", user.name ?? "Unknown"]);
+    if (user.email)
+        rows.push(["Email", user.email]);
+    rows.push(["Remote", info.remote_url || DEFAULT_API_URL]);
+    if (info.token_status)
+        rows.push(["Token Status", info.token_status]);
+    rows.push(["Data Source", info.source === "server" ? green("Server (Fresh)") : yellow("Token (Cached)")]);
+    const keyWidth = Math.max(...rows.map(([k]) => k.length));
+    let body = rows.map(([k, v]) => `${cyan(bold(k.padEnd(keyWidth)))}  ${v}`).join("\n");
+    if (info.warning)
+        body += `\n\n${yellow(`⚠ ${info.warning}`)}`;
+    if (info.source === "server") {
+        body += `\n${dim("Tip: Use --cached to use cached token data (faster but may be outdated)")}`;
+    }
+    console.log(renderPanel(body, { title: green(bold("✓ Authenticated")) }));
+    return 0;
+}
+/** `os.userInfo()` throws on hosts where the uid has no passwd entry. */
+function safeUsername() {
+    try {
+        return userInfo().username;
+    }
+    catch {
+        return process.env.USER ?? process.env.USERNAME ?? "unknown";
+    }
+}