windmill-cli 0.0.1

package/esm/folder.js

@@ -0,0 +1,97 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "./_dnt.shims.js";
+import { colors, Command, FolderService, log, SEP, Table, } from "./deps.js";
+import { requireLogin, resolveWorkspace, validatePath } from "./context.js";
+import { isSuperset, parseFromFile } from "./types.js";
+async function list(opts) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    const folders = await FolderService.listFolders({
+        workspace: workspace.workspaceId,
+    });
+    new Table()
+        .header(["Name", "Owners", "Extra Perms"])
+        .padding(2)
+        .border(true)
+        .body(folders.map((x) => [
+        x.name,
+        x.owners?.join(",") ?? "-",
+        JSON.stringify(x.extra_perms ?? {}),
+    ]))
+        .render();
+}
+export async function pushFolder(workspace, name, folder, localFolder) {
+    if (name.startsWith(SEP)) {
+        name = name.substring(1);
+    }
+    if (name.startsWith("f" + SEP)) {
+        name = name.substring(2);
+    }
+    name = name.split(SEP)[0];
+    log.debug(`Processing local folder ${name}`);
+    // deleting old app if it exists in raw mode
+    try {
+        folder = await FolderService.getFolder({ workspace, name });
+        log.debug(`Folder ${name} exists on remote`);
+    }
+    catch {
+        log.debug(`Folder ${name} does not exist on remote`);
+        //ignore
+    }
+    if (folder) {
+        if (isSuperset(localFolder, folder)) {
+            log.debug(`Folder ${name} is up to date`);
+            return;
+        }
+        log.debug(`Folder ${name} is not up-to-date, updating...`);
+        try {
+            await FolderService.updateFolder({
+                workspace: workspace,
+                name: name,
+                requestBody: {
+                    ...localFolder,
+                },
+            });
+        }
+        catch (e) {
+            console.error(e.body);
+            throw e;
+        }
+    }
+    else {
+        console.log(colors.bold.yellow("Creating new folder: " + name));
+        try {
+            await FolderService.createFolder({
+                workspace: workspace,
+                requestBody: {
+                    name: name,
+                    ...localFolder,
+                },
+            });
+        }
+        catch (e) {
+            throw Error(`Failed to create folder ${name}: ${e.body ?? e.message}`);
+        }
+    }
+}
+async function push(opts, filePath, remotePath) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    if (!validatePath(remotePath)) {
+        return;
+    }
+    const fstat = await dntShim.Deno.stat(filePath);
+    if (!fstat.isFile) {
+        throw new Error("file path must refer to a file.");
+    }
+    console.log(colors.bold.yellow("Pushing folder..."));
+    await pushFolder(workspace.workspaceId, remotePath, undefined, parseFromFile(filePath));
+    console.log(colors.bold.underline.green("Folder pushed"));
+}
+const command = new Command()
+    .description("folder related commands")
+    .action(list)
+    .command("push", "push a local folder spec. This overrides any remote versions.")
+    .arguments("<file_path:string> <remote_path:string>")
+    .action(push);
+export default command;

package/esm/hub.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "./deps.js";
+declare const command: Command<void, void, void, [], void, void, void, Command<void, void, void, [], void, {
+    number: number;
+    integer: number;
+    string: string;
+    boolean: boolean;
+    file: string;
+}, void, undefined>>;
+export default command;
+//# sourceMappingURL=hub.d.ts.map

package/esm/hub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub.d.ts","sourceRoot":"","sources":["../src/hub.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAwC,MAAM,WAAW,CAAC;AAyG1E,QAAA,MAAM,OAAO;;;;;;oBAKS,CAAC;AAEvB,eAAe,OAAO,CAAC"}

package/esm/hub.js

