@dreamlake/dreamlake-cli 0.1.0

package/dist/cli/resources.js

@@ -0,0 +1,134 @@
+// Shared helpers for project-scoped resource commands (list / create /
+// update / delete of bindrs and datasets). Centralizes project-context
+// resolution, paginated fetches, and glob matching.
+import { HttpError, requestJson } from "./client.js";
+import { resolveNamespace, resolveRemote, resolveToken } from "./config.js";
+import { fail } from "./helpers.js";
+import { matchGlob } from "./glob.js";
+import { parseProject } from "./target.js";
+/** Resolve project + namespace + token, printing the standard errors on failure. */
+export async function resolveProjectCtx(projectStr) {
+    let s;
+    try {
+        s = parseProject(projectStr);
+    }
+    catch (err) {
+        fail(err.message);
+        return null;
+    }
+    const remote = resolveRemote();
+    const token = resolveToken();
+    if (!token) {
+        fail("not authenticated. run 'dreamlake login' first");
+        return null;
+    }
+    const namespace = await resolveNamespace(s.namespace, { token, remote });
+    if (!namespace) {
+        fail("namespace not specified and no authenticated user found. run 'dreamlake login'");
+        return null;
+    }
+    s.namespace = namespace;
+    return { s, token, remote };
+}
+const PAGE_SIZE = 200;
+/** Fetch every page of a `/...?page&pageSize` collection. Returns "not-found" on 404. */
+export async function fetchAllPages(remote, path, token, key) {
+    const items = [];
+    let page = 1;
+    let total = 0;
+    for (;;) {
+        let data;
+        try {
+            data = await requestJson(remote, path, {
+                token,
+                query: { page: String(page), pageSize: String(PAGE_SIZE) },
+            });
+        }
+        catch (err) {
+            if (err instanceof HttpError && err.status === 404)
+                return "not-found";
+            throw err;
+        }
+        const batch = data[key] ?? [];
+        items.push(...batch);
+        total = Number(data.total ?? items.length);
+        const totalPages = Number(data.totalPages ?? 1);
+        if (page >= totalPages || batch.length === 0)
+            break;
+        page++;
+    }
+    return { items, total };
+}
+/** Fetch all episodes in a project (throws on error). */
+export async function fetchAllEpisodes(remote, namespace, project, token) {
+    const r = await fetchAllPages(remote, `/namespaces/${namespace}/projects/${project}/episodes`, token, "episodes");
+    return r === "not-found" ? [] : r.items;
+}
+/** Fetch all bindrs in a project (throws on error). */
+export async function fetchAllBindrs(remote, namespace, project, token) {
+    const r = await fetchAllPages(remote, `/namespaces/${namespace}/projects/${project}/bindrs`, token, "bindrs");
+    return r === "not-found" ? [] : r.items;
+}
+/** Match episodes by glob against their name OR node path (leading "/" stripped). */
+export function matchEpisodes(episodes, pattern) {
+    const pat = pattern.replace(/^\/+/, "");
+    return episodes.filter((ep) => matchGlob(ep.name ?? "", pat) ||
+        matchGlob((ep.nodePath ?? "").replace(/^\/+/, ""), pat));
+}
+/** Match bindrs by glob against their name. */
+export function matchBindrs(bindrs, pattern) {
+    return bindrs.filter((b) => matchGlob(b.name ?? "", pattern));
+}
+/** Fetch all projects in a namespace. */
+export async function fetchProjects(remote, token, namespace) {
+    const data = await requestJson(remote, `/namespaces/${namespace}/projects`, { token });
+    return data.projects ?? [];
+}
+/** "/a/b" → ",a,b," (comma prefix used by node paths). */
+export function nodePathToCommaPrefix(nodePath) {
+    const segs = nodePath.split("/").filter(Boolean);
+    return `,${segs.join(",")},`;
+}
+/** Relative display path of a file under a container's comma prefix. */
+export function relPathUnder(file, containerCommaPrefix) {
+    const p = file.path ?? "";
+    let segs = [];
+    if (p.startsWith(containerCommaPrefix)) {
+        segs = p.slice(containerCommaPrefix.length).split(",").filter(Boolean);
+    }
+    return [...segs, file.name].join("/");
+}
+/** Resolve a node by namespace+project+path (+episode) via /nodes/lookup. */
+export async function lookupNode(remote, token, q) {
+    return requestJson(remote, "/nodes/lookup", {
+        token,
+        query: {
+            namespace: q.namespace,
+            project: q.project,
+            path: q.path,
+            episode: q.episode ?? undefined,
+        },
+    });
+}
+/**
+ * Fetch every file under a container node via GET /nodes/:id/contents
+ * (paginated; ?kind= filters). NOTE: /nodes/:id/descendants exists but its
+ * response schema strips the node list on the deployed server — use this.
+ */
+export async function fetchAllContents(remote, token, nodeId, kind) {
+    const files = [];
+    let page = 1;
+    for (;;) {
+        const data = await requestJson(remote, `/nodes/${nodeId}/contents`, {
+            token,
+            query: { page, pageSize: 500, kind: kind ?? undefined },
+        });
+        const batch = data.files ?? [];
+        files.push(...batch);
+        const pageCount = Number(data.filePageCount ?? 1);
+        if (page >= pageCount || batch.length === 0)
+            break;
+        page++;
+    }
+    return files;
+}

