@dreamlake/dreamlake-cli 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,97 @@
+// `dreamlake` CLI entry. Wires Commander to subcommand modules. Mirrors
+// the command surface of dreamlake-py's `dreamlake.cli` (the data-warehouse
+// CLI), implemented in lakeshore's TypeScript conventions.
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import { authFilePath, BUILTIN_ENVS } from "./auth/credentials.js";
+import { runLogin, runLogout, runProfile, runEnvList, runEnvUse, runEnvRemove, } from "./auth/commands.js";
+import { registerUploadCommand } from "./upload/index.js";
+import { registerDownloadCommand } from "./download/index.js";
+import { registerListCommand } from "./list/index.js";
+import { registerCreateCommand } from "./create/index.js";
+import { registerUpdateCommand } from "./update/index.js";
+import { registerDeleteCommand } from "./delete/index.js";
+import { registerOrgCommand } from "./org/index.js";
+import { registerTeamCommand } from "./team/index.js";
+import { registerPipelineCommand } from "./pipeline/index.js";
+// Resolves to the package root from both src/cli/ (dev) and dist/cli/ (published).
+const { version } = createRequire(import.meta.url)("../../package.json");
+async function main(argv) {
+    const program = new Command();
+    program
+        .name("dreamlake")
+        .description("DreamLake CLI — upload/download assets and manage episodes, bindrs, and datasets.")
+        .version(version)
+        .showHelpAfterError();
+    // ─── auth ────────────────────────────────────────────────────────
+    //
+    // Credentials are stored at `$XDG_CONFIG_HOME/dreamlake/auth.yml`
+    // (default `~/.config/dreamlake/auth.yml`) with chmod 600.
+    program
+        .command("login")
+        .description(`authenticate with DreamLake (built-in envs: ${Object.keys(BUILTIN_ENVS).join(", ")})`)
+        .option("--env <name>", "environment to log into (built-in or custom; default: active, else staging)")
+        .option("--url <url>", "DreamLake server URL (for a custom env, or to override)")
+        .option("--bss <url>", "BSS server URL (for a custom env, or to override)")
+        .option("--auth <url>", "vuer-auth server URL (must match what the target server trusts)")
+        .option("--no-browser", "don't open the browser automatically")
+        .option("--token <jwt>", "save a token directly instead of the device flow")
+        .action(async (opts) => {
+        const rc = await runLogin({
+            env: opts.env,
+            url: opts.url,
+            bss: opts.bss,
+            auth: opts.auth,
+            noBrowser: opts.browser === false,
+            token: opts.token,
+        });
+        process.exit(rc);
+    });
+    program
+        .command("logout")
+        .description("log out of the active environment (removes its saved token)")
+        .action(async () => {
+        process.exit(await runLogout());
+    });
+    program
+        .command("profile")
+        .description("show the current authenticated user")
+        .option("--url <url>", "override the saved server URL")
+        .action(async (opts) => {
+        process.exit(await runProfile({ url: opts.url }));
+    });
+    // ─── env (switch between logged-in environments) ─────────────────
+    const env = program
+        .command("env")
+        .description(`switch between environments (saved at ${authFilePath()})`);
+    env
+        .command("list")
+        .description("list logged-in environments (* = active)")
+        .option("--json", "emit JSON")
+        .action(async (opts) => process.exit(await runEnvList(opts)));
+    env
+        .command("use")
+        .description("switch the active environment")
+        .argument("<name>", "environment name")
+        .action(async (name) => process.exit(await runEnvUse(name)));
+    env
+        .command("remove")
+        .description("remove a saved environment")
+        .argument("<name>", "environment name")
+        .action(async (name) => process.exit(await runEnvRemove(name)));
+    // ─── data-warehouse commands ─────────────────────────────────────
+    registerUploadCommand(program);
+    registerDownloadCommand(program);
+    registerListCommand(program);
+    registerCreateCommand(program);
+    registerUpdateCommand(program);
+    registerDeleteCommand(program);
+    registerOrgCommand(program);
+    registerTeamCommand(program);
+    registerPipelineCommand(program);
+    await program.parseAsync(argv);
+}
+main(process.argv).catch((err) => {
+    process.stderr.write(`${err.stack ?? err}\n`);
+    process.exit(1);
+});

package/dist/cli/list/index.js