@@ -0,0 +1,71 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "./_dnt.shims.js";
+import { Command, ResourceService, SettingService, log } from "./deps.js";
+import { requireLogin, resolveWorkspace } from "./context.js";
+import { pushResourceType } from "./resource-type.js";
+import { deepEqual } from "./utils.js";
+async function pull(opts) {
+    const workspace = await resolveWorkspace(opts);
+    if (workspace.workspaceId !== "admins") {
+        log.info("Should only sync to admins workspace, but current is not admins.");
+        return;
+    }
+    const userInfo = await requireLogin(opts);
+    const uid = (await SettingService.getGlobal({
+        key: "uid",
+    }));
+    const hubBaseUrl = (await SettingService.getGlobal({
+        key: "hubBaseUrl",
+    })) ?? "https://hub.windmill.dev";
+    const headers = {
+        Accept: "application/json",
+        "X-email": userInfo.email,
+    };
+    if (uid) {
+        headers["X-uid"] = uid;
+    }
+    const list = await dntShim.fetch(hubBaseUrl + "/resource_types/list", {
+        headers,
+    })
+        .then((r) => r.json())
+        .then((list) => list.map((x) => dntShim.fetch(hubBaseUrl + "/resource_types/" + x.id + "/" + x.name, {
+        headers: {
+            Accept: "application/json",
+        },
+    })))
+        .then((x) => Promise.all(x))
+        .then((x) => x.map((x) => x.json().catch((e) => {
+        log.info(e);
+        return undefined;
+    })))
+        .then((x) => Promise.all(x))
+        .then((x) => x.filter((x) => x).map((x) => x.resource_type));
+    const resourceTypes = await ResourceService.listResourceType({
+        workspace: workspace.workspaceId,
+    });
+    for (const x of list) {
+        try {
+            x.schema = JSON.parse(x.schema);
+        }
+        catch (e) {
+            log.info("failed to parse schema for " + x.name);
+            continue;
+        }
+        if (resourceTypes.find((y) => y.name === x.name &&
+            typeof y.schema !== "string" &&
+            deepEqual(y.schema, x.schema) &&
+            y.description === x.description)) {
+            log.info("skipping " + x.name + " (same as current)");
+            continue;
+        }
+        log.info("syncing " + x.name);
+        await pushResourceType(workspace.workspaceId, x.name + ".resource-type.json", undefined, x);
+    }
+}
+const command = new Command()
+    .name("hub")
+    .description("Hub related commands. EXPERIMENTAL. INTERNAL USE ONLY.")
+    .command("pull")
+    .description("pull any supported definitions. EXPERIMENTAL.")
+    .action(pull);
+export default command;

package/esm/instance.d.ts

