@dreamlake/ml-dash 0.1.0

package/dist/commands/version.js

@@ -0,0 +1,10 @@
+import { VERSION } from "../version.js";
+export const spec = {
+    name: "version",
+    help: "Show ml-dash version",
+    options: [],
+};
+export function run() {
+    console.log(`ml-dash ${VERSION}`);
+    return 0;
+}

package/dist/config.js

@@ -0,0 +1,64 @@
+/**
+ * ~/.dash/config.json — the same file the Python CLI reads and writes.
+ *
+ * Keys: remote_url, api_key, default_batch_size, auth_url, device_secret.
+ * A corrupt file is treated as empty, matching the Python behaviour, so a
+ * half-written config never blocks `ml-dash login`.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+export const DEFAULT_API_URL = "https://api.dash.ml";
+export class Config {
+    configDir;
+    configPath;
+    data;
+    constructor(configDir) {
+        this.configDir = configDir ?? process.env.ML_DASH_CONFIG_DIR ?? path.join(homedir(), ".dash");
+        this.configPath = path.join(this.configDir, "config.json");
+        this.data = this.load();
+    }
+    load() {
+        if (!existsSync(this.configPath))
+            return {};
+        try {
+            const parsed = JSON.parse(readFileSync(this.configPath, "utf8"));
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    save() {
+        mkdirSync(this.configDir, { recursive: true });
+        writeFileSync(this.configPath, JSON.stringify(this.data, null, 2));
+    }
+    get(key, fallback) {
+        return this.data[key] ?? fallback;
+    }
+    set(key, value) {
+        this.data[key] = value;
+        this.save();
+    }
+    delete(key) {
+        if (key in this.data) {
+            delete this.data[key];
+            this.save();
+        }
+    }
+    get remoteUrl() {
+        return this.get("remote_url", DEFAULT_API_URL);
+    }
+    get apiKey() {
+        return this.get("api_key", undefined);
+    }
+    get batchSize() {
+        return this.get("default_batch_size", 100);
+    }
+    get authUrl() {
+        return this.get("auth_url", undefined);
+    }
+    get deviceSecret() {
+        return this.get("device_secret", undefined);
+    }
+}

package/dist/index.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * ml-dash CLI entry point.
+ *
+ * Commands are dispatched by name and their modules are imported lazily, so
+ * `ml-dash version` does not pay for the GraphQL client or the QR encoder.
+ */
+import { ParseError, parseArgs, renderCommandHelp, renderRootHelp, usageError } from "./cli/parser.js";
+import { red, yellow } from "./util/ansi.js";
+const loaders = {
+    version: () => import("./commands/version.js"),
+    login: () => import("./commands/login.js"),
+    logout: () => import("./commands/logout.js"),
+    profile: () => import("./commands/profile.js"),
+    api: () => import("./commands/api.js"),
+    create: () => import("./commands/create.js"),
+    remove: () => import("./commands/remove.js"),
+    list: () => import("./commands/list.js"),
+    upload: () => import("./commands/upload.js"),
+    download: () => import("./commands/download.js"),
+};
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    if (!command || command === "--help" || command === "-h" || command === "help") {
+        const specs = await Promise.all(Object.values(loaders).map(async (l) => (await l()).spec));
+        console.log(renderRootHelp(specs, Object.keys(loaders)));
+        return 0;
+    }
+    if (command === "--version" || command === "-V") {
+        return (await loaders.version()).run({});
+    }
+    const loader = loaders[command];
+    if (!loader) {
+        console.error(`${red("error:")} unknown command '${command}'`);
+        console.error(`\nAvailable commands: ${Object.keys(loaders).join(", ")}`);
+        return 2;
+    }
+    const mod = await loader();
+    let args;
+    try {
+        args = parseArgs(mod.spec, rest);
+    }
+    catch (e) {
+        if (e instanceof ParseError) {
+            console.error(usageError(command, e.message));
+            return 2;
+        }
+        throw e;
+    }
+    if (args.help) {
+        console.log(renderCommandHelp(mod.spec));
+        return 0;
+    }
+    return mod.run(args);
+}
+const isEntryPoint = 
+// `import.meta.main` is set by Bun (including a compiled binary); Node needs
+// the argv comparison, and the npm shim imports this module rather than
+// running it directly, so neither check alone covers both channels.
+import.meta.main === true ||
+    process.argv[1] === undefined ||
+    /ml-dash(\.js)?$|index\.ts$|index\.js$/.test(process.argv[1]);
+if (isEntryPoint) {
+    main(process.argv.slice(2))
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch((e) => {
+        console.error(`${red("✗ Unexpected error:")} ${e instanceof Error ? e.message : String(e)}`);
+        if (process.env.ML_DASH_DEBUG === "1" && e instanceof Error)
+            console.error(yellow(e.stack ?? ""));
+        process.exitCode = 1;
+    });
+}

package/dist/local/safe-path.js

