@vention/vention-cli 0.8.1 → 0.9.0

package/cli.esm.js

@@ -31,40 +31,6 @@ const loadSession = async () => {
     }
 };
 
-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":
@@ -77,33 +43,16 @@ const getDigitalTwinUrl = (environment, sessionId) => {
             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) {
+const getAllApplicationsWithSourceCode = async (environment, designId, sessionId) => {
+    if (!sessionId) {
         throw new Error("Linked session token is not set");
     }
-    const digitalTwinUrl = getDigitalTwinUrl(session.environment, session.linkedSessionToken);
+    const digitalTwinUrl = getDigitalTwinUrl(environment, sessionId);
     const res = await fetch(`${digitalTwinUrl}/v2/library`, {
         method: "GET",
         headers: {
             Accept: "application/json",
-            Cookie: `digital-twin-session-${session.linkedDesignId}=s%3A${session.linkedSessionToken}.s`,
+            Cookie: `digital-twin-session-${designId}=s%3A${sessionId}.s`,
         },
     });
     if (!res.ok) {
@@ -112,17 +61,17 @@ const getAllApplicationsWithSourceCode = async (session) => {
     const response = await res.json();
     return response.applications || [];
 };
-const pushApplicationToDigitalTwin = async (session, application) => {
-    if (!session.linkedSessionToken) {
+const pushApplicationToDigitalTwin = async (environment, designId, sessionId, application) => {
+    if (!sessionId) {
         throw new Error("Linked session token is not set");
     }
-    const digitalTwinUrl = getDigitalTwinUrl(session.environment, session.linkedSessionToken);
+    const digitalTwinUrl = getDigitalTwinUrl(environment, sessionId);
     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`,
+            Cookie: `digital-twin-session-${designId}=s%3A${sessionId}.s`,
         },
         body: JSON.stringify(application),
     });
@@ -151,6 +100,40 @@ const readMachineCodeAppDirectoryInfo = async (projectPath) => {
     }
 };
 
+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 getDefaultIgnorePatterns = () => {
     return new Set(["venv", "node_modules", "dist", "build", "__pycache__", /\.egg-info$/, ".machine-code-app-directory-info.json"]);
 };
@@ -252,50 +235,23 @@ const checkIfDesignHasLiveAllocation = async (session, designId) => {
     const linkedAllocation = allocations.find(a => a.designId === designId);
     return linkedAllocation;
 };
-const getAppFromDigitalTwin = async (session, appId, appName) => {
+const getAppFromDigitalTwin = async (environment, machineCodeAppDirectoryInfo, sessionId) => {
     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);
+    const allApplications = await getAllApplicationsWithSourceCode(environment, machineCodeAppDirectoryInfo.designId, sessionId);
+    const targetApp = allApplications.find((app) => app.id === machineCodeAppDirectoryInfo.applicationId);
     if (!targetApp) {
         console.log();
-        console.error(chalk.red(`Application "${appName}" (ID: ${appId}) not found in the digital twin.`));
+        console.error(chalk.red(`Application "${machineCodeAppDirectoryInfo.appName}" (ID: ${machineCodeAppDirectoryInfo.applicationId}) not found in the digital twin.`));
         process.exit(1);
     }
     return targetApp;
 };
-const getAvailableAppsFromDigitalTwin = async (session) => {
-    const allApplications = await getAllApplicationsWithSourceCode(session);
+const getAvailableAppsFromDigitalTwin = async (environment, designId, sessionId) => {
+    const allApplications = await getAllApplicationsWithSourceCode(environment, designId, sessionId);
     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();
-    console.log(chalk.blue(`You are currently linked to design: ${linkedAllocation === null || linkedAllocation === void 0 ? void 0 : linkedAllocation.designName}`));
-    if (!linkedAllocation) {
-        console.log();
-        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();
-        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();
-    console.log(chalk.blue(`\nPulling application "${selectedApp.name}"...`));
+    const { selectedDesign, selectedApp } = await selectDesignAndApp(session);
     if (!selectedApp.sourceCode) {
         console.log();
         console.log(chalk.yellow("No source code found for this application."));
@@ -313,7 +269,7 @@ const createNewAppDirectory = async (session, currentDir) => {
     const appDirectoryPath = await writeApplicationToDisk(selectedApp.name, selectedApp.sourceCode, currentDir);
     await writeMachineCodeAppDirectoryInfo(appDirectoryPath, {
         appName: selectedApp.name,
-        designId: session.linkedDesignId,
+        designId: selectedDesign.id,
         applicationId: selectedApp.id,
         lastPulledAt: new Date().toISOString(),
         environment: session.environment,
@@ -325,24 +281,55 @@ const createNewAppDirectory = async (session, currentDir) => {
     console.log(chalk.cyan(`cd "${safeAppName}"`));
     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);
+const updateExistingAppDirectory = async (session, machineCodeAppDirectoryInfo, currentDir) => {
+    console.log(chalk.blue(`Found existing 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.log();
         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);
+    const appWithSourceCode = await getAppFromDigitalTwin(session.environment, machineCodeAppDirectoryInfo, linkedAllocation.sessionId);
     await writeApplicationToDisk(appWithSourceCode.name, appWithSourceCode.sourceCode, currentDir, true);
-    await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, projectState), { lastPulledAt: new Date().toISOString() }));
+    await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, machineCodeAppDirectoryInfo), { lastPulledAt: new Date().toISOString() }));
     console.log();
     console.log(chalk.green(`✅ Successfully pulled "${appWithSourceCode.name}" to: ${currentDir}`));
     console.log(chalk.blue("💡 Your project has been updated with the latest changes!"));
 };
