@vention/vention-cli 0.4.0 → 0.6.1

package/README.md

@@ -1,6 +1,6 @@
 # @vention/vention-cli
 
-A command-line interface tool to interact with MachineCode applications from your local setup
+A command-line interface Tool to interact with MachineCode applications from your local setup
 
 ## Installation
 

package/cli.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/cli";

package/cli.esm.js

@@ -0,0 +1,505 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { select, password } from '@inquirer/prompts';
+import fs, { 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 getAllApplicationsWithSourceCode = 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}/v2/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}`);
+    }
+    const response = await res.json();
+    return response.applications || [];
+};
+const pushApplicationToDigitalTwin = async (session, application) => {
+    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: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            Cookie: `digital-twin-session-${session.linkedDesignId}=s%3A${session.linkedSessionToken}.s`,
+        },
+        body: JSON.stringify(application),
+    });
+    if (!res.ok) {
+        throw new Error(`Request failed: ${res.status} ${res.statusText}`);
+    }
+    return await res.json();
+};
+
+const STATE_FILENAME = ".machine-code-app-directory-info.json";
+const writeMachineCodeAppDirectoryInfo = async (projectPath, state) => {
+    const statePath = path.join(projectPath, STATE_FILENAME);
+    await fs.promises.writeFile(statePath, JSON.stringify(state, null, 2));
+};
+const readMachineCodeAppDirectoryInfo = async (projectPath) => {
+    const statePath = path.join(projectPath, STATE_FILENAME);
+    try {
+        const data = await fs.promises.readFile(statePath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+};
+
+const getDefaultIgnorePatterns = () => {
+    return new Set(["venv", "node_modules", "dist", "build", "__pycache__", /\.egg-info$/, ".machine-code-app-directory-info.json"]);
+};
+const shouldIgnoreFileSystemNode = (nodeName, ignoredNodes) => {
+    for (const pattern of ignoredNodes) {
+        if (typeof pattern === "string" && nodeName === pattern) {
+            return true;
+        }
+        if (pattern instanceof RegExp && pattern.test(nodeName)) {
+            return true;
+        }
+    }
+    return false;
+};
+const serializeFileSystem = (sourceDirectory, ignoredFileSystemNodes, shouldBase64Encoded) => {
+    const fileSystemNode = {};
+    const directoryContents = fs.readdirSync(sourceDirectory);
+    directoryContents.forEach(directoryItem => {
+        if (shouldIgnoreFileSystemNode(directoryItem, ignoredFileSystemNodes)) {
+            return;
+        }
+        const fullPath = path.join(sourceDirectory, directoryItem);
+        const directoryItemInformation = fs.statSync(fullPath);
+        if (directoryItemInformation.isDirectory()) {
+            fileSystemNode[directoryItem] = serializeFileSystem(fullPath, ignoredFileSystemNodes, shouldBase64Encoded);
+        }
+        else if (directoryItemInformation.isFile()) {
+            const fileContent = shouldBase64Encoded ? fs.readFileSync(fullPath, "base64") : fs.readFileSync(fullPath, "utf8");
+            fileSystemNode[directoryItem] = fileContent;
+        }
+    });
+    return fileSystemNode;
+};
+const createFileSystemFromJson = async (fileSystemNode, targetDirectory) => {
+    await ensureDirectoryExists(targetDirectory);
+    const writeFiles = async (node, currentPath) => {
+        for (const [entryName, contentOrNode] of Object.entries(node)) {
+            const fullPath = path.join(currentPath, entryName);
+            if (typeof contentOrNode === "string") {
+                const decodedContent = Buffer.from(contentOrNode, "base64");
+                const fileHandle = await fs.promises.open(fullPath, "w");
+                try {
+                    await fileHandle.writeFile(decodedContent);
+                    await fileHandle.sync();
+                }
+                finally {
+                    await fileHandle.close();
+                }
+            }
+            else {
+                await ensureDirectoryExists(fullPath);
+                await writeFiles(contentOrNode, fullPath);
+            }
+        }
+    };
+    await writeFiles(fileSystemNode, targetDirectory);
+    const dirHandle = await fs.promises.open(targetDirectory, "r");
+    try {
+        await dirHandle.sync();
+    }
+    finally {
+        await dirHandle.close();
+    }
+};
+const ensureDirectoryExists = async (directory) => {
+    const directoryExists = await checkIfDirectoryExists(directory);
+    if (!directoryExists) {
+        fs.mkdirSync(directory, { recursive: true });
+    }
+};
+const checkIfDirectoryExists = async (directory) => {
+    const exists = await fs.promises
+        .access(directory)
+        .then(() => true)
+        .catch(() => false);
+    return exists;
+};
+const writeApplicationToDisk = async (appName, sourceCode, targetDirectory, overwriteExisting = false) => {
+    if (overwriteExisting) {
+        await createFileSystemFromJson(sourceCode, targetDirectory);
+        return targetDirectory;
+    }
+    const safeAppName = appName.replace(/[^a-zA-Z0-9-_]/g, "_");
+    const appDirectoryPath = path.join(targetDirectory, safeAppName);
+    await createFileSystemFromJson(sourceCode, appDirectoryPath);
+    return appDirectoryPath;
+};
+
+const checkIfDesignHasLiveAllocation = async (session, designId) => {
+    const allocations = await getUserAllocations(session);
+    const linkedAllocation = allocations.find(a => a.designId === designId);
+    return linkedAllocation;
+};
+const getAppFromDigitalTwin = async (session, appId, appName) => {
+    console.log(chalk.blue("Fetching all applications with source code from digital twin..."));
+    const allApplications = await getAllApplicationsWithSourceCode(session);
+    const targetApp = allApplications.find((app) => app.id === appId);
+    if (!targetApp) {
+        console.error(chalk.red(`Application "${appName}" (ID: ${appId}) not found in the digital twin.`));
+        process.exit(1);
+    }
+    return targetApp;
+};
+const getAvailableAppsFromDigitalTwin = async (session) => {
+    const allApplications = await getAllApplicationsWithSourceCode(session);
+    return allApplications.filter((app) => app.type === "machine_code");
+};
+const createNewAppDirectory = async (session, currentDir) => {
+    if (!session.linkedDesignId) {
+        console.error(chalk.red("No design linked. Please run 'vention link' first."));
+        process.exit(1);
+    }
+    const linkedAllocation = await checkIfDesignHasLiveAllocation(session, session.linkedDesignId);
+    console.log(chalk.blue(`You are currently linked to design: ${linkedAllocation === null || linkedAllocation === void 0 ? void 0 : linkedAllocation.designName}`));
+    if (!linkedAllocation) {
+        console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
+        console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
+        process.exit(1);
+    }
+    const availableApps = await getAvailableAppsFromDigitalTwin(session);
+    if (availableApps.length === 0) {
+        console.log(chalk.yellow("No machine code applications found in the digital twin"));
+        process.exit(1);
+    }
+    const selectedApp = await select({
+        message: "Select an application to pull:",
+        choices: availableApps.map((app) => ({
+            name: app.name,
+            value: app,
+        })),
+    });
+    console.log(chalk.blue(`\nPulling application "${selectedApp.name}"...`));
+    if (!selectedApp.sourceCode) {
+        console.log(chalk.yellow("No source code found for this application."));
+        process.exit(1);
+    }
+    const appDirectoryPath = await writeApplicationToDisk(selectedApp.name, selectedApp.sourceCode, currentDir);
+    await writeMachineCodeAppDirectoryInfo(appDirectoryPath, {
+        appName: selectedApp.name,
+        designId: session.linkedDesignId,
+        applicationId: selectedApp.id,
+        lastPulledAt: new Date().toISOString(),
+        environment: session.environment,
+        uuid: selectedApp.uuid,
+    });
+    console.log(chalk.green(`✅ Successfully pulled "${selectedApp.name}" to: ${appDirectoryPath}`));
+    console.log(chalk.blue(`📁 To navigate to your project, run:`));
+    console.log(chalk.cyan(`cd "${appDirectoryPath}"`));
+    console.log(chalk.blue("💡 You can now start working on your application!"));
+};
+const updateExistingAppDirectory = async (session, projectState, currentDir) => {
+    console.log(chalk.blue(`Found existing project: ${projectState.appName}`));
+    console.log(chalk.blue(`Design ID: ${projectState.designId}, App ID: ${projectState.applicationId}`));
+    const linkedAllocation = await checkIfDesignHasLiveAllocation(session, projectState.designId);
+    if (!linkedAllocation) {
+        console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
+        console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
+        process.exit(1);
+    }
+    await saveSession(Object.assign(Object.assign({}, session), { linkedDesignId: projectState.designId, linkedSessionToken: linkedAllocation.sessionId }));
+    const appWithSourceCode = await getAppFromDigitalTwin(session, projectState.applicationId, projectState.appName);
+    await writeApplicationToDisk(appWithSourceCode.name, appWithSourceCode.sourceCode, currentDir, true);
+    await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, projectState), { lastPulledAt: new Date().toISOString() }));
+    console.log(chalk.green(`✅ Successfully pulled "${appWithSourceCode.name}" to: ${currentDir}`));
+    console.log(chalk.blue("💡 Your project has been updated with the latest changes!"));
+};
+
+const program = new Command();
+program.name("vention").description("CLI tool for Vention").version("0.2.0");
+program
+    .command("login")
+    .description("Login to Vention")
+    .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. Please open a design and navigate to the machine logic tab to activate a digital twin."));
+            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);
+    }
+});
+program
+    .command("pull")
+    .description("Pull an application from 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 currentDir = process.cwd();
+        const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+        const isMachineCodeAppDirectory = !!machineCodeAppDirectoryInfo;
+        if (isMachineCodeAppDirectory) {
+            await updateExistingAppDirectory(session, machineCodeAppDirectoryInfo, currentDir);
+        }
+        else {
+            await createNewAppDirectory(session, currentDir);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to pull application:"));
+        console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+});
+program
+    .command("push")
+    .description("Push local changes back to the digital twin")
+    .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 currentDir = process.cwd();
+        const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+        if (!machineCodeAppDirectoryInfo) {
+            console.error(chalk.red("Not in a machine code application directory. Please run 'vention pull' first to create a project."));
+            console.error(chalk.red("Make sure you are in the root directory of a machine code application you have created using the 'vention pull' command."));
+            process.exit(1);
+        }
+        console.log(chalk.blue(`Pushing changes for project: ${machineCodeAppDirectoryInfo.appName}`));
+        console.log(chalk.blue(`Design ID: ${machineCodeAppDirectoryInfo.designId}, App ID: ${machineCodeAppDirectoryInfo.applicationId}`));
+        const linkedAllocation = await checkIfDesignHasLiveAllocation(session, machineCodeAppDirectoryInfo.designId);
+        if (!linkedAllocation) {
+            console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
+            console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
+            process.exit(1);
+        }
+        await saveSession(Object.assign(Object.assign({}, session), { linkedDesignId: machineCodeAppDirectoryInfo.designId, linkedSessionToken: linkedAllocation.sessionId }));
+        console.log(chalk.blue("Serializing local files..."));
+        const ignorePatterns = getDefaultIgnorePatterns();
+        const serializedSourceCode = serializeFileSystem(currentDir, ignorePatterns, true);
+        const applicationToPush = {
+            name: machineCodeAppDirectoryInfo.appName,
+            id: machineCodeAppDirectoryInfo.applicationId,
+            type: "machine_code",
+            sourceCode: serializedSourceCode,
+            uuid: machineCodeAppDirectoryInfo.uuid,
+        };
+        console.log(chalk.blue("Pushing to digital twin..."));
+        await pushApplicationToDigitalTwin(session, applicationToPush);
+        await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, machineCodeAppDirectoryInfo), { lastPushedAt: new Date().toISOString() }));
+        console.log(chalk.green(`✅ Successfully pushed "${machineCodeAppDirectoryInfo.appName}" to digital twin`));
+        console.log(chalk.blue("💡 Your changes have been uploaded!"));
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to push application:"));
+        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,6 +1,6 @@
 {
   "name": "@vention/vention-cli",
-  "version": "0.4.0",
+  "version": "0.6.1",
   "description": "CLI tool for Vention applications",
   "type": "module",
   "repository": {
@@ -13,8 +13,8 @@
   },
   "license": "MIT",
   "bin": {
-    "vention": "index.esm.js",
-    "vn": "index.esm.js"
+    "vention": "cli.esm.js",
+    "vn": "cli.esm.js"
   },
   "dependencies": {
     "axios": "1.7.7",
@@ -29,7 +29,7 @@
     "typescript": "5.3.3",
     "vitest": "3.2.3"
   },
-  "module": "./index.esm.js",
-  "main": "./index.esm.js",
-  "types": "./index.esm.d.ts"
+  "module": "./cli.esm.js",
+  "main": "./cli.esm.js",
+  "types": "./cli.esm.d.ts"
 }

package/src/cli-helpers.d.ts

@@ -0,0 +1,5 @@
+import { SessionData } from "./config";
+import { MachineCodeAppDirectoryInfo } from "./machine-code-app-directory-info";
+export declare const checkIfDesignHasLiveAllocation: (session: SessionData, designId: number) => Promise<import("./rails-client").AllocationResponse | undefined>;
+export declare const createNewAppDirectory: (session: SessionData, currentDir: string) => Promise<void>;
+export declare const updateExistingAppDirectory: (session: SessionData, projectState: MachineCodeAppDirectoryInfo, currentDir: string) => Promise<void>;

package/src/config.d.ts

@@ -1,4 +1,12 @@
-import { SessionData } from "./models";
+export interface SessionData {
+    environment: "local" | "demo" | "prod";
+    ventionSession: string;
+    stytchSessionJwt?: string;
+    ventionIdpSession?: string;
+    linkedDesignId?: number;
+    lastTaskId?: string;
+    linkedSessionToken?: string;
+}
 export declare const getConfigPath: () => string;
 export declare const saveSession: (data: SessionData) => Promise<void>;
 export declare const loadSession: () => Promise<SessionData | null>;

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

@@ -1,3 +1,15 @@
-import { SessionData } from "./models";
+import { SessionData } from "./config";
+export interface FileSystemNode {
+    [entryName: string]: FileSystemNode | string;
+}
+export interface Application {
+    name: string;
+    id: string;
+    uuid?: string;
+    type: string;
+    sourceCode: FileSystemNode;
+}
 export declare const getDigitalTwinUrl: (environment: SessionData["environment"], sessionId: string) => string;
 export declare const makeTestRequestToLinkedDigitalTwin: (session: SessionData) => Promise<any>;
+export declare const getAllApplicationsWithSourceCode: (session: SessionData) => Promise<Application[]>;
+export declare const pushApplicationToDigitalTwin: (session: SessionData, application: Application) => Promise<void>;

package/src/file-system.d.ts

@@ -0,0 +1,8 @@
+export interface FileSystemNode {
+    [entryName: string]: FileSystemNode | string;
+}
+export declare const getDefaultIgnorePatterns: () => Set<string | RegExp>;
+export declare const shouldIgnoreFileSystemNode: (nodeName: string, ignoredNodes: Set<string | RegExp>) => boolean;
+export declare const serializeFileSystem: (sourceDirectory: string, ignoredFileSystemNodes: Set<string | RegExp>, shouldBase64Encoded: boolean) => FileSystemNode;
+export declare const createFileSystemFromJson: (fileSystemNode: FileSystemNode, targetDirectory: string) => Promise<void>;
+export declare const writeApplicationToDisk: (appName: string, sourceCode: FileSystemNode, targetDirectory: string, overwriteExisting?: boolean) => Promise<string>;

package/src/file-system.test.d.ts

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

package/src/machine-code-app-directory-info.d.ts

@@ -0,0 +1,14 @@
+export interface MachineCodeAppDirectoryInfo {
+    appName: string;
+    designId: number;
+    applicationId: string;
+    uuid?: string;
+    lastPulledAt: string;
+    lastPushedAt?: string;
+    environment: "local" | "demo" | "prod";
+}
+export declare const writeMachineCodeAppDirectoryInfo: (projectPath: string, state: MachineCodeAppDirectoryInfo) => Promise<void>;
+export declare const readMachineCodeAppDirectoryInfo: (projectPath: string) => Promise<MachineCodeAppDirectoryInfo | null>;
+export declare const updateLastPulledAt: (projectPath: string) => Promise<void>;
+export declare const updateLastPushedAt: (projectPath: string) => Promise<void>;
+export declare const isMachineCodeAppDirectory: (projectPath: string) => Promise<boolean>;

package/src/machine-code-app-directory-info.test.d.ts

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

package/src/rails-client.d.ts

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

package/index.esm.d.ts

@@ -1 +0,0 @@
-export * from "./src/index";

package/index.esm.js

@@ -1,208 +0,0 @@
-#!/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/src/models.d.ts

@@ -1,26 +0,0 @@
-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;
-}