windmill-cli 0.0.1

package/esm/types.d.ts

@@ -0,0 +1,31 @@
+export interface DifferenceCreate {
+    type: "CREATE";
+    path: (string | number)[];
+    value: any;
+}
+export interface DifferenceRemove {
+    type: "REMOVE";
+    path: (string | number)[];
+    oldValue: any;
+}
+export interface DifferenceChange {
+    type: "CHANGE";
+    path: (string | number)[];
+    value: any;
+    oldValue: any;
+}
+export type Difference = DifferenceCreate | DifferenceRemove | DifferenceChange;
+export type GlobalOptions = {
+    workspace: string | undefined;
+    token: string | undefined;
+};
+export declare function isSuperset(subset: Record<string, any>, superset: Record<string, any>): boolean;
+export declare function showDiff(local: string, remote: string): void;
+export declare function showConflict(path: string, local: string, remote: string): void;
+export declare function pushObj(workspace: string, p: string, befObj: any, newObj: any, plainSecrets: boolean, message?: string): Promise<void>;
+export declare function parseFromPath(p: string, content: string): any;
+export declare function parseFromFile(p: string): any;
+export declare function getTypeStrFromPath(p: string): "script" | "variable" | "flow" | "resource" | "resource-type" | "folder" | "app" | "schedule" | "user" | "group" | "settings" | "encryption_key";
+export declare function removeType(str: string, type: string): string;
+export declare function removePathPrefix(str: string, prefix: string): string;
+//# sourceMappingURL=types.d.ts.map

package/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC1B,KAAK,EAAE,GAAG,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC1B,QAAQ,EAAE,GAAG,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC1B,KAAK,EAAE,GAAG,CAAC;IACX,QAAQ,EAAE,GAAG,CAAC;CACf;AAED,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,CAAC;AAEhF,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AAEF,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC5B,OAAO,CAkBT;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QA0BrD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAKvE;AAED,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,EACjB,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,GAAG,EACX,YAAY,EAAE,OAAO,EACrB,OAAO,CAAC,EAAE,MAAM,iBAiCjB;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAM7D;AACD,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAQ5C;AACD,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,MAAM,GAEP,QAAQ,GACR,UAAU,GACV,MAAM,GACN,UAAU,GACV,eAAe,GACf,QAAQ,GACR,KAAK,GACL,UAAU,GACV,MAAM,GACN,OAAO,GACP,UAAU,GACV,gBAAgB,CA2CnB;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAQnD;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAK3D"}

package/esm/types.js

