@zuplo/cli 1.50.0 → 1.52.0

package/dist/cli.js

@@ -7,7 +7,9 @@ import convert from "./cmds/convert.js";
 import deleteZup from "./cmds/delete.js";
 import deploy from "./cmds/deploy.js";
 import dev from "./cmds/dev.js";
+import link from "./cmds/link.js";
 import list from "./cmds/list.js";
+import login from "./cmds/login.js";
 import test from "./cmds/test.js";
 import tunnel from "./cmds/tunnel/index.js";
 import variable from "./cmds/variable/index.js";
@@ -21,6 +23,8 @@ if (gte(process.versions.node, MIN_NODE_VERSION)) {
         .command(deploy)
         .command(dev)
         .command(list)
+        .command(link)
+        .command(login)
         .command(test)
         .command(tunnel)
         .command(variable)

package/dist/cmds/link.js

@@ -0,0 +1,26 @@
+import setBlocking from "../common/output.js";
+import { validLinkDirectoryValidator } from "../common/validators/file-system-validator.js";
+import { YargsChecker } from "../common/validators/lib.js";
+import { link } from "../link/handler.js";
+export default {
+    desc: "Link a local directory to a Zuplo project",
+    command: "link",
+    builder: (yargs) => {
+        return yargs
+            .option("dir", {
+            type: "string",
+            describe: "The directory containing your zup",
+            default: ".",
+            normalize: true,
+            hidden: true,
+        })
+            .middleware([setBlocking])
+            .check(async (argv) => {
+            return await new YargsChecker(validLinkDirectoryValidator).check(argv);
+        });
+    },
+    handler: async (argv) => {
+        await link(argv);
+    },
+};
+//# sourceMappingURL=link.js.map

package/dist/cmds/login.js

@@ -0,0 +1,18 @@
+import setBlocking from "../common/output.js";
+import { login } from "../login/handler.js";
+export default {
+    desc: "Authenticates the user",
+    command: "login",
+    builder: (yargs) => {
+        return yargs
+            .option("print-token", {
+            type: "boolean",
+            describe: "Should the CLI print the token to the console?",
+        })
+            .middleware([setBlocking]);
+    },
+    handler: async (argv) => {
+        await login(argv);
+    },
+};
+//# sourceMappingURL=login.js.map

package/dist/common/api/lib.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lib.js.map

package/dist/common/constants.js

@@ -1,5 +1,8 @@
 export const ZUPLO_PREFERRED_JSON_FILE = "zuplo.jsonc";
 export const ZUPLO_FALLBACK_JSON_FILE = "zuplo.json";
+export const ZUPLO_CLI_XDG_FOLDER_NAME = "zup";
+export const ZUPLO_AUTH_FILE_NAME = "auth.json";
+export const ZUPLO_SYSTEM_ENV_VAR = ".env.zuplo";
 export const DEPLOYER_METADATA_FILE = "deployer.json";
 export const TEST_IN_FOLDER = "tests";
 export const TEST_OUT_FOLDER = ".zuplo/__tests__";

package/dist/common/settings.js

@@ -2,6 +2,9 @@ class Settings {
     get ZUPLO_DEVELOPER_API_ENDPOINT() {
         return process.env.ZUPLO_DEVELOPER_API_ENDPOINT ?? "https://dev.zuplo.com";
     }
+    get ZUPLO_API_ENDPOINT() {
+        return process.env.ZUPLO_API_ENDPOINT ?? "https://api.zuplo.com";
+    }
     get MAX_POLL_RETRIES() {
         return parseInt(process.env.MAX_POLL_RETRIES ?? "90");
     }

package/dist/common/validators/file-system-validator.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { simpleGit } from "simple-git";
 import { TEST_IN_FOLDER } from "../constants.js";
 import { CompositeValidator } from "./lib.js";
+import { UserIsLoggedInValidator } from "./login-state-validator.js";
 import { ProjectIsSetValidator } from "./project-name-validator.js";
 export class NotAGitRepoError extends Error {
     constructor() {
@@ -158,4 +159,5 @@ export class ZuploProjectHasTestsValidator {
 }
 export const validDeployDirectoryValidator = new CompositeValidator(new ZuploProjectValidator(), new GitVersionControlValidator(), new GitCommitValidator(), new GitBranchValidator(), new GitRemoteValidator(), new ProjectIsSetValidator());
 export const validTestDirectoryValidator = new CompositeValidator(new ZuploProjectValidator(), new ZuploProjectHasTestsValidator());
+export const validLinkDirectoryValidator = new CompositeValidator(new ZuploProjectValidator(), new UserIsLoggedInValidator());
 //# sourceMappingURL=file-system-validator.js.map

package/dist/common/validators/login-state-validator.js

@@ -0,0 +1,36 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { ZUPLO_AUTH_FILE_NAME } from "../constants.js";
+import { logger } from "../logger.js";
+import settings from "../settings.js";
+import { ZUPLO_XDG_STATE_HOME } from "../xdg/lib.js";
+export class UserIsNotLoggedIn extends Error {
+    constructor() {
+        super(`You are not logged in (or your credentials have expired). Please run \`zuplo login\` to log in.`);
+        Object.setPrototypeOf(this, UserIsNotLoggedIn.prototype);
+    }
+}
+export class UserIsLoggedInValidator {
+    async validate(options) {
+        if (!existsSync(join(ZUPLO_XDG_STATE_HOME, ZUPLO_AUTH_FILE_NAME))) {
+            return { ok: false, error: new UserIsNotLoggedIn() };
+        }
+        const rawAuth = await readFile(join(ZUPLO_XDG_STATE_HOME, ZUPLO_AUTH_FILE_NAME), "utf-8");
+        const authJson = JSON.parse(rawAuth);
+        const accountResponse = await fetch(`${settings.ZUPLO_API_ENDPOINT}/v1/accounts`, {
+            headers: {
+                authorization: `Bearer ${authJson.access_token}`,
+            },
+        });
+        if (!accountResponse.ok) {
+            logger.trace({
+                status: accountResponse.status,
+                statusText: accountResponse.statusText,
+            }, "Failed to connect to Zuplo API during verification. Assuming user is not logged in.");
+            return { ok: false, error: new UserIsNotLoggedIn() };
+        }
+        return { ok: true };
+    }
+}
+//# sourceMappingURL=login-state-validator.js.map

package/dist/common/xdg/lib.js

@@ -0,0 +1,18 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { ZUPLO_CLI_XDG_FOLDER_NAME } from "../constants.js";
+function defineDirectoryWithFallback(xdgName, fallback) {
+    if (process.env[xdgName]) {
+        return process.env[xdgName];
+    }
+    else {
+        return path.join(homedir(), fallback);
+    }
+}
+export const XDG_CONFIG_HOME = defineDirectoryWithFallback("XDG_CONFIG_HOME", ".config");
+export const XDG_DATA_HOME = defineDirectoryWithFallback("XDG_DATA_HOME", ".local/share");
+export const XDG_STATE_HOME = defineDirectoryWithFallback("XDG_DATA_HOME", ".local/state");
+export const ZUPLO_XDG_CONFIG_HOME = path.join(XDG_CONFIG_HOME, ZUPLO_CLI_XDG_FOLDER_NAME);
+export const ZUPLO_XDG_DATA_HOME = path.join(XDG_DATA_HOME, ZUPLO_CLI_XDG_FOLDER_NAME);
+export const ZUPLO_XDG_STATE_HOME = path.join(XDG_STATE_HOME, ZUPLO_CLI_XDG_FOLDER_NAME);
+//# sourceMappingURL=lib.js.map

package/dist/dev/handler.js

@@ -1,4 +1,6 @@
+import * as dotenv from "dotenv";
 import { cpSync, existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { locateDenoExecutable } from "../common/deno-utils/locator.js";
@@ -12,6 +14,11 @@ export async function dev(argv) {
     }
     process.env.GLOBAL_MODULE_LOCATION = fileURLToPath(new URL("../../node_modules", import.meta.url));
     process.env.DENO_EXECUTABLE = await locateDenoExecutable();
+    const envFile = join(sourceDirectory, ".env.zuplo");
+    if (existsSync(envFile)) {
+        const config = dotenv.parse(await readFile(envFile, "utf-8"));
+        dotenv.populate(process.env, config);
+    }
     const core = await import("@zuplo/core");
     const port = argv.port ?? 9000;
     await core.default.startDevServer({

package/dist/link/handler.js

@@ -0,0 +1,77 @@
+import { select } from "@inquirer/prompts";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { ZUPLO_AUTH_FILE_NAME } from "../common/constants.js";
+import { logger } from "../common/logger.js";
+import { printDiagnosticsToConsole } from "../common/output.js";
+import settings from "../common/settings.js";
+import { ZUPLO_XDG_STATE_HOME } from "../common/xdg/lib.js";
+import { pullSystemConfig, safeMergeConfig } from "./populate.js";
+export async function link(argv) {
+    const rawAuth = await readFile(join(ZUPLO_XDG_STATE_HOME, ZUPLO_AUTH_FILE_NAME), "utf-8");
+    const authJson = JSON.parse(rawAuth);
+    const accountResponse = await fetch(`${settings.ZUPLO_API_ENDPOINT}/v1/accounts`, {
+        headers: {
+            authorization: `Bearer ${authJson.access_token}`,
+        },
+    });
+    if (!accountResponse.ok) {
+        logger.error({
+            status: accountResponse.status,
+            statusText: accountResponse.statusText,
+            response: await accountResponse.text(),
+        }, "Failed to list accounts.");
+        printDiagnosticsToConsole("Error: Failed to list your accounts. Try again later.");
+    }
+    const accountJson = (await accountResponse.json());
+    let account;
+    if (accountJson.length === 1) {
+        account = accountJson[0].name;
+    }
+    else {
+        account = await select({
+            message: "Select the account to work with",
+            choices: accountJson.map((acc) => {
+                return {
+                    name: acc.name,
+                    value: acc.name,
+                };
+            }),
+        });
+    }
+    const projectResponse = await fetch(`${settings.ZUPLO_API_ENDPOINT}/v1/accounts/${account}/projects`, {
+        headers: {
+            authorization: `Bearer ${authJson.access_token}`,
+        },
+    });
+    if (!projectResponse.ok) {
+        logger.error({
+            status: projectResponse.status,
+            statusText: projectResponse.statusText,
+            response: await projectResponse.text(),
+        }, "Failed to list projects.");
+        printDiagnosticsToConsole("Error: Failed to list your projects. Try again later.");
+    }
+    const projectJson = (await projectResponse.json());
+    let project;
+    if (projectJson.data.length === 1) {
+        project = projectJson.data[0].name;
+    }
+    else {
+        project = await select({
+            message: "Select the project to work with",
+            choices: projectJson.data.map((prj) => {
+                return {
+                    name: prj.name,
+                    value: prj.name,
+                };
+            }),
+        });
+    }
+    await safeMergeConfig(argv.dir, { account, project });
+    await pullSystemConfig(argv.dir, {
+        account: accountJson.find((acc) => acc.name === account),
+        project: projectJson.data.find((prj) => prj.name === project),
+    });
+}
+//# sourceMappingURL=handler.js.map

package/dist/link/populate.js

@@ -0,0 +1,65 @@
+import { applyEdits, modify } from "jsonc-parser";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import prettier from "prettier";
+import { ZUPLO_FALLBACK_JSON_FILE, ZUPLO_PREFERRED_JSON_FILE, ZUPLO_SYSTEM_ENV_VAR, } from "../common/constants.js";
+export async function safeMergeConfig(dir, options) {
+    const normalizedDir = join(relative(process.cwd(), dir));
+    const zuploPreferredConfigFile = join(normalizedDir, ZUPLO_PREFERRED_JSON_FILE);
+    const zuploFallbackConfigFile = join(normalizedDir, ZUPLO_FALLBACK_JSON_FILE);
+    if (existsSync(zuploPreferredConfigFile)) {
+        const originalContents = await readFile(zuploPreferredConfigFile, "utf-8");
+        const modifyAccountEdit = modify(originalContents, ["account"], options.account, {
+            getInsertionIndex: () => 1,
+        });
+        const contentsPostAccount = applyEdits(originalContents, modifyAccountEdit);
+        const modifyProjectEdit = modify(contentsPostAccount, ["project"], options.project, {
+            getInsertionIndex: () => 2,
+        });
+        const contentsPostProject = applyEdits(contentsPostAccount, modifyProjectEdit);
+        const formatted = prettier.format(contentsPostProject, {
+            parser: "json",
+            quoteProps: "preserve",
+        });
+        await writeFile(zuploPreferredConfigFile, formatted);
+    }
+    else if (existsSync(zuploFallbackConfigFile)) {
+        const config = JSON.parse(await readFile(zuploFallbackConfigFile, "utf-8"));
+        const formatted = prettier.format(JSON.stringify({
+            version: 1,
+            account: options.account,
+            project: options.project,
+            compatibilityDate: config.compatibilityDate,
+        }), {
+            parser: "json",
+            quoteProps: "preserve",
+        });
+        await writeFile(zuploPreferredConfigFile, formatted);
+    }
+    else {
+        const formatted = prettier.format(JSON.stringify({
+            version: 1,
+            account: options.account,
+            project: options.project,
+            compatibilityDate: "2023-03-14",
+        }), {
+            parser: "json",
+            quoteProps: "preserve",
+        });
+        await writeFile(zuploPreferredConfigFile, formatted);
+    }
+}
+export async function pullSystemConfig(dir, options) {
+    const normalizedDir = join(relative(process.cwd(), dir));
+    const zuploPreferredConfigFile = join(normalizedDir, ZUPLO_SYSTEM_ENV_VAR);
+    const content = `
+  # This file is auto-generated from zup link. Please do not edit it manually.
+  # It will be auto-generated afresh the next time you run zup link.
+  
+  ZUPLO_API_KEY_SERVICE_BUCKET_NAME=z${options.project.id
+        .toLowerCase()
+        .replaceAll("_", "-")}-working-copy`;
+    await writeFile(zuploPreferredConfigFile, content);
+}
+//# sourceMappingURL=populate.js.map

package/dist/login/handler.js

@@ -0,0 +1,75 @@
+import crypto from "node:crypto";
+import { existsSync, mkdirSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { ZUPLO_AUTH_FILE_NAME } from "../common/constants.js";
+import { printResultToConsoleAndExitGracefully } from "../common/output.js";
+import { ZUPLO_XDG_STATE_HOME } from "../common/xdg/lib.js";
+import { browserAuth } from "./server.js";
+export const AUTH_SERVER_PORT = 57801;
+export const CLIENT_ID = "mYLGcH7kB4P0pw0HAk6GH7raRwYhSlW4";
+export const CALLBACK_URL = `http://localhost:${AUTH_SERVER_PORT}/`;
+export const AUTH0_DOMAIN = "auth.zuplo.com";
+export const encode = (value) => btoa(value);
+export const decode = (value) => atob(value);
+export const createRandomString = () => {
+    const charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_~.";
+    let random = "";
+    const randomValues = Array.from(crypto.getRandomValues(new Uint8Array(43)));
+    randomValues.forEach((v) => (random += charset[v % charset.length]));
+    return random;
+};
+const urlEncodeB64 = (input) => {
+    const b64Chars = { "+": "-", "/": "_", "=": "" };
+    return input.replace(/[+/=]/g, (m) => b64Chars[m]);
+};
+export const bufferToBase64UrlEncoded = (input) => {
+    const ie11SafeInput = new Uint8Array(input);
+    return urlEncodeB64(btoa(String.fromCharCode(...Array.from(ie11SafeInput))));
+};
+export const sha256 = async (s) => {
+    const digestOp = crypto.subtle.digest({ name: "SHA-256" }, new TextEncoder().encode(s));
+    return await digestOp;
+};
+export async function login(args) {
+    const code_verifier = createRandomString();
+    const code_challengeBuffer = await sha256(code_verifier);
+    const code_challenge = bufferToBase64UrlEncoded(code_challengeBuffer);
+    const authUrl = new URL(`https://${AUTH0_DOMAIN}/authorize`);
+    authUrl.searchParams.set("response_type", "code");
+    authUrl.searchParams.set("code_challenge", code_challenge);
+    authUrl.searchParams.set("code_challenge_method", "S256");
+    authUrl.searchParams.set("client_id", CLIENT_ID);
+    authUrl.searchParams.set("redirect_uri", CALLBACK_URL);
+    authUrl.searchParams.set("scope", "openid profile email");
+    authUrl.searchParams.set("audience", "https://api.zuplo.com/");
+    const params = await browserAuth(authUrl.toString());
+    const code = params.get("code");
+    if (code === null) {
+        throw new Error("No code");
+    }
+    const tokenParams = new URLSearchParams();
+    tokenParams.set("grant_type", "authorization_code");
+    tokenParams.set("client_id", CLIENT_ID);
+    tokenParams.set("code_verifier", code_verifier);
+    tokenParams.set("code", code);
+    tokenParams.set("redirect_uri", CALLBACK_URL);
+    const response = await fetch(`https://${AUTH0_DOMAIN}/oauth/token`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: tokenParams,
+    });
+    const result = (await response.json());
+    if (!existsSync(ZUPLO_XDG_STATE_HOME)) {
+        mkdirSync(ZUPLO_XDG_STATE_HOME, { recursive: true });
+    }
+    const tokenPath = join(ZUPLO_XDG_STATE_HOME, ZUPLO_AUTH_FILE_NAME);
+    await writeFile(tokenPath, JSON.stringify(result));
+    if (args["print-token"]) {
+        console.log(result.access_token);
+    }
+    printResultToConsoleAndExitGracefully("Successfully authenticated.");
+}
+//# sourceMappingURL=handler.js.map

package/dist/login/server.js

@@ -0,0 +1,35 @@
+import http from "http";
+import opn from "open";
+import { printCriticalFailureToConsoleAndExit } from "../common/output.js";
+import { AUTH_SERVER_PORT } from "./handler.js";
+export async function browserAuth(authorizationUrl) {
+    let params;
+    const handler = (req, res) => {
+        if (!req.url) {
+            throw new Error("Bad url");
+        }
+        const url = new URL(req.url, `http://localhost:${AUTH_SERVER_PORT}`);
+        if (url.pathname === "/") {
+            params = url.searchParams;
+            res.end("You can close this browser now.");
+        }
+        else {
+            res.end("Unsupported route for login server.");
+        }
+    };
+    const server = http.createServer(handler).listen(AUTH_SERVER_PORT);
+    opn(authorizationUrl);
+    let iterations = 0;
+    while (params === undefined) {
+        if (iterations++ > 60) {
+            server.close();
+            printCriticalFailureToConsoleAndExit("Timed out waiting for login in the browser. Run the zup login command again.");
+        }
+        else {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+    }
+    server.close();
+    return params;
+}
+//# sourceMappingURL=server.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuplo/cli",
-  "version": "1.50.0",
+  "version": "1.52.0",
   "type": "module",
   "repository": "https://github.com/zuplo/cli",
   "author": "Zuplo, Inc.",
@@ -8,8 +8,7 @@
   "scripts": {
     "build": "tsc --build",
     "test": "mocha",
-    "test:debug": "mocha --timeout 0",
-    "prepack": "scripts/prepack.mjs"
+    "test:debug": "mocha --timeout 0"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -50,18 +49,20 @@
     "typescript": "5.0.3"
   },
   "dependencies": {
+    "@inquirer/prompts": "^3.0.4",
     "@swc/core": "1.3.78",
-    "@zuplo/core": "5.1206.0",
-    "@zuplo/runtime": "5.1206.0",
+    "@zuplo/core": "5.1217.0",
+    "@zuplo/runtime": "5.1217.0",
     "chalk": "^5.1.2",
     "deno-bin": "1.31.1",
-    "dotenv": "^16.0.3",
+    "dotenv": "^16.3.1",
     "esbuild": "0.18.6",
     "execa": "^6.1.0",
     "fast-glob": "^3.2.12",
     "ignore": "^5.2.4",
-    "jsonc-parser": "^3.2.0",
     "jose": "^4.14.4",
+    "jsonc-parser": "^3.2.0",
+    "open": "^9.1.0",
     "pino": "^8.11.0",
     "pino-pretty": "^9.4.0",
     "prettier": "^2.8.7",