@vention/vention-cli 0.3.2 → 0.4.0

package/index.esm.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { select, password } from '@inquirer/prompts';
+import { promises, realpathSync } from 'fs';
+import path from 'path';
+
+const getConfigPath = () => {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir) {
+        console.warn(chalk.yellow("Warning: Could not determine home directory. Using current directory instead."));
+        console.warn(chalk.yellow("This may cause issues if the CLI is run from different directories."));
+        console.warn(chalk.blue("To fix this permanently, set the HOME environment variable."));
+        return path.join(process.cwd(), ".vention-cli-config.json");
+    }
+    return path.join(homeDir, ".vention-cli-config.json");
+};
+const saveSession = async (data) => {
+    const configPath = getConfigPath();
+    await promises.writeFile(configPath, JSON.stringify(data, null, 2));
+};
+const loadSession = async () => {
+    try {
+        const configPath = getConfigPath();
+        const data = await promises.readFile(configPath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (error) {
+        console.error("Failed to load session:", error);
+        return null;
+    }
+};
+
+const getBaseRailsUrl = (environment) => {
+    switch (environment) {
+        case "local":
+            return "http://localhost:3000";
+        case "demo":
+            return "https://vention.foo";
+        case "prod":
+            return "https://vention.io";
+        default:
+            throw new Error("Invalid environment");
+    }
+};
+const getUserAllocations = async (session) => {
+    const baseUrl = getBaseRailsUrl(session.environment);
+    const res = await fetch(`${baseUrl}/api/v3/digital_twin_infrastructure/allocations`, {
+        method: "GET",
+        headers: {
+            Accept: "application/json",
+            Origin: baseUrl,
+            Referer: `${baseUrl}/`,
+            Cookie: [
+                `vention_session=${session.ventionSession}`,
+                ...(session.stytchSessionJwt ? [`stytch_session_jwt=${session.stytchSessionJwt}`] : []),
+                ...(session.ventionIdpSession ? [`vention_idp_session=${session.ventionIdpSession}`] : []),
+            ].join("; "),
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Request failed: ${res.status} ${res.statusText}`);
+    }
+    const response = await res.json();
+    return response;
+};
+
+const getDigitalTwinUrl = (environment, sessionId) => {
+    switch (environment) {
+        case "local":
+            return `http://localhost:3101`;
+        case "demo":
+            return `https://digital-twin.vention.foo/digital-twin/machine-motion/passthrough/${sessionId}/80`;
+        case "prod":
+            return `https://digital-twin.vention.io/digital-twin/machine-motion/passthrough/${sessionId}/80`;
+        default:
+            throw new Error("Invalid environment");
+    }
+};
+const makeTestRequestToLinkedDigitalTwin = async (session) => {
+    if (!session.linkedSessionToken) {
+        throw new Error("Linked session token is not set");
+    }
+    const digitalTwinUrl = getDigitalTwinUrl(session.environment, session.linkedSessionToken);
+    const res = await fetch(`${digitalTwinUrl}/v1/library`, {
+        method: "GET",
+        headers: {
+            Accept: "application/json",
+            Cookie: `digital-twin-session-${session.linkedDesignId}=s%3A${session.linkedSessionToken}.s`,
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Request failed: ${res.status} ${res.statusText}`);
+    }
+    return await res.json();
+};
+
+const program = new Command();
+program.name("vention").description("CLI tool for Vention").version("0.2.0");
+program
+    .command("login")
+    .description("Login to Ventionn")
+    .action(async () => {
+    try {
+        const environment = (await select({
+            message: "Select environment:",
+            choices: [
+                { name: "local", value: "local" },
+                { name: "demo", value: "demo" },
+                { name: "prod", value: "prod" },
+            ],
+        }));
+        const ventionSession = await password({
+            message: "Enter vention_session cookie value:",
+            mask: "",
+            validate: (input) => input.length > 0 || "vention_session is required",
+        });
+        const stytchSessionJwt = environment !== "local"
+            ? await password({
+                message: "Enter stytch_session_jwt cookie value:",
+                mask: "",
+                validate: (input) => input.length > 0 || "stytch_session_jwt is required for non-local environments",
+            })
+            : undefined;
+        const ventionIdpSession = environment !== "local"
+            ? await password({
+                message: "Enter vention_idp_session cookie value:",
+                mask: "",
+                validate: (input) => input.length > 0 || "vention_idp_session is required for non-local environments",
+            })
+            : undefined;
+        await saveSession(Object.assign({ environment,
+            ventionSession }, (environment !== "local" ? { stytchSessionJwt, ventionIdpSession } : {})));
+        console.log(chalk.green("Successfully logged in!"));
+    }
+    catch (error) {
+        console.error(chalk.red("Login failed:"), error);
+        process.exit(1);
+    }
+});
+program
+    .command("link")
+    .description("Link to a one of your active designs")
+    .action(async () => {
+    try {
+        const session = await loadSession();
+        if (!session) {
+            console.error(chalk.red("Not logged in. Please run 'vention login' first."));
+            process.exit(1);
+        }
+        const allocations = await getUserAllocations(session);
+        if (allocations.length === 0) {
+            console.log(chalk.yellow("No active allocations found."));
+            process.exit(1);
+        }
+        const selectedDesign = await select({
+            message: "Select a design to link:",
+            choices: allocations.map((allocation) => ({
+                name: `${allocation.designName} (ID: ${allocation.designId})`,
+                value: { id: allocation.designId, name: allocation.designName, sessionId: allocation.sessionId },
+            })),
+        });
+        await saveSession(Object.assign(Object.assign({}, session), { linkedDesignId: selectedDesign.id, linkedSessionToken: selectedDesign.sessionId }));
+        console.log(chalk.green(`\nSuccessfully linked to design "${selectedDesign.name}" (ID: ${selectedDesign.id})`));
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to get allocations:"));
+        console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+});
+program
+    .command("test")
+    .description("Make a test request to the digital twin for the linked design")
+    .action(async () => {
+    try {
+        const session = await loadSession();
+        if (!session) {
+            console.error(chalk.red("Not logged in. Please run 'vention login' first."));
+            process.exit(1);
+        }
+        if (!session.linkedDesignId) {
+            console.error(chalk.red("No design linked. Please run 'vention link' first."));
+            process.exit(1);
+        }
+        const allocations = await getUserAllocations(session);
+        const linkedAllocation = allocations.find(a => a.designId === session.linkedDesignId);
+        if (!linkedAllocation) {
+            console.error(chalk.red("Linked design is not currently allocated. Please check if the digital twin is running."));
+            process.exit(1);
+        }
+        const digitalTwinResponse = await makeTestRequestToLinkedDigitalTwin(session);
+        console.log(chalk.green("Digital twin response:"));
+        console.log(chalk.green(JSON.stringify(digitalTwinResponse, null, 2)));
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to get digital twin response:"));
+        console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+});
+const resolvedArgv = realpathSync(process.argv[1]);
+const resolvedUrl = new URL(import.meta.url).pathname;
+if (resolvedArgv === resolvedUrl) {
+    program.parse(process.argv);
+}
+
+export { program };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@vention/vention-cli",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "CLI tool for Vention applications",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/VentionCo/machine-cloud.git"
@@ -12,21 +13,23 @@
   },
   "license": "MIT",
   "bin": {
-    "vention": "index.cjs.js",
-    "vn": "index.cjs.js"
+    "vention": "index.esm.js",
+    "vn": "index.esm.js"
   },
   "dependencies": {
-    "commander": "11.1.0",
-    "chalk": "4.1.2"
+    "axios": "1.7.7",
+    "chalk": "4.1.2",
+    "commander": "14.0.0",
+    "@inquirer/prompts": "7.6.0"
   },
-  "peerDependencies": {},
   "devDependencies": {
     "@nx/vite": "21.1.3",
+    "@types/inquirer": "9.0.8",
     "@types/node": "20.11.24",
     "typescript": "5.3.3",
     "vitest": "3.2.3"
   },
-  "main": "./index.cjs.js",
-  "type": "commonjs",
-  "types": "./index.cjs.d.ts"
+  "module": "./index.esm.js",
+  "main": "./index.esm.js",
+  "types": "./index.esm.d.ts"
 }

package/src/config.d.ts

@@ -0,0 +1,4 @@
+import { SessionData } from "./models";
+export declare const getConfigPath: () => string;
+export declare const saveSession: (data: SessionData) => Promise<void>;
+export declare const loadSession: () => Promise<SessionData | null>;

package/src/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/digital-twin-client.d.ts

@@ -0,0 +1,3 @@
+import { SessionData } from "./models";
+export declare const getDigitalTwinUrl: (environment: SessionData["environment"], sessionId: string) => string;
+export declare const makeTestRequestToLinkedDigitalTwin: (session: SessionData) => Promise<any>;

package/src/digital-twin-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-export declare const program: import("commander").Command;
+import { Command } from "commander";
+export declare const program: Command;

package/src/models.d.ts

@@ -0,0 +1,26 @@
+export interface AllocationResponse {
+    cookie: {
+        originalMaxAge: number;
+        expires: string;
+        httpOnly: boolean;
+        path: string;
+    };
+    sessionId: string;
+    tabId: string;
+    userId: string;
+    allocatedResourceId: string;
+    allocationCreationTime: number;
+    allocatedResourceLastAccessTime: number;
+    allocationType: "regular" | "custom";
+    designName: string;
+    designId: number;
+}
+export interface SessionData {
+    environment: "local" | "demo" | "prod";
+    ventionSession: string;
+    stytchSessionJwt?: string;
+    ventionIdpSession?: string;
+    linkedDesignId?: number;
+    lastTaskId?: string;
+    linkedSessionToken?: string;
+}

package/src/rails-client.d.ts

@@ -0,0 +1,3 @@
+import { SessionData, AllocationResponse } from "./models";
+export declare const getBaseRailsUrl: (environment: SessionData["environment"]) => "http://localhost:3000" | "https://vention.foo" | "https://vention.io";
+export declare const getUserAllocations: (session: SessionData) => Promise<AllocationResponse[]>;

package/src/rails-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/index.cjs.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-var commander = require('commander');
-var chalk = require('chalk');
-
-const program = new commander.Command();
-program.name("vention").description("CLI tool for Vention").version("0.1.0");
-program
-    .command("hello")
-    .description("Say hello")
-    .action(() => {
-    console.log(chalk.green("Hello from Machine Logic CLI!"));
-});
-if (require.main === module) {
-    program.parse(process.argv);
-}
-
-exports.program = program;