package/dist/cli/target.js

@@ -0,0 +1,85 @@
+// Target syntax parser — TypeScript port of dreamlake-py's cli/_target.py.
+//
+// Syntax: space[@namespace][:episode][//path]
+//
+//   robotics@alice:run-042       → project=robotics, namespace=alice, episode=run-042
+//   robotics:run-042             → namespace resolved from current user's token
+//   robotics@alice               → no episode → project-level
+//   robotics                     → minimal — namespace from token, no episode
+//
+// The `--project` flag uses the shorter space[@namespace] form.
+//
+// NOTE: the Python original (cli/_target.py) has variable-name bugs
+// (`space`/`project`/`nameproject` mixed up). This is the corrected
+// implementation following the documented intent.
+/** Parse a target string: space[@namespace][:episode][//path]. */
+export function parseTarget(target) {
+    let rest = target;
+    let path = null;
+    let episode = null;
+    let namespace = null;
+    // Split off path (everything after //).
+    const slashIdx = rest.indexOf("//");
+    if (slashIdx >= 0) {
+        path = rest.slice(slashIdx + 2).replace(/^\/+|\/+$/g, "") || null;
+        rest = rest.slice(0, slashIdx);
+    }
+    // Split off episode (everything after the first :).
+    const colonIdx = rest.indexOf(":");
+    let base;
+    if (colonIdx >= 0) {
+        base = rest.slice(0, colonIdx);
+        episode = rest.slice(colonIdx + 1) || null;
+    }
+    else {
+        base = rest;
+    }
+    // Split off namespace (everything after @).
+    const atIdx = base.indexOf("@");
+    let project;
+    if (atIdx >= 0) {
+        project = base.slice(0, atIdx);
+        namespace = base.slice(atIdx + 1) || null;
+    }
+    else {
+        project = base;
+    }
+    if (!project) {
+        throw new Error("target must include a project name");
+    }
+    return { namespace, project, episode, path };
+}
+/** Parse a space target: space[@namespace]. */
+export function parseProject(target) {
+    const atIdx = target.indexOf("@");
+    let project;
+    let namespace = null;
+    if (atIdx >= 0) {
+        project = target.slice(0, atIdx);
+        namespace = target.slice(atIdx + 1) || null;
+    }
+    else {
+        project = target;
+    }
+    if (!project) {
+        throw new Error("target must include a project name");
+    }
+    return { namespace, project };
+}
+/** Reconstruct a target string from parsed components (for display). */
+export function formatTarget(t) {
+    let parts = t.project;
+    if (t.namespace)
+        parts += `@${t.namespace}`;
+    if (t.episode)
+        parts += `:${t.episode}`;
+    if (t.path)
+        parts += `//${t.path}`;
+    return parts;
+}
+/** Reconstruct a project string for display. */
+export function formatProject(s) {
+    if (s.namespace)
+        return `${s.project}@${s.namespace}`;
+    return s.project;
+}

package/dist/cli/team/index.js