@@ -0,0 +1,137 @@
+/**
+ * Where a write is allowed to land.
+ *
+ * `download` claims it only ever writes into the `.dash` tree the user named
+ * and into its own scratch directory. Every path component that decides where
+ * a write goes — an experiment prefix, a metric name, a file's `pPath` and its
+ * filename — is server-supplied metadata, so a hostile or broken server could
+ * otherwise put `..` (or `C:`, or a backslash) in one of them and walk the
+ * write out of the tree.
+ *
+ * Two properties this file is responsible for, both learned from a review of
+ * the first version:
+ *
+ *  1. **One root, and it is the `.dash` root the user chose.** A check
+ *     anchored at a derived directory — `…/metrics`, `…/files` — trusts that
+ *     directory to be inside the tree, which is exactly what is in question
+ *     when `files` is itself a link to somewhere else. Every target is built
+ *     and checked from `rootPath` down, in one pass, including the literal
+ *     components (`files`, `data.jsonl`, `.files_metadata.json`), which can be
+ *     links too.
+ *  2. **Every component, not just the ones that exist.** Resolving the deepest
+ *     *existing* ancestor with realpath misses a dangling symlink — realpath
+ *     fails on it, which reads as "not there yet" — and misses a link at the
+ *     leaf. Write targets are walked component by component with `lstat`,
+ *     which sees a link whether or not it points at anything.
+ *
+ * The rule is reject, not repair: a component that would leave the root raises
+ * `UnsafePathError` and fails its section, rather than being rewritten into
+ * some other path that quietly stores the data in the wrong place. Legal
+ * nesting — `owner/project/folder/exp`, `train/loss`, `checkpoints/epoch-3` —
+ * still passes.
+ */
+import { lstatSync } from "node:fs";
+import path from "node:path";
+export class UnsafePathError extends Error {
+    constructor(label, value, reason) {
+        super(`unsafe ${label} ${JSON.stringify(value)}: ${reason}`);
+        this.name = "UnsafePathError";
+    }
+}
+const WINDOWS_DRIVE = /^[A-Za-z]:/;
+/** Rules every component shares, whatever its shape. */
+function checkComponent(label, value) {
+    if (typeof value !== "string") {
+        throw new UnsafePathError(label, String(value), "is not a string");
+    }
+    if (value.includes("\0")) {
+        throw new UnsafePathError(label, value, "contains a NUL byte");
+    }
+    if (value.includes("\\")) {
+        // A backslash is a separator on Windows and a legal filename character on
+        // POSIX; accepting it would make the same metadata escape on one platform
+        // and not the other.
+        throw new UnsafePathError(label, value, "contains a backslash separator");
+    }
+    if (WINDOWS_DRIVE.test(value)) {
+        throw new UnsafePathError(label, value, "names a Windows drive");
+    }
+    if (value.startsWith("/") || path.isAbsolute(value)) {
+        throw new UnsafePathError(label, value, "is an absolute path");
+    }
+}
+/** One path segment: a filename, or a directory name that may not nest. */
+export function safeSegment(label, value) {
+    checkComponent(label, value);
+    if (value === "")
+        throw new UnsafePathError(label, value, "is empty");
+    if (value.includes("/")) {
+        throw new UnsafePathError(label, value, "must be a single path segment");
+    }
+    if (value === "." || value === "..") {
+        throw new UnsafePathError(label, value, "is a relative path component");
+    }
+    return value;
+}
+/** A relative path that may nest: `owner/project/exp`, `train/loss`. */
+export function safeRelativeSegments(label, value) {
+    checkComponent(label, value);
+    const segments = value.split("/");
+    for (const segment of segments) {
+        if (segment === "." || segment === "..") {
+            throw new UnsafePathError(label, value, `contains a '${segment}' segment`);
+        }
+    }
+    const kept = segments.filter((s) => s !== "");
+    if (kept.length === 0)
+        throw new UnsafePathError(label, value, "is empty");
+    return kept;
+}
+/** A literal component this code chose, not the server: `files`, `logs.jsonl`. */
+export const literal = (value) => ({ label: "path component", value });
+const contains = (root, target) => {
+    const rel = path.relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+};
+/**
+ * Build a path under `root` from its parts, or throw.
+ *
+ * `mode: "write"` additionally refuses a target any part of which is a symlink
+ * — dangling or not — because a link inside the tree redirects the write out
+ * of it, and because following one to delete or overwrite would destroy a file
+ * that is not ours. `mode: "read"` keeps the lexical rules only, so a user who
+ * has symlinked their own metric data can still upload it.
+ */
+export function resolveUnderRoot(root, parts, mode = "write") {
+    const segments = [];
+    for (const part of parts) {
+        if (part.nested)
+            segments.push(...safeRelativeSegments(part.label, part.value));
+        else
+            segments.push(safeSegment(part.label, part.value));
+    }
+    const rootAbs = path.resolve(root);
+    const target = path.resolve(rootAbs, ...segments);
+    if (!contains(rootAbs, target)) {
+        throw new UnsafePathError(parts.map((p) => p.value).join("/"), target, "resolves outside the root");
+    }
+    if (mode === "write") {
+        let current = rootAbs;
+        for (const segment of segments) {
+            current = path.join(current, segment);
+            let stats;
+            try {
+                stats = lstatSync(current);
+            }
+            catch {
+                // Does not exist: nothing here to redirect the write, and nothing
+                // below it can exist either.
+                break;
+            }
+            if (stats.isSymbolicLink()) {
+                throw new UnsafePathError(parts.map((p) => p.value).join("/"), current, "is reached through a symbolic link inside the root");
+            }
+        }
+    }
+    return target;
+}