@@ -0,0 +1,254 @@
+// `dreamlake list ...` — assets (default), bindrs, datasets, episodes.
+// Port of dreamlake-py's cli/commands/list.py. Where the Python CLI used
+// an interactive 20-per-page pager, we fetch all pages and render one
+// table (more script-friendly); `--json` emits raw JSON.
+import { resolveNamespace, resolveRemote, resolveToken } from "../config.js";
+import { emitJson, fail, humanSize, renderTable } from "../helpers.js";
+import { fetchAllContents, fetchAllEpisodes, fetchAllPages, fetchProjects, nodePathToCommaPrefix, relPathUnder, resolveProjectCtx, } from "../resources.js";
+import { formatProject, formatTarget, parseTarget } from "../target.js";
+export async function runListAssets(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;
+    }
+    t.namespace = namespace;
+    // Resolve the container node (episode root, or project root when the
+    // target has no episode), then list its files via /nodes/:id/contents.
+    let containerId;
+    let containerPrefix;
+    try {
+        if (t.episode) {
+            const episodes = await fetchAllEpisodes(remote, t.namespace, t.project, token);
+            const ep = episodes.find((e) => e.name === t.episode);
+            if (!ep) {
+                fail(`episode '${t.episode}' not found in ${t.project}@${t.namespace}`);
+                return 1;
+            }
+            containerId = ep.id;
+            containerPrefix = nodePathToCommaPrefix(ep.nodePath ?? `/${t.project}/${t.episode}`);
+        }
+        else {
+            const projects = await fetchProjects(remote, token, t.namespace);
+            const proj = projects.find((p) => p.slug === t.project);
+            if (!proj) {
+                fail(`project '${t.project}' not found in namespace ${t.namespace}`);
+                return 1;
+            }
+            containerId = proj.id;
+            containerPrefix = `,${t.project},`;
+        }
+        const files = await fetchAllContents(remote, token, containerId, opts.type);
+        let rows = files.map((f) => ({
+            path: relPathUnder(f, containerPrefix),
+            kind: f.kind,
+            size: f.metadata?.size != null ? humanSize(f.metadata.size) : "—",
+            created: String(f.createdAt ?? "").slice(0, 10),
+        }));
+        if (opts.prefix) {
+            const want = opts.prefix.replace(/^\/+/, "");
+            rows = rows.filter((r) => r.path.startsWith(want));
+        }
+        if (opts.json) {
+            emitJson(rows);
+            return 0;
+        }
+        process.stdout.write(`Listing ${opts.type ?? "all"} assets in ${formatTarget(t)}\n\n`);
+        if (rows.length === 0) {
+            process.stdout.write("  (no assets found)\n");
+            return 0;
+        }
+        process.stdout.write(renderTable(rows, ["path", "kind", "size", "created"]));
+        process.stdout.write(`\n  ${rows.length} asset(s)\n`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── projects ────────────────────────────────────────────────────────
+export async function runListProjects(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);
+    if (opts.json) {
+        emitJson(projects);
+        return 0;
+    }
+    process.stdout.write(`Listing projects in namespace ${namespace}\n\n`);
+    const rows = projects.map((p) => ({
+        slug: p.slug,
+        name: p.name ?? "",
+        visibility: p.visibility ?? "",
+        bindrs: p.bindrCount ?? 0,
+        datasets: p.datasetCount ?? 0,
+        created: String(p.createdAt ?? "").slice(0, 10),
+    }));
+    process.stdout.write(renderTable(rows, ["slug", "name", "visibility", "bindrs", "datasets", "created"]));
+    process.stdout.write(`\n  ${projects.length} project(s)\n`);
+    return 0;
+}
+// ─── bindrs / datasets / episodes ────────────────────────────────────
+export async function runListBindrs(opts) {
+    if (!opts.project) {
+        fail("--project is required for listing bindrs");
+        return 1;
+    }
+    const ctx = await resolveProjectCtx(opts.project);
+    if (!ctx)
+        return 1;
+    const { s, token, remote } = ctx;
+    const result = await fetchAllPages(remote, `/namespaces/${s.namespace}/projects/${s.project}/bindrs`, token, "bindrs");
+    if (result === "not-found") {
+        process.stdout.write("  (project not found)\n");
+        return 0;
+    }
+    if (opts.json) {
+        emitJson(result.items);
+        return 0;
+    }
+    process.stdout.write(`Listing bindrs in ${formatProject(s)}\n\n`);
+    const rows = result.items.map((d) => ({
+        name: String(d.name ?? ""),
+        files: Array.isArray(d.members) ? d.members.length : 0,
+        tags: Array.isArray(d.tags) ? d.tags.join(", ") : "",
+        description: String(d.description ?? "").slice(0, 40),
+        created: String(d.createdAt ?? "").slice(0, 10),
+    }));
+    process.stdout.write(renderTable(rows, ["name", "files", "tags", "description", "created"]));
+    process.stdout.write(`\n  ${result.total} bindr(s)\n`);
+    return 0;
+}
+export async function runListDatasets(opts) {
+    if (!opts.project) {
+        fail("--project is required for listing datasets");
+        return 1;
+    }
+    const ctx = await resolveProjectCtx(opts.project);
+    if (!ctx)
+        return 1;
+    const { s, token, remote } = ctx;
+    const result = await fetchAllPages(remote, `/namespaces/${s.namespace}/projects/${s.project}/datasets`, token, "datasets");
+    if (result === "not-found") {
+        process.stdout.write("  (project not found)\n");
+        return 0;
+    }
+    if (opts.json) {
+        emitJson(result.items);
+        return 0;
+    }
+    process.stdout.write(`Listing datasets in ${formatProject(s)}\n\n`);
+    const rows = result.items.map((d) => ({
+        name: String(d.name ?? ""),
+        bindrs: Array.isArray(d.bindrs) ? d.bindrs.length : 0,
+        tags: Array.isArray(d.tags) ? d.tags.join(", ") : "",
+        description: String(d.description ?? "").slice(0, 40),
+        created: String(d.createdAt ?? "").slice(0, 10),
+    }));
+    process.stdout.write(renderTable(rows, ["name", "bindrs", "tags", "description", "created"]));
+    process.stdout.write(`\n  ${result.total} dataset(s)\n`);
+    return 0;
+}
+export async function runListEpisodes(opts) {
+    if (!opts.project) {
+        fail("--project is required for listing episodes");
+        return 1;
+    }
+    const ctx = await resolveProjectCtx(opts.project);
+    if (!ctx)
+        return 1;
+    const { s, token, remote } = ctx;
+    const result = await fetchAllPages(remote, `/namespaces/${s.namespace}/projects/${s.project}/episodes`, token, "episodes");
+    if (result === "not-found") {
+        process.stdout.write("  (project not found)\n");
+        return 0;
+    }
+    if (opts.json) {
+        emitJson(result.items);
+        return 0;
+    }
+    process.stdout.write(`Listing episodes in ${formatProject(s)}\n\n`);
+    const rows = result.items.map((ep) => ({
+        name: String(ep.name ?? ""),
+        path: String(ep.nodePath ?? ""),
+        status: String(ep.status ?? ""),
+        tags: Array.isArray(ep.tags) ? ep.tags.join(", ") : "",
+        created: String(ep.createdAt ?? "").slice(0, 10),
+    }));
+    process.stdout.write(renderTable(rows, ["name", "path", "status", "tags", "created"]));
+    process.stdout.write(`\n  ${result.total} episode(s)\n`);
+    return 0;
+}
+// ─── registration ────────────────────────────────────────────────────
+export function registerListCommand(program) {
+    const list = program
+        .command("list")
+        .description("list assets (default), or projects / bindrs / datasets / episodes")
+        .option("--episode <target>", "episode scope: space[@namespace][:episode]")
+        .option("--prefix <path>", "filter assets by path prefix")
+        .option("--type <category>", "filter assets by category")
+        .option("--json", "emit JSON instead of a table")
+        .action(async (opts) => {
+        process.exit(await runListAssets(opts));
+    });
+    list
+        .command("project")
+        .description("list projects in a namespace")
+        .option("--namespace <slug>", "namespace (default: your own)")
+        .option("--json", "emit JSON instead of a table")
+        .action(async (opts) => {
+        process.exit(await runListProjects(opts));
+    });
+    list
+        .command("bindr")
+        .description("list bindrs in a project")
+        .requiredOption("--project <target>", "project scope: space[@namespace]")
+        .option("--json", "emit JSON instead of a table")
+        .action(async (opts) => {
+        process.exit(await runListBindrs(opts));
+    });
+    list
+        .command("dataset")
+        .description("list datasets in a project")
+        .requiredOption("--project <target>", "project scope: space[@namespace]")
+        .option("--json", "emit JSON instead of a table")
+        .action(async (opts) => {
+        process.exit(await runListDatasets(opts));
+    });
+    list
+        .command("episode")
+        .description("list episodes in a project")
+        .requiredOption("--project <target>", "project scope: space[@namespace]")
+        .option("--json", "emit JSON instead of a table")
+        .action(async (opts) => {
+        process.exit(await runListEpisodes(opts));
+    });
+}