@interactivethings/scripts 0.0.8 → 2.0.0

package/dist/vercel/cli.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.configParser = void 0;
+const deployments_1 = require("./deployments");
+const argparse_1 = require("argparse");
+const configParser = (parser) => {
+    const commands = parser.add_subparsers({
+        title: "Vercel commands",
+        dest: "subcommand",
+        help: "Use 'ixt vercel <command> --help' for more information",
+    });
+    // wait-deployment subcommand
+    const waitDeploymentParser = commands.add_parser("wait-deployment", {
+        help: "Wait for a Vercel deployment to complete",
+    });
+    waitDeploymentParser.add_argument("commit", {
+        help: "Commit that started the deployment",
+    });
+    waitDeploymentParser.add_argument("--interval", {
+        default: 5000,
+        type: Number,
+    });
+    waitDeploymentParser.add_argument("--project", {
+        required: true,
+    });
+    waitDeploymentParser.add_argument("--team", {
+        required: true,
+    });
+    waitDeploymentParser.add_argument("--timeout", {
+        default: 10 * 60 * 1000,
+        type: Number,
+    });
+};
+exports.configParser = configParser;
+const run = async (args) => {
+    const accessToken = process.env.VERCEL_TOKEN;
+    switch (args.subcommand) {
+        case "wait-deployment":
+            const deployment = await (0, deployments_1.waitForDeploymentReady)({
+                commitSha: args.commit,
+                interval: args.interval,
+                timeout: args.timeout,
+                team: args.team,
+                project: args.project,
+                accessToken: accessToken,
+            });
+            if (!deployment) {
+                throw new Error("Could not retrieve deployment");
+            }
+            console.log(`DEPLOYMENT_URL=https://${deployment.url}`);
+            break;
+    }
+};
+exports.run = run;
+async function main() {
+    const parser = new argparse_1.ArgumentParser({
+        description: "Vercel deployment utilities",
+    });
+    const args = parser.parse_args();
+    (0, exports.configParser)(parser);
+    await (0, exports.run)(args);
+}
+// Only run main if this file is being executed directly
+if (require.main === module) {
+    main().catch((e) => {
+        console.error(e);
+        process.exit(1);
+    });
+}

package/dist/vercel/cli.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const argparse_1 = require("argparse");
+const cli_1 = require("./cli");
+// Mock the waitForDeploymentReady function
+vitest_1.vi.mock("@interactivethings/scripts/vercel/deployments", () => ({
+    waitForDeploymentReady: vitest_1.vi.fn(),
+}));
+const deployments_1 = require("@interactivethings/scripts/vercel/deployments");
+(0, vitest_1.describe)("Vercel CLI", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        // Mock environment variable
+        process.env.VERCEL_TOKEN = "test-token";
+    });
+    (0, vitest_1.describe)("configParser", () => {
+        (0, vitest_1.it)("should configure the argument parser correctly", () => {
+            const parser = new argparse_1.ArgumentParser();
+            const addSubparsersSpy = vitest_1.vi.spyOn(parser, "add_subparsers");
+            (0, cli_1.configParser)(parser);
+            (0, vitest_1.expect)(addSubparsersSpy).toHaveBeenCalledWith({
+                title: "Vercel commands",
+                dest: "subcommand",
+                help: "Use 'ixt vercel <command> --help' for more information",
+            });
+        });
+    });
+    (0, vitest_1.describe)("run", () => {
+        (0, vitest_1.it)("should successfully wait for deployment with valid args", async () => {
+            const mockDeployment = {
+                url: "test-deployment.vercel.app",
+                state: "READY",
+                meta: {
+                    githubCommitSha: "test-commit-sha",
+                },
+            };
+            vitest_1.vi.mocked(deployments_1.waitForDeploymentReady).mockResolvedValue(mockDeployment);
+            const consoleSpy = vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+            const args = {
+                subcommand: "wait-deployment",
+                commit: "test-commit-sha",
+                interval: 5000,
+                timeout: 600000,
+                team: "test-team",
+                project: "test-project",
+            };
+            await (0, cli_1.run)(args);
+            (0, vitest_1.expect)(deployments_1.waitForDeploymentReady).toHaveBeenCalledWith({
+                commitSha: "test-commit-sha",
+                interval: 5000,
+                timeout: 600000,
+                team: "test-team",
+                project: "test-project",
+                accessToken: "test-token",
+            });
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith("DEPLOYMENT_URL=https://test-deployment.vercel.app");
+            consoleSpy.mockRestore();
+        });
+        (0, vitest_1.it)("should throw error when deployment is not found", async () => {
+            vitest_1.vi.mocked(deployments_1.waitForDeploymentReady).mockResolvedValue(undefined);
+            const args = {
+                subcommand: "wait-deployment",
+                commit: "test-commit-sha",
+                interval: 5000,
+                timeout: 600000,
+                team: "test-team",
+                project: "test-project",
+            };
+            await (0, vitest_1.expect)((0, cli_1.run)(args)).rejects.toThrow("Could not retrieve deployment");
+        });
+        (0, vitest_1.it)("should throw error when waitForDeploymentReady fails", async () => {
+            const error = new Error("Network error");
+            vitest_1.vi.mocked(deployments_1.waitForDeploymentReady).mockRejectedValue(error);
+            const args = {
+                subcommand: "wait-deployment",
+                commit: "test-commit-sha",
+                interval: 5000,
+                timeout: 600000,
+                team: "test-team",
+                project: "test-project",
+            };
+            await (0, vitest_1.expect)((0, cli_1.run)(args)).rejects.toThrow("Network error");
+        });
+    });
+});