+const selectDesignAndApp = async (session) => {
+    const allocations = await getUserAllocations(session);
+    if (allocations.length === 0) {
+        console.log();
+        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:",
+        choices: allocations.map((allocation) => ({
+            name: `${allocation.designName} (ID: ${allocation.designId})`,
+            value: { id: allocation.designId, name: allocation.designName, sessionId: allocation.sessionId },
+        })),
+    });
+    const availableApps = await getAvailableAppsFromDigitalTwin(session.environment, selectedDesign.id, selectedDesign.sessionId);
+    if (availableApps.length === 0) {
+        console.log();
+        console.log(chalk.yellow("No machine code applications found in the digital twin"));
+        process.exit(1);
+    }
+    const selectedApp = await select({
+        message: "Select an application:",
+        choices: availableApps.map((app) => ({
+            name: app.name,
+            value: app,
+        })),
+    });
+    return {
+        selectedDesign,
+        selectedApp,
+    };
+};
 
 const program = new Command();
 program.name("vention").description("CLI tool for Vention").version("0.2.0");
@@ -403,7 +390,7 @@ program
 });
 program
     .command("link")
-    .description("Link to a one of your active designs")
+    .description("Link current directory to a Vention design application")
     .action(async () => {
     try {
         const session = await loadSession();
@@ -411,33 +398,31 @@ program
             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();
-            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 },
-            })),
+        const currentDir = process.cwd();
+        const { selectedDesign, selectedApp } = await selectDesignAndApp(session);
+        await writeMachineCodeAppDirectoryInfo(currentDir, {
+            appName: selectedApp.name,
+            designId: selectedDesign.id,
+            applicationId: selectedApp.id,
+            lastPulledAt: new Date().toISOString(),
+            environment: session.environment,
+            uuid: selectedApp.uuid,
         });
-        await saveSession(Object.assign(Object.assign({}, session), { linkedDesignId: selectedDesign.id, linkedSessionToken: selectedDesign.sessionId }));
         console.log();