@@ -0,0 +1,411 @@
+// `dreamlake team ...` — team management within an organization.
+// GraphQL-backed (see ../graphql.ts). Teams are scoped to an org and
+// identified by (org-slug, team-slug); the CLI resolves them to ids.
+import { gql } from "../graphql.js";
+import { resolveOrg, resolveTeam, resolveUserId } from "../graphql-helpers.js";
+import { emitJson, fail, ok, renderTable } from "../helpers.js";
+import { confirm } from "../prompt.js";
+function normalizeRole(raw) {
+    if (!raw)
+        return undefined;
+    const v = raw.toLowerCase();
+    if (v === "maintainer")
+        return "MAINTAINER";
+    if (v === "member")
+        return "MEMBER";
+    throw new Error(`--role must be 'maintainer' or 'member', got '${raw}'`);
+}
+function normalizeVisibility(raw) {
+    if (!raw)
+        return undefined;
+    const v = raw.toLowerCase();
+    if (v === "visible")
+        return "VISIBLE";
+    if (v === "secret")
+        return "SECRET";
+    throw new Error(`--visibility must be 'visible' or 'secret', got '${raw}'`);
+}
+// ─── list ────────────────────────────────────────────────────────────
+export async function runTeamList(orgSlug, opts) {
+    try {
+        let teams;
+        if (orgSlug) {
+            const org = await resolveOrg(orgSlug);
+            if (!org) {
+                fail(`organization '${orgSlug}' not found`);
+                return 1;
+            }
+            const data = await gql(`query($orgId:ID!){ organizationTeams(orgId:$orgId){ slug name visibility } }`, { orgId: org.id });
+            teams = data.organizationTeams ?? [];
+        }
+        else {
+            const data = await gql(`query{ myTeams{ slug name visibility org{ slug } } }`);
+            teams = data.myTeams ?? [];
+        }
+        if (opts.json) {
+            emitJson(teams);
+            return 0;
+        }
+        process.stdout.write(orgSlug ? `Teams in ${orgSlug}\n\n` : "My teams\n\n");
+        if (teams.length === 0) {
+            process.stdout.write("  (none)\n");
+            return 0;
+        }
+        const rows = teams.map((t) => ({
+            slug: t.slug,
+            name: t.name,
+            visibility: t.visibility ?? "",
+            ...(orgSlug ? {} : { org: t.org?.slug ?? "" }),
+        }));
+        const cols = orgSlug ? ["slug", "name", "visibility"] : ["slug", "name", "visibility", "org"];
+        process.stdout.write(renderTable(rows, cols));
+        process.stdout.write(`\n  ${teams.length} team(s)\n`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── show ────────────────────────────────────────────────────────────
+export async function runTeamShow(orgSlug, teamSlug, opts) {
+    try {
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        const data = await gql(`query($id:ID!){ team(id:$id){
+         slug name description visibility myRole
+         parent{ slug name } children{ slug name }
+         members{ role user{ name email slug } }
+       } }`, { id: ref.id });
+        const team = data.team;
+        if (!team) {
+            fail(`team '${teamSlug}' not found`);
+            return 1;
+        }
+        if (opts.json) {
+            emitJson(team);
+            return 0;
+        }
+        process.stdout.write(`Team: ${team.name}  (${orgSlug}/${team.slug})\n`);
+        process.stdout.write(`  visibility: ${team.visibility ?? ""}\n`);
+        process.stdout.write(`  your role:  ${team.myRole ?? "(not a member)"}\n`);
+        if (team.description)
+            process.stdout.write(`  description: ${team.description}\n`);
+        if (team.parent)
+            process.stdout.write(`  parent:     ${team.parent.slug}\n`);
+        if (team.children?.length) {
+            process.stdout.write(`  children:   ${team.children.map((c) => c.slug).join(", ")}\n`);
+        }
+        process.stdout.write(`\n  Members (${team.members?.length ?? 0}):\n`);
+        const rows = (team.members ?? []).map((m) => ({
+            role: m.role,
+            name: m.user?.name ?? "",
+            email: m.user?.email ?? "",
+            namespace: m.user?.slug ?? "",
+        }));
+        process.stdout.write(rows.length ? renderTable(rows, ["role", "name", "email", "namespace"]) : "  (none)\n");
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── create / update / delete / leave ────────────────────────────────
+export async function runTeamCreate(orgSlug, teamSlug, opts) {
+    try {
+        const visibility = normalizeVisibility(opts.visibility);
+        const org = await resolveOrg(orgSlug);
+        if (!org) {
+            fail(`organization '${orgSlug}' not found`);
+            return 1;
+        }
+        let parentId;
+        if (opts.parent) {
+            const parent = await resolveTeam(orgSlug, opts.parent);
+            if (!parent) {
+                fail(`parent team '${opts.parent}' not found in ${orgSlug}`);
+                return 1;
+            }
+            parentId = parent.id;
+        }
+        const input = {
+            orgId: org.id,
+            slug: teamSlug,
+            name: opts.name ?? teamSlug,
+        };
+        if (opts.description)
+            input.description = opts.description;
+        if (visibility)
+            input.visibility = visibility;
+        if (parentId)
+            input.parentId = parentId;
+        await gql(`mutation($input:TeamCreateInput!){ teamCreate(input:$input){ id slug } }`, { input });
+        ok(`Created team: ${teamSlug} in ${orgSlug}`);
+        process.stdout.write(`  you are now MAINTAINER\n`);
+        if (opts.parent)
+            process.stdout.write(`  parent: ${opts.parent}\n`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runTeamUpdate(orgSlug, teamSlug, opts) {
+    try {
+        const visibility = normalizeVisibility(opts.visibility);
+        if (opts.name === undefined && opts.description === undefined && visibility === undefined) {
+            fail("nothing to update. use --name, --description, or --visibility");
+            return 1;
+        }
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        const input = {};
+        if (opts.name !== undefined)
+            input.name = opts.name;
+        if (opts.description !== undefined)
+            input.description = opts.description;
+        if (visibility !== undefined)
+            input.visibility = visibility;
+        await gql(`mutation($id:ID!,$input:TeamUpdateInput!){ teamUpdate(id:$id, input:$input){ id } }`, { id: ref.id, input });
+        ok(`Updated team: ${orgSlug}/${teamSlug}`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runTeamDelete(orgSlug, teamSlug, opts) {
+    try {
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        if (!opts.yes) {
+            const proceed = await confirm(`Delete team '${orgSlug}/${teamSlug}'? (must have no child teams)`, false);
+            if (!proceed) {
+                process.stdout.write("Cancelled.\n");
+                return 0;
+            }
+        }
+        await gql(`mutation($id:ID!){ teamDelete(id:$id) }`, { id: ref.id });
+        ok(`Deleted team: ${orgSlug}/${teamSlug}`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runTeamLeave(orgSlug, teamSlug, opts) {
+    try {
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        if (!opts.yes) {
+            const proceed = await confirm(`Leave team '${orgSlug}/${teamSlug}'?`, false);
+            if (!proceed) {
+                process.stdout.write("Cancelled.\n");
+                return 0;
+            }
+        }
+        await gql(`mutation($id:ID!){ teamMemberLeave(teamId:$id) }`, { id: ref.id });
+        ok(`Left team: ${orgSlug}/${teamSlug}`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── member subcommands ──────────────────────────────────────────────
+export async function runTeamMemberList(orgSlug, teamSlug, opts) {
+    try {
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        const data = await gql(`query($id:ID!){ teamMembers(teamId:$id){ role joinedAt user{ name email slug } } }`, { id: ref.id });
+        const members = data.teamMembers ?? [];
+        if (opts.json) {
+            emitJson(members);
+            return 0;
+        }
+        process.stdout.write(`Members of ${orgSlug}/${teamSlug}\n\n`);
+        const rows = members.map((m) => ({
+            role: m.role,
+            name: m.user?.name ?? "",
+            email: m.user?.email ?? "",
+            namespace: m.user?.slug ?? "",
+            joined: String(m.joinedAt ?? "").slice(0, 10),
+        }));
+        process.stdout.write(rows.length ? renderTable(rows, ["role", "name", "email", "namespace", "joined"]) : "  (none)\n");
+        process.stdout.write(`\n  ${members.length} member(s)\n`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runTeamMemberAdd(orgSlug, teamSlug, user, opts) {
+    try {
+        const role = normalizeRole(opts.role);
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        const userId = await resolveUserId(user);
+        await gql(`mutation($teamId:ID!,$userId:ID!,$role:TeamRole){
+         teamMemberAdd(teamId:$teamId, userId:$userId, role:$role){ id } }`, { teamId: ref.id, userId, role: role ?? null });
+        ok(`Added ${user} to ${orgSlug}/${teamSlug} as ${role ?? "MEMBER"}`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runTeamMemberRole(orgSlug, teamSlug, user, opts) {
+    try {
+        const role = normalizeRole(opts.role);
+        if (!role) {
+            fail("--role is required (maintainer|member)");
+            return 1;
+        }
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        const userId = await resolveUserId(user);
+        await gql(`mutation($teamId:ID!,$userId:ID!,$role:TeamRole!){
+         teamMemberUpdateRole(teamId:$teamId, userId:$userId, role:$role){ id } }`, { teamId: ref.id, userId, role });
+        ok(`Set ${user}'s role in ${orgSlug}/${teamSlug} to ${role}`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+export async function runTeamMemberRemove(orgSlug, teamSlug, user, opts) {
+    try {
+        const ref = await resolveTeam(orgSlug, teamSlug);
+        if (!ref) {
+            fail(`team '${teamSlug}' not found in ${orgSlug}`);
+            return 1;
+        }
+        const userId = await resolveUserId(user);
+        if (!opts.yes) {
+            const proceed = await confirm(`Remove ${user} from ${orgSlug}/${teamSlug}?`, false);
+            if (!proceed) {
+                process.stdout.write("Cancelled.\n");
+                return 0;
+            }
+        }
+        await gql(`mutation($teamId:ID!,$userId:ID!){ teamMemberRemove(teamId:$teamId, userId:$userId) }`, { teamId: ref.id, userId });
+        ok(`Removed ${user} from ${orgSlug}/${teamSlug}`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── registration ────────────────────────────────────────────────────
+export function registerTeamCommand(program) {
+    const team = program.command("team").description("manage teams within an organization");
+    team
+        .command("list")
+        .description("list teams in an org, or all teams you belong to (omit <org>)")
+        .argument("[org]", "organization slug (omit to list your own teams)")
+        .option("--json", "emit JSON")
+        .action(async (org, opts) => process.exit(await runTeamList(org, opts)));
+    team
+        .command("show")
+        .description("show a team with its members and sub-teams")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .option("--json", "emit JSON")
+        .action(async (org, t, opts) => process.exit(await runTeamShow(org, t, opts)));
+    team
+        .command("create")
+        .description("create a team in an organization (you become MAINTAINER)")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug (3-40 chars, lowercase/hyphens)")
+        .option("--name <text>", "display name (default: slug)")
+        .option("--description <text>", "description")
+        .option("--visibility <vis>", "visible|secret (default: visible)")
+        .option("--parent <team>", "parent team slug (for nesting)")
+        .action(async (org, t, opts) => process.exit(await runTeamCreate(org, t, opts)));
+    team
+        .command("update")
+        .description("update a team's name / description / visibility")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .option("--name <text>", "new display name")
+        .option("--description <text>", "new description")
+        .option("--visibility <vis>", "visible|secret")
+        .action(async (org, t, opts) => process.exit(await runTeamUpdate(org, t, opts)));
+    team
+        .command("delete")
+        .description("delete a team (must have no child teams)")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (org, t, opts) => process.exit(await runTeamDelete(org, t, opts)));
+    team
+        .command("leave")
+        .description("leave a team (last maintainer must promote someone first)")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (org, t, opts) => process.exit(await runTeamLeave(org, t, opts)));
+    // ── members ──
+    const member = team.command("member").description("manage team members");
+    member
+        .command("list")
+        .description("list members of a team")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .option("--json", "emit JSON")
+        .action(async (org, t, opts) => process.exit(await runTeamMemberList(org, t, opts)));
+    member
+        .command("add")
+        .description("add a user to a team (added to the org too if needed)")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .argument("<user>", "user email or name")
+        .option("--role <role>", "maintainer|member (default: member)")
+        .action(async (org, t, user, opts) => process.exit(await runTeamMemberAdd(org, t, user, opts)));
+    member
+        .command("role")
+        .description("change a team member's role")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .argument("<user>", "user email or name")
+        .requiredOption("--role <role>", "maintainer|member")
+        .action(async (org, t, user, opts) => process.exit(await runTeamMemberRole(org, t, user, opts)));
+    member
+        .command("remove")
+        .description("remove a member from a team")
+        .argument("<org>", "organization slug")
+        .argument("<team>", "team slug")
+        .argument("<user>", "user email or name")
+        .option("--yes", "skip the confirmation prompt")
+        .action(async (org, t, user, opts) => process.exit(await runTeamMemberRemove(org, t, user, opts)));
+}