package/dist/vercel/deployments.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForDeploymentReady = void 0;
+async function fetchDeploymentForCommit(commitSha, teamId, projectId, accessToken) {
+    try {
+        const response = await fetch(`https://vercel.com/api/v6/deployments?limit=20&projectId=${projectId}&state=READY,ERROR,BUILDING,QUEUED&teamId=${teamId}`, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        }).then((x) => x.json());
+        const deployments = response.deployments.filter((deployment) => deployment.meta.githubCommitSha === commitSha);
+        return deployments;
+    }
+    catch (error) {
+        console.error("Error:", error);
+        return [];
+    }
+}
+const sleep = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+async function waitForDeploymentReady({ team, project, commitSha, interval, timeout, accessToken, }) {
+    const start = Date.now();
+    const end = start + timeout;
+    while (Date.now() < end) {
+        const deployments = await fetchDeploymentForCommit(commitSha, team, project, accessToken);
+        if (deployments.length === 0 || deployments[0].state !== "READY") {
+            const state = deployments[0].state;
+            if (state === "ERROR") {
+                throw new Error("Deployment errored");
+            }
+            console.log(`Deployment not yet ready (state: ${deployments[0].state}), waiting ${interval}ms for deployment with commit ${commitSha}`);
+            await sleep(Math.min(end - Date.now(), interval));
+        }
+        else {
+            console.log(`Deployment for commit ${commitSha} is READY`);
+            return deployments[0];
+        }
+    }
+    if (Date.now() > end) {
+        throw new Error("Timeout for waitForDeploymentReady");
+    }
+}
+exports.waitForDeploymentReady = waitForDeploymentReady;

package/dist/vercel/waitForDeploymentReady.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForDeploymentReady = void 0;
+const cli_1 = require("@interactivethings/scripts/vercel/cli");
+async function fetchDeploymentForCommit(commitSha, teamId, projectId) {
+    try {
+        const response = await fetch(`https://vercel.com/api/v6/deployments?limit=20&projectId=${projectId}&state=READY,ERROR,BUILDING,QUEUED&teamId=${teamId}`, {
+            headers: {
+                Authorization: `Bearer ${cli_1.accessToken}`,
+            },
+        }).then((x) => x.json());
+        const deployments = response.deployments.filter((deployment) => deployment.meta.githubCommitSha === commitSha);
+        return deployments;
+    }
+    catch (error) {
+        console.error("Error:", error);
+        return [];
+    }
+}
+const sleep = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+async function waitForDeploymentReady({ team, project, commitSha, interval, timeout, }) {
+    const start = Date.now();
+    const end = start + timeout;
+    while (Date.now() < end) {
+        const deployments = await fetchDeploymentForCommit(commitSha, team, project);
+        if (deployments.length === 0 || deployments[0].state !== "READY") {
+            const state = deployments[0].state;
+            if (state === "ERROR") {
+                throw new Error("Deployment errored");
+            }
+            console.log(`Deployment not yet ready (state: ${deployments[0].state}), waiting ${interval}ms for deployment with commit ${commitSha}`);
+            await sleep(Math.min(end - Date.now(), interval));
+        }
+        else {
+            console.log(`Deployment for commit ${commitSha} is READY`);
+            return deployments[0];
+        }
+    }
+    if (Date.now() > end) {
+        throw new Error("Timeout for waitForDeploymentReady");
+    }
+}
+exports.waitForDeploymentReady = waitForDeploymentReady;

package/package.json

@@ -1,25 +1,65 @@
 {
   "name": "@interactivethings/scripts",
-  "version": "0.0.8",
-  "main": "index.js",
+  "version": "2.0.0",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tokens-studio": "./dist/tokens-studio/index.js",
+    "./types": "./dist/types.js"
+  },
+  "typesVersions": {
+    "*": {
+      "tokens-studio": [
+        "./dist/tokens-studio/index.d.ts"
+      ],
+      "types": [
+        "./dist/types.d.ts"
+      ]
+    }
+  },
   "repository": "git@github.com:interactivethings/ixt-scripts.git",
   "author": "Interactive Things <we@interactivethings.com>",
   "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "lint": "oxlint",
+    "test": "vitest",
+    "start": "bun ./dist/cli.js"
+  },
   "bin": {
+    "ixt": "dist/cli.js",
     "wait-for-vercel-deploy": "dist/wait-for-vercel-deploy.js",
     "mui-tokens-studio": "dist/mui-tokens-studio.js"
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "codemods"
   ],
   "dependencies": {
+    "@next/env": "^15.5.4",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.6",
     "@types/argparse": "^2.0.12",
+    "@types/jscodeshift": "^0.11.10",
     "argparse": "^2.0.1",
-    "remeda": "^1.19.0"
+    "jiti": "^2.6.1",
+    "ora": "^9.0.0",
+    "prompts": "^2.4.2",
+    "remeda": "^1.19.0",
+    "zod": "^4.1.11"
   },
   "devDependencies": {
-    "@types/node": "^20.3.1",
-    "typescript": "^5.2.2"
+    "@types/node": "22",
+    "@types/prompts": "^2.4.9",
+    "jscodeshift": "^0.15.1",
+    "oxlint": "^1.19.0",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.6"
+  },
+  "peerDependencies": {
+    "@next/env": "^15.5.4"
   }
 }