-        console.log(chalk.green(`\nSuccessfully linked to design "${selectedDesign.name}" (ID: ${selectedDesign.id})`));
+        console.log(chalk.green(`Successfully linked current directory to design "${selectedDesign.name}" (ID: ${selectedDesign.id})`));
+        console.log(chalk.green(`Application: "${selectedApp.name}" (ID: ${selectedApp.id})`));
+        console.log(chalk.blue("You can now use 'vention pull' to download app content or 'vention push' to upload local changes."));
     }
     catch (error) {
         console.log();
-        console.error(chalk.red("Failed to get allocations:"));
+        console.error(chalk.red("Failed to link directory:"));
         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")
+    .command("push")
+    .description("Push local changes from this directory to the linked digital twin")
     .action(async () => {
     try {
         const session = await loadSession();
@@ -445,32 +430,78 @@ program
             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."));
+        const currentDir = process.cwd();
+        const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+        if (!machineCodeAppDirectoryInfo) {
+            console.log();
+            console.log(chalk.yellow("This directory is not linked to a Vention application."));
+            const shouldLink = await select({
+                message: "Would you like to link this directory to an application?",
+                choices: [
+                    { name: "Yes, link this directory", value: true },
+                    { name: "No, cancel push operation", value: false },
+                ],
+            });
+            if (!shouldLink) {
+                console.log(chalk.blue("Push operation cancelled. Run 'vention link' when you're ready to link this directory."));
+                process.exit(0);
+            }
+            const { selectedDesign, selectedApp } = await selectDesignAndApp(session);
+            await writeMachineCodeAppDirectoryInfo(currentDir, {
+                appName: selectedApp.name,
+                designId: selectedDesign.id,
+                applicationId: selectedApp.id,
+                lastPulledAt: new Date().toISOString(),
+                environment: session.environment,
+                uuid: selectedApp.uuid,
+            });
+            console.log(chalk.green(`Successfully linked directory to design "${selectedDesign.name}" (ID: ${selectedDesign.id})`));
+            console.log(chalk.green(`Application: "${selectedApp.name}" (ID: ${selectedApp.id})`));
+            console.log(chalk.blue("Continuing with push operation..."));
+        }
+        const updatedMachineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+        if (!updatedMachineCodeAppDirectoryInfo) {
+            console.log(chalk.red("Error reading directory metadata after linking."));
             process.exit(1);
         }
-        const allocations = await getUserAllocations(session);
-        const linkedAllocation = allocations.find(a => a.designId === session.linkedDesignId);
+        console.log();
+        console.log(chalk.blue(`Pushing changes for project: ${updatedMachineCodeAppDirectoryInfo.appName}`));
+        console.log(chalk.blue(`Design ID: ${updatedMachineCodeAppDirectoryInfo.designId}, App ID: ${updatedMachineCodeAppDirectoryInfo.applicationId}`));
+        const linkedAllocation = await checkIfDesignHasLiveAllocation(session, updatedMachineCodeAppDirectoryInfo.designId);
         if (!linkedAllocation) {
             console.log();
-            console.error(chalk.red("Linked design is not currently allocated. Please check if the digital twin is running."));
+            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 digitalTwinResponse = await makeTestRequestToLinkedDigitalTwin(session);
         console.log();
-        console.log(chalk.green("Digital twin response:"));
-        console.log(chalk.green(JSON.stringify(digitalTwinResponse, null, 2)));
+        console.log(chalk.blue("Serializing local files..."));
+        const ignorePatterns = getDefaultIgnorePatterns();
+        const serializedSourceCode = serializeFileSystem(currentDir, ignorePatterns, true);
+        const applicationToPush = {
+            name: updatedMachineCodeAppDirectoryInfo.appName,
+            id: updatedMachineCodeAppDirectoryInfo.applicationId,
+            type: "machine_code",
+            sourceCode: serializedSourceCode,
+            uuid: updatedMachineCodeAppDirectoryInfo.uuid,
+        };
+        console.log(chalk.blue("Pushing to digital twin..."));
+        await pushApplicationToDigitalTwin(session.environment, updatedMachineCodeAppDirectoryInfo.designId, linkedAllocation.sessionId, applicationToPush);
+        await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, updatedMachineCodeAppDirectoryInfo), { lastPushedAt: new Date().toISOString() }));
+        console.log();
+        console.log(chalk.green(`✅ Successfully pushed to digital twin`));
+        console.log(chalk.blue("💡 Your changes have been uploaded!"));
     }
     catch (error) {
         console.log();
-        console.error(chalk.red("Failed to get digital twin response:"));
+        console.error(chalk.red("Failed to push application:"));
         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")
+    .description("Pull an application from a design to this directory")
     .action(async () => {
     try {
         const session = await loadSession();
@@ -480,8 +511,9 @@ program
         }
         const currentDir = process.cwd();
         const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
-        const isMachineCodeAppDirectory = !!machineCodeAppDirectoryInfo;
-        if (isMachineCodeAppDirectory) {
+        if (machineCodeAppDirectoryInfo) {
+            console.log(chalk.blue(`This directory is linked to app: ${machineCodeAppDirectoryInfo.appName}`));
+            console.log(chalk.blue(`Pulling latest content from design ID: ${machineCodeAppDirectoryInfo.designId}`));
             await updateExistingAppDirectory(session, machineCodeAppDirectoryInfo, currentDir);
         }
         else {
@@ -495,60 +527,6 @@ program
         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.log();
-            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();
-        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.log();
-            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();
-        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();
-        console.log(chalk.green(`✅ Successfully pushed "${machineCodeAppDirectoryInfo.appName}" to digital twin`));
-        console.log(chalk.blue("💡 Your changes have been uploaded!"));
-    }
-    catch (error) {
-        console.log();
-        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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vention/vention-cli",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "CLI tool for Vention applications",
   "type": "module",
   "repository": {

package/src/cli-helpers.d.ts

@@ -1,5 +1,18 @@
 import { SessionData } from "./config";
+import { Application } from "./digital-twin-client";
 import { MachineCodeAppDirectoryInfo } from "./machine-code-app-directory-info";
-export declare const checkIfDesignHasLiveAllocation: (session: SessionData, designId: number) => Promise<import("./rails-client").AllocationResponse | undefined>;
+import { AllocationResponse } from "./rails-client";
+export declare const checkIfDesignHasLiveAllocation: (session: SessionData, designId: number) => Promise<AllocationResponse | undefined>;
+export declare const getAppFromDigitalTwin: (environment: SessionData["environment"], machineCodeAppDirectoryInfo: MachineCodeAppDirectoryInfo, sessionId: string) => Promise<Application>;
+export declare const getAvailableAppsFromDigitalTwin: (environment: SessionData["environment"], designId: number, sessionId: string) => Promise<Application[]>;
 export declare const createNewAppDirectory: (session: SessionData, currentDir: string) => Promise<void>;
-export declare const updateExistingAppDirectory: (session: SessionData, projectState: MachineCodeAppDirectoryInfo, currentDir: string) => Promise<void>;
+export declare const updateExistingAppDirectory: (session: SessionData, machineCodeAppDirectoryInfo: MachineCodeAppDirectoryInfo, currentDir: string) => Promise<void>;
+export interface DesignAndAppSelection {
+    selectedDesign: {
+        id: number;
+        name: string;
+        sessionId: string;
+    };
+    selectedApp: Application;
+}
+export declare const selectDesignAndApp: (session: SessionData) => Promise<DesignAndAppSelection>;

package/src/config.d.ts

@@ -3,9 +3,6 @@ export interface SessionData {
     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>;

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

@@ -10,6 +10,5 @@ export interface Application {
     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>;
+export declare const getAllApplicationsWithSourceCode: (environment: SessionData["environment"], designId: number, sessionId: string) => Promise<Application[]>;
+export declare const pushApplicationToDigitalTwin: (environment: SessionData["environment"], designId: number, sessionId: string, application: Application) => Promise<void>;