@@ -0,0 +1,179 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "./_dnt.shims.js";
+import { SEP, colors, log, path, yamlParse, yamlStringify } from "./deps.js";
+import { pushApp } from "./apps.js";
+import { pushFolder } from "./folder.js";
+import { pushFlow } from "./flow.js";
+import { pushResource } from "./resource.js";
+import { pushResourceType } from "./resource-type.js";
+import { pushVariable } from "./variable.js";
+import * as Diff from "diff";
+import { yamlOptions } from "./sync.js";
+import { showDiffs } from "./main.js";
+import { deepEqual } from "./utils.js";
+import { pushSchedule } from "./schedule.js";
+import { pushWorkspaceUser } from "./user.js";
+import { pushGroup } from "./user.js";
+import { pushWorkspaceSettings, pushWorkspaceKey } from "./settings.js";
+export function isSuperset(subset, superset) {
+    return Object.keys(subset).every((key) => {
+        const eq = deepEqual(subset[key], superset[key]);
+        if (!eq && showDiffs) {
+            const sub = subset[key];
+            const supers = superset[key];
+            if (!supers) {
+                log.info(`Key ${key} not found in remote`);
+            }
+            else {
+                log.info(`Found diff for ${key}:`);
+                showDiff(yamlStringify(sub, yamlOptions), yamlStringify(supers, yamlOptions));
+            }
+        }
+        return eq;
+    });
+}
+export function showDiff(local, remote) {
+    let finalString = "";
+    if (local?.length > 20000 || remote?.length > 20000) {
+        log.info("Diff too large to display");
+        return;
+    }
+    for (const part of Diff.diffLines(local, remote)) {
+        if (part.removed) {
+            // print red if removed without newline
+            finalString += `\x1b[31m${part.value}\x1b[0m`;
+        }
+        else if (part.added) {
+            // print green if added
+            finalString += `\x1b[32m${part.value}\x1b[0m`;
+        }
+        else {
+            let lines = part.value.split("\n");
+            if (lines.length > 4) {
+                lines = lines.slice(0, 2);
+                lines.push("...");
+                lines = lines.concat(part.value.split("\n").slice(-2));
+            }
+            // print white if unchanged
+            finalString += `\x1b[37m${lines.join("\n")}\x1b[0m`;
+        }
+    }
+    log.info(finalString);
+}
+export function showConflict(path, local, remote) {
+    log.info(colors.yellow(`- ${path}`));
+    showDiff(local, remote);
+    log.info("\x1b[31mlocal\x1b[31m - \x1b[32mremote\x1b[32m");
+    log.info("\n");
+}
+export async function pushObj(workspace, p, befObj, newObj, plainSecrets, message) {
+    const typeEnding = getTypeStrFromPath(p);
+    if (typeEnding === "app") {
+        const appName = p.split(".app" + SEP)[0];
+        await pushApp(workspace, appName, appName + ".app", message);
+    }
+    else if (typeEnding === "folder") {
+        await pushFolder(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "variable") {
+        await pushVariable(workspace, p, befObj, newObj, plainSecrets);
+    }
+    else if (typeEnding === "flow") {
+        const flowName = p.split(".flow" + SEP)[0];
+        await pushFlow(workspace, flowName, flowName + ".flow", message);
+    }
+    else if (typeEnding === "resource") {
+        await pushResource(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "resource-type") {
+        await pushResourceType(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "schedule") {
+        await pushSchedule(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "user") {
+        await pushWorkspaceUser(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "group") {
+        await pushGroup(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "settings") {
+        await pushWorkspaceSettings(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "encryption_key") {
+        await pushWorkspaceKey(workspace, p, befObj, newObj);
+    }
+    else {
+        throw new Error(`The item ${p} has an unrecognized type ending ${typeEnding}`);
+    }
+}
+export function parseFromPath(p, content) {
+    return p.endsWith(".yaml")
+        ? yamlParse(content)
+        : p.endsWith(".json")
+            ? JSON.parse(content)
+            : content;
+}
+export function parseFromFile(p) {
+    if (p.endsWith(".json")) {
+        return JSON.parse(dntShim.Deno.readTextFileSync(p));
+    }
+    else if (p.endsWith(".yaml") || p.endsWith(".yml")) {
+        return yamlParse(dntShim.Deno.readTextFileSync(p));
+    }
+    else {
+        throw new Error("Could not read file " + p);
+    }
+}
+export function getTypeStrFromPath(p) {
+    if (p.includes(".flow" + SEP)) {
+        return "flow";
+    }
+    if (p.includes(".app" + SEP)) {
+        return "app";
+    }
+    const parsed = path.parse(p);
+    if (parsed.ext == ".go" ||
+        parsed.ext == ".ts" ||
+        parsed.ext == ".sh" ||
+        parsed.ext == ".py" ||
+        parsed.ext == ".sql" ||
+        parsed.ext == ".gql" ||
+        parsed.ext == ".ps1" ||
+        parsed.ext == ".js" ||
+        parsed.ext == ".php") {
+        return "script";
+    }
+    if (parsed.name === "folder.meta") {
+        return "folder";
+    }
+    const typeEnding = parsed.name.split(".").at(-1);
+    if (typeEnding === "script" ||
+        typeEnding === "variable" ||
+        typeEnding === "resource" ||
+        typeEnding === "resource-type" ||
+        typeEnding === "app" ||
+        typeEnding === "schedule" ||
+        typeEnding === "user" ||
+        typeEnding === "group" ||
+        typeEnding === "settings" ||
+        typeEnding === "encryption_key") {
+        return typeEnding;
+    }
+    else {
+        throw new Error("Could not infer type of path " + JSON.stringify(parsed));
+    }
+}
+export function removeType(str, type) {
+    if (!str.endsWith("." + type + ".yaml") &&
+        !str.endsWith("." + type + ".json")) {
+        throw new Error(str + " does not end with ." + type + ".(yaml|json)");
+    }
+    return str.slice(0, str.length - type.length - 6);
+}
+export function removePathPrefix(str, prefix) {
+    if (!str.startsWith(prefix + "/")) {
+        throw new Error(str + " does not start with " + prefix);
+    }
+    return str.slice(prefix.length + 1);
+}

package/esm/user.d.ts

@@ -0,0 +1,30 @@
+import { Command } from "./deps.js";
+interface SimplifiedUser {
+    role: string;
+    username: string;
+    disabled: boolean;
+}
+export declare function pushWorkspaceUser(workspace: string, path: string, user: SimplifiedUser | undefined, localUser: SimplifiedUser): Promise<void>;
+interface SimplifiedGroup {
+    summary: string | undefined;
+    admins: string[];
+    members: string[];
+}
+export declare function pushGroup(workspace: string, path: string, group: SimplifiedGroup | undefined, localGroup: SimplifiedGroup): Promise<void>;
+export declare function pullInstanceUsers(preview?: boolean): Promise<number | undefined>;
+export declare function pushInstanceUsers(preview?: boolean): Promise<number | undefined>;
+export declare function pullInstanceGroups(preview?: boolean): Promise<number | undefined>;
+export declare function pushInstanceGroups(preview?: boolean): Promise<number | undefined>;
+declare const command: Command<void, void, {
+    email?: import("./deps/jsr.io/@cliffy/command/1.0.0-rc.5/mod.js").StringType | undefined;
+} & {
+    password?: import("./deps/jsr.io/@cliffy/command/1.0.0-rc.5/mod.js").StringType | undefined;
+}, [], void, void, void, Command<void, void, void, [], void, {
+    number: number;
+    integer: number;
+    string: string;
+    boolean: boolean;
+    file: string;
+}, void, undefined>>;
+export default command;
+//# sourceMappingURL=user.d.ts.map

package/esm/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../src/user.ts"],"names":[],"mappings":"AAWA,OAAO,EAEL,OAAO,EAWR,MAAM,WAAW,CAAC;AA2FnB,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,cAAc,GAAG,SAAS,EAChC,SAAS,EAAE,cAAc,GACxB,OAAO,CAAC,IAAI,CAAC,CA0Ef;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,wBAAsB,SAAS,CAC7B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,eAAe,GAAG,SAAS,EAClC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,IAAI,CAAC,CA2Kf;AAED,wBAAsB,iBAAiB,CAAC,OAAO,GAAE,OAAe,+BAkB/D;AAED,wBAAsB,iBAAiB,CAAC,OAAO,GAAE,OAAe,+BAgB/D;AAED,wBAAsB,kBAAkB,CAAC,OAAO,UAAQ,+BAoBvD;AAED,wBAAsB,kBAAkB,CAAC,OAAO,GAAE,OAAe,+BAgBhE;AAED,QAAA,MAAM,OAAO;;;;;;;;;;oBA8BgB,CAAC;AAE9B,eAAe,OAAO,CAAC"}

package/esm/user.js

@@ -0,0 +1,396 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "./_dnt.shims.js";
+import { requireLogin } from "./context.js";
+import { isSuperset, removeType, removePathPrefix, } from "./types.js";
+import { compareInstanceObjects } from "./instance.js";
+import { colors, Command, log, Table, UserService, GroupService, WorkspaceService, GranularAclService, yamlStringify, yamlParse, } from "./deps.js";
+import { SettingService } from "./deps.js";
+async function list(opts) {
+    await requireLogin(opts);
+    const perPage = 10;
+    let page = 0;
+    const total = [];
+    while (true) {
+        const res = await UserService.listUsersAsSuperAdmin({ page, perPage });
+        total.push(...res);
+        page += 1;
+        if (res.length < perPage) {
+            break;
+        }
+    }
+    new Table()
+        .header(["email", "name", "company", "verified", "super admin"])
+        .padding(2)
+        .border(true)
+        .body(total.map((x) => [
+        x.email,
+        x.name ?? "-",
+        x.company ?? "-",
+        x.verified ? "true" : "false",
+        x.super_admin ? "true" : "false",
+    ]))
+        .render();
+}
+function rdString() {
+    return Math.random().toString(36).slice(2, 7);
+}
+async function add(opts, email, password) {
+    await requireLogin(opts);
+    const password_final = password ?? rdString();
+    await UserService.createUserGlobally({
+        requestBody: {
+            email,
+            password: password_final,
+            super_admin: opts.superadmin ?? false,
+            company: opts.company,
+            name: opts.name,
+        },
+    });
+    if (!password) {
+        log.info(colors.red("New Password: " + password_final));
+    }
+    log.info(colors.underline.green("New User Created."));
+}
+async function remove(opts, email) {
+    await requireLogin(opts);
+    await UserService.globalUserDelete({ email });
+    log.info(colors.green("Deleted User " + email));
+}
+async function createToken(opts) {
+    if (opts.email && opts.password) {
+        log.info("Token: " +
+            (await UserService.login({
+                requestBody: {
+                    email: opts.email,
+                    password: opts.password,
+                },
+            })));
+    }
+    await requireLogin(opts);
+    log.info("Token: " + (await UserService.createToken({ requestBody: {} })));
+}
+export async function pushWorkspaceUser(workspace, path, user, localUser) {
+    const email = removePathPrefix(removeType(path, "user"), "users");
+    log.debug(`Processing local user ${email}`);
+    if (!["operator", "developer", "admin"].includes(localUser.role)) {
+        throw new Error(`Invalid role for user ${email}: ${localUser.role}`);
+    }
+    try {
+        const remoteUser = await UserService.getUser({
+            workspace,
+            username: localUser.username,
+        });
+        user = {
+            role: remoteUser.is_admin
+                ? "admin"
+                : remoteUser.operator
+                    ? "operator"
+                    : "developer",
+            username: remoteUser.username,
+            disabled: remoteUser.disabled,
+        };
+        log.debug(`User ${email} exists on remote`);
+    }
+    catch {
+        log.debug(`User ${email} does not exist on remote`);
+        //ignore
+    }
+    if (user && user.username !== localUser.username) {
+        throw new Error("Username cannot be changed");
+    }
+    if (user) {
+        if (isSuperset(localUser, user)) {
+            log.debug(`User ${email} is up to date`);
+            return;
+        }
+        log.debug(`User ${email} is not up-to-date, updating...`);
+        try {
+            await UserService.updateUser({
+                workspace: workspace,
+                username: localUser.username,
+                requestBody: {
+                    is_admin: localUser.role === "admin",
+                    operator: localUser.role === "operator",
+                    disabled: localUser.disabled,
+                },
+            });
+        }
+        catch (e) {
+            console.error(e.body);
+            throw e;
+        }
+    }
+    else {
+        console.log(colors.bold.yellow("Creating new user: " + email));
+        try {
+            const automatedUsernameCreation = (await SettingService.getGlobal({
+                key: "automate_username_creation",
+            }));
+            await WorkspaceService.addUser({
+                workspace: workspace,
+                requestBody: {
+                    email: email,
+                    is_admin: localUser.role === "admin",
+                    operator: localUser.role === "operator",
+                    username: !automatedUsernameCreation ? localUser.username : undefined,
+                },
+            });
+        }
+        catch (e) {
+            console.error(e.body);
+            throw e;
+        }
+    }
+}
+export async function pushGroup(workspace, path, group, localGroup) {
+    const name = removePathPrefix(removeType(path, "group"), "groups");
+    log.debug(`Processing local group ${name}`);
+    try {
+        const remoteGroup = await GroupService.getGroup({
+            workspace,
+            name,
+        });
+        // only consider extra_perms that concern actual members of the group
+        const admins = Object.entries(remoteGroup.extra_perms ?? {})
+            .filter(([k, v]) => v && remoteGroup.members?.includes(k.slice(2)))
+            .map(([k, _]) => k)
+            .sort();
+        group = {
+            summary: remoteGroup.summary,
+            admins,
+            // remove members that are also admins as they are already in the admins list
+            members: (remoteGroup.members ?? [])
+                .map((m) => "u/" + m)
+                .filter((m) => !admins.includes(m)),
+        };
+        log.debug(`Group ${name} exists on remote`);
+    }
+    catch {
+        log.debug(`Group ${name} does not exist on remote`);
+        //ignore
+    }
+    if (group) {
+        if (isSuperset(localGroup, group)) {
+            log.debug(`Group ${name} is up to date`);
+            return;
+        }
+        log.debug(`Group ${name} is not up-to-date, updating...`);
+        try {
+            await GroupService.updateGroup({
+                workspace: workspace,
+                name,
+                requestBody: {
+                    summary: localGroup.summary,
+                },
+            });
+        }
+        catch (e) {
+            console.error(e.body);
+            throw e;
+        }
+        for (const member of [...localGroup.members, ...localGroup.admins]) {
+            try {
+                if ([...group.members, ...group.admins].includes(member)) {
+                    log.debug(`${member} is already in group ${name}`);
+                }
+                else {
+                    log.debug(`Adding ${member} to group ${name}`);
+                    await GroupService.addUserToGroup({
+                        workspace: workspace,
+                        name,
+                        requestBody: {
+                            username: member.slice(2),
+                        },
+                    });
+                }
+                if (localGroup.admins.includes(member) &&
+                    !group.admins.includes(member)) {
+                    log.debug(`Setting role of ${member} as admin in group ${name}`);
+                    await GranularAclService.addGranularAcls({
+                        workspace: workspace,
+                        kind: "group_",
+                        path: name,
+                        requestBody: {
+                            owner: member,
+                            write: true,
+                        },
+                    });
+                }
+                if (localGroup.members.includes(member) &&
+                    !group.members.includes(member)) {
+                    log.debug(`Setting role of ${member} as member in group ${name}`);
+                    await GranularAclService.addGranularAcls({
+                        workspace: workspace,
+                        kind: "group_",
+                        path: name,
+                        requestBody: {
+                            owner: member,
+                            write: false,
+                        },
+                    });
+                }
+            }
+            catch (e) {
+                console.error(e.body);
+                throw e;
+            }
+        }
+        for (const member of [...group.members, ...group.admins]) {
+            if (![...localGroup.members, ...localGroup.admins].includes(member)) {
+                log.debug(`Removing ${member} and any associated role from group ${name}`);
+                try {
+                    await GroupService.removeUserToGroup({
+                        workspace: workspace,
+                        name,
+                        requestBody: {
+                            username: member.slice(2),
+                        },
+                    });
+                    await GranularAclService.removeGranularAcls({
+                        workspace: workspace,
+                        kind: "group_",
+                        path: name,
+                        requestBody: {
+                            owner: member,
+                        },
+                    });
+                }
+                catch (e) {
+                    console.error(e.body);
+                    throw e;
+                }
+            }
+        }
+    }
+    else {
+        console.log(colors.bold.yellow("Creating new user: " + name));
+        try {
+            await GroupService.createGroup({
+                workspace: workspace,
+                requestBody: {
+                    name,
+                    summary: localGroup.summary,
+                },
+            });
+            for (const member of [...localGroup.members, ...localGroup.admins]) {
+                log.debug(`Adding user ${member} to group ${name}`);
+                try {
+                    await GroupService.addUserToGroup({
+                        workspace: workspace,
+                        name,
+                        requestBody: {
+                            username: member.slice(2),
+                        },
+                    });
+                    if (localGroup.admins.includes(member)) {
+                        log.debug(`Setting role of ${member} as admin in group ${name}`);
+                        await GranularAclService.addGranularAcls({
+                            workspace: workspace,
+                            kind: "group_",
+                            path: name,
+                            requestBody: {
+                                owner: member,
+                                write: true,
+                            },
+                        });
+                    }
+                }
+                catch (e) {
+                    console.error(e.body);
+                    throw e;
+                }
+            }
+        }
+        catch (e) {
+            console.error(e.body);
+            throw e;
+        }
+    }
+}
+export async function pullInstanceUsers(preview = false) {
+    const remoteUsers = await UserService.globalUsersExport();
+    if (preview) {
+        let localUsers = [];
+        try {
+            const raw = await dntShim.Deno.readTextFile("instance_users.yaml");
+            localUsers = yamlParse(raw);
+        }
+        catch { }
+        return compareInstanceObjects(remoteUsers, localUsers, "email", "user");
+    }
+    else {
+        log.info("Pulling users from instance...");
+        await dntShim.Deno.writeTextFile("instance_users.yaml", yamlStringify(remoteUsers));
+        log.info(colors.green("Users written to instance_users.yaml"));
+    }
+}
+export async function pushInstanceUsers(preview = false) {
+    const remoteUsers = await UserService.globalUsersExport();
+    const localUsers = (await dntShim.Deno.readTextFile("instance_users.yaml")
+        .then((raw) => yamlParse(raw))
+        .catch(() => []));
+    if (preview) {
+        return compareInstanceObjects(localUsers, remoteUsers, "email", "user");
+    }
+    else {
+        log.info("Pushing users to instance...");
+        await UserService.globalUsersOverwrite({
+            requestBody: localUsers,
+        });
+        log.info(colors.green("Users pushed to the instance"));
+    }
+}
+export async function pullInstanceGroups(preview = false) {
+    const remoteGroups = await GroupService.exportInstanceGroups();
+    if (preview) {
+        let localGroups = [];
+        try {
+            const raw = await dntShim.Deno.readTextFile("instance_groups.yaml");
+            localGroups = yamlParse(raw);
+        }
+        catch { }
+        return compareInstanceObjects(remoteGroups, localGroups, "name", "group");
+    }
+    else {
+        log.info("Pulling groups from instance...");
+        await dntShim.Deno.writeTextFile("instance_groups.yaml", yamlStringify(remoteGroups));
+        log.info(colors.green("Groups written to instance_groups.yaml"));
+    }
+}
+export async function pushInstanceGroups(preview = false) {
+    const remoteGroups = await GroupService.exportInstanceGroups();
+    const localGroups = (await dntShim.Deno.readTextFile("instance_groups.yaml")
+        .then((raw) => yamlParse(raw))
+        .catch(() => []));
+    if (preview) {
+        return compareInstanceObjects(localGroups, remoteGroups, "name", "group");
+    }
+    else {
+        log.info("Pushing groups to instance...");
+        await GroupService.overwriteInstanceGroups({
+            requestBody: localGroups,
+        });
+        log.info(colors.green("Groups pushed to the instance"));
+    }
+}
+const command = new Command()
+    .description("user related commands")
+    .action(list)
+    .command("add", "Create a user")
+    .arguments("<email:string> [password:string]")
+    .option("--superadmin", "Specify to make the new user superadmin.")
+    .option("--company <company:string>", "Specify to set the company of the new user.")
+    .option("--name <name:string>", "Specify to set the name of the new user.")
+    .action(add)
+    .command("remove", "Delete a user")
+    .arguments("<email:string>")
+    .action(remove)
+    .command("create-token")
+    .option("--email <email:string>", "Specify credentials to use for authentication. This will not be stored. It will only be used to exchange for a token with the API server, which will not be stored either.", {
+    depends: ["password"],
+})
+    .option("--password <password:string>", "Specify credentials to use for authentication. This will not be stored. It will only be used to exchange for a token with the API server, which will not be stored either.", {
+    depends: ["email"],
+})
+    .action(createToken);
+export default command;

package/esm/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function deepEqual<T>(a: T, b: T): boolean;
+export declare function getHeaders(): Record<string, string> | undefined;
+export declare function digestDir(path: string, conf: string): Promise<string>;
+export declare function generateHash(content: string): Promise<string>;
+export declare function generateHashFromBuffer(content: BufferSource): Promise<string>;
+export declare function readInlinePathSync(path: string): string;
+export declare function sleep(ms: number): Promise<unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/esm/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAQA,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAwEhD;AAED,wBAAgB,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAa/D;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,mBAWzD;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGnE;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,MAAM,CAAC,CAGjB;AAMD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAE/B"}