@dreamlake/dreamlake-cli 0.1.0

package/dist/cli/delete/index.js

@@ -0,0 +1,228 @@
+// `dreamlake delete bindr|dataset <name> --project <target> [--yes]`.
+// Port of dreamlake-py's cli/commands/delete.py.
+import { HttpError, requestJson } from "../client.js";
+import { resolveNamespace, resolveRemote, resolveToken } from "../config.js";
+import { fail, ok } from "../helpers.js";
+import { confirm } from "../prompt.js";
+import { fetchAllEpisodes, fetchProjects, lookupNode, resolveProjectCtx, } from "../resources.js";
+import { formatProject, parseTarget } from "../target.js";
+async function runDelete(kind, name, opts) {
+    if (!opts.project) {
+        fail("--project is required");
+        return 1;
+    }
+    const ctx = await resolveProjectCtx(opts.project);
+    if (!ctx)
+        return 1;
+    const { s, token, remote } = ctx;
+    const proj = formatProject(s);
+    if (!opts.yes) {
+        const proceed = await confirm(`Delete ${kind} '${name}' from ${proj}?`, false);
+        if (!proceed) {
+            process.stdout.write("Cancelled.\n");
+            return 0;
+        }
+    }
+    const collection = kind === "bindr" ? "bindrs" : "datasets";
+    try {
+        await requestJson(remote, `/namespaces/${s.namespace}/projects/${s.project}/${collection}/${name}`, { method: "DELETE", token });
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`${kind} '${name}' not found in ${proj}`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+    ok(`Deleted ${kind}: ${name} from ${proj}`);
+    return 0;
+}
+export const runDeleteBindr = (name, opts) => runDelete("bindr", name, opts);
+export const runDeleteDataset = (name, opts) => runDelete("dataset", name, opts);
+// ─── node deletions (DELETE /nodes/:id — hard-deletes the subtree) ───
+async function deleteNodeById(remote, token, nodeId) {
+    const res = await requestJson(remote, `/nodes/${nodeId}`, {
+        method: "DELETE",
+        token,
+    });
+    return res.deleted ?? 1;
+}
+export async function runDeleteProject(slug, opts) {
+    const remote = resolveRemote();
+    const token = resolveToken();
+    if (!token) {
+        fail("not authenticated. run 'dreamlake login' first");
+        return 1;
+    }
+    const namespace = await resolveNamespace(opts.namespace, { token, remote });
+    if (!namespace) {
+        fail("namespace not specified and no authenticated user found. run 'dreamlake login'");
+        return 1;
+    }
+    const projects = await fetchProjects(remote, token, namespace);
+    const proj = projects.find((p) => p.slug === slug);
+    if (!proj) {
+        fail(`project '${slug}' not found in namespace ${namespace}`);
+        return 1;
+    }
+    if (!opts.yes) {
+        const proceed = await confirm(`HARD-DELETE project '${slug}' (${namespace}) and EVERYTHING inside it (episodes, files, S3 objects)?`, false);
+        if (!proceed) {
+            process.stdout.write("Cancelled.\n");
+            return 0;
+        }
+    }
+    try {
+        const deleted = await deleteNodeById(remote, token, proj.id);
+        ok(`Deleted project: ${slug} (${deleted} node(s) removed)`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runDeleteEpisode(name, opts) {
+    if (!opts.project) {
+        fail("--project is required");
+        return 1;
+    }
+    const ctx = await resolveProjectCtx(opts.project);
+    if (!ctx)
+        return 1;
+    const { s, token, remote } = ctx;
+    const proj = formatProject(s);
+    const episodes = await fetchAllEpisodes(remote, s.namespace, s.project, token);
+    const ep = episodes.find((e) => e.name === name);
+    if (!ep) {
+        fail(`episode '${name}' not found in ${proj}`);
+        return 1;
+    }
+    if (!opts.yes) {
+        const proceed = await confirm(`HARD-DELETE episode '${name}' from ${proj} and all files inside it?`, false);
+        if (!proceed) {
+            process.stdout.write("Cancelled.\n");
+            return 0;
+        }
+    }
+    try {
+        const deleted = await deleteNodeById(remote, token, ep.id);
+        ok(`Deleted episode: ${name} from ${proj} (${deleted} node(s) removed)`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runDeleteFile(filePath, opts) {
+    if (!opts.episode) {
+        fail("--episode is required");
+        return 1;
+    }
+    let t;
+    try {
+        t = parseTarget(opts.episode);
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+    const remote = resolveRemote();
+    const token = resolveToken();
+    if (!token) {
+        fail("not authenticated. run 'dreamlake login' first");
+        return 1;
+    }
+    const namespace = await resolveNamespace(t.namespace, { token, remote });
+    if (!namespace) {
+        fail("namespace not specified and no authenticated user found. run 'dreamlake login'");
+        return 1;
+    }
+    const assetPath = "/" + filePath.replace(/^\/+/, "");
+    let node;
+    try {
+        node = await lookupNode(remote, token, {
+            namespace,
+            project: t.project,
+            path: assetPath,
+            episode: t.episode,
+        });
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`nothing found at ${assetPath}`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+    if (!opts.yes) {
+        const what = node.kind === "folder" ? `folder '${assetPath}' and everything inside it` : `${node.kind} '${assetPath}'`;
+        const proceed = await confirm(`HARD-DELETE ${what}?`, false);
+        if (!proceed) {
+            process.stdout.write("Cancelled.\n");
+            return 0;
+        }
+    }
+    try {
+        const deleted = await deleteNodeById(remote, token, node.id);
+        ok(`Deleted: ${assetPath} (${deleted} node(s) removed)`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export function registerDeleteCommand(program) {
+    const del = program
+        .command("delete")
+        .description("delete a project, episode, file, bindr, or dataset");
+    del
+        .command("project")
+        .description("HARD-delete a project and its entire subtree (episodes, files, S3)")
+        .argument("<slug>", "project slug")
+        .option("--namespace <slug>", "namespace (default: your own)")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (slug, opts) => {
+        process.exit(await runDeleteProject(slug, opts));
+    });
+    del
+        .command("episode")
+        .description("HARD-delete an episode and all files inside it")
+        .argument("<name>", "episode name")
+        .requiredOption("--project <target>", "project scope: space[@namespace]")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (name, opts) => {
+        process.exit(await runDeleteEpisode(name, opts));
+    });
+    del
+        .command("file")
+        .description("HARD-delete a file (or folder, recursively) inside an episode")
+        .argument("<path>", "path within the episode, e.g. /camera/front/clip.mp4")
+        .requiredOption("--episode <target>", "episode scope: space[@namespace][:episode]")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (p, opts) => {
+        process.exit(await runDeleteFile(p, opts));
+    });
+    del
+        .command("bindr")
+        .description("delete a bindr")
+        .argument("<name>", "bindr name")
+        .requiredOption("--project <target>", "project scope: space[@namespace]")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (name, opts) => {
+        process.exit(await runDeleteBindr(name, opts));
+    });
+    del
+        .command("dataset")
+        .description("delete a dataset")
+        .argument("<name>", "dataset name")
+        .requiredOption("--project <target>", "project scope: space[@namespace]")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (name, opts) => {
+        process.exit(await runDeleteDataset(name, opts));
+    });
+}

package/dist/cli/download/index.js

@@ -0,0 +1,128 @@
+// `dreamlake download --episode <target> --from <path> [-o <out>]`.
+//
+// Node-based download (the current server protocol):
+//   GET /nodes/lookup?namespace&project&path&episode  → node record
+//   leaf      → GET /nodes/:id/download → presigned URL → stream to disk
+//   container → GET /nodes/:id/contents → download every file, preserving
+//               the relative tree under the output directory
+//
+// (The old /assets/video/download route this command originally ported from
+// dreamlake-py's CLI no longer exists server-side; any kind downloads now.)
+import { createWriteStream, mkdirSync } from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { HttpError, requestJson, requestRaw } from "../client.js";
+import { resolveNamespace, resolveRemote, resolveToken } from "../config.js";
+import { fail, ok } from "../helpers.js";
+import { BytesProgress } from "../progress.js";
+import { fetchAllContents, lookupNode, relPathUnder, } from "../resources.js";
+import { formatTarget, parseTarget } from "../target.js";
+const CONTAINER_KINDS = new Set(["folder", "episode", "project"]);
+async function downloadNodeToFile(remote, token, nodeId, dest) {
+    const presigned = await requestJson(remote, `/nodes/${nodeId}/download`, { token });
+    const res = await requestRaw(presigned.url, {});
+    const total = Number(res.headers.get("content-length") ?? 0);
+    const progress = new BytesProgress(total);
+    const body = res.body;
+    if (!body)
+        throw new Error("empty response body");
+    mkdirSync(path.dirname(path.resolve(dest)), { recursive: true });
+    const nodeStream = Readable.fromWeb(body);
+    nodeStream.on("data", (chunk) => progress.advance(chunk.length));
+    await pipeline(nodeStream, createWriteStream(dest));
+    progress.finish();
+}
+export async function runDownload(opts) {
+    if (!opts.episode) {
+        fail("--episode is required");
+        return 1;
+    }
+    if (!opts.from) {
+        fail("--from is required");
+        return 1;
+    }
+    let t;
+    try {
+        t = parseTarget(opts.episode);
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+    const remote = resolveRemote();
+    const token = resolveToken();
+    if (!token) {
+        fail("not authenticated. run 'dreamlake login' first");
+        return 1;
+    }
+    const namespace = await resolveNamespace(t.namespace, { token, remote });
+    if (!namespace) {
+        fail("namespace not specified and no authenticated user found. run 'dreamlake login'");
+        return 1;
+    }
+    t.namespace = namespace;
+    const assetPath = "/" + opts.from.replace(/^\/+/, "");
+    process.stdout.write(`Downloading ${assetPath}\n`);
+    process.stdout.write(`  episode: ${formatTarget(t)}\n`);
+    // Resolve the node.
+    let node;
+    try {
+        node = await lookupNode(remote, token, {
+            namespace: t.namespace,
+            project: t.project,
+            path: assetPath,
+            episode: t.episode,
+        });
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`asset not found at ${assetPath}`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+    try {
+        // ── Single file ─────────────────────────────────────────────────
+        if (!CONTAINER_KINDS.has(node.kind)) {
+            const output = opts.output ?? path.basename(assetPath);
+            process.stdout.write(`  output:  ${output}\n`);
+            await downloadNodeToFile(remote, token, node.id, output);
+            ok(`Downloaded: ${output}`);
+            return 0;
+        }
+        // ── Container (folder / episode / project) — recursive ──────────
+        const outDir = opts.output ?? node.name;
+        const prefix = `${node.path ?? ""}${node.name},`;
+        const files = await fetchAllContents(remote, token, node.id);
+        if (files.length === 0) {
+            process.stdout.write(`  (no files under ${node.kind} '${node.name}')\n`);
+            return 0;
+        }
+        process.stdout.write(`  output:  ${outDir}/ (${files.length} file(s) from ${node.kind} '${node.name}')\n`);
+        for (const f of files) {
+            const rel = relPathUnder(f, prefix);
+            const dest = path.join(outDir, rel);
+            process.stdout.write(`  → ${rel}\n`);
+            await downloadNodeToFile(remote, token, f.id, dest);
+        }
+        ok(`Downloaded: ${outDir} (${files.length} files)`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export function registerDownloadCommand(program) {
+    program
+        .command("download")
+        .description("download a file (or a whole folder/episode, recursively) from DreamLake")
+        .requiredOption("--episode <target>", "episode scope: space[@namespace][:episode]")
+        .requiredOption("--from <path>", "source path within the episode (file or folder)")
+        .option("-o, --output <path>", "output file/directory (default: derived from --from)")
+        .action(async (opts) => {
+        process.exit(await runDownload(opts));
+    });
+}

package/dist/cli/glob.js

@@ -0,0 +1,45 @@
+// Minimal fnmatch-style glob matching — zero-dependency replacement for
+// Python's `fnmatch.fnmatch`, which dreamlake-py uses to match episodes
+// by node path and bindrs by name.
+//
+// Supports `*` (any run), `?` (single char), and `[seq]` / `[!seq]`
+// character classes. Case-sensitive (POSIX fnmatch semantics).
+function translate(pattern) {
+    let re = "";
+    let i = 0;
+    while (i < pattern.length) {
+        const c = pattern[i++];
+        if (c === "*") {
+            re += ".*";
+        }
+        else if (c === "?") {
+            re += ".";
+        }
+        else if (c === "[") {
+            let j = i;
+            if (pattern[j] === "!")
+                j++;
+            if (pattern[j] === "]")
+                j++;
+            while (j < pattern.length && pattern[j] !== "]")
+                j++;
+            if (j >= pattern.length) {
+                re += "\\[";
+            }
+            else {
+                let stuff = pattern.slice(i, j).replace(/\\/g, "\\\\");
+                i = j + 1;
+                if (stuff.startsWith("!"))
+                    stuff = "^" + stuff.slice(1);
+                re += `[${stuff}]`;
+            }
+        }
+        else {
+            re += c.replace(/[.+^${}()|\\]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+export function matchGlob(name, pattern) {
+    return translate(pattern).test(name);
+}

package/dist/cli/graphql-helpers.js

@@ -0,0 +1,42 @@
+// Shared GraphQL resolution helpers for org/team commands: turn the
+// slugs / emails users type into the ids the GraphQL API wants.
+import { gql } from "./graphql.js";
+/** Resolve an org slug to {id,name}, or null if not found. */
+export async function resolveOrg(slug) {
+    const data = await gql(`query($slug:String!){ organizationBySlug(slug:$slug){ id name } }`, { slug });
+    return data.organizationBySlug;
+}
+/**
+ * Resolve a user reference (email or name) to a userId via the global
+ * searchUsers query. Exact email match wins; multiple matches → error
+ * listing them; zero → error.
+ */
+export async function resolveUserId(ref) {
+    const data = await gql(`query($kw:String!){ searchUsers(keyword:$kw, limit:10){ id name email } }`, { kw: ref });
+    const users = data.searchUsers ?? [];
+    if (users.length === 0)
+        throw new Error(`no user matches '${ref}'`);
+    const exact = users.filter((u) => u.email?.toLowerCase() === ref.toLowerCase());
+    if (exact.length === 1)
+        return exact[0].id;
+    if (users.length > 1) {
+        const list = users.map((u) => `    ${u.email ?? "?"} (${u.name ?? "?"})`).join("\n");
+        throw new Error(`'${ref}' is ambiguous — ${users.length} matches. Use an exact email:\n${list}`);
+    }
+    return users[0].id;
+}
+/**
+ * Resolve (orgSlug, teamSlug) → team. Team slugs are unique only within an
+ * org, and the API has no teamBySlug query, so we list the org's teams and
+ * match by slug. Returns null if either the org or the team is not found.
+ */
+export async function resolveTeam(orgSlug, teamSlug) {
+    const org = await resolveOrg(orgSlug);
+    if (!org)
+        return null;
+    const data = await gql(`query($orgId:ID!){ organizationTeams(orgId:$orgId){ id slug name } }`, { orgId: org.id });
+    const team = (data.organizationTeams ?? []).find((t) => t.slug === teamSlug);
+    if (!team)
+        return null;
+    return { id: team.id, slug: team.slug, name: team.name, orgId: org.id };
+}

package/dist/cli/graphql.js

@@ -0,0 +1,47 @@
+// Minimal GraphQL client. Organization/team operations live on the
+// dreamlake-server GraphQL endpoint (POST {server}/graphql) rather than
+// the REST routes the rest of the CLI uses — same bearer token, same host.
+import { resolveRemote, resolveToken } from "./config.js";
+export class GraphQLClientError extends Error {
+}
+/**
+ * Run a GraphQL query/mutation against {server}/graphql with the saved
+ * token. Throws GraphQLClientError on transport errors or a non-empty
+ * `errors` array (messages joined). Returns the `data` payload.
+ */
+export async function gql(query, variables = {}, opts = {}) {
+    const token = resolveToken();
+    if (!token) {
+        throw new GraphQLClientError("not authenticated. run 'dreamlake login' first");
+    }
+    const remote = resolveRemote();
+    let res;
+    try {
+        res = await fetch(`${remote}/graphql`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ query, variables }),
+            signal: AbortSignal.timeout(opts.timeoutMs ?? 30000),
+        });
+    }
+    catch (err) {
+        throw new GraphQLClientError(`request failed: ${err.message}`);
+    }
+    let body;
+    try {
+        body = (await res.json());
+    }
+    catch {
+        throw new GraphQLClientError(`(${res.status}) non-JSON response`);
+    }
+    if (body.errors && body.errors.length > 0) {
+        throw new GraphQLClientError(body.errors.map((e) => e.message).join("; "));
+    }
+    if (!res.ok) {
+        throw new GraphQLClientError(`(${res.status}) request failed`);
+    }
+    return body.data;
+}

package/dist/cli/helpers.js

@@ -0,0 +1,106 @@
+// Small shared helpers for the dreamlake CLI subcommands. Adapted from
+// lakeshore/src/cli/helpers.ts — zero dependencies beyond `yaml` (already
+// a dep for the auth file). Keep this file presentation-only: glyphs,
+// table rendering, JSON emit, CSV/tag parsing.
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+// ─── ✓ / ✗ / ⚠ glyph wrappers ────────────────────────────────────────
+export function ok(line) {
+    process.stdout.write(`✓ ${line}\n`);
+}
+export function warn(line) {
+    process.stdout.write(`⚠ ${line}\n`);
+}
+export function fail(line) {
+    process.stderr.write(`✗ ${line}\n`);
+}
+// ─── splitCsv — comma-separated values → trimmed non-empty list ──────
+//
+// Used for `--tags a,b,c` and `--bindr name1,name2`. Mirrors the Python
+// CLI's `[t.strip() for t in s.split(",") if t.strip()]`.
+export function splitCsv(raw) {
+    if (!raw)
+        return [];
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+// ─── renderTable ─────────────────────────────────────────────────────
+//
+// Minimal monospaced table renderer. Columns are exactly the `cols`
+// names; each row may have arbitrary keys (others are ignored).
+// Returns the rendered string (caller prints).
+export function renderTable(rows, cols) {
+    if (rows.length === 0) {
+        return "(none)\n";
+    }
+    const stringRows = rows.map((r) => cols.map((c) => stringifyCell(r[c])));
+    const widths = cols.map((c, i) => Math.max(c.length, ...stringRows.map((r) => r[i].length)));
+    const lines = [];
+    // Header.
+    lines.push(cols
+        .map((c, i) => c.padEnd(widths[i]))
+        .join("  ")
+        .trimEnd());
+    // Body.
+    for (const r of stringRows) {
+        lines.push(r.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd());
+    }
+    return lines.join("\n") + "\n";
+}
+function stringifyCell(v) {
+    if (v == null)
+        return "—";
+    if (typeof v === "string")
+        return v;
+    if (typeof v === "number" || typeof v === "boolean")
+        return String(v);
+    if (Array.isArray(v))
+        return v.map(stringifyCell).join(", ");
+    return JSON.stringify(v);
+}
+// ─── emitJson — for `--json` / `--json-output` flags ─────────────────
+//
+// Single canonical JSON emitter. 2-space indent, trailing newline.
+export function emitJson(value) {
+    process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+// ─── loadStructuredFile — YAML or JSON ───────────────────────────────
+export function loadStructuredFile(filePath) {
+    const resolved = path.resolve(filePath);
+    if (!existsSync(resolved)) {
+        throw new Error(`file not found: ${resolved}`);
+    }
+    const text = readFileSync(resolved, "utf8");
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            throw new Error("expected an object at top level");
+        }
+        catch (err) {
+            throw new Error(`failed to parse JSON ${resolved}: ${err.message}`);
+        }
+    }
+    try {
+        const parsed = YAML.parse(text);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        throw new Error("expected an object at top level");
+    }
+    catch (err) {
+        throw new Error(`failed to parse YAML ${resolved}: ${err.message}`);
+    }
+}
+// ─── humanSize — bytes → "1.5 MB" / "12.3 KB" ───────────────────────
+export function humanSize(bytes) {
+    if (bytes > 1024 * 1024)
+        return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+    return `${(bytes / 1024).toFixed(1)} KB`;
+}