@@ -0,0 +1,39 @@
+import { Command } from "./deps.js";
+export interface Instance {
+    remote: string;
+    name: string;
+    token: string;
+    prefix: string;
+}
+export declare function allInstances(): Promise<Instance[]>;
+export declare function addInstance(): Promise<{
+    name: string;
+    remote: string;
+    token: string;
+    prefix: string;
+}>;
+type CompareObject<T extends string> = {
+    [K in T]: string;
+};
+export declare function compareInstanceObjects<T extends string>(fromObjects: CompareObject<T>[], toObjects: CompareObject<T>[], idProp: T, objectName: string): number;
+declare const command: Command<void, void, {
+    skipUsers?: true | undefined;
+} & {
+    skipSettings?: true | undefined;
+} & {
+    skipConfigs?: true | undefined;
+} & {
+    skipGroups?: true | undefined;
+} & {
+    includeWorkspaces?: true | undefined;
+} & {
+    baseUrl?: true | 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=instance.d.ts.map

package/esm/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,OAAO,EAER,MAAM,WAAW,CAAC;AA6BnB,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,YAAY,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAiBxD;AACD,wBAAsB,WAAW;;;;;GAqChC;AA4BD,KAAK,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI;KACpC,CAAC,IAAI,CAAC,GAAG,MAAM;CACjB,CAAC;AACF,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EACrD,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,EAC/B,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,EAC7B,MAAM,EAAE,CAAC,EACT,UAAU,EAAE,MAAM,UAwBnB;AAoUD,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;oBA8BiB,CAAC;AAE/B,eAAe,OAAO,CAAC"}

package/esm/instance.js

@@ -0,0 +1,384 @@
+import * as dntShim from "./_dnt.shims.js";
+import { Select, WorkspaceService, path, Confirm, yamlStringify, yamlParse, Command, setClient, } from "./deps.js";
+import { Input, colors, log } from "./deps.js";
+import { loginInteractive } from "./login.js";
+import { getRootStore } from "./store.js";
+import { push, pull } from "./sync.js";
+import { showDiff } from "./types.js";
+import { pushInstanceUsers, pullInstanceUsers, pullInstanceGroups, pushInstanceGroups, } from "./user.js";
+import { add as workspaceSetup, addWorkspace, allWorkspaces, removeWorkspace, } from "./workspace.js";
+import { pushInstanceSettings, pullInstanceSettings, pullInstanceConfigs, pushInstanceConfigs, } from "./settings.js";
+import { sleep, deepEqual } from "./utils.js";
+export async function allInstances() {
+    try {
+        const file = (await getRootStore()) + "instances.ndjson";
+        const txt = await dntShim.Deno.readTextFile(file);
+        return txt
+            .split("\n")
+            .map((line) => {
+            if (line.length <= 2) {
+                return;
+            }
+            const instance = JSON.parse(line);
+            return instance;
+        })
+            .filter(Boolean);
+    }
+    catch (_) {
+        return [];
+    }
+}
+export async function addInstance() {
+    let remote = await Input.prompt({
+        message: "Enter the remote url of this instance",
+        default: "https://app.windmill.dev/",
+    });
+    remote = new URL(remote).toString(); // add trailing slash in all cases!
+    const defaultName = new URL(remote).hostname;
+    const name = await Input.prompt({
+        message: "Enter a name for this instance",
+        default: defaultName,
+    });
+    const prefix = name.toLowerCase().replace(/[^a-z0-9]/g, "");
+    let token = undefined;
+    while (!token) {
+        token = await loginInteractive(remote);
+    }
+    await appendInstance({
+        name,
+        remote,
+        token,
+        prefix,
+    });
+    log.info(colors.green.underline(`Added instance ${name} with remote ${remote}!`));
+    return {
+        name,
+        remote,
+        token,
+        prefix,
+    };
+}
+async function appendInstance(instance) {
+    instance.remote = new URL(instance.remote).toString(); // add trailing slash in all cases!
+    await removeInstance(instance.name);
+    const file = await dntShim.Deno.open((await getRootStore()) + "instances.ndjson", {
+        append: true,
+        write: true,
+        read: true,
+        create: true,
+    });
+    await file.write(new TextEncoder().encode(JSON.stringify(instance) + "\n"));
+    file.close();
+}
+async function removeInstance(name) {
+    const orgWorkspaces = await allInstances();
+    await dntShim.Deno.writeTextFile((await getRootStore()) + "instances.ndjson", orgWorkspaces
+        .filter((x) => x.name !== name)
+        .map((x) => JSON.stringify(x))
+        .join("\n") + "\n");
+}
+export function compareInstanceObjects(fromObjects, toObjects, idProp, objectName) {
+    let changes = 0;
+    for (const toObject of toObjects) {
+        const fromMatch = fromObjects.find((u) => u[idProp] === toObject[idProp]);
+        if (!fromMatch) {
+            log.info(colors.red(`- instance ${objectName} ${toObject[idProp]}`));
+            changes += 1;
+        }
+        else if (!deepEqual(toObject, fromMatch)) {
+            log.info(colors.yellow(`~ instance ${objectName} ${toObject[idProp]}`));
+            showDiff(yamlStringify(toObject), yamlStringify(fromMatch));
+            changes += 1;
+        }
+    }
+    for (const fromObject of fromObjects) {
+        const toMatch = toObjects.find((u) => u[idProp] === fromObject[idProp]);
+        if (!toMatch) {
+            log.info(colors.green(`+ instance ${objectName} ${fromObject[idProp]}`));
+            changes += 1;
+        }
+    }
+    return changes;
+}
+async function instancePull(opts) {
+    const instances = await allInstances();
+    let instance;
+    if (instances.length < 1) {
+        instance = await addInstance();
+    }
+    else {
+        const choice = (await Select.prompt({
+            message: "Select an instance to pull from",
+            options: [
+                ...instances.map((i) => ({
+                    name: `${i.name} (${i.remote})`,
+                    value: i.name,
+                })),
+                { name: "Add new instance", value: "new" },
+            ],
+        }));
+        if (choice === "new") {
+            instance = await addInstance();
+        }
+        else {
+            instance = instances.find((i) => i.name === choice);
+        }
+    }
+    setClient(instance.token, instance.remote.slice(0, instance.remote.length - 1));
+    log.info("Pulling instance-level changes");
+    log.info(`remote (${instance.name}) -> local`);
+    let uChanges = 0;
+    if (!opts.skipUsers) {
+        uChanges = (await pullInstanceUsers(true));
+    }
+    let sChanges = 0;
+    if (!opts.skipSettings) {
+        sChanges = (await pullInstanceSettings(true));
+    }
+    let cChanges = 0;
+    if (!opts.skipConfigs) {
+        cChanges = (await pullInstanceConfigs(true));
+    }
+    let gChanges = 0;
+    if (!opts.skipGroups) {
+        gChanges = (await pullInstanceGroups(true));
+    }
+    const totalChanges = uChanges + sChanges + cChanges + gChanges;
+    if (totalChanges > 0) {
+        const confirm = await Confirm.prompt({
+            message: `Do you want to apply these ${totalChanges} instance-level changes?`,
+            default: true,
+        });
+        if (confirm) {
+            if (!opts.skipUsers && uChanges > 0) {
+                await pullInstanceUsers();
+            }
+            if (!opts.skipSettings && sChanges > 0) {
+                await pullInstanceSettings();
+            }
+            if (!opts.skipConfigs && cChanges > 0) {
+                await pullInstanceConfigs();
+            }
+            if (!opts.skipGroups && gChanges > 0) {
+                await pullInstanceGroups();
+            }
+        }
+    }
+    else {
+        log.info("No instance-level changes to apply");
+    }
+    sleep(1000);
+    if (opts.includeWorkspaces) {
+        log.info("\nPulling all workspaces");
+        const remoteWorkspaces = await WorkspaceService.listWorkspacesAsSuperAdmin({
+            page: 1,
+            perPage: 1000,
+        });
+        let localWorkspaces = await allWorkspaces();
+        localWorkspaces = localWorkspaces.filter((w) => w.name.startsWith(instance.prefix + "_"));
+        const rootDir = dntShim.Deno.cwd();
+        for (const remoteWorkspace of remoteWorkspaces) {
+            log.info("\nPulling workspace " + remoteWorkspace.id);
+            sleep(1000);
+            const workspaceName = instance.prefix + "_" + remoteWorkspace.id;
+            await dntShim.Deno.mkdir(path.join(rootDir, workspaceName), {
+                recursive: true,
+            });
+            await dntShim.Deno.chdir(path.join(rootDir, workspaceName));
+            await addWorkspace({
+                remote: instance.remote,
+                name: workspaceName,
+                workspaceId: remoteWorkspace.id,
+                token: instance.token,
+            }, {
+                token: undefined,
+                workspace: undefined,
+            });
+            await pull({
+                workspace: workspaceName,
+                token: undefined,
+                includeGroups: true,
+                includeSchedules: true,
+                includeSettings: true,
+                includeUsers: true,
+                includeKey: true,
+            });
+        }
+        const localWorkspacesToDelete = localWorkspaces.filter((w) => !remoteWorkspaces.find((r) => r.id === w.workspaceId));
+        if (localWorkspacesToDelete.length > 0) {
+            const confirmDelete = await Confirm.prompt({
+                message: "Do you want to delete the local copy of workspaces that don't exist anymore on the instance?\n" +
+                    localWorkspacesToDelete.map((w) => w.workspaceId).join(", "),
+                default: true,
+            });
+            if (confirmDelete) {
+                for (const workspace of localWorkspacesToDelete) {
+                    await removeWorkspace(workspace.name, false, {});
+                    await dntShim.Deno.remove(path.join(rootDir, workspace.name), {
+                        recursive: true,
+                    });
+                }
+            }
+        }
+        log.info(colors.green.underline.bold("All workspaces pulled"));
+    }
+}
+async function instancePush(opts) {
+    let instances = await allInstances();
+    let instance;
+    if (instances.length < 1) {
+        instance = await addInstance();
+    }
+    else {
+        const choice = (await Select.prompt({
+            message: "Select an instance to push to",
+            options: [
+                ...instances.map((i) => ({
+                    name: `${i.name} (${i.remote})`,
+                    value: i.name,
+                })),
+                { name: "Add new instance", value: "new" },
+            ],
+        }));
+        if (choice === "new") {
+            instance = await addInstance();
+        }
+        else {
+            instance = instances.find((i) => i.name === choice);
+        }
+    }
+    setClient(instance.token, instance.remote.slice(0, instance.remote.length - 1));
+    log.info("Pushing instance-level changes");
+    log.info(`remote (${instance.name}) <- local`);
+    let uChanges = 0;
+    if (!opts.skipUsers) {
+        uChanges = (await pushInstanceUsers(true));
+    }
+    let sChanges = 0;
+    if (!opts.skipSettings) {
+        sChanges = (await pushInstanceSettings(true, opts.baseUrl));
+    }
+    let cChanges = 0;
+    if (!opts.skipConfigs) {
+        cChanges = (await pushInstanceConfigs(true));
+    }
+    let gChanges = 0;
+    if (!opts.skipGroups) {
+        gChanges = (await pushInstanceGroups(true));
+    }
+    const totalChanges = uChanges + sChanges + cChanges + gChanges;
+    if (totalChanges > 0) {
+        const confirm = await Confirm.prompt({
+            message: `Do you want to apply these ${totalChanges} instance-level changes?`,
+            default: true,
+        });
+        if (confirm) {
+            if (!opts.skipUsers && uChanges > 0) {
+                await pushInstanceUsers();
+            }
+            if (!opts.skipSettings && sChanges > 0) {
+                await pushInstanceSettings(false, opts.baseUrl);
+            }
+            if (!opts.skipConfigs && cChanges > 0) {
+                await pushInstanceConfigs();
+            }
+            if (!opts.skipGroups && gChanges > 0) {
+                await pushInstanceGroups();
+            }
+        }
+    }
+    else {
+        log.info("No instance-level changes to apply");
+    }
+    sleep(1000);
+    if (opts.includeWorkspaces) {
+        instances = await allInstances();
+        const localPrefix = (await Select.prompt({
+            message: "What is the prefix of the local workspaces you want to sync?",
+            options: [
+                ...instances.map((i) => ({
+                    name: `${i.prefix} (${i.name} - ${i.remote})`,
+                    value: i.prefix,
+                })),
+            ],
+            default: instance.prefix,
+        }));
+        const remoteWorkspaces = await WorkspaceService.listWorkspacesAsSuperAdmin({
+            page: 1,
+            perPage: 1000,
+        });
+        let localWorkspaces = await allWorkspaces();
+        localWorkspaces = localWorkspaces.filter((w) => w.name.startsWith(localPrefix + "_"));
+        log.info("\nPushing all workspaces");
+        const rootDir = dntShim.Deno.cwd();
+        for (const localWorkspace of localWorkspaces) {
+            log.info("\nPushing workspace " + localWorkspace.workspaceId);
+            sleep(1000);
+            try {
+                await dntShim.Deno.chdir(path.join(rootDir, localWorkspace.name));
+            }
+            catch (_) {
+                throw new Error("Workspace folder not found, are you in the right directory?");
+            }
+            try {
+                const workspaceSettings = yamlParse(await dntShim.Deno.readTextFile("settings.yaml"));
+                await workspaceSetup({
+                    token: instance.token,
+                    workspace: undefined,
+                    create: true,
+                    createWorkspaceName: workspaceSettings.name,
+                    createUsername: undefined,
+                }, localWorkspace.name, localWorkspace.workspaceId, instance.remote);
+            }
+            catch (_) {
+                log.error("Settings file not found in workspace local folder, skipping");
+                continue;
+            }
+            await push({
+                workspace: localWorkspace.name,
+                token: undefined,
+                includeGroups: true,
+                includeSchedules: true,
+                includeSettings: true,
+                includeUsers: true,
+                includeKey: true,
+            });
+        }
+        const workspacesToDelete = remoteWorkspaces.filter((w) => !localWorkspaces.find((l) => l.workspaceId === w.id));
+        if (workspacesToDelete.length > 0) {
+            const confirmDelete = await Confirm.prompt({
+                message: "Do you want to delete the following remote workspaces that don't exist locally?\n" +
+                    workspacesToDelete.map((w) => w.id).join(", "),
+                default: true,
+            });
+            if (confirmDelete) {
+                for (const workspace of workspacesToDelete) {
+                    await WorkspaceService.deleteWorkspace({ workspace: workspace.id });
+                    log.info(colors.green.underline("Deleted workspace " + workspace.id));
+                }
+            }
+        }
+        log.info(colors.green.underline.bold("All workspaces pushed"));
+    }
+}
+const command = new Command()
+    .description("sync local with a remote instance or the opposite (push or pull)")
+    .action(() => log.info("2 actions available, pull and push. Use -h to display help."))
+    .command("pull")
+    .description("Pull instance settings, users, configs, instance groups and overwrite local")
+    .option("--skip-users", "Skip pulling users")
+    .option("--skip-settings", "Skip pulling settings")
+    .option("--skip-configs", "Skip pulling configs (worker groups and SMTP)")
+    .option("--skip-groups", "Skip pulling instance groups")
+    .option("--include-workspaces", "Also pull workspaces")
+    .action(instancePull)
+    .command("push")
+    .description("Push instance settings, users, configs, group and overwrite remote")
+    .option("--skip-users", "Skip pushing users")
+    .option("--skip-settings", "Skip pushing settings")
+    .option("--skip-configs", "Skip pushing configs (worker groups and SMTP)")
+    .option("--skip-groups", "Skip pushing instance groups")
+    .option("--include-workspaces", "Also push workspaces")
+    .option("--base-url", "Base url to be passed to the instance settings instead of the local one")
+    .action(instancePush);
+export default command;

package/esm/login.d.ts

@@ -0,0 +1,5 @@
+import { GlobalOptions } from "./types.js";
+export declare function loginInteractive(remote: string): Promise<string | undefined>;
+export declare function tryGetLoginInfo(opts: GlobalOptions): Promise<string | undefined>;
+export declare function browserLogin(baseUrl: string): Promise<string | undefined>;
+//# sourceMappingURL=login.d.ts.map

package/esm/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../src/login.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAI3C,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,+BA2BpD;AAGD,wBAAsB,eAAe,CACnC,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAM7B;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAqE7B"}